Prise en charge d’Azure CLI et de PowerShell avec GitHub Copilot

8 minutes

Tip

Pour plus d’informations, consultez l’onglet Texte et images !

Malgré l’essor des outils IaC déclaratifs comme Bicep, les outils en ligne de commande tels que Azure CLI et Azure PowerShell restent essentiels pour les ingénieurs cloud. Certaines tâches ne s’intègrent pas correctement dans un modèle : vérifications de prédéploiement, migrations de données, runbooks opérationnels, résolution des problèmes non planifiés et automatisation impliquant une logique ou des boucles conditionnelles.

Les scripts CommandLine (CLI) sont également souvent la première chose qu’une équipe atteint, quand quelque chose doit se produire rapidement. La vitesse à laquelle vous pouvez écrire et exécuter un script compte. Exactement où GitHub Copilot ajoute une valeur immédiate. Au lieu de rechercher la documentation pour la commande appropriée et ses paramètres, vous décrivez ce que vous souhaitez en langage brut et Copilot génère le script.

Azure CLI ou Azure PowerShell

Il est utile de savoir quel outil utiliser avant de générer des scripts.

Azure CLI (az) est un outil en ligne de commande multiplateforme qui s’exécute sur Windows, macOS et Linux. Sa sortie est au format JSON par défaut, ce qui facilite son intégration avec d'autres outils. Azure CLI est largement utilisé dans les scripts bash, les agents CI/CD basés sur Linux et par les équipes avec un arrière-plan Linux ou DevOps.

Azure PowerShell (module Az) utilise le langage PowerShell et s’exécute sur Windows, macOS et Linux via PowerShell 7+. Sa sortie consiste en des objets .NET structurés, ce qui le rend puissant pour la logique complexe, le filtrage et l’intégration avec d'autres services Microsoft. PowerShell semble préféré par les équipes Windows et les administrateurs système.

Les deux outils couvrent les mêmes opérations de Azure. Le choix entre eux est en grande partie une question de langue dans laquelle votre équipe est la plus à l’aise avec et l’environnement dans lequel vos scripts s’exécutent. GitHub Copilot gère couramment différentes langues et peut traduire entre elles.

Générer des scripts Azure CLI avec Copilot

Commencez simplement

Pour créer des ressources simples, une consigne directe fonctionne bien. Copilot connaît la structure de commandes az et peut générer une syntaxe correcte pour les opérations courantes.

Voici à quoi pourrait ressembler un exemple de requête :

Generate an Azure CLI command to create a resource group called "rg-webapp-prod" in the West Europe region, tagged with Environment=Production and Owner=platform-team.

Où la réponse de GitHub Copilot peut être similaire à :

az group create \
  --name rg-webapp-prod \
  --location westeurope \
  --tags Environment=Production Owner=platform-team

Pour une seule commande, la syntaxe est simple. La valeur réelle s’affiche lorsque vous demandez à GitHub Copilot de générer un script complet avec plusieurs étapes, variables et gestion des erreurs.

Générer un script d’approvisionnement complet

Dans cette approche plus avancée, votre invite peut contenir plus de détails, comme dans l’exemple suivant :

Generate an Azure CLI bash script that provisions the following resources:
- Resource group: rg-iaclab in East US
- VNet: vnet-iaclab with address space 10.0.0.0/16
- Subnet: snet-app at 10.0.1.0/24
- NSG: nsg-app with a rule denying all inbound internet traffic
  except HTTPS (port 443)
- Associate the NSG with snet-app

Requirements:
- Use variables at the top for all configurable values
- Check if the resource group already exists before creating it
- Print a status message after each successful resource creation
- Exit immediately if any command fails (set -e)
- Tag all resources with Environment=Training and Owner=lab-user

Copilot génère un script avec un bloc de variables propre, des vérifications d’idempotency et des messages d’état. Les techniques d’invite clés sont les suivantes :

Variables en haut : empêche les valeurs codées en dur dispersées dans le script
Vérification de l’existence avant la création : rend le script idempotent (sûr à réexécuter)
Sortie en cas d’échec (set -e) : empêche la propagation des échecs silencieux

Ajouter une idempotence

L’Idempotency signifie que le script produit le même résultat, qu’il s’exécute une fois ou 10 fois. Ce qui est essentiel pour les scripts d’automatisation qui peuvent s’exécuter selon une planification ou dans le cadre de pipelines CI/CD.

Voici un exemple d’utilisation d’un prompt pour ajouter une idempotence à votre génération de script :

Refactor this script so that each resource creation command first checks whether the resource already exists. If it exists, print "already exists — skipping" and continue. If it does not exist, create it.
Use az [resource] show with a 2>/dev/null check to test for existence.

Copilot encapsule chaque commande az ... create dans un schéma de vérification d'existence :

if ! az network vnet show --name "$VNET_NAME" --resource-group "$RG_NAME" \
     --query id -o tsv 2>/dev/null; then
  echo "Creating VNet: $VNET_NAME..."
  az network vnet create \
    --name "$VNET_NAME" \
    --resource-group "$RG_NAME" \
    --address-prefix "$VNET_PREFIX"
  echo "VNet created successfully."
else
  echo "VNet $VNET_NAME already exists — skipping."
fi

Ajouter une validation de paramètre

Un autre cas d’usage utile consiste à utiliser la validation des paramètres dans votre invite. Consultez l’exemple ici :

Add a validation block at the top of the script that:
- Checks that the az CLI is installed and the user is logged in
- Verifies the target subscription is set correctly
- Accepts RESOURCE_GROUP, LOCATION, and OWNER as command-line arguments
  and exits with a usage message if they are not provided

Ce modèle rend les scripts adaptés à une utilisation dans les pipelines Automation où les entrées proviennent de variables d’environnement ou de paramètres CI/CD plutôt que de valeurs codées en dur.

Générer des scripts Azure PowerShell avec GitHub Copilot

La même approche du langage naturel fonctionne pour (Azure) PowerShell. Copilot comprend les applets de commande du module Az et génère du PowerShell idiomatique plutôt que de traduire la syntaxe CLI mot à mot.

En incluant le langage de script requis dans une invite, vous limitez l’étendue GitHub Copilot :

Generate an Azure PowerShell script that:
- Connects to Azure using a service principal (client ID, client secret,
  tenant ID passed as parameters)
- Creates a resource group "rg-iaclab" in East US if it does not already exist
- Creates a Storage Account with Standard_LRS SKU, HTTPS-only access,
  and blob soft delete enabled (30 days)
- Outputs the storage account's primary connection string at the end
Use proper error handling with try/catch blocks.

GitHub Copilot répond avec une syntaxe PowerShell claire, en comprenant les ressources et paramètres Azure :

param(
    [Parameter(Mandatory=$true)][string]$TenantId,
    [Parameter(Mandatory=$true)][string]$ClientId,
    [Parameter(Mandatory=$true)][string]$ClientSecret,
    [string]$Location = "eastus",
    [string]$ResourceGroupName = "rg-iaclab",
    [string]$StorageAccountName = "stiaclab$(Get-Random -Maximum 9999)"
)

# Connect using service principal
$SecureSecret = ConvertTo-SecureString $ClientSecret -AsPlainText -Force
$Credential = New-Object System.Management.Automation.PSCredential($ClientId, $SecureSecret)

try {
    Connect-AzAccount -ServicePrincipal -Credential $Credential -Tenant $TenantId
    Write-Host "Connected to Azure successfully." -ForegroundColor Green
} catch {
    Write-Error "Failed to connect to Azure: $_"
    exit 1
}

# Create resource group if it does not exist
$RG = Get-AzResourceGroup -Name $ResourceGroupName -ErrorAction SilentlyContinue
if (-not $RG) {
    Write-Host "Creating resource group: $ResourceGroupName..."
    New-AzResourceGroup -Name $ResourceGroupName -Location $Location `
        -Tag @{ Environment = "Training"; Owner = "lab-user" }
}

Notez que Copilot produit naturellement des modèles PowerShell-idiomatiques : blocs param(), try/catch, -ErrorAction SilentlyContinue et la syntaxe d’expansion $(...). Il n’essaie pas de répliquer des modèles bash dans PowerShell.

Traduire entre l’interface CLI et PowerShell

L’une des utilisations les plus pratiques de GitHub Copilot pour le travail d’infrastructure consiste à convertir des scripts entre des outils. Voici des cas d’utilisation courants :

Un script écrit par une équipe centrée sur Linux et doit s’exécuter sur Windows
Les exemples de documentation sont dans l’interface CLI, mais votre équipe utilise PowerShell
Vous souhaitez normaliser toutes les automatisations en une seule langue

Un exemple de cette invite de transformation peut être similaire à cet exemple :

Translate the following Azure CLI bash script to Azure PowerShell.
Use Az module cmdlets throughout. Preserve:
- The same variable/parameter names where possible
- All error handling logic
- The existence check pattern before each resource creation
- Tag application on all resources
Do not add features that are not in the original script.

[paste your CLI script here]

L’instruction Do not add features that are not in the original est importante. Sans cela, Copilot ajoute parfois la journalisation, la télémétrie ou des fonctionnalités supplémentaires qui n'ont pas été demandées. Il est plus difficile de comparer les deux scripts et de vérifier l’équivalence.

Équivalents principaux de CLI et PowerShell

Comprendre les mappages vous aide à vérifier les traductions de Copilot :

Azure CLI	Azure PowerShell
`az group create`	`New-AzResourceGroup`
`az group show`	`Get-AzResourceGroup`
`az network vnet create`	`New-AzVirtualNetwork`
`az network nsg create`	`New-AzNetworkSecurityGroup`
`az vm create`	`New-AzVM`
`az storage account create`	`New-AzStorageAccount`
`az keyvault create`	`New-AzKeyVault`
`--query` + `--output tsv`	`Select-Object` + `.PropertyName`
`$?` (vérification du code de sortie)	`$?` ou `try/catch`

Modèles efficaces pour le travail CLI assisté par Copilot

Générer des commandes pour des ressources inconnues

Même les ingénieurs Azure expérimentés utilisent des types de ressources Azure qu'ils ont déjà utilisés. Copilot supprime la recherche de documentation :

L’inclusion d’une référence claire au type de ressource Azure dans votre invite suffit à Copilot pour générer la commande correcte :

Generate an Azure CLI command to create an Azure Container Registry with
Premium SKU, geo-replication to West Europe, admin account disabled,
and a system-assigned managed identity. Output the login server at the end.

Copilot génère la commande az acr create correcte avec les noms d’indicateurs appropriés. Y compris les indicateurs faciles à oublier, tels que --sku, --admin-enabled falseet --identity [system].

Générer des scripts de nettoyage

Les scripts de nettoyage sont essentiels dans les environnements d’entraînement et le développement. Copilot les génère rapidement. Un exemple de cette invite peut ressembler à ceci :

Generate an Azure CLI script that:
- Lists all resource groups with the tag Environment=Training
- Prints each group name and asks for confirmation before deleting
- Deletes confirmed groups with --no-wait for speed
- Reports how many groups were deleted at the end

Générer des scripts entre abonnements

Les environnements d’entreprise s’appuient souvent sur plusieurs abonnements Azure. Avec GitHub Copilot, cette complexité ajoutée est facile à gérer. Incluez cette spécification dans le cadre de votre invite, comme indiqué ici :

Generate an Azure CLI script that iterates over all subscriptions in my tenant,
checks each one for storage accounts that have public blob access enabled,
and outputs a CSV report with: SubscriptionName, ResourceGroup, StorageAccountName, Location.

Copilot génère correctement la structure de boucle à l’aide de az account list et az account set, tout en gérant le changement de contexte d’abonnement qui constitue une difficulté pour de nombreux ingénieurs lorsqu’ils écrivent depuis zéro.

Points importants à retenir

Azure CLI et PowerShell sont essentiels pour l'automatisation opérationnelle et conditionnelle qui ne correspond pas à un modèle déclaratif.
Les invites CLI efficaces incluent les blocs de variables, les vérifications d’existence, la gestion des erreurs et les exigences en matière de balises.
Copilot produit une sortie idiomatique dans l’interface CLI et PowerShell ; Pas une traduction mécanique de l’un à l’autre.
Utilisez le modèle de traduction (« Traduire ce script CLI en PowerShell, conservez toute la logique, n’ajoutez pas de fonctionnalités ») pour une conversion multi-outil fiable.
Utiliser l’interface CLI pour les tâches opérationnelles et conditionnelles ; utilisez Bicep pour gérer l’état de l’infrastructure de longue durée.

Commentaires

Cette page a-t-elle été utile ?