Cómo recopilar datos básicos para Migraciones de GNU/Linux

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

Tener una información detallada de la máquina antes de la migración debería ser una garantía de que la migración que se va a llevar a cabo sin problemas y que vamos a tener una máquina operativa en el nuevo entorno.

Lo primero que tendremos que definir la información a recopilar del sistema de origen. En este caso, 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 que en este caso, siendo un sistema GNU/Linux será la Shell del sistema.

Cómo hacer la recopilación de datos básicos para Migraciones de GNU/Linux

Pre-requisitos o pre-configuración

Para completar de forma satisfactoria este tutorial hacer la recopilación de datos básicos para Migraciones de GNU/Linux, 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 GNU/Linux

Para la recopilación de la información podemos usar distintas opciones, pero en este caso se va a proponer un script sencillo que se podrá ejecutar de la manera que se expone un poco más abajo.

El script propuesto es el siguiente:

#!/bin/bash
Fecha=$(date +"%Y-%m-%d")
Hora=$(date +"%H:%M:%S")
ServerName=$(hostname)
CPUCores=$( lscpu | grep '^CPU(s):' | awk '{print $2}')
RAM=$( lshw -C memory | awk '/size:/ {sum+=$2} END {print sum, "GB"}')
DiskInfo=$(lsblk -dn -o NAME,SIZE)
NetworkInfo=$(ip -4 addr show | awk '/inet / {split($2, ip, "/"); print $NF, ip[1], ip[2]}')
echo "########################################################"
echo "####   Breve Recopilación de Datos del Servidor   ####"
echo "########################################################"
echo ""
echo "Informacion extraida el dia $Fecha a las $Hora horas"
echo ""
echo "Nombre del Servidor:"
echo "--------------------"
echo "$ServerName"
echo ""
echo "Direcciones IP y Mascaras de Red:"
echo "---------------------------------"
echo "$NetworkInfo"
echo ""
echo "Numero de Cores:"
echo "----------------"
echo "$CPUCores"
echo ""
echo "Volumen de la Memoria RAM:"
echo "--------------------------"
echo "${RAM}GB"
echo ""
echo "Numero y Volumen de Discos:"
echo "---------------------------"
echo "$DiskInfo"
echo ""

NOTA: En el siguiente apartado se ve cómo se puede crear y ejecutar el script. Si además quieres aprender qué hace cada cosa para reutilizarlo o adaptarlo a tus necesidades puedes acceder a la tercera sección de este tutorial.

Cómo podemos ejecutar el script:

Para poder ejecutar el script, se deberá crear un archivo con extensión “.sh” que es la usada para los scripts de la Shell en GNU/Linux.

Para crear el fichero en el que introduciremos el código tenemos varias opciones:

Crear el fichero con el comand “touch”.
Crear el fichero con un editor de texto como Vi, eMacs, Nano, etc.

En este caso vamos a crearlo con el comando “touch”, que es un comando que se puede usar para múltiples cosas, como por ejemplo actualizar la fecha y hora de acceso a un fichero, o, como es el caso, para crear un nuevo fichero.

El modo de uso es muy sencillo:

# touch <Nombre_Fichero.extension>

En este caso, dado que queremos llamar al fichero “DatosServidor.sh” ejecutaremos el siguiente comando:

# touch DatosServidor.sh

Tras esto ya se puede comprobar que existe el fichero haciendo un listado del mismo:

# ls -lah DatosServidor.sh

Tras esto se le deben dar permisos de ejecución al script, de lo contrario no se podrá lanzar ni ejecutar. Para ello se debe usar el comando “chmod” que se usa para cambiar permisos de accesos a ficheros. En este caso se quiere permitir la ejecución, que es el permiso “x” por lo que se añadirá un “+x” y como nos da igual quien lo ejecute lo permitiremos a todo el mundo por lo que se deberá escribir:

# chmod +x DatosServidor.sh

Y hecho esto, se puede hacer la edición de este. Para ello se debe seleccionar el editor a usar, que dependerá de los gustos de cada cual, y que en este caso se usará “Vi” más que nada por preferencia del escritor por su potencia y simplicidad.

Para ello se deberá lanzar el comando de llamada al editor seguido por el nombre de fichero:

# vi DatosServidor.sh

Hecho esto, se deberá pulsar la tecla “i” para entrar en modo inserción, copiar y pegar el script que se facilita más arriba y para salvar los cambios se deberá hacer clic en “ESC” (Escape) y tras ello escribir “:wq” (sin las comillas “”) que ejecutará un guardar (write) y salir (quit).

En este momento ya se podrá ejecutar el script, para ello se debe escribir el nombre del dichero que contiene el script precedido de un “./” que indica que se ejecute el fichero:

 # ./DatosServidor.sh

Una buena practica es enviar la salida de la ejecución a un fichero para guardar los datos recopilados. Para ello se deberá hacer lo siguiente:

# ./ DatosServidor.sh >> DatosServidor.txt

Ejecución del script de recogida de información en GNU/Linux

Breve explicación del script:

A continuación, vamos a tomar el script y vamos a comentar cada una de sus partes para entender su funcionamiento y poder hacer los cambios que deseemos para que se adapte mejor a nuestras necesidades.

El script comienza con una línea en la que se está declarando que se va a ejecutar un script usando la línea de comandos, es lo que se llama comúnmente “shebang”.

#!/bin/bash

Donde:

#! : Es el propio “shebang” que indica que se use la Shell para ejecutar.
/bin/bash: Es la Shell con la que se ejecuta, que en este caso es la BASH o Bourne Again Shell, que es la Shell por defecto de la mayoría de las distribuciones de GNU/Linux.

Lo siguiente que haremos es sacar la fecha y hora del sistema, para ello se usaran las siguientes líneas del script:

Fecha=$(date +"%Y-%m-%d")
Hora=$(date +"%H:%M:%S")

Donde:

Fecha= $(): Se usa para declarar la variable donde se guardará la salida del comando situada tras el símbolo igual. En este caso para recoger la fecha del momento de la ejecución.
Hora= $(): Se usa para declarar la variable donde se guardará la salida del comando situada tras el símbolo igual. En este caso para recoger el día del momento de la ejecución.
Date: Es el comando que permite mostrar la fecha y hora del sistema en el momento de la ejecución.
+»%Y-%m-%d»: Se recoge la información de la fecha en formato “Año-Mes-Día”.
+»%H:%M:%S»: Se recoge la información de la hora en formato “Hora:Minutos:Segundos”.

El siguiente punto es la recogida del nombre del servidor:

ServerName=$(hostname)

Donde:

ServerName=$(): Se usa para declarar la variable donde se guardará la salida del comando.
Hostname: Comando usado para consultar el nombre de máquina.

El siguiente punto es extraer el número de cores de la máquina:

CPUCores=$( lscpu | grep '^CPU(s):' | awk '{print $2}')

Donde:

CPUCores=$(): Se usa para declarar la variable donde se guardará la salida del comando.
lscpu: Sirve para mostrar el número de procesadores y núcleos del sistema.
|: Se usa para canalizar la salida de un comando al siguiente, lo que comúnmente se llama pipeline o tubería.
grep ‘^CPU(s):’ : Se usa el comando de búsqueda de cadenas en texto “grep” para buscar la línea que empiece por “CPU”.
awk ‘{print $2}’: Se usa el lenguaje de tratamiento de texto AWK para mostrar solo la segunda columna que en este caso es el número de cores.

El siguiente punto es consultar la RAM o memoria principal del sistema:

RAM=$( lshw -C memory | awk '/size:/ {sum+=$2} END {print sum, "GB"}')

Donde:

RAM=$(): Se usa para declarar la variable donde se guardará la salida del comando.
lshw -C memory: El comando “lshw” se usa para mostrar información del hardware (list hardware), tomando en este caso la memoria.
| : Se usa para canalizar la salida de un comando al siguiente, lo que comúnmente se llama pipeline o tubería.
awk ‘/size:/ {sum+=$2} END {print sum, «GB»}’: Usamos AWK para hacer la búsqueda de la cadena “size” que da los tamaños de los módulos de RAM y los suma.

El siguiente punto es sacar la información de los discos del sistema.

DiskInfo=$(lsblk -dn -o NAME,SIZE)

Donde:

DiskInfo=$(): Se usa para declarar la variable donde se guardará la salida del comando.
lsblk -dn -o NAME,SIZE: El comando “lsblk” se usa para listar los dispositivos de bloque como discos o particiones. En este caso, como se le pasa el modificador -dn solo se muestran los discos físicos de manera limpia. Además, el modificador “-o NAME,SIZE” hace que se muestren el nombre del disco y el tamaño en GB.

Finalmente, del lado de los datos del equipo, queda por sacar la información de la red que la extraemos con la siguiente línea:

NetworkInfo=$(ip -4 addr show | awk '/inet / {split($2, ip, "/"); print $NF, ip[1], ip[2]}')

Donde:

NetworkInfo=$(): Se usa para declarar la variable donde se guardará la salida del comando.
ip -4 addr show : Comando usado para mostrar las configuraciones de red IPv4.
| : Se usa para canalizar la salida de un comando al siguiente, lo que comúnmente se llama pipeline o tubería.
awk ‘/inet / {split($2, ip, «/»); print $NF, ip[1], ip[2]}’ : Usamos AWK para hacer la búsqueda de la cadena “inet” que solo cogerá los datos de IPv4, a continuación extrae la información de la columna 2 que son los datos de IP y máscara.

Por otro lado, vamos a ver como sacar información por pantalla con el comando “echo”, como hay un montón de líneas de este tipo vamos a coger una en la que mezclamos variables y texto plano.

echo "Informacion extraida el dia $Fecha a las $Hora horas"

Donde:

Echo: Es el comando usado en GNU/Linux para mostrar un texto por pantalla. En este caso, si se escribe echo “Hola mundo!” lo que se mostrará en pantalla será: Hola mundo! Si en cambio, se pone un echo “Día $Fecha” lo que se mostrará es la cadena “Día” seguida por la fecha que devuelva la variable que se ha guardado previamente durante la ejecución del comando de $Fecha tal como se ha visto más arriba.

Con esto ya tendríamos revisado el script y esperamos que haya quedado más o menos claro.

Conclusiones:

Tal como hemos visto en el tutorial, saber cómo recopilar datos básicos para Migraciones de GNU/Linux es relativamente sencillo con el script que proponemos, ya que está perfectamente ensamblado para que se pueda copiar directamente a la consola de GNU/Linux mediante la shell, 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 GNU/Linux con pequeñas variaciones sobre lo que nosotros hemos propuesto.

Esperamos que te resulte útil.

¡Gracias por leernos!