Condividi tramite

Popolare le variabili da usare negli script dell'interfaccia della riga di comando di Azure

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.

È possibile usare la variabile nell'interfaccia della riga di comando di Azure per eseguire operazioni di compilazione e eliminazione definitiva 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 e specifica all'ambiente. Se ricevi risultati vuoti, controlla l'uso delle maiuscole. Evitare errori di quotatura applicando le regole apprese in Scopri le differenze di sintassi di Azure CLI 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 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

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

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.

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

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 un nuovo segreto, e restituire 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.

# 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

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.

Lo script Bash seguente è stato testato in Azure Cloud Shell e dipende da Bash jq, 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 ricevuto un errore "comando jq non trovato"? Questo errore si verifica perché lo script dipende dal comando Jq Bash. Installare jq nell'ambiente o eseguire questo script in Azure Cloud Shell.

È 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 --queryImpara 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

  • Last updated on