Verwendung der Azure CLI in einer Bash-Skriptsprache
Azure CLI-Referenzbefehle können in mehreren Skriptsprachen ausgeführt werden. Wenn Sie neu bei Bash und auch der Azure CLI sind, ist dieser Artikel ein guter Ausgangspunkt für Ihre Lern-Journey. Arbeiten Sie in diesem Artikel ähnlich wie ein Lernprogramm, um zu erfahren, wie Sie die Azure CLI in einer Bash-Skriptsprache mit Leichtigkeit verwenden können.
In diesem Artikel werden folgende Vorgehensweisen behandelt:
- Abfragen von Ergebnissen als JSON-Wörterbücher oder Arrays
- Formatieren der Ausgabe als JSON, Tabelle oder TSV
- Abfragen, Filtern und Formatieren einzelner und mehrerer Werte
- Verwenden von if-exists-then- und case-Syntax
- Verwenden von for-Schleifen
- Verwenden von grep-, sed-, paste- und bc-Befehlen
- Auffüllen und Verwenden von Shell- und Umgebungsvariablen
Wenn Sie kein Azure-Abonnement haben, erstellen Sie ein kostenloses Azure-Konto, bevor Sie beginnen.
Starten von Bash
Starten Sie Bash mithilfe von Azure Cloud Shell oder einer lokalen Installation der Azure CLI. In diesem Artikel wird davon ausgegangen, dass Sie Bash entweder mithilfe von Azure Cloud Shell oder Azure CLI lokal in einem Docker-Container ausführen.
Abfragen von Wörterbuchergebnissen
Ein Befehl, der immer nur ein einzelnes Objekt zurückgibt, gibt ein JSON-Wörterbuch zurück. Wörterbücher sind unsortierte Objekte, auf die mit Schlüsseln zugegriffen wird. In diesem Artikel fragen wir zunächst das Konto-Objekt mithilfe des Befehls Konto anzeigen ab.
az account show
az account show --output json # JSON is the default format
Die folgende JSON-Wörterbuchausgabe enthält einige Felder, die aus Platzgründen weggelassen werden, und die Identifizierung von Informationen wird entfernt.
bash-5.1# az account show
{
"environmentName": "AzureCloud",
"isDefault": true,
"managedByTenants": [],
"name": "My test subscription",
"state": "Enabled",
"user": {
"name": "user@contoso.com",
"type": "user"
}
}
Formatieren der Ausgabe als YAML
Verwenden Sie das Argument --output yaml (oder -o yaml) zum Formatieren der Ausgabe im YAML-Format, einem Serialisierungsformat für Nur-Text-Daten. YAML ist in der Regel leichter lesbar als JSON und lässt sich problemlos diesem Format zuordnen. Einige Anwendungen und CLI-Befehle verwenden als Konfigurationseingabe YAML anstelle von JSON.
az account show --output yaml
Weitere Informationen zum Formatieren der Ausgabe als YAML finden Sie unter YAML-Ausgabeformat.
Formatieren der Ausgabe als Tabelle
Verwenden Sie das Argument --output table (oder -o table) zum Formatieren der Ausgabe als ASCII-Tabelle. Geschachtelte Objekte sind in der Tabellenausgabe nicht enthalten, können jedoch im Rahmen einer Abfrage gefiltert werden.
az account show --output table
Weitere Informationen zum Formatieren der Ausgabe als Tabelle finden Sie unter Tabellenausgabeformat.
Abfragen und Formatieren einzelner Werte und geschachtelter Werte
Die folgenden Abfragen veranschaulichen die Abfrage einzelner Werte, einschließlich geschachtelter Werte in einer JSON-Wörterbuchausgabe. Die letzte Abfrage in dieser Gruppe veranschaulicht die Formatierung der Ausgabe mithilfe des Arguments -o tsv. Dieses Argument gibt die Ergebnisse als durch Tabstopp oder Zeilenumbruch getrennte Werte zurück. Diese Aktion ist hilfreich zum Entfernen von Anführungszeichen im zurückgegebenen Wert. Dies ist wiederum nützlich, um die Ausgabe in anderen Befehlen und Tools zu nutzen, in denen der Text in irgendeiner Form verarbeitet werden muss (wie später in diesem Artikel veranschaulicht).
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
Abfragen und Formatieren von Eigenschaften aus Arrays
Die folgende Abfrage veranschaulicht das Abrufen von Eigenschaften in einem JSON-Array. Abonnementeigenschaften werden abgerufen und als Tabelle mit Abonnements angezeigt.
az account list --query "[].{subscription_id:id, name:name, isDefault:isDefault}" -o table
Diese Abfrage gibt ähnliche Ergebnisse wie die Folgenden zurück:
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
Abfragen und Formatieren mehrerer Werte, einschließlich geschachtelter Werte
Um mehrere Eigenschaften abzurufen, schließen Sie Ausdrücke als durch Trennzeichen getrennte Liste in eckige Klammern [ ] (eine Mehrfachauswahlliste) ein. Die folgenden Abfragen veranschaulichen das Abfragen mehrerer Werte in einer JSON-Wörterbuchausgabe mit mehreren Ausgabeformaten.
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
Weitere Informationen zum Zurückgeben mehrerer Werte finden Sie unter Abrufen mehrerer Werte.
Umbenennen von Eigenschaften in einer Abfrage
Die folgenden Abfragen veranschaulichen die Verwendung des Operators { } (Mehrfachauswahl-Hash) zum Abrufen eines Wörterbuchs anstelle eines Arrays beim Abfragen nach mehreren Werten. Außerdem wird das Umbenennen von Eigenschaften im Abfrageergebnis veranschaulicht.
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
Weitere Informationen zum Umbenennen von Eigenschaften in einer Abfrage finden Sie unter Umbenennen von Eigenschaften in einer Abfrage.
Abfragen boolescher Werte
Boolesche Werte werden als „true“ angenommen, sodass die Abfragesyntax "[?isDefault]" für den Befehl az account list das aktuelle Standardabonnement zurückgibt. Um die false-Werte abzurufen, müssen Sie ein Escapezeichen verwenden, z. B. \.
Die folgenden Abfragen veranschaulichen das Abfragen aller Konten in einem Abonnement, bei denen möglicherweise eine JSON-Array zurückgegeben wird, wenn für ein bestimmtes Konto mehrere Abonnements vorhanden sind, und die anschließende Abfrage, welches Konto das Standardabonnement ist. Außerdem wird die Abfrage für der Konten veranschaulicht, die nicht zum Standardabonnement gehören. Diese Abfragen bauen auf dem auf, was Sie zuvor über das Filtern und Formatieren der Ergebnisse gelernt haben. Die letzte Abfrage veranschaulicht schließlich das Speichern der Abfrageergebnisse in einer Variablen.
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
- Weitere Informationen zum Filtern von Arrays und Abfragen von booleschen Werten finden Sie unter Filtern von Arrays mit booleschen Ausdrücken.
- Weitere Informationen zur Verwendung von Variablen finden Sie unter Verwenden von Variablen in Azure CLI-Befehlen.
- Weitere Informationen zum Verwenden von Abonnements finden Sie unter Verwalten von Azure-Abonnements mit der Azure CLI.
Erstellen von Objekten mithilfe von Variablen und Randomisierung
Festlegen eines Zufallswerts für die Verwendung in nachfolgenden Befehlen
Wenn Sie einen Zufallswert für die Verwendung in Variablen festlegen und verwenden, können Sie Skripts mehrmals ohne Benennungskonflikte ausführen. Benennungskonflikte treten auf, da ein Wert für den gesamten Dienst eindeutig sein muss oder weil ein objekt, das Sie gelöscht haben, weiterhin in Azure vorhanden ist, bis der Löschvorgang abgeschlossen ist.
$RANDOM ist eine Bash-Funktion (keine Konstante), die eine zufällige signierte 16-Bit-Ganzzahl (von 0 bis 32767) zurückgibt. Der Befehl let ist ein integrierter Bash-Befehl für die Auswertung arithmetischer Ausdrücke.
Mit dem folgenden Befehl wird ein für die meisten Zwecke ausreichend eindeutiger Wert erstellt:
let "randomIdentifier=$RANDOM*$RANDOM"
Arbeiten mit Leerzeichen und Anführungszeichen
Leerzeichen werden zum Trennen von Befehlen, Optionen und Argumenten verwendet. Verwenden Sie Anführungszeichen, um die Bash-Shell anzuweisen, alle Sonderzeichen zu ignorieren. Leerzeichen gelten hierbei als Sonderzeichen. Wenn die Bash-Shell das erste Anführungszeichen erkennt, ignoriert sie Sonderzeichen bis zum schließenden Anführungszeichen. Manchmal möchten Sie jedoch, dass die Bash-Shell bestimmte Sonderzeichen analysiert, z. B. Dollarzeichen, invertierte Hochkommas und umgekehrte Schrägstriche. Verwenden Sie für dieses Szenario doppelte Anführungszeichen.
Die folgenden Befehle verwenden den Befehl az group create, um die Verwendung einfacher und doppelter Anführungszeichen zu veranschaulichen. Diese Befehle werden verwendet, um Leerzeichen zu behandeln und Sonderzeichen auszuwerten, wenn Sie mit Variablen arbeiten und ein Objekt erstellen.
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
Überprüfen Sie in der JSON-Wörterbuchausgabe die Eigenschaften der Ressourcengruppe, die erstellt wurde.
Verwenden von If-Then-Else zum Ermitteln, ob die Variable NULL ist
Verwenden Sie zum Auswerten von Zeichenfolgen != und zum Auswerten von Zahlen -ne. Die folgende If-Then-Else-Anweisung wertet aus, ob die Variable „$resourceGroup“ festgelegt wurde. Falls ja, wird der Wert der Variablen zurückgegeben. Falls nein, wird die Variable festgelegt.
if [ $resourceGroup != '' ]; then
echo $resourceGroup
else
resourceGroup="msdocs-learn-bash-$randomIdentifier"
fi
Verwenden von If-Then zum Erstellen oder Löschen einer Ressourcengruppe
Das folgende Skript erstellt nur dann eine neue Ressourcengruppe, wenn noch keine Gruppe mit dem angegebenen Namen vorhanden ist.
if [ $(az group exists --name $resourceGroup) = false ]; then
az group create --name $resourceGroup --location "$location"
else
echo $resourceGroup
fi
Das folgende Skript löscht eine vorhandene Ressourcengruppe, wenn bereits eine mit dem angegebenen Namen vorhanden ist. Sie können das Argument --no-wait verwenden, um die Kontrolle zurückzugeben, ohne auf den Abschluss des Befehls zu warten. In diesem Artikel möchten wir jedoch warten, bis die Ressourcengruppe gelöscht ist, bevor wir den Vorgang fortsetzen. Weitere Informationen zu asynchronen Vorgängen finden Sie unter Tipps für die erfolgreiche Verwendung der Azure CLI – asynchrone Vorgänge.
Wir veranschaulichen die Verwendung des --no-wait-Arguments am Ende dieses Artikels.
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
Verwendung von Grep, um zu ermitteln, ob eine Ressourcengruppe vorhanden ist, und Erstellen der Ressourcengruppe, wenn dies nicht der Fall ist
Der folgende Befehl übergibt die Ausgabe des Befehls az group list an den Befehl grep. Wenn die angegebene Ressourcengruppe nicht vorhanden ist, erstellt der Befehl die Ressourcengruppe mithilfe der zuvor definierten Variablen.
az group list --output tsv | grep $resourceGroup -q || az group create --name $resourceGroup --location "$location"
Verwendung der CASE-Anweisung, um zu ermitteln, ob eine Ressourcengruppe vorhanden ist, und Erstellen der Ressourcengruppe, wenn dies nicht der Fall ist
Die folgende CASE-Anweisung erstellt nur dann eine neue Ressourcengruppe, wenn noch keine Gruppe mit dem angegebenen Namen vorhanden ist. Wenn eine Ressourcengruppe mit dem angegebenen Namen vorhanden ist, gibt die CASE-Anweisung zurück, dass die Ressourcengruppe vorhanden ist.
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
Verwenden von for-Schleifen und Abfragen von Arrays
In diesem Abschnitt des Artikels erstellen wir ein Speicherkonto und verwenden dann „for“-Schleifen, um Blobs und Container zu erstellen. Wir demonstrieren auch das Abfragen von JSON-Arrays und das Arbeiten mit Umgebungsvariablen.
Speicherkonto erstellen
Der folgende Befehl verwendet den Befehl az storage account create, um ein Speicherkonto zu erstellen, das wir beim Erstellen von Speichercontainern verwenden.
storageAccount="learnbash$randomIdentifier"
az storage account create --name $storageAccount --location "$location" --resource-group $resourceGroup --sku Standard_LRS --encryption-services blob
Abrufen der Speicherkontoschlüssel
Die folgenden Befehle verwenden den Befehl az storage account keys list, um Schlüsselwerte für das Speicherkonten zurückzugeben. Anschließend wird ein Schlüsselwert in einer Variablen zur Verwendung beim Erstellen von Speichercontainern gespeichert.
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
Erstellen eines Speichercontainers
Wir verwenden zunächst den Befehl az storage container create zum Erstellen eines einzelnen Speichercontainers und dann az storage container list, um den Namen des erstellten Containers abzufragen.
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
Hochladen von Daten in einen Container
Das folgende Skript erstellt drei Beispieldateien, die eine for-Schleife verwenden:
for i in `seq 1 3`; do
echo $randomIdentifier > container_size_sample_file_$i.txt
done
Das folgende Skript verwendet den Befehl az storage blob upload-batch, um die Blobs in den Speichercontainer hochzuladen:
az storage blob upload-batch \
--pattern "container_size_sample_file_*.txt" \
--source . \
--destination $container \
--account-key $accountKey \
--account-name $storageAccount
Das folgende Skript verwendet den Befehl az storage blob list, um die Blobs im Container aufzulisten:
az storage blob list \
--container-name $container \
--account-key $accountKey \
--account-name $storageAccount \
--query "[].name"
Das folgende Skript zeigt die gesamten Bytes im Speichercontainer an:
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
Erstellen zahlreicher Container mithilfe von Schleifen
Als Nächstes erstellen wir mehrere Container mithilfe einer Schleife und veranschaulichen dabei eine Reihe von Möglichkeiten zum Schreiben der Schleife.
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
Verwenden von EXPORT zum Definieren von Umgebungsvariablen
In den vorherigen Speichercontainerskripts haben wir mit jedem Befehl den Kontonamen und den Kontoschlüssel angegeben. Stattdessen können Sie Ihre Authentifizierungsanmeldeinformationen mithilfe der entsprechenden Umgebungsvariablen speichern: AZURE_STORAGE_ACCOUNT und AZURE_STORAGE_KEY. Um diese Aktion auszuführen, verwenden Sie 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.
Das folgende Skript erstellt eine Metadatenzeichenfolge und verwendet dann den Befehl az storage container metadata update, um einen Container mit dieser Zeichenfolge zu aktualisieren. Dazu werden erneut die Umgebungsvariablen verwendet:
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
Im folgenden Befehl wird der Befehl az storage container delete verwendet, um einen einzelnen benannten Container zu löschen und dann mehrere Container in einer Schleife zu löschen:
az storage container delete \
--name $container
Rufen Sie eine Liste der Container ab, die ein bestimmtes Präfix enthalten, und speichern Sie die Ergebnisse in einer Variablen.
containerPrefix="learnbash"
containerList=$(az storage container list \
--query "[].name" \
--prefix $containerPrefix \
--output tsv)
Löschen Sie die Liste der Container in einer Schleife mithilfe des Arguments --prefix.
for row in $containerList
do
tmpName=$(echo $row | sed -e 's/\r//g')
az storage container delete \
--name $tmpName
done
Fehlerbehandlung
Um ein Skript sofort zu beenden, wenn ein Befehl einen Nicht-Null-Status zurückgibt, verwenden Sie den folgenden Befehl:
set -e
Wenn Sie weitere Informationen zum Festlegen von Shell-Optionen und andere Hilfe benötigen, führen Sie die folgenden Befehle aus:
help set
help help
Bereinigen von Ressourcen
Nachdem Sie diesen Artikel abgeschlossen haben, löschen Sie die Ressourcengruppe und alle darin enthaltenen Ressourcen. Verwenden Sie das Argument --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
