Comment effectuer une collecte de données de base pour les migrations GNU/Linux ?
Comment effectuer une collecte de données de base pour les migrations GNU/Linux ?
Écrit par
Insya Regig
Catégories
Migrations
Serveurs

Découvrez comment effectuer la collecte de données de base pour les migrations GNU/Linux afin d’assurer une migration réussie de vos serveurs vers Jotelulu.

Le fait de disposer d’informations détaillées sur les machines avant la migration devrait être une garantie que la migration se déroulera sans problème et que nous disposerons d’une machine opérationnelle dans le nouvel environnement.

La première chose à définir est l’information à collecter à partir du système source. Dans ce cas, les informations les plus importantes sont les suivantes :

  • Nom de l’appareil.
  • Adresse IP et masque.
  • Nombre de cœurs.
  • Taille de la mémoire RAM.
  • Nombre et taille des disques.

Une fois que les informations à collecter sont claires, il est nécessaire de réfléchir au meilleur outil pour les répertorier dans le système, qui dans ce cas, étant un système GNU/Linux, sera le Shell du système.

Comment effectuer une collecte de données de base pour les migrations GNU/Linux ?
Pré-requis ou pré-configuration

Pour réussir ce tutoriel de collecte de données de base pour les migrations GNU/Linux, vous aurez besoin de :

  • D’une part, vous devez être inscrit sur la plateforme Jotelulu et vous être connecté avec votre nom et votre mot de passe par le biais de la procédure de connexion.
  • Disposer d’un abonnement Serveurs.
Comment effectuer une collecte de données de base pour les migrations GNU/Linux ?

Pour la collecte des informations, nous pouvons utiliser différentes options, mais dans ce cas, nous proposerons un simple script qui peut être exécuté comme décrit ci-dessous.

Le scénario proposé est le suivant :

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

NOTE : Dans la section suivante, vous pouvez voir comment créer et exécuter le script, si vous voulez aussi savoir ce qu’il fait afin de le réutiliser ou de l’adapter à vos besoins, vous pouvez accéder à la troisième section de ce tutoriel.

Comment exécuter le script :

Pour exécuter le script, un fichier portant l’extension « .sh », utilisée pour les scripts shell sous GNU/Linux, doit être créé.

Pour créer le fichier dans lequel nous introduirons le code, nous avons plusieurs options :

  • Créer le fichier avec la commande « touch ».
  • Créer le fichier avec un éditeur de texte tel que Vi, eMacs, Nano, etc.

Dans ce cas, nous allons le créer avec la commande « touch », qui est une commande qui peut être utilisée pour plusieurs choses, comme la mise à jour de la date et de l’heure d’accès à un fichier, ou, comme dans le cas précis, la création d’un nouveau fichier.

Son utilisation est très simple :

<p># touch</p>

Dans ce cas, comme nous voulons appeler le fichier « DatosServidor.sh », nous exécuterons la commande suivante :

<p># touch DatosServidor.sh</p>

Ensuite, vous pouvez vérifier que le fichier existe en le listant :

<p># ls -lah DatosServidor.sh</p>

Ensuite, il faut donner au script les permissions d’exécution, sinon il ne pourra pas être lancé ou exécuté. Pour ce faire, il faut utiliser la commande « chmod », qui permet de modifier les autorisations d’accès aux fichiers. Dans ce cas, nous voulons autoriser l’exécution, ce qui correspond à la permission « x », nous ajouterons donc un « +x » et comme nous ne nous soucions pas de savoir qui l’exécute, nous l’autoriserons à tout le monde, il faut donc l’écrire :

<p># chmod +x DatosServidor.sh</p>

Une fois que cela est fait, vous pouvez l’éditer. Pour ce faire, il faut choisir l’éditeur à utiliser, qui dépendra des goûts de chacun, et dans ce cas, on utilisera surtout « Vi » en raison de la préférence de l’auteur pour sa puissance et sa simplicité.

Pour ce faire, la commande call de l’éditeur suivie du nom du fichier doit être émise :

<p># vi DatosServidor.sh</p>

Une fois cela fait, appuyez sur la touche « i “ pour entrer en mode insertion, copiez et collez le script fourni ci-dessus et pour sauvegarder les changements, cliquez sur ” ESC “ (Escape) et tapez ensuite ” :wq “ (sans les guillemets ” »), ce qui exécutera une opération d’écriture et quittera l’application.

A ce stade, le script peut être exécuté, en tapant le nom du répertoire contenant le script précédé d’un « ./ » qui indique que le fichier doit être exécuté :

<p># ./DatosServidor.sh</p>

Une bonne pratique consiste à envoyer la sortie de l’exécution dans un fichier afin de sauvegarder les données collectées. Il convient de procéder comme suit :

<p># ./ DatosServidor.sh >> DatosServidor.txt</p>
Ejecución del script de recogida de información en GNULinux

Exécution du script de collecte d’informations sous GNULinux

Brève explication du script :

Ensuite, nous allons prendre le script et examiner chacune de ses parties afin de comprendre comment il fonctionne et d’être en mesure d’apporter les modifications que nous souhaitons pour mieux répondre à nos besoins.

Le script commence par une ligne où vous déclarez que vous allez exécuter un script en utilisant la ligne de commande, c’est ce qu’on appelle communément un « shebang ».

<p>#!/bin/bash</p>

Où :

  • #! : est le « shebang » lui-même, qui indique d’utiliser le shell pour s’exécuter.
  • /bin/bash: Le shell à utiliser, qui dans ce cas est le BASH ou Bourne Again Shell, qui est le shell par défaut de la plupart des distributions GNU/Linux.

La prochaine chose à faire est d’obtenir la date et l’heure du système, en utilisant les lignes suivantes du script :

<p>Fecha=$(date +”%Y-%m-%d”)<br />
Hora=$(date +”%H:%M:%S”)</p>

Où :

  • Fecha= $(): Utilisé pour déclarer la variable dans laquelle la sortie de la commande sera stockée après le symbole égal. Dans ce cas, il s’agit de recueillir la date au moment de l’exécution.
  • Hora= $(): Utilisé pour déclarer la variable dans laquelle la sortie de la commande située après le symbole égal sera stockée. Dans ce cas, il s’agit de collecter le jour de l’heure d’exécution.
  • Date: Cette commande permet d’afficher la date et l’heure du système au moment de l’exécution.
  • +”%Y-%m-%d”: Les informations relatives à la date sont collectées au format “Année-Mois-Jour”.
  • +”%H:%M:%S”: Les informations relatives à l’heure sont collectées au format “Heure:Minutes:Secondes”.

L’étape suivante est la collecte du nom du serveur :

<p>ServerName=$(hostname)</p>

Où :

  • ServerName=$(): Permet de déclarer la variable dans laquelle la sortie de la commande sera stockée.
  • Hostname: commande utilisée pour demander le nom d’hôte.

L’étape suivante consiste à extraire le nombre de cœurs de processeurs de la machine :

<p>CPUCores=$( lscpu | grep ‘^CPU(s):’ | awk ‘{print $2}’)</p>

Où :

  • CPUCores=$(): Permet de déclarer la variable dans laquelle la sortie de la commande sera stockée.
  • lscpu: Permet d’afficher le nombre de processeurs et de cœurs dans le système.
  • |: Il est utilisé pour acheminer les données d’une commande à l’autre, ce que l’on appelle communément un pipeline.
  • grep ‘^CPU(s):’ : La commande de recherche de chaîne de texte « grep » est utilisée pour rechercher la ligne commençant par « CPU ».
  • awk ‘{print $2}’: Le langage de traitement de texte AWK est utilisé pour n’afficher que la deuxième colonne, qui dans ce cas est le nombre de cœurs.

Le point suivant consiste à consulter la RAM ou mémoire principale du système :

<p>RAM=$( lshw -C memory | awk ‘/size:/ {sum+=$2} END {print sum, “GB”}’)</p>

Où :

  • RAM=$(): Permet de déclarer la variable dans laquelle la sortie de la commande sera stockée.
  • lshw -C memory: La commande « lshw » permet d’afficher des informations sur le matériel (list hardware), en l’occurrence sur la mémoire.
  • | : Il est utilisé pour acheminer les données d’une commande à l’autre, ce que l’on appelle communément un pipeline.
  • awk ‘/size:/ {sum+=$2} END {print sum, “GB”}’: Nous utilisons AWK pour effectuer la recherche de la chaîne « size » qui donne les tailles des modules de RAM et les additionne.

L’étape suivante consiste à supprimer les informations des disques du système.

<p>DiskInfo=$(lsblk -dn -o NAME,SIZE)</p>

Où :

  • DiskInfo=$(): Permet de déclarer la variable dans laquelle la sortie de la commande sera stockée.
  • lsblk -dn -o NAME,SIZE: La commande « lsblk » est utilisée pour dresser la liste des périphériques en mode bloc, tels que les disques ou les partitions. Dans ce cas, étant donné que l’option -dn lui a été attribuée, seuls les disques physiques sont affichés proprement. En outre, le commutateur « -o NAME,SIZE » permet d’afficher le nom et la taille du disque en Go.

Enfin, du côté des données des équipements, il reste à extraire les informations sur le réseau, que nous extrayons avec la ligne suivante :

<p>NetworkInfo=$(ip -4 addr show | awk ‘/inet / {split($2, ip, “/”); print $NF, ip[1], ip[2]}’)</p>

Où :

  • NetworkInfo=$(): Permet de déclarer la variable dans laquelle la sortie de la commande sera stockée.
  • ip -4 addr show : Commande utilisée pour afficher les configurations du réseau IPv4.
  • | : Il est utilisé pour acheminer les données d’une commande à l’autre, ce que l’on appelle communément un pipeline.
  • awk ‘/inet / {split($2, ip, “/”); print $NF, ip[1], ip[2]}’ : Nous utilisons AWK pour effectuer la recherche de la chaîne « inet » qui ne prendra que les données IPv4, puis nous extrayons les informations de la colonne 2 qui sont les données IP et le masque.

D’autre part, nous allons voir comment obtenir des informations à l’écran avec la commande « echo », comme il y a beaucoup de lignes de ce type, nous allons en prendre une dans laquelle nous mélangeons des variables et du texte brut.

<p>echo “Informacion extraida el dia $Fecha a las $Hora horas”</p>

Où :

  • Echo: C’est la commande utilisée dans GNU/Linux pour afficher du texte à l’écran. Dans ce cas, si vous tapez echo « Hello world ! », ce qui s’affichera à l’écran sera : Bonjour tout le monde ! Si, au contraire, vous tapez echo « Jour $Date », ce qui s’affichera est la chaîne « Jour » suivie de la date renvoyée par la variable qui a été préalablement sauvegardée lors de l’exécution de la commande $Date comme on l’a vu plus haut.

Nous avons donc revu le scénario et espérons qu’il est plus ou moins clair.

Conclusion :

Comme nous l’avons vu dans le tutoriel, savoir faire la collecte de données de base pour les migrations GNU/Linux est relativement simple avec le script que nous proposons, car il est parfaitement assemblé pour pouvoir être copié directement dans la console GNU/Linux à travers le shell, bien que nous recommandions toujours de le lancer à partir d’un fichier script généré pour cette opération.

Par ailleurs, différentes requêtes peuvent être effectuées pour la configuration de base des appareils sur les systèmes GNU/Linux, avec de légères variations par rapport à ce que nous avons proposé.

En espérant que cela vous sera utile.

Merci !