Compartilhar via

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

Os comandos de referência da CLI do Azure podem ser executados em vários idiomas de script. Se você é novo no Bash e também na CLI do Azure, este artigo é um ótimo lugar para começar sua jornada de aprendizagem. Trabalhe neste artigo da mesma forma que você faria um tutorial para aprender a usar a CLI do Azure em uma linguagem de script bash com facilidade.

Neste artigo, você aprenderá a:

  • Consultar resultados como dicionários JSON ou matrizes
  • Formatar saída como JSON, tabela ou TSV
  • Consultar, filtrar e formatar valores únicos e múltiplos
  • Como usar as sintaxes "if/exists/then" e "case"
  • Usar para loops
  • Usar comandos grep, sed, paste e bc
  • Definir e usar variáveis de shell e ambiente

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

Iniciando 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 apenas um único objeto retorna um dicionário JSON. Dicionários são objetos não ordenados acessados com chaves. Para este 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 questão de 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 --output yaml argumento (ou -o yaml) para formatar a saída no formato yaml, que é um formato de serialização de dados em texto simples. O YAML tende a ser mais fácil de ler do que o JSON e é facilmente mapeado 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 sobre como formatar a saída como yaml, consulte o formato de saída YAML.

Formatar a saída como uma tabela

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

az account show --output table

Para obter mais informações sobre como formatar a saída como uma tabela, consulte o formato de saída da tabela.

Consultar e formatar valores individuais 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 -o tsv argumento. Esse argumento retorna os resultados como valores separados por guia e nova linha. Essa ação é útil para remover aspas no valor retornado , o que é útil para consumir a saída em outros comandos e ferramentas que precisam processar o texto de alguma forma (como é demonstrado posteriormente 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 as propriedades da 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

Consultando e formatando vários valores, incluindo valores aninhados

Para obter mais de uma propriedade, coloque expressões em colchetes [ ] (uma lista multisseleção) como uma lista separada por vírgulas. 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 sobre como retornar vários valores, consulte Obter vários valores.

Renomeando propriedades em uma consulta

As consultas a seguir demonstram o uso do operador { } (hash multiseleção) para obter um dicionário em vez de uma matriz ao consultar vários valores. Ele também demonstra 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 sobre como renomear propriedades em uma consulta, consulte Renomear propriedades em uma consulta.

Consultando valores boolianos

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

As consultas a seguir demonstram a consulta de todas as contas em uma assinatura, potencialmente retornando uma matriz JSON se houver várias assinaturas para uma determinada conta e, em seguida, consultando para qual conta é a assinatura padrão. Ele também demonstra a consulta das contas que não são a assinatura predefinida. Essas consultas se baseiam no que você aprendeu anteriormente 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

Criando objetos usando variáveis e randomização

Definindo um valor aleatório para uso em comandos subsequentes

Definir e usar um valor aleatório para uso em variáveis permite que você execute scripts várias vezes sem nomear conflitos. Conflitos de nomenclatura ocorrem porque um valor deve ser exclusivo em todo o 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 número inteiro com sinal de 16 bits aleatório (entre 0 e 32.767). O let comando é 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"

Trabalhando com espaços e aspas

Espaços são usados para separar comandos, opções e argumentos. Use aspas para instruir o shell Bash a ignorar todos os caracteres especiais, incluindo o espaço em branco como um caractere especial. Quando o shell bash vê a primeira marca de aspas, ele ignora caracteres especiais até a marca de aspas de fechamento. No entanto, às vezes você quer que o shell Bash analise certos caracteres especiais, como sinais de dólar, crases e barras invertidas. Para esse cenário, use aspas duplas.

Os comandos a seguir usam o comando az group create para 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 foi criado.

Usando 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, retornará o valor da variável. Se não, define a variável.

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

Usando If Then para criar ou excluir um grupo de recursos

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

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

O script a seguir excluirá um novo grupo de recursos existente se já existir um com o nome especificado. Você pode usar o argumento --no-wait para retornar o controle sem esperar que o comando seja concluído. No entanto, para este artigo, queremos aguardar a exclusão do grupo de recursos antes de 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. Demonstramos o uso do --no-wait argumento 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 o grupo de recursos se ele não existir

O comando a seguir canaliza a saída do az group list comando para o grep comando. Se o grupo de recursos especificado não existir, o comando criará o grupo de recursos usando as variáveis definidas anteriormente.

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

Usando a instrução CASE para determinar se existe um grupo de recursos e criar o grupo de recursos se ele não existir

A instrução CASE a seguir cria um novo grupo de recursos somente se um com o nome especificado ainda não existir. Se houver um com o nome especificado, a instrução CASE indica que o grupo de recursos 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 para loops e matrizes de consulta

Nesta seção do artigo, criamos uma conta de armazenamento e usamos laços 'for' para criar blobs e contêineres. Também demonstramos a consulta de matrizes JSON e o trabalho 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 usamos 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 da conta de armazenamento. Em seguida, armazenamos um valor de chave em uma variável para uso ao criar 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 contêiner de armazenamento

Começamos usando o az storage container create para criar um único contêiner de armazenamento e, em seguida, usamos a lista de contêineres de armazenamento az 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 loop for.

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 muitos contêineres usando loops

Em seguida, criamos vários contêineres usando um loop demonstrando algumas maneiras de gravar o loop.

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

Usar EXPORT para definir variáveis de ambiente

Nos scripts de contêiner de armazenamento anteriores, especificamos o nome da conta e a chave da conta com cada comando. Em vez disso, você pode armazenar suas 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, em seguida, usa o comando de atualização de metadados do contêiner de armazenamento az 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 único contêiner nomeado e, em seguida, excluir vários contêineres em um loop.

az storage container delete \
    --name $container

Obtenha uma lista de contêineres que contêm um prefixo específico e armazene resultados em uma variável.

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

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

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 se um comando retornar um status diferente de zero, execute o seguinte comando:

set -e

Para obter mais informações sobre como definir opções de shell e outras ajudas, 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 --no-wait argumento.

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

Consulte também