Popolare le variabili per l'uso negli script

2025-05-22

In questo passaggio dell'esercitazione si apprenderà come usare le variabili:

Eseguire un comando dell'interfaccia della riga di comando di Azure e archiviare l'output in una variabile.
Leggere un file JSON locale e archiviare i valori delle proprietà in una variabile.

Alcuni casi d'uso comuni per le variabili sono:

Ottenere informazioni su una risorsa di Azure esistente, ad esempio un ID risorsa.
Ottenere l'output da un comando Azure CLI, come ad esempio una password.
Ottenere oggetti JSON per informazioni sull'ambiente, ad esempio sviluppo, fase e ID di produzione.

La variabile può quindi essere usata nell'interfaccia della riga di comando di Azure per eseguire processi di compilazione ed eliminazione su larga scala.

Prerequisiti

È possibile accedere a un gruppo di risorse e a un account di archiviazione con reader o autorizzazioni superiori a livello di account di archiviazione.

Ottenere l'output di un comando utilizzando una query JMESPath

Ottenere informazioni su una risorsa di Azure esistente usando il --query parametro del show comando . Viene eseguita una query JMESPath e vengono restituiti uno o più valori di proprietà di una risorsa di Azure.

Suggerimento

La sintassi per --query fa distinzione tra maiuscole e minuscole ed è specifica all'ambiente. Se ricevi risultati vuoti, controlla l'uso delle maiuscole. Evitare errori di citazione applicando le regole apprese in le differenze di sintassi della CLI di Azure in Bash, PowerShell e Cmd

A meno che il parametro --output non venga specificato, questi esempi si basano su una configurazione di output predefinita json impostata in Preparare l'ambiente per l'interfaccia della riga di comando di Azure.

Ottenere le proprietà del dizionario JSON di una risorsa di Azure

Usando l'account di archiviazione creato in Informazioni sulle differenze di sintassi dell'interfaccia della riga di comando di Azure in Bash, PowerShell e Cmd, ottieni il primaryEndpoints del tuo nuovo account di archiviazione.

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

Output del dizionario JSON della console:

{
  "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/"
}

Ottenere singoli oggetti JSON

Specificare un elenco delimitato da virgole delle proprietà dell'account di archiviazione per restituire singole proprietà in una matrice (elenco).

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

Output della matrice JSON della console:

[
  "/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"
]

Rinominare le proprietà

Rinominare le proprietà usando parentesi graffe ({}) e un elenco delimitato da virgole. I nuovi nomi di proprietà non possono contenere spazi. Questo esempio restituisce l'output in table formato .

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

Output della tabella della console. La prima lettera di ogni colonna viene maiuscola in --output table:

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

Filtrare i risultati della query

Combina ciò che hai imparato sulle virgolette con ciò che hai appena appreso su --query. Questi esempi applicano un filtro.

Bash
PowerShell

In Bash non è possibile avere uno spazio prima o dopo il segno di uguale (=). È possibile scegliere di usare le virgolette intorno al valore della variabile, quindi msdocs-tutorial-rg-00000000 e "msdocs-tutorial-rg-00000000" sono entrambe corrette.

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

PowerShell consente di creare variabili con o senza spazi che circondano il segno di uguale (=), quindi rgName="msdocs-tutorial-rg-00000000" e rgName = "msdocs-tutorial-rg-00000000" sono entrambi corretti. In PowerShell, tuttavia, è necessario usare le virgolette intorno al valore della variabile.

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

# Get a list of all Azure storage accounts that allow blob public access.
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=Get-Date
$saDate=$saDate.AddDays(-30).tostring("yyyy-mm-dd")
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

Creare una nuova risorsa di Azure che archivia l'output in una variabile

L'apprendimento per archiviare l'output dei comandi in una variabile è utile quando si creano risorse di Azure che generano segreti che devono essere protetti. Ad esempio, quando si crea un'entità servizio, si reimposta una credenziale o si ottiene un segreto dell'insieme di credenziali delle chiavi di Azure, l'output del comando deve essere protetto.

Creare un nuovo Azure Key Vault e definire un segreto, restituendo l'output del comando a una variabile. Il nome dell'insieme di credenziali delle chiavi di Azure deve essere univoco a livello globale, quindi l'identificatore $RANDOM viene usato in questo esempio. Per altre regole di denominazione di Azure Key Vault, vedere Codici di errore comuni per Azure Key Vault.

Questi esempi usano echo per verificare i valori delle variabili perché si tratta di un'esercitazione informativa. Non usare echo per i valori segreti e password negli ambienti a livello di produzione.

Bash
PowerShell

# 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 Kev 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

# Set your variables.
$randomIdentifier=(New-Guid).ToString().Substring(0,8)
$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 Kev 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

Ottenere il contenuto di un file JSON e archiviarlo in una variabile

Questa sezione successiva è un compito sfidante per un tutorial di onboarding. Tuttavia, per gestire le risorse di Azure negli ambienti di sviluppo, fase e produzione, spesso è necessario leggere un file di configurazione.

Sei pronto a migliorare le tue competenze con l'interfaccia della riga di comando di Azure? Creare un file JSON contenente il codice JSON seguente o il contenuto del file desiderato. Salvare il file di testo nell'unità locale. Se si usa Azure Cloud Shell, usare l'icona upload/download files nella barra dei menu per archiviare il file di testo nell'unità di archiviazione cloud.

{
  "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"
    }
  }
}

Archiviare il contenuto del file JSON in una variabile per usarlo ulteriormente nei comandi dell'interfaccia della riga di comando di Azure. In questo esempio, cambiare msdocs-tutorial.json con il nome del tuo file. Non salvare il echo comando negli script a livello di produzione perché l'output viene salvato nel file di log.

Bash
PowerShell

Questo script Bash è stato testato in Azure Cloud Shell e dipende dal Jq Bash che deve essere installato nell'ambiente in uso.

# 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

Hai appena ricevuto un errore "comando jq non trovato"? Questo perché questo script dipende dal comando Jq Bash. Installare jq nell'ambiente o eseguire questo script in Azure Cloud Shell.

Questo script di PowerShell è stato testato in Windows PowerShell e PowerShell 7.

# Show the contents of a file in the console
$fileName="c:\myPath\msdocs-tutorial.json"
$fileContents = Get-Content -Path $fileName | ConvertFrom-Json

# Get a JSON dictionary object
$stgKV=$($fileContents.environments.stg."kv-secretName")
echo $stgKV

# Filter a JSON array
$devKV=$($fileContents.environments.dev | 
    Where-Object status -eq 'active' | 
    Select-Object -ExpandProperty 'kv-secretName')
echo $devKV

È ora disponibile un nome segreto di Azure Key Vault specifico dell'ambiente archiviato in una variabile ed è possibile usarlo per connettersi alle risorse di Azure. Questo stesso metodo è valido per gli indirizzi IP delle macchine virtuali di Azure e delle stringhe di connessione di SQL Server quando si vogliono riutilizzare gli script dell'interfaccia della riga di comando di Azure.

Ottenere altri dettagli

Vuoi maggiori dettagli su uno degli argomenti trattati in questo passaggio dell'esercitazione? Per altre informazioni, usare i collegamenti in questa tabella.

Oggetto	Ulteriori informazioni
Variabili	Vedere esempi avanzati in Usare correttamente l'interfaccia della riga di comando di Azure - Passare i valori a un altro comando
	Leggere una buona panoramica delle variabili in Come usare le variabili nei comandi dell'interfaccia della riga di comando di Azure.
Query	Trovare un'ampia gamma di esempi in Come eseguire query sull'output dei comandi di Azure CLI usando una query JMESPath.
	Approfondisci l'uso di Bash in `--query`Impara a usare Bash con Azure CLI.
Insieme di credenziali delle chiavi di Azure	Informazioni su Azure Key Vault
	Fornire l'accesso a chiavi, certificati e segreti di Key Vault con un controllo degli accessi in base al ruolo di Azure.
	Codici di errore comuni per Azure Key Vault
PowerShell	Collegamenti di riferimento: Get-content, Where-Object, Select-Object

Passaggio successivo

Ora che si è appreso come usare le variabili per archiviare l'output dei comandi dell'interfaccia della riga di comando di Azure e i valori delle proprietà JSON, passare al passaggio successivo per informazioni su come usare gli script per eliminare le risorse di Azure.

Eliminare le risorse di Azure su larga scala usando uno script