Come usare l'interfaccia della riga di comando di Azure in un linguaggio di scripting Bash

  • Articolo

I comandi di riferimento dell'interfaccia della riga di comando di Azure possono essere eseguiti in diversi linguaggi di scripting. Se non si ha familiarità con Bash e l'interfaccia della riga di comando di Azure, questo articolo è un ottimo punto di partenza per iniziare il percorso di apprendimento. Per informazioni su come usare l'interfaccia della riga di comando di Azure in un linguaggio di scripting Bash con facilità, vedere questo articolo.

In questo articolo vengono illustrate le operazioni seguenti:

  • Risultati delle query come dizionari o matrici JSON
  • Formattare l'output come JSON, tabella o TSV
  • Eseguire query, filtrare e formattare valori singoli e multipli
  • Usare la sintassi if/exists/then e case
  • Usare per i cicli
  • Usare comandi grep, sed, incolla e bc
  • Popolare e usare le variabili di ambiente e della shell

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.

Avvio di Bash

Avviare Bash usando Azure Cloud Shell o un'installazione locale dell'interfaccia della riga di comando di Azure. Questo articolo presuppone che si stia eseguendo Bash usando Azure Cloud Shell o eseguendo l'interfaccia della riga di comando di Azure in locale in un contenitore Docker.

Esecuzione di query sui risultati del dizionario

Un comando che restituisce sempre solo un singolo oggetto restituisce un dizionario JSON. I dizionari sono oggetti non ordinati a cui si accede con chiavi. Per questo articolo, si inizierà eseguendo una query sull'oggetto Account usando il comando Account Show .

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

L'output del dizionario JSON seguente contiene alcuni campi omessi per brevità e le informazioni di identificazione vengono rimosse.

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

Formattazione dell'output come YAML

Usare l'argomento --output yaml (o -o yaml) per formattare l'output in formato yaml , un formato di serializzazione dei dati in testo normale. YAML tende a essere più facile da leggere rispetto a JSON, a cui può comunque essere eseguito facilmente il mapping. Alcune applicazioni e alcuni comandi dell'interfaccia della riga di comando accettano YAML come input di configurazione invece di JSON.

az account show --output yaml

Per altre informazioni sulla formattazione dell'output come yaml, vedere Formato di output YAML.

Formattazione dell'output come tabella

Usare l'argomento --output table (o -o table) per formattare l'output come tabella ASCII. Gli oggetti annidati non sono inclusi nell'output della tabella, ma possono comunque essere filtrati come parte di una query.

az account show --output table

Per altre informazioni sulla formattazione dell'output come tabella, vedere Formato di output tabella.

Esecuzione di query e formattazione di singoli valori e valori annidati

Le query seguenti illustrano l'esecuzione di query su singoli valori, inclusi i valori annidati in un output del dizionario JSON. La query finale in questo set illustra la formattazione dell'output usando l'argomento -o tsv . Questo argomento restituisce i risultati come valori delimitati da tabulazioni e righe nuove. Questa azione è utile per rimuovere le virgolette nel valore restituito, utile per utilizzare l'output in altri comandi e strumenti che devono elaborare il testo in qualche formato (come illustrato più avanti in questo articolo).

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

Esecuzione di query e formattazione di proprietà da matrici

La query seguente illustra come ottenere proprietà in una matrice JSON. Ottenere le proprietà della sottoscrizione, visualizzate come tabella delle sottoscrizioni.

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

Questa query restituisce risultati simili 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

Esecuzione di query e formattazione di più valori, inclusi i valori annidati

Per ottenere più di una proprietà, inserire le espressioni tra parentesi quadre [ ] (un elenco a selezione multipla) come elenco delimitato da virgole. Le query seguenti illustrano l'esecuzione di query su più valori in un output del dizionario JSON, usando più formati di output.

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

Per altre informazioni sulla restituzione di più valori, vedere Ottenere più valori.

Ridenominazione delle proprietà in una query

Le query seguenti illustrano l'uso dell'operatore { } (hash multiselect) per ottenere un dizionario anziché una matrice quando si eseguono query per più valori. Illustra anche la ridenominazione delle proprietà nel risultato della query.

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

Per altre informazioni sulla ridenominazione delle proprietà in una query, vedere Rinominare le proprietà in una query.

Esecuzione di query su valori booleani

Si presuppone che i valori booleani siano true, quindi la "[?isDefault]" sintassi della query per il az account list comando restituisce la sottoscrizione predefinita corrente. Per ottenere i valori false, è necessario usare un carattere di escape, ad esempio \.

Le query seguenti illustrano l'esecuzione di query su tutti gli account in una sottoscrizione, restituendo potenzialmente una matrice JSON se sono presenti più sottoscrizioni per un determinato account e quindi eseguendo query su quale account è la sottoscrizione predefinita. Viene inoltre illustrata l'esecuzione di query per gli account che non sono la sottoscrizione predefinita. Queste query si basano su ciò che si è appreso in precedenza per filtrare e formattare i risultati. Infine, la query finale illustra l'archiviazione dei risultati della query in una variabile.

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

Creazione di oggetti tramite variabili e casualizzazione

Impostazione di un valore casuale da usare nei comandi successivi

L'impostazione e l'uso di un valore casuale da usare nelle variabili consentono di eseguire script più volte senza conflitti di denominazione. I conflitti di denominazione si verificano perché un valore deve essere univoco nel servizio o perché un oggetto eliminato esiste ancora in Azure fino al completamento del processo di eliminazione.

$RANDOM è una funzione bash (non una costante) che restituisce un intero con segno casuale a 16 bit (da 0 a 32767). Il let comando è un comando Bash predefinito per valutare le espressioni aritmetiche. Usando il comando seguente viene creato un valore sufficientemente univoco per la maggior parte degli scopi.

let "randomIdentifier=$RANDOM*$RANDOM"

Utilizzo di spazi e virgolette

Gli spazi vengono usati per separare comandi, opzioni e argomenti. Usare i segni di virgolette per indicare alla shell Bash di ignorare tutti i caratteri speciali, di cui uno spazio vuoto è un carattere speciale. Quando la shell Bash vede il primo segno di virgolette, ignora i caratteri speciali fino al segno di virgolette di chiusura. Tuttavia, a volte si vuole che la shell Bash analizzi determinati caratteri speciali, ad esempio segni di dollaro, virgolette indietro e barre rovesciate. Per questo scenario, usare virgolette doppie.

I comandi seguenti usano il comando az group create per illustrare l'uso di virgolette singole e doppie. Questi comandi vengono usati per gestire gli spazi e valutare i caratteri speciali quando si usano variabili e si crea un oggetto.

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

Nell'output del dizionario JSON esaminare le proprietà del gruppo di risorse creato.

Utilizzo di If Then Else per determinare se la variabile è null

Per valutare le stringhe, usare != e per valutare i numeri usare -ne. L'istruzione If Then Else seguente valuta se la variabile $resourceGroup è stata impostata. In caso affermativo, restituisce il valore della variabile. In caso contrario, imposta la variabile .

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

Utilizzo di If Then per creare o eliminare un gruppo di risorse

Lo script seguente crea un nuovo gruppo di risorse solo se non esiste già uno con il nome specificato.

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

Lo script seguente elimina un gruppo di risorse nuovo esistente se ne esiste già uno con il nome specificato. È possibile usare l'argomento --no-wait per restituire il controllo senza attendere il completamento del comando. Tuttavia, per questo articolo, si vuole attendere che il gruppo di risorse venga eliminato prima di continuare. Per altre informazioni sulle operazioni asincrone, vedere Suggerimenti per l'uso corretto dell'interfaccia della riga di comando di Azure - Operazioni asincrone. Viene illustrato l'uso dell'argomento --no-wait alla fine di questo articolo.

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

Uso di Grep per determinare se esiste un gruppo di risorse e creare il gruppo di risorse in caso contrario

Il comando seguente invia tramite pipe l'output del az group list comando al grep comando . Se il gruppo di risorse specificato non esiste, il comando crea il gruppo di risorse usando le variabili definite in precedenza.

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

Uso dell'istruzione CASE per determinare se esiste un gruppo di risorse e creare il gruppo di risorse se non esiste

L'istruzione CASE seguente crea un nuovo gruppo di risorse solo se non esiste già uno con il nome specificato. Se esiste uno con il nome specificato, l'istruzione CASE restituisce che il gruppo di risorse esiste.

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

Uso di cicli for ed esecuzione di query su matrici

In questa sezione dell'articolo viene creato un account di archiviazione e quindi viene usato per i cicli per creare BLOB e contenitori. Viene anche illustrata l'esecuzione di query su matrici JSON e l'uso delle variabili di ambiente.

Creare un account di archiviazione

Il comando seguente usa il comando az storage account create per creare un account di archiviazione usato durante la creazione di contenitori di archiviazione.

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

Ottenere le chiavi dell'account di archiviazione

I comandi seguenti usano il comando az storage account keys list per restituire i valori di chiave dell'account di archiviazione. Si archivia quindi un valore di chiave in una variabile da usare durante la creazione di contenitori di archiviazione.

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

Creare un contenitore di archiviazione

Per iniziare, usare il comando az storage container create per creare un singolo contenitore di archiviazione e quindi usare az storage container list per eseguire una query sul nome del contenitore creato.

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

Caricare i dati nel contenitore

Lo script seguente crea tre file di esempio usando un ciclo for.

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

Lo script seguente usa il comando az storage blob upload-batch per caricare i BLOB nel contenitore di archiviazione.

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

Lo script seguente usa il comando az storage blob list per elencare i BLOB nel contenitore.

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

Nello script seguente vengono visualizzati i byte totali nel contenitore di archiviazione.

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

Creare molti contenitori usando cicli

Successivamente, si creano più contenitori usando un ciclo che illustra un paio di modi per scrivere il ciclo.

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

Usare EXPORT per definire le variabili di ambiente

Negli script del contenitore di archiviazione precedenti è stato specificato il nome dell'account e la chiave dell'account con ogni comando. È invece possibile archiviare le credenziali di autenticazione usando le variabili di ambiente corrispondenti: AZURE_STORAGE_ACCOUNT e AZURE_STORAGE_KEY. Per eseguire questa azione, utilizzare 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.

Lo script seguente crea una stringa di metadati e quindi usa il comando az storage container metadata update per aggiornare un contenitore con tale stringa, usando di nuovo le variabili di 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

Il comando seguente usa il comando az storage container delete per eliminare un singolo contenitore denominato e quindi eliminare più contenitori in un ciclo.

az storage container delete \
    --name $container

Ottenere un elenco di contenitori contenenti un prefisso specifico e archiviare i risultati in una variabile.

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

Eliminare l'elenco di contenitori in un ciclo usando l'argomento --prefix .

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

Gestione degli errori

Per uscire immediatamente da uno script se un comando restituisce uno stato diverso da zero, eseguire il comando seguente:

set -e

Per altre informazioni sull'impostazione delle opzioni della shell e altre informazioni, eseguire i comandi seguenti:

help set
help help

Pulire le risorse

Dopo aver completato questo articolo, eliminare il gruppo di risorse e tutte le risorse al suo interno. Usare l'argomento --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

Vedi anche