Dela via

Fylla i variabler för användning i Azure CLI-skript

I det här självstudiesteget lär du dig att arbeta med variabler:

  • Kör ett Azure CLI-kommando och lagra utdata i en variabel.
  • Läs en lokal JSON-fil och lagra egenskapsvärden i en variabel.

Några vanliga användningsfall för variabler är:

  • Hämta information om en befintlig Azure-resurs, till exempel ett resurs-ID.
  • Hämta utdata från ett Azure CLI-kommando, till exempel ett lösenord.
  • Hämta JSON-objekt för miljöinformation, till exempel utvecklings-, fas- och produktions-ID: er.

Du kan använda variabeln i Azure CLI för att utföra bygg- och förstöringsåtgärder i stor skala.

Förutsättningar

  • Du har åtkomst till en resursgrupp och ett lagringskonto med reader eller högre behörigheter på lagringskontonivå.

Hämta kommandoutdata med JMESPath-fråga

Hämta information om en befintlig Azure-resurs med hjälp av parametern --query för show kommandot. En JMESPath-fråga körs och ett eller flera egenskapsvärden för en Azure-resurs returneras.

Tips/Råd

Syntaxen för --query är skiftlägeskänslig och miljöspecifik. Om du får tomma resultat, kontrollera din användning av versaler. Undvik att citera fel genom att tillämpa de regler som du har lärt dig i Learn Azure CLI-syntaxskillnader i Bash, PowerShell och Cmd

Om inte parametern --output anges förlitar sig de här exemplen på en standardkonfiguration för json utdata som anges i Förbereda din miljö för Azure CLI

Hämta JSON-ordlisteegenskaper för en Azure-resurs

Använd lagringskontot som skapats i Learn Azure CLI-syntaxskillnader i Bash, PowerShell och Cmd, och hämta primaryEndpoints för ditt nya lagringskonto.

az storage account show --resource-group <msdocs-tutorial-rg-00000000> \
                        --name <msdocssa000000000> \
                        --query primaryEndpoints

JSON-ordlisteutdata för konsolen:

{
  "blob": "https://msdocssa00000000.blob.core.windows.net/",
  "dfs": "https://msdocssa00000000.dfs.core.windows.net/",
  "file": "https://msdocssa00000000.file.core.windows.net/",
  "internetEndpoints": null,
  "microsoftEndpoints": null,
  "queue": "https://msdocssa00000000.queue.core.windows.net/",
  "table": "https://msdocssa00000000.table.core.windows.net/",
  "web": "https://msdocssa00000000.z13.web.core.windows.net/"
}

Hämta enskilda JSON-objekt

Om du vill returnera enskilda egenskaper i en matris (lista) anger du en kommaavgränsad lista över lagringskontoegenskaper.

az storage account show --resource-group <msdocs-tutorial-rg-00000000> \
                        --name <msdocssa000000000> \
                        --query "[id, primaryLocation, primaryEndpoints.blob, encryption.services.blob.lastEnabledTime]"

Konsol-JSON-fältutdata

[
  "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/msdocs-tutorial-rg-00000000/providers/Microsoft.Storage/storageAccounts/   msdocssa000000000",
  "eastus",
  "https://msdocssa000000000.blob.core.windows.net/",
  "yyyy-mm-ddT19:11:56.399484+00:00"
]

Byt namn på egenskaper

Byt namn på egenskaper med hjälp av klammerparenteser ({}) och en kommaavgränsad lista. De nya egenskapsnamnen får inte innehålla blanksteg. Det här exemplet returnerar utdata i table format.

az storage account show --resource-group <msdocs-tutorial-rg-00000000> \
                        --name <msdocssa000000000> \
                        --query "{saName:name, saKind:kind, saMinTLSVersion:minimumTlsVersion}" \
                        --output table

Utdata för konsolbord. Den första bokstaven i varje kolumn är versal i --output table:

SaName             SaKind     SaMinTLSversion
-----------------  ---------  -----------------
msdocssa000000000  StorageV2  TLS1_0

Filtrera frågeresultat

Kombinera det du har lärt dig om att citera med det du just har lärt dig om --query. De här exemplen använder ett filter.

I Bash kan du inte ha ett blanksteg före eller efter likhetstecknet (=). Du kan välja att använda citattecken runt variabelvärdet, så msdocs-tutorial-rg-00000000 och "msdocs-tutorial-rg-00000000" båda är korrekta.

rgName="<msdocs-tutorial-rg-00000000>"

# Get a list of all Azure storage accounts that allow blob public access.
# Notice the backticks and escape characters needed for boolean values.
az storage account list --resource-group $rgName \
                        --query "[?allowBlobPublicAccess == \`true\`].name"

# Get a list of Azure storage accounts that were created in the last 30 days. Return the results as a table.
saDate=$(date +%F -d "-30days")
az storage account list --resource-group $rgName \
                        --query "[?creationTime >='$saDate'].{saName:name, createdTimeStamp:creationTime}" \
                        --output table

# Get a list of Azure storage accounts created in this tutorial
az storage account list --resource-group $rgName \
                        --query "[?contains(name, 'msdocs')].{saName:name, saKind:kind, saPrimaryLocation:primaryLocation, createdTimeStamp:creationTime}" \
                        --output table

Skapa en ny Azure-resurs som lagrar utdata i en variabel

Att lära sig lagra kommandoutdata i en variabel är fördelaktigt när du skapar Azure-resurser som utdatahemligheter som ska skyddas. När du till exempel skapar ett huvudnamn för tjänsten, återställer en autentiseringsuppgift eller hämtar en Azure-nyckelvalvshemlighet bör kommandoutdata skyddas.

Skapa en ny Azure Key Vault och en sekretessvariabel, och returnera kommandoutdata till en variabel. Ditt Azure Key Vault-namn måste vara globalt unikt, så identifieraren $RANDOM används i det här exemplet. Mer information om namngivningsregler för Azure Key Vault finns i Vanliga felkoder för Azure Key Vault.

De här exemplen används echo för att verifiera variabelvärden eftersom det här är en undervisningskurs. Använd inte echo för hemlighets- och lösenordsvärden i miljöer på produktionsnivå.

# Set your variables.
let "randomIdentifier=$RANDOM*$RANDOM"
rgName="<msdocs-tutorial-rg-00000000>"
kvName="msdocs-kv-$randomIdentifier"
location="eastus"

# Set your default output to none
az config set core.output=none

# Create a new Azure Key Vault returning the Key Vault ID
myNewKeyVaultID=$(az keyvault create --name $kvName --resource-group $rgName --location $location --query id --output tsv)
echo "My new Azure Key Vault ID is $myNewKeyVaultID"

# Wait about 1 minute for your Key Vault creation to complete.

# Create a new secret returning the secret ID
kvSecretName="<myKVSecretName>"
kvSecretValue="<myKVSecretValue>"
myNewSecretID=$(az keyvault secret set --vault-name $kvName --name $kvSecretName --value $kvSecretValue --query id --output tsv)
echo "My new secret ID is $myNewSecretID"

# Reset your default output to json
az config set core.output=json

Hämta innehållet i en JSON-fil och lagra den i en variabel

Nästa avsnitt är en "utmaningsuppgift" för en introduktionstutorial. Men för att hantera Azure-resurser i utvecklings-, fas- och produktionsmiljöer behöver du ofta läsa en konfigurationsfil.

Är du redo att utöka dina Azure CLI-kunskaper? Skapa en JSON-fil som innehåller följande JSON eller valfritt filinnehåll. Spara textfilen på den lokala enheten. Om du arbetar i Azure Cloud Shell använder du upload/download files ikonen i menyraden för att lagra textfilen på molnlagringsenheten.

{
  "environments": {
    "dev": [
      {
        "id": "1",
        "kv-secretName": "dev1SecretName",
        "status": "inactive",
      },
      {
        "id": "2",
        "kv-secretName": "dev2SecretName",
        "status": "active"
      }
    ],
    "stg": {
      "id": "3",
      "kv-secretName": "dev3SecretName"
    },
    "prod": {
      "id": "4",
      "kv-secretName": "dev4SecretName"
    }
  }
}

Lagra innehållet i JSON-filen i en variabel för ytterligare användning i dina Azure CLI-kommandon. I det här exemplet ändrar du msdocs-tutorial.json till namnet på filen. Spara inte kommandot i skript på echo produktionsnivå eftersom utdata sparas i loggfilen.

Följande Bash-skript testades i Azure Cloud Shell och är beroende av Bash jq, som måste installeras i din miljö.

# Show the contents of a file in the console
fileName="msdocs-tutorial.json"
cat $fileName | jq

# Get a JSON dictionary object
stgKV=$(jq -r '.environments.stg."kv-secretName"' $fileName)
echo $stgKV

# Filter a JSON array
devKV=$(jq -r '.environments.dev[] | select(.status=="active") | ."kv-secretName"' $fileName)
echo $devKV

Fick du felet "jq-kommandot hittades inte"? Det här felet beror på att skriptet är beroende av Bash jq-kommandot . Installera jq i din miljö eller kör det här skriptet i Azure Cloud Shell.

Nu har du ett miljöspecifikt Hemligt Azure Key Vault-namn som lagras i en variabel och du kan använda det för att ansluta till Azure-resurser. Samma metod är bra för IP-adresser för virtuella Azure-datorer och SQL Server-anslutningssträng när du vill återanvända Azure CLI-skript.

Få mer information

Vill du ha mer information om något av de ämnen som beskrivs i det här självstudiesteget? Använd länkarna i den här tabellen om du vill veta mer.

Ämne Lära sig mer
Variabler Se avancerade exempel i Använda Azure CLI – Skicka värden till ett annat kommando
Läs en bra översikt över variabler i Använda variabler i Azure CLI-kommandon.
Sökning Hitta ett brett utbud av exempel i Köra frågor mot Azure CLI-kommandoutdata med hjälp av en JMESPath-fråga.
Ta en djupare titt i Bash med hjälp av --query i Learn för att använda Bash med Azure CLI.
Azure Key Vault Om Azure Key Vault
Ge åtkomst till Key Vault-nycklar, certifikat och hemligheter med en rollbaserad åtkomstkontroll i Azure.
Vanliga felkoder för Azure Key Vault
PowerShell Referenslänkar: Get-content, Where-Object, Select-Object

Nästa steg

Nu när du förstår hur du använder variabler för att lagra Azure CLI-kommandoutdata och JSON-egenskapsvärden går du vidare till nästa steg för att lära dig hur du använder skript för att ta bort Azure-resurser.

Ta bort Azure-resurser i stor skala med hjälp av ett skript

  • Last updated on