Administrateurs : demandez à ChatGPT d’écrire votre code PowerShell

Quels sont les avantages de l’IA générative dans l’écriture de scripts PowerShell ?

L’un des avantages d’un modèle d’IA en langage naturel, tel que ChatGPT, est que vous n’avez qu’à demander à l’IA quel code vous souhaitez qu’elle écrive pour qu’elle vous présente un code particulièrement fonctionnel. C’est bien plus efficace que faire des recherches sur Google et rassembler soi-même les bouts de code trouvés de-ci, de-là. Vos interactions avec ChatGPT sont conversationnelles, de sorte que vous pouvez guider l’IA vers les informations que vous souhaitez en vous appuyant sur des réponses antérieures.

Par exemple, supposons que vous souhaitiez écrire un script pour trouver toutes les machines virtuelles d’Azure qui portent une étiquette spécifique afin de les éteindre. Avant l’IA, votre processus consistait à examiner la sortie de la commande PowerShell Get-AzVM, à y rechercher une propriété avec des balises en guise de filtres, puis à examiner la syntaxe de la cmdlet Stop-AzVM.

Vous pouvez demander à ChatGPT d’écrire le script qui va réaliser toutes ces actions en lui envoyant la requête suivante :

Écris un script qui récupère toutes les machines virtuelles d’Azure qui ont la balise 'shutdown' avec la valeur 'daily' et qui arrête ces machines virtuelles.

Nous n’avons pas ici spécifié PowerShell ni suggéré de méthode pour réaliser l’action. Voici le script qui a été généré :

# Connect to Azure
Connect-AzAccount

# Define the resource group and tag criteria
$resourceGroup = "YourResourceGroup"
$tagName = "shutdown"
$tagValue = "daily"

# Retrieve the virtual machines with the specified tag
$vms = Get-AzResource -ResourceGroupName $resourceGroup -Tag @{ $tagName = $tagValue } | Where-Object {$_.ResourceType -eq "Microsoft.Compute/virtualMachines"}

# Stop each virtual machine
foreach ($vm in $vms) {
    $vmName = $vm.Name
    Write-Host "Stopping virtual machine: $vmName"
    Stop-AzVM -ResourceGroupName $resourceGroup -Name $vmName -Force
}

ChatGPT n’a pas utilisé la cmdlet Get-AzVM, mais plutôt une cmdlet Get-AzResource, qui peut récupérer des ressources et les filtrer en spécifiant une balise. Votre serviteur ne connaissait pas cette fonctionnalité ; ChatGPT participe donc à notre formation.

Un autre point à souligner est la façon dont le script gère les groupes de ressources. Le script PowerShell généré par ChatGPT suppose que l’on souhaite indiquer en dur dans le code un groupe de ressources sur lequel on limite notre travail. Ce n’est pas nécessairement ce que nous voulons faire. D’autant que chaque valeur produite par Get-AzResource contient le nom du groupe auquel appartiennent les ressources trouvées. Vous pourriez préférer n’indiquer aucun nom de groupe vous-mêmes et demander au script de le déterminer pour chaque valeur produite par Get-AzResource.

Dès lors, demandez à ChatGPT de corriger le problème avec la requête suivante :

La sortie de 'Get-AzResource' inclut le nom du groupe de ressources, pourrais-tu l’utiliser avec 'stop-azvm' au lieu de coder en dur le nom du groupe de ressources ?

ChatGPT répond avec cette nouvelle version du script :

# Connect to Azure
Connect-AzAccount

# Define the tag criteria
$tagName = "shutdown"
$tagValue = "daily"

# Retrieve the virtual machines with the specified tag
$vms = Get-AzResource -Tag @{ $tagName = $tagValue } | Where-Object {$_.ResourceType -eq "Microsoft.Compute/virtualMachines"}

# Stop each virtual machine
foreach ($vm in $vms) {
    $vmName = $vm.Name
    $resourceGroup = $vm.ResourceGroupName
    Write-Host "Stopping virtual machine: $vmName"
    Stop-AzVM -ResourceGroupName $resourceGroup -Name $vmName -Force
}

Ce script correspond à la tâche attendue. Cependant, il est important de toujours examiner attentivement le code. Le pire qui aurait pu arriver dans notre cas aurait été que le script génère une erreur en essayant d’arrêter une VM avec le mauvais groupe de ressources.

Comment utiliser ChatGPT pour améliorer du code PowerShell ?

Un autre avantage de l’utilisation de ChatGPT avec PowerShell est de dépanner ou d’améliorer un code existant. Par exemple, disons que vous avez le script suivant qui doit récupérer toutes les connexions TCP ouvertes et les lier à un processus en cours :

Get-NetTCPConnection | foreach-Object {
    [pscustomobject]@{
        LocalAddress = $_.LocalAddress
        LocalPort = $_.LocalPort
        RemoteAddress = $_.RemoteAddress
        RemotePort = $_.RemotePort
        State = $_.State
        OwningProcess = $_.OwningProcess
        CreationTime = $_.CreationTime
        PID = $_.OwningProcess
        Process = (Get-Process -Id $_.OwningProcess).Name
        UserName = (Get-Process -IncludeUserName -Id $_.OwningProcess).UserName
        Path = (Get-Process -Id $_.OwningProcess).Path
        SHA1 = try{(Get-FileHash (Get-Process -Id $_.OwningProcess).Path -Algorithm SHA1 | select-object -ExpandProperty Hash)}catch{};
        CommandLine = (Get-Process -Id $_.OwningProcess).CommandLine
    }
}

Ce script s’exécute en deux minutes environ sur notre ordinateur de test. Vous pouvez demander à ChatGPT d’optimiser le code PowerShell pour voir s’il trouve comment l’exécuter plus rapidement :

Pouvez-vous optimiser ce script PowerShell pour moi ?

<coller le code ici>

ChatGPT répond avec le script PowerShell suivant :

$tcpConnections = Get-NetTCPConnection
$connectionInfo = foreach ($connection in $tcpConnections) {
    $process = Get-Process -Id $connection.OwningProcess -ErrorAction SilentlyContinue
    [pscustomobject]@{
        LocalAddress   = $connection.LocalAddress
        LocalPort      = $connection.LocalPort
        RemoteAddress  = $connection.RemoteAddress
        RemotePort     = $connection.RemotePort
        State          = $connection.State
        OwningProcess  = $connection.OwningProcess
        CreationTime   = $connection.CreationTime
        PID            = $connection.OwningProcess
        Process        = if ($process) { $process.Name } else { $null }
        UserName       = if ($process) { $process.UserName } else { $null }
        Path           = if ($process) { $process.Path } else { $null }
        SHA1           = try { (Get-FileHash $process.Path -Algorithm SHA1).Hash } catch { $null }
        CommandLine    = if ($process) { $process.CommandLine } else { $null }
    }
}
$connectionInfo

Mais, à l’exécution, ce code génère une erreur :

C’est regrettable, car ChatGPT n’est pas ici en mesure de nous aider. Nous collons donc l’erreur mot pour mot et demandons à ChatGPT de faire la correction. Mais il s’obstine à toujours donner le même code jusqu’à ce que nous lui disions explicitement quelle est l’erreur dans le code :

La ligne SHA1, où se trouve le bloc "try catch", a besoin d’un point-virgule à la fin de la ligne pour que le code fonctionne.

Dès lors, ChatGPT produit enfin un code fonctionnel, avec le point-virgule à la ligne 18. La bonne nouvelle est que le script mis à jour s’exécute en 35 secondes sur notre ordinateur de test, au lieu de deux minutes.

La stratégie d’optimisation de ChatGPT pour ce script est bonne. La première version du script appelait plusieurs fois la cmdlet Get-Process et récupérait souvent le même processus par son identifiant. ChatGPT évite ce ralentissement en interrogeant le processus propriétaire une fois par boucle.

ChatGPT peut être utile, mais il présente des inconvénients

Comme nous l’avons vu dans les exemples précédents, ChatGPT n’est pas parfait. Tout code qu’il produit doit être examiné avec soin et, surtout si vous ne le comprenez pas, exécuté avec prudence. Vous devriez envisager d’utiliser le paramètre -WhatIf pour visualiser les changements avant qu’ils ne se produisent. Ou commenter les cmdlets qui effectuent les changements, pendant que vous exécutez les tests.

Gardez à l’esprit qu’en tant qu’utilisateur de ChatGPT, vous le formez. Rien de ce que vous utilisez pour solliciter ChatGPT ne doit être considéré comme privé. Si vous écrivez un code propriétaire, vous risquez d’enfreindre la politique de votre entreprise lorsque vous collez des scripts dans ChatGPT.