Assistência com CLI do Azure e PowerShell usando GitHub Copilot

8 minutos

Dica

Consulte a guia Texto e imagens para obter mais detalhes!

Apesar do aumento das ferramentas declarativas de IaC, como Bicep, as ferramentas de linha de comando, como CLI do Azure e Azure PowerShell, permanecem essenciais para os engenheiros de nuvem. Algumas tarefas não se encaixam perfeitamente em um modelo: verificações de pré-implantação, migrações de dados, runbooks operacionais, solução de problemas não planejada e automação que envolve lógica condicional ou loops.

Scripts de CLI (CommandLine) geralmente são também a primeira coisa a que uma equipe recorre quando algo precisa acontecer rapidamente. A velocidade com que você pode escrever e executar um script importa. Exatamente onde GitHub Copilot adiciona valor imediato. Em vez de pesquisar a documentação para o comando correto e seus parâmetros, você descreve o que deseja em linguagem simples e Copilot gera o script.

CLI do Azure versus Azure PowerShell

Isso ajuda a compreender qual ferramenta usar, antes de gerar scripts.

CLI do Azure (az) é uma ferramenta de linha de comando multiplataforma que é executada em Windows, macOS e Linux. A saída é JSON por padrão, facilitando o redirecionamento para outras ferramentas. CLI do Azure é amplamente usado em scripts bash, agentes de CI/CD baseados em Linux e por equipes com um plano de fundo Linux ou DevOps.

Azure PowerShell (módulo Az) usa o idioma do PowerShell e é executado em Windows, macOS e Linux por meio do PowerShell 7+. Sua saída são objetos .NET estruturados, o que os torna poderosos para lógica complexa, filtragem e integração com outros serviços da Microsoft. O PowerShell parece preferido por equipes Windows pesadas e administradores do sistema.

Ambas as ferramentas abrangem as mesmas operações de Azure. Escolher entre eles é, em grande parte, uma questão de qual idioma sua equipe está mais confortável e em qual ambiente seus scripts são executados. GitHub Copilot manipula ambos fluentemente e pode traduzir entre eles.

Gerar scripts de CLI do Azure com Copilot

Comece de forma simples

Para a criação direta de recursos, um prompt direto funciona bem. Copilot conhece a estrutura de comandos az e pode gerar a sintaxe correta para operações comuns.

Um prompt de exemplo pode ter esta aparência:

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.

Onde a resposta do GitHub Copilot pode ser semelhante a:

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

Para um único comando, a sintaxe é simples. O valor real aparece quando você solicita GitHub Copilot criar um script completo com várias etapas, variáveis e tratamento de erros.

Criar um script de provisionamento completo

Nesta abordagem mais avançada, seu prompt pode conter mais detalhes, como o exemplo aqui:

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 gera um script com um bloco limpo de variáveis, verificações de idempotência e mensagens de status. As técnicas de sugestão-chave aqui são:

Variáveis na parte superior: impede valores codificados espalhados pelo script
Verificação de existência antes da criação: torna o script idempotente (seguro para executar novamente)
Exit on failure (set -e): evita que falhas silenciosas se propaguem

Adicionar idempotência

Idempotência significa que o script produz o mesmo resultado, seja executado uma vez ou dez vezes. Isso é fundamental para scripts de automação que podem ser executados de forma agendada ou como parte de pipelines de CI/CD.

Aqui está um exemplo de como usar um prompt para adicionar idempotência à geração do seu 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 encapsula cada comando az ... create em um padrão de verificação de existência:

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

Adicionar validação de parâmetro

Outro caso de uso útil é usar a validação de parâmetro, como parte do prompt. Veja o exemplo aqui:

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

Esse padrão torna os scripts adequados para uso em pipelines de automação em que as entradas vêm de variáveis de ambiente ou parâmetros de CI/CD em vez de valores codificados.

Gerar os scripts do Azure PowerShell com GitHub Copilot

A mesma abordagem de linguagem natural funciona para o PowerShell (Azure). Copilot entende os cmdlets do módulo Az e gera o PowerShell de forma idiomática em vez de traduzir literalmente a sintaxe da CLI.

Ao incluir o idioma de script necessário em um prompt, você restringe o escopo 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 responde com sintaxe clara do PowerShell, entendendo os Azure recursos e parâmetros:

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" }
}

Observe que Copilot produz naturalmente padrões idiomáticos do PowerShell: param() blocos, try/catch, -ErrorAction SilentlyContinue e a sintaxe de expansão $(...). Ele não tenta replicar padrões bash no PowerShell.

Traduzir entre a CLI e o PowerShell

Um dos usos mais práticos de GitHub Copilot para o trabalho de infraestrutura é converter scripts entre ferramentas. Cenários comuns são:

Um script escrito por uma equipe centrada no Linux e precisa ser executado no Windows
Exemplos de documentação estão na CLI, mas sua equipe usa o PowerShell
Você deseja padronizar toda a automação em um idioma

Um exemplo desse prompt de transformação pode ser semelhante a este exemplo:

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]

A instrução Do not add features that are not in the original é importante. Sem ela, Copilot às vezes adiciona log, telemetria ou funcionalidade extra que não foi solicitada. Tornando mais difícil comparar os dois scripts e verificar a equivalência.

Principais equivalentes da CLI para o PowerShell

Entender os mapeamentos ajuda você a verificar as traduções do Copilot:

CLI do Azure	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`
`$?` (verificação de código de saída)	`$?` ou `try/catch`

Padrões práticos para trabalho em CLI assistido pelo Copilot

Gerar comandos para recursos desconhecidos

Até mesmo engenheiros experientes do Azure encontram tipos de recursos do Azure com os quais já tenham trabalhado. Copilot remove a consulta da documentação:

Incluir uma referência clara ao tipo de recurso Azure no prompt é suficiente para Copilot gerar o comando correto:

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 gera o comando az acr create correto com os nomes de sinalizador corretos. Incluindo sinalizadores que são fáceis de esquecer, como --sku, --admin-enabled falsee --identity [system].

Criar scripts de limpeza

Scripts de limpeza são essenciais em ambientes de treinamento e desenvolvimento. Copilot gera-os rapidamente. Um exemplo desse prompt pode ter esta aparência:

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

Gerar scripts para múltiplas assinaturas

Os ambientes empresariais geralmente dependem de várias assinaturas Azure. Com GitHub Copilot, essa complexidade adicional é fácil de lidar. Inclua essa especificação como parte do prompt, conforme mostrado aqui:

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.

O Copilot gera a estrutura de loop usando az account list e az account set corretamente, lidando com a troca de contexto de assinatura que confunde muitos engenheiros que escrevem do zero.

Principais conclusões

CLI do Azure e PowerShell são essenciais para automação operacional e condicional que não se ajusta a um modelo declarativo.
Mensagens eficazes da CLI incluem blocos de variáveis, verificações de existência, tratamento de erros e requisitos de etiquetas.
Copilot produz saída idiomática na CLI e no PowerShell; Não é uma tradução mecânica de um para o outro.
Use o padrão de tradução ("Traduzir esse script da CLI para o PowerShell, preservar toda a lógica, não adicionar recursos") para conversão de ferramentas cruzadas confiável.
Use a CLI para tarefas operacionais e condicionais; use o Bicep para gerenciar o estado da infraestrutura de longa duração.

Comentários

Esta página foi útil?