Partilhar via

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

  • Artigo

Os comandos de referência da CLI do Azure podem ser executados em várias linguagens 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 aprendizado. Trabalhe neste artigo como faria com um tutorial para aprender a usar a CLI do Azure em uma linguagem de script Bash com facilidade.

Neste artigo, vai aprender a:

  • Resultados da consulta como dicionários ou matrizes JSON
  • Formatar saída como JSON, tabela ou TSV
  • Consultar, filtrar e formatar valores únicos e múltiplos
  • Use a sintaxe if/exists/then e case
  • Uso para loops
  • Usar comandos grep, sed, paste e bc
  • Preencher e usar variáveis de shell e ambiente

Se você não tiver 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.

Consultando resultados de dicionários

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

Formatando a saída como YAML

Use o --output yaml argumento (ou -o yaml) para formatar a saída no formato yaml , um formato de serialização de dados de texto simples. O YAML tende a ser mais fácil de ler do que o JSON e facilmente mapeia para esse formato. Algumas aplicações e os comandos da CLI utilizam o YAML como uma entrada de configuração, em vez do JSON.

az account show --output yaml

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

Formatando a saída como uma tabela

Use o --output table argumento (ou ) para formatar -o tablea saída como uma tabela ASCII. Os objetos aninhados não são incluídos na saída da tabela, mas ainda assim 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 Formato de saída da tabela.

Consultando e formatando 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 -o tsv argumento. Esse argumento retorna os resultados como valores separados por tabulação e nova linha. Esta 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 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

Consultando e formatando propriedades de matrizes

A consulta a seguir demonstra a obtenção de 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

Esta 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 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 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 multiselect) 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 booleanos

Os valores booleanos são considerados verdadeiros, portanto, a sintaxe de "[?isDefault]" 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 consultar todas as contas em uma assinatura, potencialmente retornar uma matriz JSON se houver várias assinaturas para uma determinada conta e, em seguida, consultar qual conta é a assinatura padrão. Ele também demonstra a consulta para as contas que não são a assinatura padrão. Essas consultas se baseiam no que você aprendeu anteriormente para filtrar e formatar os resultados. Finalmente, a consulta final demonstra o armazenamento dos 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

Criação de 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 executar scripts várias vezes sem conflitos de nomenclatura. Os 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 inteiro de 16 bits assinado aleatoriamente (de 0 a 32767). O let comando é um comando Bash integrado 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 dizer ao shell Bash para ignorar todos os caracteres especiais, dos quais um espaço em branco é um caractere especial. Quando o shell Bash vê as primeiras aspas, ele ignora caracteres especiais até as aspas de fechamento. No entanto, às vezes você quer que o shell Bash analise certos caracteres especiais, como cifrões, aspas traseiras 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, revise 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, ele retorna 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 exclui um novo grupo de recursos existente se já existir um com o nome especificado. Você pode usar o argumento para retornar o --no-wait controle sem esperar que o comando seja concluído. No entanto, para este artigo, queremos aguardar que o grupo de recursos seja excluído 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

Usando o Grep para determinar se um grupo de recursos existe 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 existir um com o nome especificado, a instrução CASE ecoa 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

Usando para loops e consultando matrizes

Nesta seção do artigo, criamos uma conta de armazenamento e, em seguida, usamos para loops para criar blobs e contêineres. Também demonstramos 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 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 de 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 contentor de armazenamento

Começamos usando o contêiner de armazenamento az 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 para o 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

Crie muitos contêineres usando loops

Em seguida, criamos vários contêineres usando um loop demonstrando algumas maneiras de escrever 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

Use 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 EXPORTAR.

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 metadados e, em seguida, 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 ú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 contendo um prefixo específico e armazene os 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

Processamento 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 do shell e outras ajudas, execute os seguintes comandos:

help set
help help

Clean up resources (Limpar 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