Découvrez comment procéder à la collecte des données de base pour les migrations Windows afin de garantir une migration réussie de vos serveurs vers Jotelulu.
Le fait de disposer d’informations détaillées et fiables sur la machine, les programmes et les services est une garantie que la migration à effectuer se déroulera sans problème et que nous disposerons d’une machine opérationnelle immédiatement dans notre nouvel environnement, c’est pourquoi nous devons décrire une stratégie de migration qui comprend la capture des informations pertinentes pour la migration.
La première chose à définir est l’information à collecter auprès du système. Dans le cas présent, pour la migration, on a estimé que les informations les plus importantes étaient les suivantes :
- Nom de l’équipe.
- 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 faut envisager le meilleur outil pour les répertorier sur le système. Dans ce cas, étant donné qu’il s’agit d’un serveur Microsoft Windows, la meilleure option est sans aucun doute l’utilisation de PowerShell, qui est un système natif, de sorte que nous ne dépendrons pas d’add-ons ou de programmes d’installation, comme nous pourrions le faire si nous voulions utiliser Perl ou Python.
Pour réussir ce tutoriel sur la collecte de données de base pour les migrations Windows, vous aurez besoin de :
- D’une part, vous devez être inscrit sur la plateforme Jotelulu et vous être connecté avec votre identifiant et votre mot de passe par le biais de la procédure de connexion.
- Disposer d’un abonnement Serveurs.
Nous allons vous présenter un script permettant d’obtenir les informations nécessaires pour la migration, bien que, comme nous le disons toujours, il n’existe pas une seule façon d’obtenir ces données. En effet, rien que pour récupérer les informations du processeur en PowerShell, il existe au moins quatre méthodes différentes.
Le script proposé est le suivant :
<p>$Fecha = Get-Date -Format “yyyy-MM-dd”<br /> $Hora = Get-Date -Format “HH:mm:ss”<br /> $ServerName = $env:COMPUTERNAME<br /> $NetworkInfo = Get-NetIPAddress -AddressFamily IPv4 | Select-Object IPAddress, PrefixLength<br /> $CPUCores = (Get-ComputerInfo).CsNumberOfLogicalProcessors<br /> $RAM = [math]::Round((Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB)<br /> $DiskInfo = Get-Disk | Select-Object Number, @{Name=”Size (GB)”; Expression={ [math]::Round($_.Size / 1GB, 2) }}<br /> Write-Host “########################################################”<br /> Write-Host “#### Breve Recopilacion de Datos del Servidor ####”<br /> Write-Host “########################################################”<br /> Write-Host “Informacion extraida el dia $Fecha a las $Hora horas”<br /> Write-Host “Nombre de Equipo: $ServerName”<br /> Write-Host “A continuacion se listan las Direcciones IP y las Mascara de Red:”<br /> $NetworkInfo | Format-Table -AutoSize<br /> Write-Host “Numero de Cores: $CPUCores”<br /> Write-Host “Volumen de Memoria RAM: $RAM”<br /> Write-Host “Numero y Volumen de Discos es el siguiente:”<br /> $DiskInfo | Format-Table -AutoSize</p>
Pour l’exécuter, il est recommandé de créer un fichier avec l’extension “.ps1” et d’y copier le contenu du script. Il est important d’être attentif lors du copier/coller, car certains caractères peuvent être tronqués ou modifiés, ce qui pourrait provoquer des erreurs d’exécution. Nous conseillons donc de bien vérifier ce point pour éviter des problèmes qui peuvent être frustrants (et oui, je parle d’expérience).

Exemple d’exécution du script de collecte de données pour la migration sous Windows
Nous allons maintenant voir une brève explication de chacune des parties.
La première chose à faire est d’utiliser des variables. Au début du script, nous voyons une série de lignes commençant par un symbole dollar ($), suivi d’un mot, d’un signe égal (=) et d’une série de commandes derrière.
La partie avant le signe égal, comme par exemple “$Date”, est une variable qui stocke le résultat de ce qui suit après le signe égal (=), qui peut être une commande ou un ensemble de commandes.
Cela permet de travailler avec les résultats par la suite, afin d’afficher les exécutions de manière ordonnée.
Maintenant que nous avons compris cela, passons à l’explication de chaque ligne.
La première commande extrait la date d’exécution du script, ce qui peut être très utile pour conserver un historique et savoir si l’on utilise la dernière version :
<p>$Fecha = Get-Date -Format “yyyy-MM-dd”</p>
Où :
- $Fecha: Nom de la variable qui stockera temporairement l’exécution de la commande.
- Get-Date: Permet d’extraire la date et l’heure du système au moment de l’exécution.
- -Format “yyyy-MM-dd”: Permet de formater la sortie pour n’afficher que la date sous la forme Année (4 chiffres) + Mois (2 chiffres) + Jour (2 chiffres).
Nous exécutons ensuite une commande très similaire pour récupérer uniquement l’heure :
<p>$Hora = Get-Date -Format “HH:mm:ss”</p>
Où :
- $Hora: Variable stockant l’heure de l’exécution.
- Get-Date: Extrait la date et l’heure du système.
- -Format “HH:mm:ss”: Affiche uniquement l’heure au format Heure (2 chiffres) + Minutes (2 chiffres) + Secondes (2 chiffres).
Le point suivant consiste à récupérer le nom de la machine :
<p>$ServerName = $env:COMPUTERNAME</p>
Où :
- $ServerName: Stocke temporairement le nom de l’ordinateur.
- $env:COMPUTERNAME: Récupère le nom de la machine à partir des variables d’environnement.
Un autre point important est l’information des interfaces réseau. Il est important de connaître les adresses IP dont dispose la machine, après avoir précisé le nombre d’interfaces, les adresses IP et les masques réseau associés, nous les obtiendrons avec la commande suivante :
<p>$NetworkInfo = Get-NetIPAddress -AddressFamily IPv4 | Select-Object IPAddress, PrefixLength</p>
Où :
- $NetworkInfo: Stocke temporairement les informations réseau.
- Get-NetIPAddress: Récupère les informations des interfaces réseau.
- -AddressFamily IPv4: Utilisé pour filtrer et afficher les informations provenant uniquement des dispositifs INET IPv4.
- | : Sert à rediriger la sortie de la commande vers une autre commande (pipeline).
- Select-Object IPAddress, PrefixLength: Sélectionne uniquement l’adresse IP et le masque de sous-réseau.
Pour connaître la taille de la machine avant la migration et le nombre de cœurs (cores) de la machine, la commande suivante peut être utilisée :
<p>$CPUCores = (Get-ComputerInfo).CsNumberOfLogicalProcessors</p>
Où :
- $CPUCores: Stocke le nombre de cœurs logiques du processeur.
- (Get-ComputerInfo).CsNumberOfLogicalProcessors: Récupère cette information à partir des détails du système.
Une autre valeur qui nous aide à avoir une idée claire de la taille de la machine avant la migration est la mémoire physique (RAM) de l’équipement, que nous pouvons obtenir avec la commande suivante :
<p>$RAM = [math]::Round((Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB)</p>
NOTE : Cette commande est de loin la plus compliquée de tout ce script car, entre autres, elle fait appel à des fonctions mathématiques pour les arrondis, etc. Malgré tout, il est beaucoup plus simple de la lire que de l’écrire et je suis sûr qu’une brève explication vous permettra de comprendre son fonctionnement.
Où :
- $RAM: Il s’agit du nom de la variable dans laquelle nous stockerons temporairement l’exécution de la commande.
- [math]::Round(): Applique un arrondi au résultat.
- (Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory / 1GB): Utilise l’outil CIM (Common Information Model) pour récupérer la mémoire physique (RAM) et la convertit en gigaoctets (GB) pour une lecture plus facile.
Enfin, les informations relatives aux disques durs disponibles dans l’ordinateur doivent être collectées à l’aide de la ligne de commande suivante :
<p>$DiskInfo = Get-Disk | Select-Object Number, @{Name=”Size (GB)”; Expression={ [math]::Round($_.Size / 1GB, 2) }}</p>
Où :
- $DiskInfo: Stocke les informations des disques durs.
- Get-Disk: Récupère les détails des disques.
- |: Redirige la sortie vers une autre commande (pipeline).
- Select-Object: Sélectionne les attributs à afficher.
- Number: Affiche les identifiants des disques.
- @{Name=”Size (GB)”; Expression={ [math]::Round($_.Size / 1GB, 2) }}: Formate la taille des disques en gigaoctets avec deux décimales.
Maintenant que nous avons terminé la partie extraction des données, nous passons à la partie représentation des données.
Pour afficher les résultats, nous utilisons la commande Write-Host. Elle permet d’afficher des messages et le contenu des variables à l’écran.
Si, par exemple, vous écrivez « Hello » à Write-Host, il affichera « Hello » à l’écran, c’est-à-dire qu’il s’agit de l’équivalent PowerShell de « echo » de CMD ou de Bash dans GNU/Linux.
De même, à certains moments, des commandes sont exécutées directement, comme par exemple :
<p>Write-Host “Numero de Cores: $CPUCores”</p>
Où :
- On exécute l’une de ces commandes “echo” qui affichent un message à l’écran, suivi d’un appel à une variable. Dans ces cas-là, ce qui sera affiché est le contenu de la variable précédemment enregistrée.
- Prenons l’exemple de “CPUCores”. Dans cet environnement, si nous exécutons la commande “(Get-ComputerInfo).CsNumberOfLogicalProcessors”, la sortie affichera “2”, car c’est le nombre de cœurs du processeur de la machine utilisée dans ce cas. Toutefois, dans le script, nous avons redirigé cette valeur vers une variable “$CPUCores” avec la ligne suivante : “$CPUCores = (Get-ComputerInfo).CsNumberOfLogicalProcessors”. Cela signifie que la valeur ne s’affichera pas immédiatement, mais qu’elle sera visible lorsqu’on appellera cette variable. Comme vous l’aurez deviné, l’appel se fera ainsi :
- Write-Host “Numero de Cores: $CPUCores” ce qui affichera alors sur l’écran le message “Nombre de Cœurs : 2”.
Enfin, prenons un autre exemple avec la ligne suivante, qui affiche les informations de la configuration réseau :
<p>$NetworkInfo | Format-Table -AutoSize</p>
Où :
- $NetworkInfo: C’est la variable qui contient les informations réseau, que nous consultons à ce moment précis.
- | : Ce symbole est utilisé pour rediriger la sortie d’une commande vers une autre, un processus appelé “pipeline”.
- Format-Table -AutoSize: Cette commande formate l’affichage de la sortie sous forme de tableau.
Avec cela, nous avons parcouru l’ensemble du script, en espérant que cette explication ait été plus ou moins clair.
Comme nous l’avons vu dans ce tutoriel, la collecte des données de base pour les migrations Windows est relativement simple grâce au script proposé. Celui-ci est conçu pour être copié directement dans la console PowerShell, bien que nous recommandions toujours de l’exécuter à partir d’un fichier script dédié à cette opération.
De plus, il est possible d’effectuer diverses requêtes sur la configuration de base des appareils sous Windows en adaptant légèrement notre proposition.
Nous espérons que cela vous sera utile.
Merci de nous avoir lus !