Cómo hacer la recopilación de datos básicos para Migraciones de Windows
Cómo hacer la recopilación de datos básicos para Migraciones de Windows
Escrito por
Juan Ignacio Oller Aznar
Categorías
Migraciones
Servidores

Continúa leyendo si quieres saber cómo hacer la recopilación de datos básicos para Migraciones de Windows y así tener garantizado el éxito en la migración de tus servidores a Jotelulu.

Tener una información detallada y fidedigna de la máquina, los programas y servicios, es una garantía de que la migración que se va a llevar a cabo va a transcurrir sin sobresaltos y que vamos a tener una máquina operativa desde el primer momento en nuestro nuevo entorno, por eso, debemos describir una estrategia de migración que incluya la captación de la información pertinente para la migración.

Lo primero que se tendrá que definir es la información que se quiere recolectar del sistema. En este caso, para la migración, se ha pensado que la información más importante debe ser la siguiente:

  • Nombre de equipo.
  • Dirección IP y máscara.
  • Numero de cores.
  • Tamaño de memoria RAM.
  • Número y tamaño de discos.

Teniendo clara la información que se quiere recolectar, se deberá pensar en la mejor herramienta para listarla del sistema. En este caso, dado que se trata de un servidor Microsoft Windows, la mejor opción es sin duda el uso de PowerShell que es un sistema nativo, por lo que no dependeremos ni de añadidos ni de instalables como podría darse en el caso de querer usar Perl o Python.

Cómo hacer la recopilación de datos básicos para Migraciones de Windows
Pre-requisitos o pre-configuración

Para completar de forma satisfactoria este tutorial hacer la recopilación de datos básicos para Migraciones de Windows, necesitarás:

  • Por un lado, estar dado de alta en la Plataforma Jotelulu y haber accedido a la misma con tu nombre y contraseña a través del proceso de Log-in
  • Tener una suscripción de Servidores.
Cómo hacer la recopilación de datos básicos para Migraciones de Windows

A continuación, vamos a presentar el script que proponemos para la obtención de la información deseada, aunque, tal como decimos siempre, no hay un único modo de obtener esta información; de hecho, solo para la obtención de la información de la CPU en PowerShell podemos usar al menos cuatro formas distintas.

El script propuesto es:

$Fecha = Get-Date -Format "yyyy-MM-dd"
$Hora = Get-Date -Format "HH:mm:ss"
$ServerName = $env:COMPUTERNAME
$NetworkInfo = Get-NetIPAddress -AddressFamily IPv4 | Select-Object IPAddress, PrefixLength
$CPUCores = (Get-ComputerInfo).CsNumberOfLogicalProcessors
$RAM = [math]::Round((Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB)
$DiskInfo = Get-Disk | Select-Object Number, @{Name="Size (GB)"; Expression={ [math]::Round($_.Size / 1GB, 2) }}
Write-Host "########################################################"
Write-Host "####	Breve Recopilacion de Datos del Servidor	####"
Write-Host "########################################################"
Write-Host "Informacion extraida el dia $Fecha a las $Hora horas"
Write-Host "Nombre de Equipo: $ServerName" 
Write-Host "A continuacion se listan las Direcciones IP y las Mascara de Red:"
$NetworkInfo | Format-Table -AutoSize
Write-Host "Numero de Cores: $CPUCores"
Write-Host "Volumen de Memoria RAM: $RAM"
Write-Host "Numero y Volumen de Discos es el siguiente:"
$DiskInfo | Format-Table -AutoSize

Para ejecutarlo, lo recomendable es crear un fichero con extensión “.ps1” y copiar el contenido de script propuesto. Es importante estar atentos cuando se haga el copy/paste porque es posible que algún caracter quede truncado o cambiado, lo cual puede producir problemas de ejecución. La recomendación es mirar bien este punto para evitar problemas en tiempo de ejecución que pueden volvernos locos, y sí, por desgracia lo digo por experiencia.

Ejemplo de ejecución del script de recopilación de datos para la migración en Windows

Ejemplo de ejecución del script de recopilación de datos para la migración en Windows

A continuación, vamos a ver una breve explicación de cada una de las partes.

Lo primero con lo que debemos comenzar es el uso de variables; al principio del script podemos ver que hay una serie de líneas que empiezan con un símbolo de dólar ($) seguido por una palabra, un signo igual (=) y una serie de palabras detrás.

Bien, la cadena inicial de antes del igual, como por ejemplo “$Fecha” es una variable, esta se usa para almacenar el resultado de lo que hay tras el igual (=), que será un comando o conjunto de comandos.

Esto se hace para poder trabajar posteriormente con la salida de alguna manera, que en este caso es para poder presentar las ejecuciones de los comandos de manera ordenada.

Sabiendo esto, vamos a pasar a explicar cada una de las líneas una por una.

Lo primero que ejecutaremos será un comando para la extracción de la fecha en que se ejecuta el script, que puede ser muy útil para guardar un histórico y saber si es la última versión:

$Fecha = Get-Date -Format "yyyy-MM-dd"

Donde:

  • $Fecha: Es el nombre de la variable donde almacenaremos temporalmente la ejecución del comando.
  • Get-Date: Se usa para extraer la fecha y hora del sistema en el momento de la ejecución.
  • -Format «yyyy-MM-dd»: Se usa para forzar que la salida de la fecha únicamente muestre la fecha en formato de Año (cuatro dígitos) + Mes (dos dígitos) + Día (dos dígitos).

A continuación, ejecutamos un comando muy similar al anterior en el que filtramos únicamente la hora:

$Hora = Get-Date -Format "HH:mm:ss"

Donde:

  • $Hora: Es el nombre de la variable donde almacenaremos temporalmente la ejecución del comando.
  • Get-Date: Se usa para extraer la fecha y hora del sistema en el momento de la ejecución.
  • -Format «HH:mm:ss»: Se usa para forzar que la salida de la fecha únicamente muestre la hora en un formato dado (dos dígitos) + Minutos (dos dígitos) + Segundos (dos dígitos).

El siguiente punto es recuperar el nombre de la máquina:

$ServerName = $env:COMPUTERNAME

Donde:

  • $ServerName: Es el nombre de la variable donde almacenaremos temporalmente la ejecución del comando.
  • $env:COMPUTERNAME: Lista las variables de entorno y recupera el nombre de la máquina.

Otro punto importante es el de la información de las interfaces de red. Es importante saber las direcciones IP que tiene la máquina, teniendo claro el número de interfaces, las direcciones IP y las máscaras de red asociadas, esto lo obtendremos con el siguiente comando:

$NetworkInfo = Get-NetIPAddress -AddressFamily IPv4 | Select-Object IPAddress, PrefixLength

Donde:

  • $NetworkInfo: Es el nombre de la variable donde almacenaremos temporalmente la ejecución del comando.
  • Get-NetIPAddress: Se usa para recuperar información de los dispositivos de red.
  • -AddressFamily IPv4: Se usa para filtrar y mostrar información únicamente de los dispositivos INET IPv4.
  • | : Se usa para encaminar la salida del comando hacia el segundo comando, lo que se llama una tubería o pipeline.
  • Select-Object IPAddress, PrefixLength: Se filtra la información seleccionando únicamente la dirección IP y la máscara de red.

Para tener claro el tamaño de la máquina antes de la migración, y saber el número de cores (núcleos) del equipo, se puede usar el comando siguiente:

$CPUCores = (Get-ComputerInfo).CsNumberOfLogicalProcessors

Donde:

  • $CPUCores: Es el nombre de la variable donde almacenaremos temporalmente la ejecución del comando.
  • (Get-ComputerInfo).CsNumberOfLogicalProcessors: Se usa para recuperar la información del equipo, y de toda ella únicamente filtrar el número de procesadores lógicos.

Otro valor que nos ayuda a tener claro el tamaño de la máquina antes de la migración es el referente a la memoria física (RAM) del equipo que podremos obtener con el siguiente comando:

$RAM = [math]::Round((Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB)

NOTA: Este comando es con diferencia el más complicado de todo este script porque entre otras cosas hace uso de funciones matemáticas para el redondeo y demás. Aun así, leerlo es mucho más simple que escribirlo y seguro que con una breve explicación se entiende su funcionamiento.

Donde:

  • $RAM: Es el nombre de la variable donde almacenaremos temporalmente la ejecución del comando.
  • [math]::Round(): Se usa para cargar la aplicación matemática de redondeo al resultado del comando contenido dentro del paréntesis ().
  • (Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB): En este caso, se hace uso de Common Information Model (CIM), que es un servicio Instrumental de administración de Windows (WMI) que permite hacer consultas de hardware para obtener la memoria física (RAM) y el resultado lo divide por 1GB para obtener los datos en GB de manera que sea mas cómodo de leer.

Por último, se tiene que recoger la información de los discos duros disponibles en el equipo para ello se usa el siguiente one-line:

$DiskInfo = Get-Disk | Select-Object Number, @{Name="Size (GB)"; Expression={ [math]::Round($_.Size / 1GB, 2) }}

Donde:

  • $DiskInfo: Es el nombre de la variable donde almacenaremos temporalmente la ejecución del comando.
  • Get-Disk: Permite recopilar información de los discos del sistema.
  • |: Se usa para encaminar la salida del comando hacia el segundo comando, lo que se llama una tubería o pipeline.
  • Select-Object: Permite elegir los atributos a mostrar.
  • Number: Mostrará los identificadores de disco.
  • @{Name=»Size (GB)»; Expression={ [math]::Round($_.Size / 1GB, 2) }}: Es

Ahora ya se ha terminado con la parte de la extracción de datos, y pasamos a la parte de representación de estos.

En este lado se tienen varios puntos a mirar, por un lado, cuando se tiene el comando “Write-Host”, este se usa para escribir por pantalla la salida del comando.

Si, por ejemplo, se hace Write-Host «Hola», se mostrará «Hola» por pantalla, o sea, es el equivalente de PowerShell al “echo” de CMD o Bash en GNU/Linux.

De la misma manera, en algunos puntos se ejecutan directamente comandos como:

Write-Host "Numero de Cores: $CPUCores"

Donde:

  • Se hace una ejecución de uno de esos “ecos” que muestran por pantalla un mensaje y después llevan también una llamada a una variable. En esos casos, lo que se mostrará es el contenido de la variable que se ha guardado antes.
  • Veamos el ejemplo de “CPUCores”, en este entorno, si ejecutamos el comando “(Get-ComputerInfo).CsNumberOfLogicalProcessors” lo que sucederá es que se mostrará un “2” ya que es el número de cores que tiene la máquina que estamos usando en este caso. Lo que sucede es que en el script lo hemos redirigido a una variable “$CPUCores” mediante la siguiente linea “$CPUCores = (Get-ComputerInfo).CsNumberOfLogicalProcessors”, esto hará que de entrada no se muestre el valor, pero si que se muestre cuando se haga la llamada a esa variable, que tal como habrá supuesto el lector, será llamada de la siguiente manera:
  • Write-Host «Numero de Cores: $CPUCores” por lo que, ahora sí, se obtendrá por pantalla el mensaje “Numero de Cores: 2”.

Por último, tenemos otro ejemplo, el de la siguiente línea en la que se da la información de la configuración de red:

$NetworkInfo | Format-Table -AutoSize

Donde:

  • $NetworkInfo: Es la variable que contiene la información de red, cuyo contenido consultamos en este momento.
  • | : Se usa para encaminar la salida del comando hacia el segundo comando, lo que se llama una tubería o pipeline.
  • Format-Table -AutoSize: Con este comando le damos formato a la salida del comando dándole formato de tabla.

Y con esto hemos hecho un repaso general al contenido del script que esperamos que haya sido esclarecedor, al menos en parte.

Conclusiones:

Tal como hemos visto en el tutorial saber cómo hacer la recopilación de datos básicos para Migraciones de Windows es relativamente sencillo con el script que proponemos, ya que está perfectamente ensamblado para que se pueda copiar directamente a la consola de PowerShell, aunque siempre recomendamos lanzarlo desde un fichero de script generado de propio para esta operativa.

Al margen, se pueden hacer distintas consultas de la configuración básica de los dispositivos en sistemas Windows con pequeñas variaciones sobre lo que nosotros hemos propuesto.

Esperamos que te resulte útil.

¡Gracias por leernos!