Buscar este blog

lunes, 28 de octubre de 2013

Windows Server 2012 Como configurar un RAID y crear un recurso compartido



  • Pon en marcha el servidor pdc y el servidor de ficheros que montaste ayer. (siguiendo el enunciado del primer ejercicio del grupo 3 de ejercicios). Debes conseguir meter el servidor de ficheros en el dominio del pdc. Su nombre quedará como files.apellido.evil.lan Llama a ese volumen DATOS.
  • Crea un recurso compartido en ese servidor dentro del nuevo volumen. Crea una carpeta llamada Compartida. Publícala en el dominio.
  • En el PDC crea un usuario y modifica su perfil para que mapee la unidad Z: al recurso que acabas de crear. Inicia el cliente con el nuevo usuario y verifica que se le mapea la unidad al iniciar la sesión.


 Configuración de un RAID5



    • Para crear los diferentes tipos de RAID en nuestro servidor deberemos ir a: Administrador del Servidor/Herramientas/Administrador de equipos.


    • En esta nueva ventana seleccionamos la opción: Administrador de discos
    • A partir de aquí podemos empezar a formar los diferentes tipos de RAID
      • RAID0: Nos colocamos encima de uno de los discos sin crear y botón derecho. Se nos depliega un menú con diferentes opciones y seleccionamos la opción: NUEVO VOLUMEN DE DISCO DISTRIBUIDO

    
    • Seleccionamos los discos que queremos utilizar y seguimos con el asistente.


    • RAID1: Nos colocamos encima de uno de los discos sin crear y botón derecho. Se nos depliega un menú con diferentes opciones y seleccionamos la opción: NUEVO VOLUMEN DE DISCO REFLEJADO

    • Seleccionamos los discos que queremos utilizar y seguimos con el asistente.





    • RAID5: Nos colocamos encima de uno de los discos sin crear y botón derecho. Se nos despliega un menú con diferentes opciones y seleccionamos la opción: NUEVO VOLUMEN DE RAID5




      • Ya tenemos instalado un RAID5 en nuestro servidor de ficheros.
      • Ahora tenemos que crear un recurso compartido:

      Windows Server 2012 Configuración Copia de Seguridad

      1.2. Montar un backup.
      -Instala la característica de copia de seguridad en el PDC.
      -Crea un recurso compatido en el servidor de ficheros llamado c:\Backup. 
      -Programa una copia de seguridad en el PDC para guardar alguna carpeta (que no tenga mucho contenido).
      -Verifica que la copia se hace. Mueve la carpeta que habías guardado y prueba a restablecer la copia de seguridad..
      --------------------------------------------------------------------------------------------------------------------
      Lo primero es instalar la caracteristica de copias de se seguriad. En el Administrador de servidor seleccionamos: Agrerar un rol o caracterisitca y seguiremos los pasos


      Cuando nos indica que rol queremos agregar, pincharemos encima de características y seleccionaremos encima de: "Copia de seguridad de Windows Server..."


      Seguiremos con el asistente que terminara instalando el programa para realizar copias de seguridad.
      Una vez instalado, dentro del administrador del Servidor vamos a Herramientas  y seleccionamos la opción de Copias de seguridad de windows server.


      Nos aparecerá una ventana nueva  que nos indicara que nunca se ha realizado ninguna copia de seguridad y que puede ser un problema.
      Seleccionamos la opción de: "Programar copia de seguridad"


      Este asistente nos ayuda a realizar una copia de seguridad según nuestras necesidades.


      Nos permite hacer una copia completa de nuestra maquina o una copia personalizada. Según nuestras necesidades elegiremos una opción u otra. (una copia completa no esta nada mal, por si tenemos algún problema grabe y necesitamos restaurar todo el sistema. El problema esta en el volumen que esta copia suele tener. en nuestro caso casi 60GB).
      Elegiremos la opción personalizada y que la copia que queremos realizar es de datos y no del sistema.


      Agregaremos los elementos de los que queremos hacer una copia de seguridad.


      A la hora de seleccionar los elementos nos permite seleccionar:

      • Reconstrucción completa (esta opción nos copiara todo el disco donde se encuentra instalado el servidor y el estado del sistema).
      • Estado del sistema: Copia la configuración del sistema en ese momento.
      • Unidades de disco: Podemos seleccionar o el disco entero o los elementos que se encuentran dentro de las unidades.




      Tras terminar de elegir los elemento que queremos copiar, tendremos que indicar cuando se va a realizar la copia de seguridad.


      Despues de seleccionar la hora a la que se va a realizar la copia de seguridad tendremos que indicar donde queremos que se guarde la copia de seguridad. Opciones:


      • En un disco duro dedicado para copias de seguridad
      • En un volumen.
      • En una carpeta de red compartida (un servidor de datos)
      Nosotros elegiremos la opción 3 una carpeta de red ya que tenemos un servidor de archivos


      Indicamos la ruta.


      Terminaremos la instalación.



      Windows Server 2012 Auditar un recurso compartido

      1.1. Continuar/acabar/terminar el montaje que iniciaste ayer del servidor
      de ficheros, pdc y cliente.
      En el pdc debes
      - Crear una unidad organizativa llamada Sospechosos
      - Meter al usuario luis_barcenas dentro de esa UO
      - Crear una GPO para la UO Sospechosos que incluya auditoría
      de datos.
      - Crea un recurso compartido en files que incluya auditoría
      para el usuario luis_barcenas.
      Utiliza el cliente para acceder al recurso y verificar que la auditoría se registra en el visor de eventos.
      --------------------------------------------------------------------------------------------------------------------


      - Crear una unidad organizativa llamada Sospechosos
      - Meter al usuario luis_barcenas dentro de esa UO
      - Crear una GPO para la UO Sospechosos que incluya auditoría
      de datos.
      - Crea un recurso compartido en files que incluya auditoría
      para el usuario luis_barcenas.
      Utiliza el cliente para acceder al recurso y verificar que la auditoría se registra en el visor de eventos.

      Crear una UO
      Dentro del centro de administración de Active Directoy, crearemos una nueva Unidad Organizativa (UO).
      ·         Nuevo\unidad organizativa

      Es muy fácil crear una UO: Introducimos el nombre dela UO y Aceptar. Tiene mas opciones de configuración, pero eso será en otro punto.


      Despues de crear la UO, buscaremos al usuario “Luis Barcenas” y lo agregaremos a esta nueva UO.
      Para realizar este cambio pincharemos encima del usuario y “mover…”

      Nos saldrá una nueva ventana donde le indicaremos donde lo queremos mover. En nuestro caso a la UO “Sospechosos


      Ya hemos terminado con el primer paso. Agregar al usuario a una UO.
      Nos pasamos al Administrador de Directivas de Grupo, para indicarle una nueva GPO para la UO de sospechosos.
      Tendremos que dirigirnos a “sospechosos”: Bosque del dominio\dominio\sospechosos. Pincharemos encima de sospechosos y elegiremos: Nuevo GPO.
      Introducimos el nombre de la GPO, en nuestro caso “Auditar Datos”

      A continuación presionamos encima de la nueva GPO y elegimos dentro del menú: Editar.


      La nueva ventana que nos aparece es el: Editor de administración de directivas de grupo.
      Buscaremos la directiva de: “Auditar el acceso a objetos”, que se encuentra en la ruta: “Configuración de equipo\Directivas\Configuración de windows\Configuración de seguridad\Directivas locales\Auditar el acceso a objetos”



      Entraremos en las propiedades y activaremos las opciones que necesitaremos para definir la configuración de la directiva. Nosotros activaremos todas las opciones.



      Ya hemos terminado con esta parte, aceptaremos los cambios en todas las ventanas y nos dirigiremos a la las carpetas compartidas donde el usuario tiene acceso a los datos con los que trabaja o no.


      Entraremos en las propiedades del recurso compartido donde tiene acceso el usuario. En nuestro caso Luis Barcenas. Nos vamos a la pestaña de “Compartir” y accedemos a “Uso compartido avanzado…



      Miramos si tiene bien configurado el recurso comparitdo (si se esta compartiendo y con que usuarios)

      Miramos los permisos y si el usuario no tiene permisos lo agregamos a la lista de usuarios. Y le damos permisos de todoooo!!!






      Dentro de la pestaña de seguridad seleccionaremos: Opciones Avanzadas.






      Nos aparece otra ventana y accedemos a la pestaña Auditoria que nos permitirá auditar el recurso compartido.


      Agregamos una nueva auditoria y seleccionaremos en la nueva ventana: “Seleccionar una entidad de seguridad
      Como queremos observar todo lo que hace este usuario le indicamos que queremos auditar todo y en todas las carpetas que tenga este recurso compartido.



      Ya tenemos la configuración para hacer una auditoria al sr Luis Barcenas

      Para saber si el usuario a utilizado el recurso compartido nos dirigiremos al "visor de eventos"
      Dentro del visor de eventos crearemos un "Nuevo filtro o vista personalizada" y lo configuraremos para que nos haga un filtro.

      Indicamos en la casilla "Usuarios" el usuario que nos tiene que filtrar.


      En la palabra clave indicaremos las palabras a filtrar. En nuestro caso hemos elegido: "Auditoria correcta"y "Error de auditoria"


      Guardamos el filtro con un nuevo nombre: "Auditoria Luis Barcenas"


      Ya tenemos el filtro para ver que esta haciendo este usuario en el recurso compartido.

      lunes, 21 de octubre de 2013

      Windows Server 2012 5. Ejercicios Powershell

      5. Ejercicios Powershell


      2. Crea un cmdlet de powershell que defina un array relacional con las ips de los alumnos. Luego debes crear un bucle foreach para mostrar todos los registros.
      --------------------------------------------------------------------------------------------------------------------
      Las direcciones IP están almacendas en un fichero: IPs.csv con este formato
      usuario pdc local
      Juan 192.168.45.251 192.168.254.254


      # El fichero IPs.csv tiene todos los datos de los usuarios en columnas.
      #get-content e:\documentos\IPs.csv
      $fichero = Import-Csv -Delimiter " " e:\documentos\IPs.csv
      #mostrar el numero de lineas
      #Write-Output $fichero.count

      #recorrer el contenido y mostrarlo en tablas
      for($i=0;$i -lt $fichero.Count; $i++)
      {
          #Write-Output $fichero[$i]
          Write-Output $fichero[$i].usuario
          Write-Output $fichero[$i].pdc
          Write-Output $fichero[$i].local
          write-output "-------------------------------"
      }
      --------------------------------------------------------------------------------------------------------------------
      3. Crea un cmdlet de powershell que tenga un array relacional como el definido antes y que genere las rutas necesarias para llegar a esas máquinas con el comando Set-NetRoute
      --------------------------------------------------------------------------------------------------------------------
      # 3. Crea un cmdlet de powershell que tenga un array relacional como el definido ante

      # y que genere las rutas necesarias para llegar a esas máquinas con el comando Set-NetRoute
      #En prueba aun no funciona bien.....

      $usuarios = Import-Csv E:\IPs.csv

      foreach ($linea in $usuarios){

      new-netroute -destinationprefix $usuarios.pdc -nexthop $usuarios.local -ifindex 13
      #El valor del -ifindex varia mirar con el get-netroute el valor.


      }
      --------------------------------------------------------------------------------------------------------------------
      4.Crea un cmdlet de powershell que defina una función llamada hail. La función debe recibir un parámetros que indique el idioma (es, en, eu, kg, ev). Según el idioma que se introduzca (con un switch case), la función debe mostrar un saludo en ese idioma.
      --------------------------------------------------------------------------------------------------------------------
      function hail([string]$idioma)
      {
          switch ($idioma)
          {
              "es" { Write-Output "Hola Mundo."
              }
              "en" { Write-Output "Hello Wold"
              }
              "eu" { Write-Output "Kaiso Mundu"
              }
              "al" { Write-Output "Hallo Welt"
              }
              "it" { Write-Output "Ciao Mondo"
              }
          }
      }
       $saludo=hail -idioma eu
       Write-Output $saludo
      --------------------------------------------------------------------------------------------------------------------
      5.Crea un cmdlet de powershell que defina una función llamada generaCuentaSegura. La función debe generar una cadena que tenga 3 letras aleatorias seguida de 8 números aleatorios.
      --------------------------------------------------------------------------------------------------------------------
      $contrasena=generar -num_carac 3 -num_numer 8

          Write-Output $contrasena

       function generar([int]$num_carac,[int]$num_numer)
       {
          $caracteres="a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"
          $numeros="0","1","2","3","4","5","6","7","8","9"
          [string]$nombre=""

              for($i=0;$i -lt $num_carac;$i++)
              {
                  $s= Get-Random $caracteres.Length
                  #Write-Output $caracteres[$s]
                  [string] $nombre=$nombre+$caracteres[$s]
              }
                  #Write-Output $nombre
              for($i=0;$i -lt $num_numer;$i++)
              {
                  $s= Get-Random $numeros.Length
                  #Write-Output $numeros[$s]
                  [string]$nombre=$nombre+$numeros[$s]
              }
              $result=$nombre
       }
      --------------------------------------------------------------------------------------------------------------------
      6. Crea un cmdlet de powershell que defina una función llamada generaCuenta. La función debe como parámetro un Nombre y un Apellido y debe ser capaz de generar un string con la forma nombre_apellido con todo en minúsculas.
      --------------------------------------------------------------------------------------------------------------------
      function generaCuenta([string]$nombre, [string]$apellido)
      {
          [string]$minusculas=$nombre.ToLower() + "_" + $apellido.ToLower()
          return $minusculas
      }

      Write-Output "Introducir el nombre de usuario: "
      $nom=Read-Host
      Write-Output "Introducir el apellido del susario: "
      $ape=Read-Host

      $resultado=generaCuenta -nombre $nom -apellido $ape

      Write-Output $resultado
      --------------------------------------------------------------------------------------------------------------------
      7. Crea un cmdlet de powershell que defina una función llamada generaNombre.
      La función debe recibir como parámetro un número que serán las sílabas. La función debe devolver un nombre que tenga consonante,
      vocal, consonante-vocal,.. por ejemplo
      generaNombre(6) = manolo
      --------------------------------------------------------------------------------------------------------------------

      function generaNombre([int]$numero)
      {
          $consonante="b","c","d","f","g","h","j","k","l","m","n","p","q","r","s","t","v","w","x","y","z"
          $vocal="a","e","i","o","u"
       
          for($i=0;$i -lt $numero;$i++)
          {
              $n=$i%2
              if ($($i%2) -eq 0)
              {
                  $s=Get-Random $consonante.Length
                  $resul=$resul+$consonante[$s]
              }else
              {
                  $s= Get-Random $vocal.Length
                  $resul=$resul+$vocal[$s]
              }
          }
          Write-Output $resul
          #$result=$resul  
      }
      $mostrar=generaNombre 8
      Write-Output $mostrar

      martes, 15 de octubre de 2013

      4. Ejericicios PowerShell

      4. Ejericicios PowerShell 



      2. Crea un cmdlet que recoja como parámetro un nombre de directorio. Verifica
      que ese directorio exista. Luego debes listar los contenidos del directorio ordenados
      por tamaño, y de cada elemento debes sacar el tamaño y el nombre.

      ------------------------------------------------------------------------------------------------------------

      # Introduce un directorio que muestre la información de su contenido en orden de tamaño mostrando el nombre y el tamaño
      # Miguel Revuelta

      $i=0
      while ($i -eq 0)
      {
          Write-Output "Introduce el directorio"
          $direc= Read-Host
          if (Test-Path $direc)
          { $i=1   }
          else { Write-Output "El directorio no existe." }
      }
      #muestra el contenido del directorio, solo el tamaño y el nombre y lo ordena por tamaño.
      cd $direc
      Get-ChildItem | Select-Object length, name | Sort-Object -Descending length
      cd..




      ------------------------------------------------------------------------------------------------------------

      3. Crea un cmdlet llamado CheckPorts que defina un array con los puertos que queremos que estén en
      listening. Ejecuta el comando para sacar los puertos y verifica que están abiertos los indicados en el array.
      Vete sacando un mensaje que indique qué puertos están correctamente en estado listening y cuáles no.

      ------------------------------------------------------------------------------------------------------------
      #Mostar los puertos abiertos

      $Puertos=Get-NetTCPConnection #| Where-Object -FilterScript {$_.state -eq "listen"}
      #Write-Output $Puertos
      Write-Output "Los puertos que estan abiertos son:"
      for($i=0;$i -lt $puertos.length;$i++)
      {
          if ($Puertos[$i].State -eq "listen")
          {
              Write-Output "Este puerto esta abierto: " $Puertos[$i]
          }else{
              Write-Output $puertos[$i]
          }
      }


      ------------------------------------------------------------------------------------------------------------

      4. Crea un cmdlet llamado AlertDist que defina un array relacional con las unidades y el límite de capacidad.
      Debe ejecutarse un comando que saque el tamaño ocupado en las unidades y que nos avise si
      se ha superado el límite impuesto
      ------------------------------------------------------------------------------------------------------------
      #Write-Output "Introduce el espacio minimo que tiene que tener libre (GB): "
      #$espacio= Read-Host
      #$espacio=$espacio*1000000
      #Write-Output $espacio

      $Unidades=Get-PSDrive | select root, used, free

      Write-Output $Unidades.Length

      for ($unid=0;$unid -lt $Unidades.Length;$unid++) {
       
          $tamaño=$Unidades[$unid].free
          #Write-Output $tamaño
          if ($Unidades[$unid].root -ne "" -and $Unidades[$unid].root -ne "\")
          {
              if ($Unidades[$unid].free -lt 2000000)#$espacio)
              {
                   Write-Output $Unidades[$unid].root "tiene poco espacio libre. Espacio libre: "$Unidades[$unid].free
              }
              else
              {
                  Write-Output $Unidades[$unid].root "tiene espacio libre. Espacio libre: "$Unidades[$unid].free
              }
          }
      }

      ------------------------------------------------------------------------------------------------------------

      5. Crea un cmdlet de PowerShell que defina un array relacional con usuarios. Los campos de cada elemento
      deben ser nombre_cuenta, nombre y password. El programa debe mantener ese array con un menú en el que se pueda:
      -añadir
      -eliminar
      -buscar por nombre
      -mostrar todos
      Al crear uno nuevo deben solicitarse datos y el campo password debe ocultarse al escribir.
      ------------------------------------------------------------------------------------------------------------


      #Gestion de usuario

      $tabla_usuario=@{
      "Juan"=@{nombre="juan";cuenta="juan";contrasena="12345678"};
      "Pablo"=@{nombre="Pablo";cuenta="Pablo";contrasena="12345678"};
      "Ana"=@{nombre="Ana";cuenta="Ana";contrasena="12345678"}



      }
      $valor=0

      while ($valor -ne 5)



      {
      Write-Output "Menu de gestion de un usuario"
      Write-Output "-----------------------------------------"
      Write-Output " 1 Crear un usuario"
      Write-Output " 2 Borrar un usuario"
      Write-Output " 3 Buscar un usuario"
      Write-Output " 4 Mostar todos los usuarios"
      Write-Output " 5 Salir"
      $valor=Read-Host

      switch($valor)



      {
      1 { Write-Output " Crear usuario"
      Write-Output "-----------------------------------------"
      # $verdadero=0
      #comprobamos que el nuevo usuario no existe
      #Introducimos los datos en la tabla de usuarios
      Write-Output "Introduce el nombre del usuario: "
      $usuario=Read-Host
      Write-Output "Introduce la cuenta de usuario:"
      $cuenta=Read-Host
      Write-Output "Introduce la contraseña de usuario:"
      $contra=Read-Host
      $tabla_usuario=@{$usuario=@{nombre=$usuario;cuenta=$cuenta;contrasena=$contra}}



      }
      2 {
      Write-Output " Borrar usuario"
      Write-Output "-----------------------------------------"

      write-output "Introduce el usuario que quieres eliminar."
      $usuario= read-host
      #Write-Output $tabla_usuario[$usuario].Values

      if($tabla_usuario.ContainsKey($usuario)) {
      write-output " El usuario se ha eliminado:"
      $tabla_usuario.Remove($usuario)

      }else


      {
      Write-Output "El usuario introducido no existe"


      }

      }
      3 {
      Write-Output " Buscar usuario"
      Write-Output "-----------------------------------------"
      write-output "Introduce el usuario que quieres buscar."
      $usuario= read-host

      if($tabla_usuario.ContainsKey($usuario)) {
      write-output " El usuario buscado es:"
      Write-Output $usuario.key
      write-output $($usuario.Value["cuenta"])
      write-output $($usuario.Value["contrasena"])
      Write-Output "-----------------------------------------"

      }else


      {
      Write-Output "El usuario introducido no existe"


      }

      }
      4 {
      Write-Output " Mostar usuarios"
      Write-Output "-----------------------------------------"
      foreach($usuario in $tabla_usuario.GetEnumerator())



      {
      Write-Output $usuario.key
      write-output $($usuario.Value["cuenta"])
      write-output $($usuario.Value["contrasena"])
      Write-Output "-----------------------------------------"


      }

      }

      }

      }

       
      Write-Output " Has salido del programa."
      ------------------------------------------------------------------------------------------------------------