Comment utiliser GitHub Copilot pour créer de scripts PowerShell

Le fonctionnement de GitHub Copilot

Copilot utilise des modèles d’IA générative entraînés sur du code source public pour prédire et proposer les lignes, blocs ou fonctions entières suivants en fonction de votre fichier actuel, du contexte du projet et de vos prompts.

Dans VS Code, vous pouvez saisir un commentaire descriptif ou une chaîne de caractères, telle que « Que doit faire ce script ? », et GitHub Copilot vous proposera un brouillon que vous pourrez peaufiner. Plus votre intention, vos contraintes et les détails de votre environnement (version de PowerShell, noms et versions des modules, système d’exploitation cible) sont clairs, meilleures seront ses suggestions. Une bonne maîtrise de PowerShell vous aidera à orienter GitHub Copilot vers des scripts corrects et efficaces, tout en évitant les modèles obsolètes.

GitHub Copilot tient compte des retours d’expérience au fur et à mesure du travail. S’il suggère une cmdlet ou une API obsolète et que vous la remplacez par son équivalent moderne, les suggestions suivantes s’aligneront généralement sur votre correction.

Par exemple, lors de la rédaction d’un script d’automatisation Azure, GitHub Copilot peut initialement proposer une cmdlet de connexion AzureRM obsolète ; l’utilisation de Connect-AzAccount l’incite à recourir aux cmdlets du module Az actuel (également appelé module Azure PowerShell Account) dans ses suggestions ultérieures. Cette adaptabilité est précieuse, mais elle ne remplace pas la nécessité d’une révision par un expert.

Voici quelques conseils pratiques à garder à l’esprit :

• La qualité dépend de la clarté de vos prompts. Indiquez explicitement « cible PowerShell 7 », précisez les modules, tels que Az.Accounts ou Az.Compute, et mentionnez les propriétés requises pour réduire les retouches.
• Les suggestions peuvent s’appuyer sur des modèles obsolètes ou sous-optimaux. Vérifiez leur exactitude, leurs performances et leur sécurité avant de les adopter. GitHub Copilot ne remplace pas l’expertise métier ni les processus de révision.
• GitHub Copilot apprend les conventions de codage générales à partir de dépôts publics ; il ne copie pas votre code privé, sauf si vous l’autorisez explicitement à utiliser votre contenu pour améliorer le produit. Vous pouvez également contrôler, lors de la configuration, si les suggestions peuvent correspondre à des modèles de code publics.

En amont de l’utilisation de GitHub Copilot

Une petite configuration préalable permet d’améliorer considérablement les résultats, en particulier dans les environnements d’entreprise.

1/ Choisissez votre forfait et activez GitHub Copilot :

• Vous devez disposer d’un compte GitHub. Activez Copilot depuis vos paramètres GitHub (Paramètres > Copilot). Vous y trouverez les options d’essai et les tarifs. Les organisations peuvent mettre en place GitHub Copilot pour leurs équipes en appliquant des contrôles de politique ; vérifiez les conditions en vigueur avant le déploiement.
• Lors de votre inscription, vous pouvez choisir d’autoriser ou non les suggestions susceptibles de correspondre à du code public et de partager ou non vos extraits de code à des fins d’amélioration du produit. Ces deux paramètres sont facultatifs et doivent respecter les politiques de votre organisation.

2/ Installez et configurez l’extension dans VS Code :

• Installez l’extension GitHub Copilot pour VS Code et connectez-vous avec votre identifiant GitHub ; un indicateur d’état Copilot s’affichera dans l’éditeur une fois l’extension activée.
• Ajoutez GitHub Copilot Chat pour bénéficier de workflows basés sur le chat : expliquez et refactorisez du code, demandez des tests et de la documentation, et appliquez des modifications à plusieurs fichiers. Cette boucle axée sur le chat est souvent le moyen le plus rapide d’obtenir des résultats de haute qualité.
• Assurez-vous que l’extension PowerShell pour VS Code est installée afin que GitHub Copilot prenne en charge la syntaxe, le formatage et le débogage spécifiques au langage.

3/ Préparez votre environnement PowerShell et Azure :

• Adoptez de manière standardisée un runtime PowerShell 7.x pris en charge et maintenez à jour les modules essentiels, tels que les modules Az pour Azure. Demandez à Copilot de vous fournir du code compatible avec PS7 et d’éviter les cmdlets obsolètes, comme la famille AzureRM héritée ; apportez des corrections directement dans le code si Copilot vous suggère le contraire, afin que les complétions futures suivent cette ligne. L’utilisation d’un conteneur défini de manière centralisée et distribué pour le développement local est un bon moyen de garantir que tout le monde utilise la même version de PowerShell, les mêmes cmdlets et les mêmes outils.
• Adoptez des contrôles de qualité de base dans votre espace de travail, tels que PSScriptAnalyzer pour l’analyse syntaxique et Pester pour les tests, afin de pouvoir valider rapidement les résultats de GitHub Copilot au fur et à mesure de vos itérations.

4/ Définissez des garde-fous en matière de sécurité et de gouvernance :

• Pour une utilisation individuelle, passez en revue les options « correspondance de code public » et « partage de contenu » lors de la configuration et choisissez la posture la plus prudente qui permette tout de même de rester productif.
• Pour les organisations, appliquez les politiques de manière centralisée, définissez les limites des données et décidez quand activer l’assistance tenant compte du dépôt ou de l’espace de travail. Traitez les résultats de GitHub Copilot comme n’importe quelle contribution de code : recherchez les secrets, vérifiez le respect du principe du privilège minimal et contrôlez si des modules ou des API sont obsolètes avant la fusion.

5/ Définissez des prompts efficaces pour tirer le meilleur parti de GitHub Copilot :

• Précisez l’objectif, les contraintes et l’environnement : version de PowerShell, système d’exploitation, modules et exigences en matière de performances ou de sécurité.
• Demandez explicitement l’utilisation de modèles modernes : « Utilise Get‑CimInstance, pas Get‑WmiObject », « Privilégie Connect‑AzAccount, pas AzureRM », « Renvoie des objets structurés ; évite Write‑Host » et « Intègre la gestion des erreurs et la prise en charge de -WhatIf ». GitHub Copilot répond au mieux à ce niveau de précision.

Grâce à ces préparatifs, GitHub Copilot devient un accélérateur fiable pour les administrateurs PowerShell : il rédige les 80 % premiers du code et vous appliquez votre expertise pour affiner et consolider le résultat. Les commentaires que vous fournissez orientent ses prochaines suggestions sans perdre de vue l’exactitude, la sécurité et la maintenabilité.

Comment écrire du code PowerShell avec GitHub Copilot

GitHub Copilot fonctionne de manière optimale lorsque vous lui fournissez une intention précise, un environnement d’exécution clair et des contraintes de qualité. Considérez-le comme un programmeur junior travaillant en binôme : vous spécifiez le « quoi » et les contraintes ; il rédige le « comment ». Ensemble, vous révisez, affinez et testez le code. GitHub Copilot a besoin de vos indications pour comprendre comment il doit procéder. Des prompts explicites produisent des résultats nettement meilleurs.

1/ Travaillez de manière itérative dans VS Code :

• Commencez par ajouter un commentaire descriptif ou un squelette de fonction minimal : CmdletBinding, paramètres, try/catch, ShouldProcess. GitHub Copilot proposera des complétions qui respectent votre intention et votre style.
• Si une suggestion est proche mais pas parfaite, acceptez-la et modifiez-la directement dans le code. Les complétions suivantes de GitHub Copilot dans ce fichier suivent généralement vos corrections, par exemple en passant de « AzureRM » à « Az », ou de « WMI » à « CIM ».
• Utilisez GitHub Copilot Chat pour : expliquer ou refactoriser un bloc, ajouter des tests Pester et une aide basée sur les commentaires, appliquer les règles de PSScriptAnalyzer, demander des modifications sur plusieurs fichiers à la fois, par exemple pour la mise à jour d’un module et de ses tests.

2/ Privilégiez l’exactitude, les performances et la facilité de maintenance :

• Renvoyez des objets riches depuis le pipeline ; évitez d’utiliser Write-Host dans le code de la bibliothèque.
• Préférez une requête unique, bien ciblée, aux recherches élément par élément. Par exemple, appeler une cmdlet à l’intérieur d’une boucle alors que vous disposez déjà des données est inutile et inefficace.
• Vérifiez les versions des modules et la disponibilité des cmdlets. Demandez à GitHub Copilot d’épingler ou de vérifier les versions lorsque cela est pertinent.
• Ajoutez une gestion des erreurs et la méthode ShouldProcess afin de pouvoir exécuter le code avec les options -WhatIf ou -Confirm pendant les tests.

Par exemple, pour répertorier les services en cours d’exécution et leurs comptes de connexion, demandez à GitHub Copilot, sous forme de commentaire ou dans le chat :

« PowerShell 7. Récupère tous les services Windows en cours d’exécution et affiche le nom du service, le nom d’affichage et le compte sous lequel le service s’exécute. Utilise Get-CimInstance (et non Get-WmiObject). Renvoie des objets ; pas de Write-Host. »

« Approche résultante : concise, compatible PS7 »

« Effectue une seule requête via CIM et sélectionne les propriétés dont tu as besoin : »

$services = Get-CimInstance -ClassName Win32_Service | Where-Object { $_.State -eq 'Running' }

$services | Select-Object Name, DisplayName, State, StartName

Ce code évite les appels WMI par service et s’appuie sur la méthode `Win32_Service.StartName` pour le compte de connexion. Il évite également de faire référence à des propriétés qui n’existent pas dans la commande Get-Service de PowerShell 7.x, telles que la propriété UserName.

Utilisez GitHub Copilot pour améliorer la qualité du code

GitHub Copilot vous aide à mettre en œuvre les meilleures pratiques PowerShell au-delà des fonctionnalités de base. Il peut affiner un script si vous demandez des améliorations supplémentaires en sollicitant :

• Des tests Pester couvrant les conditions d’erreur.
• Une aide basée sur les commentaires et des attributs de validation des paramètres.
• La correction des résultats de PSScriptAnalyzer.
• Des modèles plus sûrs, tels que les informations d’identification via Get-Credential ou une identité gérée ; un modèle RBAC (contrôle d’accès basé sur les rôles) selon le principe du privilège minimal.
• La répétition de l’opération jusqu’à ce que le script réponde à vos normes de style et de fiabilité, puis l’exécution des tests et un essai à blanc avec l’option -WhatIf avant d’appliquer les modifications.

Les erreurs courantes commises par GitHub Copilot et leur remédiation sont les suivantes :

• Suggestion de cmdlets ou de modules obsolètes, tels que AzureRM et Get-WmiObject. Corrigez-les et poursuivez ; GitHub Copilot suivra généralement votre exemple dans les complétions suivantes.
• Utilisation de boucles inefficaces qui interrogent à nouveau l’état à chaque itération. Regroupez-les en une seule requête et ne récupérez que les champs dont vous avez besoin.
• Affichage des chaînes via Write-Host au lieu de renvoyer des objets. Demandez à GitHub Copilot de générer des PSCustomObjects ou de sélectionner des propriétés spécifiques.

En combinant une intention claire, les contraintes de l’environnement et une révision itérative, vous obtiendrez de GitHub Copilot un code précis, compatible avec PowerShell 7 et facile à maintenir : c’est bien plus rapide que de partir d’un fichier vierge et plus sûr que d’accepter la première suggestion telle quelle.

Exemples de prompts PowerShell pour GitHub Copilot

Vous trouverez ci-dessous une série de prompts pratiques que vous pouvez coller dans le chat de GitHub Copilot et adapter à vos besoins. Utilisez des espaces réservés, tels que <FILE>, <FUNCTION>, <MODULE>, <RESOURCE_GROUP>, <PS_VERSION>, <RULESET> et <TARGET>.

Voici quelques conseils rapides :

• Soyez précis concernant la version de PowerShell, les modules et les contraintes ; GitHub Copilot fonctionne mieux avec des instructions claires et des API à jour, telles que PS7, les modules Az et CIM plutôt que WMI.
• Si GitHub Copilot suggère des modèles obsolètes, tels que AzureRM ou Get-WmiObject, corrigez-le une seule fois ; les suggestions suivantes suivront généralement votre modification.
• Privilégiez les requêtes uniques et bien ciblées, et renvoyez des objets. Évitez les requêtes répétées pour chaque élément et l’utilisation de `Write-Host` dans le code de la bibliothèque.

Principes de base et contraintes :

« Tu es mon partenaire de programmation PowerShell. Contraintes : PowerShell 7.x uniquement ; compatibilité multiplateforme garantie ; évite les cmdlets obsolètes ; évite AzureRM (utilise les modules Az, Connect-AzAccount) ; renvoie des objets (pas de Write-Host) ; ajoute la gestion des erreurs (try/catch), la validation des paramètres et ShouldProcess avec -WhatIf/-Confirm ; respecte les paramètres par défaut de PSScriptAnalyzer et les bonnes pratiques de style PowerShell. »

Refactorisation et modernisation exclusivement pour PowerShell 7 :

« Refactorise <FICHIER> pour qu’il fonctionne exclusivement sous PowerShell 7 : remplace les cmdlets obsolètes, assure la compatibilité multiplateforme, supprime Write-Host au profit d’une sortie compatible avec le pipeline, ajoute CmdletBinding et ShouldProcess, et inclue une aide sous forme de commentaires. Explique chaque changement de compatibilité et pourquoi il est nécessaire pour PS7. »

Audit et corrections avec PSScriptAnalyzer :

« Exécute PSScriptAnalyzer sur <FICHIER> en utilisant les règles par défaut (ou ces paramètres personnalisés : <ENSEMBLE DE RÈGLES>). Répertorie les violations avec leurs identifiants de règle et leurs lignes, puis propose des corrections minimales et sûres. Applique les corrections dans une version mise à jour de <FICHIER>. Lorsqu’une exception justifiée est nécessaire, ajoute [Diagnostics.CodeAnalysis.SuppressMessage()] en expliquant la raison dans les commentaires. »

Générer des tests Pester :

« Génére des tests Pester v5 pour <FONCTION>/<MODULE> : inclue la structure Arrange/Act/Assert, des simulacres pour les appels externes (système de fichiers, registre, réseau, cmdlets Azure), des tests pour -WhatIf/-Confirm, les chemins d’erreur, la validation des paramètres et au moins un test piloté par tableau. Cible PS7. Exporte les tests dans un nouveau fichier nommé <FONCTION>.Tests.ps 1 adapté à l’intégration continue. »

Cet article est initialement paru en anglais sur Techtarget.com, une publication sœur du MagIT.