Lär dig hur du använder Bash med Azure CLI

Azure CLI-referenskommandon kan köras i flera olika gränssnittsmiljöer, men Microsoft Docs använder främst Bash-miljön. Om du är nybörjare på Bash och även Azure CLI är den här artikeln ett bra ställe att börja din utbildningsresa på. Gå igenom den här artikeln ungefär som i en självstudiekurs om hur du enkelt kan använda Azure CLI i en Bash-miljö.

I den här artikeln kan du se hur du:

  • Frågeresultat som JSON-ordlistor eller matriser
  • Formatera utdata som JSON, tabell eller TSV
  • Fråga, filtrera och formatera enkla och flera värden
  • Använd if/exists/then och skiftlägessyntax
  • Använd för loopar
  • Använda kommandona grep, sed, paste och bc
  • Fylla i och använda gränssnitts- och miljövariabler

Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-konto innan du börjar.

Startar Bash

Starta Bash med Azure Cloud Shell eller en lokal installation av Azure CLI. Den här artikeln förutsätter att du kör Bash antingen med Azure Cloud Shell eller kör Azure CLI lokalt i en docker-container.

Köra frågor mot ordlisteresultat

Ett kommando som alltid returnerar endast ett enskilt objekt returnerar en JSON-ordlista. Ordlistor är osorterade objekt som används med nycklar. I den här artikeln börjar vi med att köra frågor mot kontoobjektet med hjälp av kommandot Kontovisning.

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

Följande JSON-ordlisteutdata har vissa fält utelämnats för korthet och identifierande information har tagits bort eller genericiserats.

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

Formatera utdata som YAML

--output yaml Använd argumentet (eller -o yaml) för att formatera utdata i yaml-format, ett format för oformaterad dataserialisering. YAML kan vara lättare att läsa än JSON, och mappas enkelt till det formatet. Vissa program och CLI-kommandon tar YAML som konfigurationsindata, i stället för JSON.

az account show --output yaml

Mer information om hur du formaterar utdata som yaml finns i YAML-utdataformat.

Formatera utdata som en tabell

--output table Använd argumentet (eller -o table) för att formatera utdata som en ASCII-tabell. Kapslade objekt ingår inte i tabellutdata, men kan fortfarande filtreras som en del av en fråga.

az account show --output table

Mer information om hur du formaterar utdata som en tabell finns i Tabellutdataformat.

Köra frågor mot och formatera enskilda värden och kapslade värden

Följande frågor visar hur du kör frågor mot enskilda värden, inklusive kapslade värden i en JSON-ordlista. Den sista frågan i den här uppsättningen visar formatering av utdata med argumentet -o tsv . Det här argumentet returnerar resultatet som tab- och newline-avgränsade värden. Den här åtgärden är användbar för att ta bort citattecken i det returnerade värdet , vilket är användbart för att använda utdata till andra kommandon och verktyg som behöver bearbeta texten i någon form (vilket visas senare i den här artikeln).

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

Fråga efter och formatera egenskaper från matriser

Följande fråga visar hur du hämtar egenskaper i en JSON-matris. Hämta prenumerationsegenskaper, som visas som en tabell med prenumerationer.

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

Den här frågan returnerar resultat som liknar:

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

Köra frågor mot och formatera flera värden, inklusive kapslade värden

Om du vill hämta mer än en egenskap placerar du uttryck inom hakparenteser [ ] (en flervalslista) som en kommaavgränsad lista. Följande frågor visar hur du frågar efter flera värden i en JSON-ordlista med hjälp av flera utdataformat.

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

Mer information om hur du returnerar flera värden finns i Hämta flera värden.

Byta namn på egenskaper i en fråga

Följande frågor visar hur operatorn { } (multiselect hash) används för att hämta en ordlista i stället för en matris när du frågar efter flera värden. Den visar också namnbyte av egenskaper i frågeresultatet.

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

Mer information om hur du byter namn på egenskaper i en fråga finns i Byt namn på egenskaper i en fråga.

Köra frågor mot booleska värden

Booleska värden antas vara sanna, så "[?isDefault]" frågesyntaxen az account list för kommandot returnerar den aktuella standardprenumerationen. Om du vill hämta falska värden måste du använda ett escape-tecken, till exempel \.

Följande frågor visar hur du frågar efter alla konton i en prenumeration, eventuellt returnerar en JSON-matris om det finns flera prenumerationer för ett visst konto och sedan frågar efter vilket konto som är standardprenumerationen. Det visar också frågor för de konton som inte är standardprenumerationen. Dessa frågor bygger på det du lärde dig tidigare för att filtrera och formatera resultaten. Slutligen visar den sista frågan hur du lagrar frågeresultaten i en variabel.

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

Skapa objekt med hjälp av variabler och slumpmässighet

Ange ett slumpmässigt värde för användning i efterföljande kommandon

Om du anger och använder ett slumpmässigt värde för användning i variabler kan du köra skript flera gånger utan att namnge konflikter. Namngivningskonflikter kan uppstå på grund av att ett värde måste vara unikt för tjänsten, eller för att ett objekt som du har tagit bort fortfarande finns i Azure tills borttagningsprocessen är klar.

$RANDOM är en bash-funktion (inte en konstant) som returnerar ett slumpmässigt signerat 16-bitars heltal (från 0 till 32767). Kommandot let är ett inbyggt Bash-kommando för att utvärdera aritmetiska uttryck. Med följande kommando skapas ett tillräckligt unikt värde för de flesta ändamål.

let "randomIdentifier=$RANDOM*$RANDOM"

Arbeta med blanksteg och citattecken

Blanksteg används för att separera kommandon, alternativ och argument. Använd citattecken för att tala om för Bash-gränssnittet att ignorera alla specialtecken, varav ett tomt utrymme är ett specialtecken. När Bash-gränssnittet ser det första citattecknet ignoreras specialtecken fram till det avslutande citattecknet. Ibland vill du dock att Bash-gränssnittet parsar vissa specialtecken, till exempel dollartecken, citattecken och omvänt snedstreck. I det här scenariot använder du dubbla citattecken.

Följande kommandon använder kommandot az group create för att illustrera användningen av enkla och dubbla citattecken. Dessa kommandon används för att hantera blanksteg och utvärdera specialtecken när du arbetar med variabler och skapar ett objekt.

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 

I JSON-ordlistans utdata granskar du egenskaperna för den resursgrupp som skapades.

Använda If Then Else för att avgöra om variabeln är null

Om du vill utvärdera strängar använder != du och utvärderar tal med -ne. Följande If Then Else-instruktion utvärderar om variabeln $resourceGroup har angetts. Om ja returneras värdet för variabeln. Om nej anger den variabeln.

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

Använda Om sedan för att skapa eller ta bort en resursgrupp

Följande skript skapar endast en ny resursgrupp om en med det angivna namnet inte redan finns.

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

Följande skript tar bort en befintlig ny resursgrupp om en med det angivna namnet redan finns. Du kan använda --no-wait argumentet för att returnera kontrollen utan att vänta på att kommandot ska slutföras. För den här artikeln vill vi dock vänta tills resursgruppen tas bort innan du fortsätter. Mer information om asynkrona åtgärder finns i Asynkrona åtgärder. Vi demonstrerar användningen av --no-wait argumentet i slutet av den här artikeln.

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

Använda Grep för att avgöra om det finns en resursgrupp och skapa resursgruppen om den inte gör det

Följande kommando skickar utdata från az group list kommandot till grep kommandot. Om den angivna resursgruppen inte finns skapar kommandot resursgruppen med hjälp av tidigare definierade variabler.

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

Använda CASE-instruktionen för att avgöra om en resursgrupp finns och skapa resursgruppen om den inte finns

Följande CASE-instruktion skapar endast en ny resursgrupp om en med det angivna namnet inte redan finns. Om en med det angivna namnet finns, ekar CASE-instruktionen att resursgruppen finns.

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

Använda för loopar och frågematriser

I det här avsnittet av artikeln skapar vi ett lagringskonto och använder sedan för loopar för att skapa blobar och containrar. Vi demonstrerar också frågor mot JSON-matriser och arbetar med miljövariabler.

Skapa lagringskonto

Följande kommando använder kommandot az storage account create för att skapa ett lagringskonto som vi använder när vi skapar lagringscontainrar.

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

Hämta lagringskontonycklarna

Följande kommandon använder kommandot az storage account keys list för att returnera nyckelvärden för lagringskontot. Sedan lagrar vi ett nyckelvärde i en variabel som ska användas när du skapar lagringscontainrar.

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

Skapa en lagringscontainer

Vi börjar med att använda az storage container create för att skapa en enda lagringscontainer och sedan använda listan az storage container för att fråga efter namnet på den skapade containern.

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

Ladda upp data till containern

Följande skript skapar tre exempelfiler med hjälp av en for-loop.

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

Följande skript använder kommandot az storage blob upload-batch för att ladda upp blobarna till lagringscontainern.

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

Följande skript använder kommandot az storage blob list för att lista blobarna i containern.

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

Följande skript visar totalt antal byte i lagringscontainern.

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

Skapa många containrar med hjälp av loopar

Sedan skapar vi flera containrar med hjälp av en loop som visar ett par sätt att skriva loopen.

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

Använda EXPORT för att definiera miljövariabler

I föregående lagringscontainerskript angav vi kontonamnet och kontonyckeln med varje kommando. I stället kan du lagra dina autentiseringsuppgifter med hjälp av motsvarande miljövariabler: AZURE_STORAGE_ACCOUNT och AZURE_STORAGE_KEY. Använd EXPORT för att utföra den här åtgärden.

export AZURE_STORAGE_ACCOUNT=$storageAccount
export AZURE_STORAGE_KEY=$accountKey
az storage container list # Uses the environment variables to display the list of containers.

Följande skript skapar en metadatasträng och använder sedan kommandot az storage container metadata update för att uppdatera en container med strängen, återigen med hjälp av miljövariablerna.

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

Följande kommando använder kommandot az storage container delete för att ta bort en enda namngiven container och sedan ta bort flera containrar i en loop.

az storage container delete \
    --name $container

Hämta en lista över containrar som innehåller ett specifikt prefix och lagra resultat i en variabel.

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

Ta bort listan över containrar i en loop med argumentet --prefix .

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

Felhantering

Om du vill avsluta ett skript omedelbart om ett kommando returnerar en icke-nollstatus kör du följande kommando:

set -e

Om du vill ha mer information om hur du ställer in gränssnittsalternativ och annan hjälp kör du följande kommandon:

help set
help help

Rensa resurser

När du är klar med den här artikeln tar du bort resursgruppen och alla resurser i den. --no-wait Använd argumentet .

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

Se även