Freigeben über

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 der Azure CLI sind, ist dieser Artikel ein großartiger Ort, um Ihre Lernreise zu beginnen. Arbeiten Sie mit diesem Artikel so, wie Sie es mit einem Tutorial tun würden, um mit Leichtigkeit zu lernen, wie Sie die Azure CLI in der Bash-Skriptsprache verwenden können.

In diesem Artikel erfahren Sie, wie Sie:

  • Abfrageergebnisse als JSON-Wörterbücher oder Arrays
  • Formatieren der Ausgabe als JSON, Tabelle oder TSV
  • Abfragen, Filtern und Formatieren einzelner und mehrerer Werte
  • Verwenden Sie if/exists/then und case syntax
  • Verwendung von For-Schleifen
  • Verwenden Sie die Befehle grep, sed, paste und bc
  • 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 mit 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 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 ungeordnete Objekte, auf die mit Schlüsseln zugegriffen wird. In diesem Artikel beginnen wir mit der Abfrage des Account-Objekts mithilfe des Befehls "Konto anzeigen ".

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

Die folgende JSON-Wörterbuchausgabe hat einige Felder der Kürze halber ausgelassen, und identifizierende Informationen werden 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 --output yaml Argument (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 im YAML-Ausgabeformat.

Formatieren der Ausgabe als Tabelle

Verwenden Sie das --output table Argument (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 im Tabellenausgabeformat.

Abfragen und Formatieren einzelner Werte und geschachtelter Werte

Die folgenden Abfragen veranschaulichen das Abfragen einzelner Werte, einschließlich geschachtelter Werte in einer JSON-Wörterbuchausgabe. Die letzte Abfrage in diesem Satz veranschaulicht die Formatierung der Ausgabe mithilfe des -o tsv Arguments. Dieses Argument gibt die Ergebnisse als mit Tabulator- und Zeilenumbruch getrennte Werte zurück. Diese Aktion ist hilfreich, um Anführungszeichen im zurückgegebenen Wert zu entfernen, sodass die Ausgabe in andere Befehle und Tools eingespeist werden kann, die den Text in irgendeiner Form verarbeiten müssen (wie weiter unten in diesem Artikel gezeigt wird).

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 abrufen, die als Tabelle der Abonnements angezeigt werden.

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

Diese Abfrage gibt Ergebnisse ähnlich wie folgt 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

Wenn Sie mehr als eine Eigenschaft abrufen möchten, platzieren Sie Ausdrücke in eckigen Klammern [ ] (eine Mehrfachauswahlliste) als durch Trennzeichen getrennte Liste. Die folgenden Abfragen veranschaulichen das Abfragen mehrerer Werte in einer JSON-Wörterbuchausgabe mithilfe mehrerer Ausgabeformate.

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 (Multiselect 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 wahr angenommen, sodass die "[?isDefault]" Abfragesyntax für den az account list Befehl das aktuelle Standardabonnement zurückgibt. Um die falschen Werte zu erhalten, müssen Sie ein Escapezeichen verwenden, z.B. \.

Die folgenden Abfragen zeigen, wie alle Konten innerhalb einer Abonnementgruppe abgefragt werden, wobei ein JSON-Array zurückgegeben werden kann, falls es mehrere Konten in einer bestimmten Abonnementgruppe gibt. Anschließend wird abgefragt, welches Abonnement das Standardkonto ist. Außerdem wird die Abfrage der Konten veranschaulicht, die nicht das Standardabonnement sind. Diese Abfragen basieren auf dem, was Sie zuvor gelernt haben, um die Ergebnisse zu filtern und zu formatieren. Schließlich veranschaulicht die endgültige Abfrage 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

Erstellen von Objekten mithilfe von Variablen und Zufallsvariablen

Festlegen eines Zufallswerts für die Verwendung in nachfolgenden Befehlen

Das Festlegen und Verwenden eines Zufallswerts für die Verwendung in Variablen ermöglicht es Ihnen, Skripts mehrmals ohne Namenskonflikte auszufü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ällig signierte 16-Bit-Ganzzahl (von 0 bis 32767) zurückgibt. Der let Befehl ist ein integrierter Bash-Befehl zum Auswerten arithmetischer Ausdrücke. Die Verwendung des folgenden Befehls erstellt für die meisten Zwecke einen ausreichend eindeutigen Wert.

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 dazu zu bringen, alle Sonderzeichen zu ignorieren, wobei ein Leerzeichen ein solches Sonderzeichen ist. Wenn die Bash-Shell das erste Anführungszeichen sieht, ignoriert sie Sonderzeichen bis zum schließenden Anführungszeichen. Manchmal möchten Sie jedoch, dass die Bash-Shell bestimmte Sonderzeichen analysiert, z. B. Dollarzeichen, Zurückführungszeichen und umgekehrte Schrägstriche. Verwenden Sie für dieses Szenario doppelte Anführungszeichen.

Mit den folgenden Befehlen wird der Befehl "az group create " verwendet, um die Verwendung von einfachen und doppelten Anführungszeichen zu veranschaulichen. Diese Befehle werden verwendet, um Leerzeichen zu verarbeiten 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 erstellten Ressourcengruppe.

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. Wenn ja, wird der Wert der Variablen zurückgegeben. Wenn 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 eine mit dem angegebenen Namen noch nicht 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 neue Ressourcengruppe, wenn eine mit dem angegebenen Namen bereits vorhanden ist. Sie können das --no-wait Argument verwenden, um die Steuerung zurückzugeben, ohne auf den Abschluss des Befehls zu warten. Für diesen Artikel möchten wir jedoch warten, bis die Ressourcengruppe gelöscht wird, bevor sie fortgesetzt wird. 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

Verwenden von Grep, um zu ermitteln, ob eine Ressourcengruppe vorhanden ist, und erstellen Sie die Ressourcengruppe, wenn sie nicht vorhanden ist.

Der folgende Befehl gibt die Ausgabe des az group list Befehls an den grep Befehl weiter. 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"

Verwenden der CASE-Anweisung, um zu ermitteln, ob eine Ressourcengruppe vorhanden ist, und erstellen Sie die Ressourcengruppe, falls dies nicht der Fall ist.

Die folgende CASE-Anweisung erstellt nur dann eine neue Ressourcengruppe, wenn eine mit dem angegebenen Namen noch nicht vorhanden ist. Wenn ein Objekt mit dem angegebenen Namen vorhanden ist, wird durch die CASE-Anweisung ausgegeben, 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 das Abfragen von Arrays

In diesem Abschnitt des Artikels erstellen wir ein Speicherkonto und verwenden anschließend Schleifen, um Blobs und Container zu erstellen. Außerdem veranschaulichen wir das Abfragen von JSON-Arrays und das Arbeiten mit Umgebungsvariablen.

Speicherkonto erstellen

Der folgende Befehl verwendet den Befehl "az storage account create " zum Erstellen eines Speicherkontos, 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 Listenbefehl "az storage account keys list " zum Zurückgeben von Speicherkontoschlüsselwerten. Anschließend wird ein Schlüsselwert in einer Variablen gespeichert, die beim Erstellen von Speichercontainern verwendet werden kann.

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

Zunächst verwenden wir den az-Speichercontainer zum Erstellen eines einzelnen Speichercontainers und verwenden dann die Az-Speichercontainerliste , 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 Container

Das folgende Skript erstellt drei Beispieldateien mit einer For-Schleife.

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

Das folgende Skript verwendet den Az Storage Blob Upload-Batch-Befehl , 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" zum Auflisten der Blobs im Container.

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

Das folgende Skript zeigt die Gesamtbytes 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 vieler Container mithilfe von Schleifen

Als Nächstes erstellen wir mehrere Container mithilfe einer Schleife, die einige Möglichkeiten veranschaulicht, die Schleife zu schreiben.

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 den Kontonamen und den Kontoschlüssel mit jedem Befehl 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 Aktualisierungsbefehl für az Storage-Containermetadaten , um einen Container mit dieser Zeichenfolge erneut mithilfe der Umgebungsvariablen zu aktualisieren.

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

Der folgende Befehl verwendet den Befehl " az storage container delete", um einen einzelnen benannten Container zu löschen und dann mehrere Container in einer Schleife zu löschen.

az storage container delete \
    --name $container

Dient zum Abrufen einer Liste von Containern, die ein bestimmtes Präfix enthalten, und speichern Sie 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 --prefix Arguments.

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

Fehlerbehandlung

Führen Sie den folgenden Befehl aus, um ein Skript sofort zu beenden, wenn ein Befehl den Status ungleich Null zurückgibt:

set -e

Wenn Sie weitere Informationen zum Festlegen von Shelloptionen und anderen Hilfen wünschen, 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 --no-wait Argument.

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

Siehe auch