Como usar a CLI do Azure em uma linguagem de script Bash

Artigo
06/29/2024

Os comandos de referência da CLI do Azure podem ser executados em várias linguagens de script. Se você está começando a usar o Bash e a CLI do Azure, este artigo é ótimo para começar seu percurso de aprendizagem. Trabalhe neste artigo da mesma forma que faria com um tutorial para aprender a usar a CLI do Azure em uma linguagem de script Bash com facilidade.

Neste artigo, você aprenderá como:

Consultar resultados como dicionários ou matrizes JSON
Formatar a saída como JSON, tabela ou TSV
Consultar, filtrar e formatar valores únicos e múltiplos
Usar if/exists/then e sintaxe de maiúsculas e minúsculas
Usar for loops
Usar os comandos grep, sed, paste e bc
Popular e usar variáveis do shell e de ambiente

Caso você não tenha uma assinatura do Azure, crie uma conta gratuita do Azure antes de começar.

Iniciar o Bash

Inicie o Bash usando o Azure Cloud Shell ou uma instalação local da CLI do Azure. Este artigo pressupõe que você esteja executando o Bash usando o Azure Cloud Shell ou executando a CLI do Azure localmente em um contêiner do Docker.

Consultar resultados do dicionário

Um comando que sempre retorna um só objeto retorna um dicionário JSON. Dicionários são objetos não ordenados acessados com chaves. Neste artigo, vamos começar consultando o objeto Account usando o comando Account Show.

az account show
az account show --output json # JSON is the default format

A saída do dicionário JSON a seguir tem alguns campos omitidos por brevidade e as informações de identificação são removidas.

bash-5.1# az account show
{
  "environmentName": "AzureCloud",
  "isDefault": true,
  "managedByTenants": [],
  "name": "My test subscription",
  "state": "Enabled",
  "user": {
    "name": "user@contoso.com",
    "type": "user"
  }
}

Formatar a saída como YAML

Use o argumento --output yaml (ou -o yaml) para formatar a saída no formato yaml, um formato de serialização de dados de texto sem formatação. YAML tende a ser mais fácil de ler que o JSON e facilmente mapeia para esse formato. Alguns aplicativos e comandos da CLI usam YAML como entrada de configuração, em vez de JSON.

az account show --output yaml

Para obter mais informações de como formatar a saída como YAML, confira Formato de saída YAML.

Formatar a saída como uma tabela

Use o argumento --output table (ou -o table) para formatar a saída como uma tabela ASCII. Objetos aninhados não são incluídos na saída da tabela, mas ainda podem ser filtrados como parte de uma consulta.

az account show --output table

Para obter mais informações de como formatar a saída como uma tabela, confira Formato de saída de tabela.

Consultar e formatar valores únicos e valores aninhados

As consultas a seguir demonstram a consulta de valores únicos, incluindo valores aninhados em uma saída de dicionário JSON. A consulta final neste conjunto demonstra a formatação da saída usando o argumento -o tsv. Esse argumento retorna os resultados como valores separados por nova linha e por tabulação. Essa ação é útil para remover as aspas no valor retornado, o que ajuda outros comandos e ferramentas a consumir a saída necessária para processar o texto de alguma forma (como demonstraremos mais adiante neste artigo).

az account show --query name # Querying a single value
az account show --query name -o tsv # Removes quotation marks from the output

az account show --query user.name # Querying a nested value
az account show --query user.name -o tsv # Removes quotation marks from the output

Consultar e formatar propriedades de matrizes

A consulta a seguir demonstra como obter propriedades em uma matriz JSON. Obtenha propriedades de assinatura, exibidas como uma tabela de assinaturas.

az account list --query "[].{subscription_id:id, name:name, isDefault:isDefault}" -o table

Essa consulta retorna resultados semelhantes a:

Subscription_id                       Name                                               IsDefault
------------------------------------  -------------------------------------------------  -----------
11111111-3ddc-45ce-8334-c7b28a9e1c3a  C & L Azure developer experience content projects  False
22222222-8f1c-409b-af1e-8e2e65d9b90a  DevCenter - Infrastructure - Dogfood               False
33333333-c080-42a7-8973-1aa853ab4df3  Babel                                              False

Consultar e formatar vários valores, incluindo valores aninhados

Para obter mais do que uma propriedade, coloque as expressões entre colchetes [ ] (uma lista de seleção múltipla), como uma lista separada por vírgula. As consultas a seguir demonstram a consulta de vários valores em uma saída de dicionário JSON, usando vários formatos de saída.

az account show --query [name,id,user.name] # return multiple values
az account show --query [name,id,user.name] -o table # return multiple values as a table

Para obter mais informações de como retornar vários valores, confira Obter vários valores.

Renomear as propriedades em uma consulta

As consultas a seguir demonstram o uso do operador { } (hash de seleção múltipla) para obter um dicionário em vez de uma matriz ao consultar vários valores. Elas também demonstram a renomeação de propriedades no resultado da consulta.

az account show --query "{SubscriptionName: name, SubscriptionId: id, UserName: user.name}" # Rename the values returned
az account show --query "{SubscriptionName: name, SubscriptionId: id, UserName: user.name}" -o table # Rename the values returned in a table

Para obter mais informações de como renomear propriedades em uma consulta, confira Renomear propriedades em uma consulta.

Consultar valores boolianos

Os valores boolianos são considerados verdadeiros, portanto, a sintaxe de consulta "[?isDefault]" do comando az account list retorna a assinatura padrão atual. Para obter os valores falsos, use um caractere de escape, como \.

As consultas a seguir demonstram consultas de todas as contas em uma assinatura, podendo retornar uma matriz JSON quando há várias assinaturas em uma determinada conta e depois consultar de qual conta é a assinatura padrão. Elas também demonstram consultas de contas que não são a assinatura padrão. Essas consultas se baseiam no que você já aprendeu para filtrar e formatar os resultados. Por fim, a consulta final demonstra como armazenar os resultados da consulta em uma variável.

az account list
az account list --query "[?isDefault]" # Returns the default subscription
az account list --query "[?isDefault]" -o table # Returns the default subscription as a table
az account list --query "[?isDefault].[name,id]" # Returns the name and id of the default subscription
az account list --query "[?isDefault].[name,id]" -o table # Returns the name and id of the default subscription as a table
az account list --query "[?isDefault].{SubscriptionName: name, SubscriptionId: id}" -o table # Returns the name and id of the default subscription as a table with friendly names

az account list --query "[?isDefault == \`false\`]" # Returns all non-default subscriptions, if any
az account list --query "[?isDefault == \`false\`].name" -o table # Returns all non-default subscriptions, if any, as a table

az account list --query "[?isDefault].id" -o tsv # Returns the subscription id without quotation marks
subscriptionId="$(az account list --query "[?isDefault].id" -o tsv)" # Captures the subscription id as a variable.
echo $subscriptionId # Returns the contents of the variable.
az account list --query "[? contains(name, 'Test')].id" -o tsv # Returns the subscription id of a non-default subscription containing the substring 'Test'
subscriptionId="$(az account list --query "[? contains(name, 'Test')].id" -o tsv) # Captures the subscription id as a variable. 
az account set -s $subscriptionId # Sets the current active subscription

Para obter mais informações sobre como filtrar matrizes e consultar valores boolianos, confira Filtrar matrizes com expressões boolianas.
Para obter mais informações de como usar variáveis, confira Como usar variáveis.
Para obter mais informações de como trabalhar com assinaturas, confira Gerenciar assinaturas.

Criar objetos usando variáveis e aleatorização

Configurar um valor aleatório a ser usado nos próximos comandos

Com a configuração e o uso de um valor aleatório em variáveis, você pode executar scripts várias vezes sem conflitos de nomenclatura. Os conflitos de nomenclatura ocorrem porque um valor deve ser exclusivo no serviço ou porque um objeto excluído ainda existe no Azure até que o processo de exclusão seja concluído.

$RANDOM é uma função Bash (não uma constante) que retorna um inteiro aleatório de 16 bits com sinal (de 0 a 32767). let é um comando Bash interno para avaliar expressões aritméticas. O uso do comando a seguir cria um valor suficientemente exclusivo para a maioria das finalidades.

let "randomIdentifier=$RANDOM*$RANDOM"

Trabalhar com espaços e aspas

Os espaços são usados para separar comandos, opções e argumentos. Use aspas para solicitar que o shell Bash ignore todos os caracteres especiais, considerando o espaço em branco como caractere especial. Na primeira vez que o shell Bash encontra aspas simples, ele ignora os caracteres especiais até as aspas simples de fechamento. No entanto, às vezes você precisa que o shell Bash analise certos caracteres especiais, como sinais de dólar, sinais de crase e barra invertida. Para esse cenário, use aspas duplas.

Os comandos a seguir usam o comando az group createpara ilustrar o uso de aspas simples e duplas. Esses comandos são usados para manipular espaços e avaliar caracteres especiais ao trabalhar com variáveis e criar um objeto.

resourceGroup='msdocs-learn-bash-$randomIdentifier'
echo $resourceGroup # The $ is ignored in the creation of the $resourceGroup variable
resourceGroup="msdocs-learn-bash-$randomIdentifier"
echo $resourceGroup # The $randomIdentifier is evaluated when defining the $resourceGroup variable
location="East US" # The space is ignored when defining the $location variable
echo The value of the location variable is $location # The value of the $location variable is evaluated
echo "The value of the location variable is $location" # The value of the $location variable is evaluated
echo "The value of the location variable is \$location" # The value of the $location variable is not evaluated
echo 'The value of the location variable is $location' # The value of the $location variable is not evaluated
az group create --name $resourceGroup --location $location # Notice that the space in the $location variable is not ignored and the command fails as it treats the value after the space as a new command 
az group create --name $resourceGroup --location "$location" # Notice that the space in the $location variable is ignored and the location argument accepts the entire string as the value

Na saída do dicionário JSON, examine as propriedades do grupo de recursos que acabou de ser criado.

Usar If Then Else para determinar se a variável é nula

Para avaliar cadeias de caracteres, use != e para avaliar números, use -ne. A instrução If Then Else a seguir avalia se a variável $resourceGroup foi definida. Se sim, ela retorna o valor da variável. Se não, ela define a variável.

if [ $resourceGroup != '' ]; then
   echo $resourceGroup
else
   resourceGroup="msdocs-learn-bash-$randomIdentifier"
fi

Usar If Then para criar ou excluir um grupo de recursos

O script a seguir cria um novo grupo de recursos somente quando ainda não existe um com o nome especificado.

if [ $(az group exists --name $resourceGroup) = false ]; then 
   az group create --name $resourceGroup --location "$location" 
else
   echo $resourceGroup
fi

O script a seguir exclui um grupo de recursos novo existente quando já existe um com o nome especificado. Você pode usar o argumento --no-wait para retornar o controle sem aguardar a conclusão do comando. No entanto, neste artigo, vamos aguardar a exclusão do grupo de recursos para continuar. Para obter mais informações sobre operações assíncronas, consulte Dicas para usar a CLI do Azure com êxito - operações assíncronas. Demonstraremos o uso do argumento --no-wait no final deste artigo.

if [ $(az group exists --name $resourceGroup) = true ]; then 
   az group delete --name $resourceGroup -y # --no-wait
else
   echo The $resourceGroup resource group does not exist
fi

Usar o Grep para determinar se existe um grupo de recursos e criar um, caso não exista

O comando a seguir canaliza a saída do comando az group list para o comando grep. Quando o grupo de recursos especificado não existe, o comando o cria usando as variáveis já definidas.

az group list --output tsv | grep $resourceGroup -q || az group create --name $resourceGroup --location "$location"

Usar a instrução CASE para determinar se um grupo de recursos existe e criá-lo, caso não exista

A instrução CASE a seguir cria um grupo de recursos somente quando ainda não existe um com o nome especificado. Se existir um grupo de recursos com o nome especificado, a instrução CASE ecoará que ele existe.

var=$(az group list --query "[? contains(name, '$resourceGroup')].name" --output tsv)
case $resourceGroup in
$var)
echo The $resourceGroup resource group already exists.;;
*)
az group create --name $resourceGroup --location "$location";;
esac

Usar for loops e matrizes de consulta

Nesta seção do artigo, criaremos uma conta de armazenamento e a usaremos em loops para criar vários blobs e contêineres. Também demonstraremos como consultar matrizes JSON e trabalhar com variáveis de ambiente.

Criar Conta de Armazenamento

O comando a seguir usa o comando az storage account create para criar uma conta de armazenamento que usaremos ao criar contêineres de armazenamento.

storageAccount="learnbash$randomIdentifier"
az storage account create --name $storageAccount --location "$location" --resource-group $resourceGroup --sku Standard_LRS --encryption-services blob

Obter as chaves da conta de armazenamento

Os comandos a seguir usam o comando az storage account keys list para retornar valores de chave de conta de armazenamento. Depois, armazenaremos um valor de chave em uma variável, que será usado durante a criação de contêineres de armazenamento.

az storage account keys list --resource-group $resourceGroup --account-name $storageAccount --query "[].value" -o tsv # returns both storage account key values

az storage account keys list --resource-group $resourceGroup --account-name $storageAccount --query "[0].value" -o tsv # returns a single storage account key value

accountKey=$(az storage account keys list --resource-group $resourceGroup --account-name $storageAccount --query "[0].value" -o tsv)

echo $accountKey

Criar um contêiner de armazenamento

Começaremos usando o comando az storage container create para criar um só contêiner de armazenamento e depois usaremos o az storage container list para consultar o nome do contêiner criado.

container="learningbash"
az storage container create --account-name $storageAccount --account-key $accountKey --name $container

az storage container list --account-name $storageAccount --account-key $accountKey --query [].name

Carregar dados no contêiner

O script a seguir cria três arquivos de exemplo usando um for loop.

for i in `seq 1 3`; do
    echo $randomIdentifier > container_size_sample_file_$i.txt
done

O script a seguir usa o comando az storage blob upload-batch para carregar os blobs no contêiner de armazenamento.

az storage blob upload-batch \
    --pattern "container_size_sample_file_*.txt" \
    --source . \
    --destination $container \
    --account-key $accountKey \
    --account-name $storageAccount

O script a seguir usa o comando az storage blob list para listar os blobs no contêiner.

az storage blob list \
    --container-name $container \
    --account-key $accountKey \
    --account-name $storageAccount \
    --query "[].name"

O script a seguir exibe o total de bytes no contêiner de armazenamento.

bytes=`az storage blob list \
    --container-name $container \
    --account-key $accountKey \
    --account-name $storageAccount \
    --query "[*].[properties.contentLength]" \
    --output tsv | paste -s -d+ | bc`

echo "Total bytes in container: $bytes"
echo $bytes

Criar vários contêineres usando loops

Agora, criaremos vários contêineres usando um loop, demonstrando algumas maneiras de gravá-lo.

for i in `seq 1 4`; do 
az storage container create --account-name $storageAccount --account-key $accountKey --name learnbash-$i
done

for value in {5..8}
for (( i=5; i<10; i++));
do
az storage container create --account-name $storageAccount --account-key $accountKey --name learnbash-$i
done

az storage container list --account-name $storageAccount --account-key $accountKey --query [].name

Para definir variáveis de ambiente, use EXPORT

Nos scripts de contêiner de armazenamento anteriores, especificamos o nome da conta e a chave da conta com cada comando. Neste caso, você pode armazenar as credenciais de autenticação usando as variáveis de ambiente correspondentes: AZURE_STORAGE_ACCOUNT e AZURE_STORAGE_KEY. Para executar essa ação, use EXPORT.

export AZURE_STORAGE_ACCOUNT=$storageAccount
export AZURE_STORAGE_KEY=$accountKey
az storage container list # Uses the environment variables to display the list of containers.

O script a seguir cria uma cadeia de caracteres de metadados e usa o comando az storage container metadata update para atualizar um contêiner com essa cadeia de caracteres, novamente usando as variáveis de ambiente.

metadata="key=value pie=delicious" # Define metadata
az storage container metadata update \
    --name $container \
    --metadata $metadata # Update the metadata
az storage container metadata show \
    --name $containerName # Show the metadata

O comando a seguir usa o comando az storage container delete para excluir um só contêiner nomeado e depois excluir vários contêineres em um loop.

az storage container delete \
    --name $container

Obter a lista de contêineres que contêm um prefixo específico e armazenar os resultados em uma variável.

containerPrefix="learnbash"
containerList=$(az storage container list \
    --query "[].name" \
    --prefix $containerPrefix \
    --output tsv)

Excluir a lista de contêineres em um loop usando o argumento --prefix.

for row in $containerList
do
    tmpName=$(echo $row | sed -e 's/\r//g')
    az storage container delete \
    --name $tmpName 
done

Tratamento de erros

Para sair de um script imediatamente quando um comando retorna um status diferente de zero, execute o seguinte comando:

set -e

Para obter mais informações de como configurar opções do shell e outros tópicos de ajuda, execute os seguintes comandos:

help set
help help

Limpar os recursos

Depois de concluir este artigo, exclua o grupo de recursos e todos os recursos dentro dele. Use o argumento --no-wait.

if [ $(az group exists --name $resourceGroup) = true ]; then 
   az group delete --name $resourceGroup -y  --no-wait
else
   echo The $resourceGroup resource group does not exist
fi

Confira também

Tutorial: saiba como usar a CLI do Azure
Como usar a CLI do Azure com êxito
Como consultar uma saída dos comandos da CLI do Azure
Encontrar amostras da CLI do Azure e artigos publicados

Compartilhar via