Rellenar variables para su uso en scripts

Artículo
12/10/2023

En este paso del tutorial, aprenderá a trabajar con variables:

Ejecute un comando de la CLI de Azure y almacene la salida en una variable.
Lea un archivo JSON local y almacene los valores de propiedad en una variable.

Algunos casos de uso comunes para las variables son:

Obtenga información sobre un recurso de Azure existente, como un identificador de recurso.
Obtenga la salida de un comando de la CLI de Azure, como una contraseña.
Obtenga objetos JSON para obtener información del entorno, como los identificadores de desarrollo, fase y producción.

Después, la variable se puede usar en la CLI de Azure para realizar trabajos de compilación y destrucción a escala.

Requisitos previos

Tiene acceso a un grupo de recursos y una cuenta de almacenamiento con reader o permisos superiores en un nivel de cuenta de almacenamiento.

Obtención de la salida del comando mediante la consulta JMESPath

Obtenga información sobre un recurso de Azure existente mediante el parámetro --query del comando show. Se ejecuta una consulta JMESPath y se devuelven uno o varios valores de propiedad de un recurso de Azure.

Sugerencia

La sintaxis de --query distingue mayúsculas de minúsculas y es específica del entorno. Si recibe resultados vacíos, compruebe el uso de mayúsculas. Evite los errores de comillas aplicando las reglas que ha aprendido en Obtenga información acerca de las diferencias de sintaxis de la CLI de Azure en Bash, PowerShell y Cmd.

A menos que se especifique el parámetro --output, estos ejemplos se basan en una configuración de salida predeterminada de json establecida en Preparar el entorno para la CLI de Azure.

Obtención de propiedades de diccionario JSON de un recurso de Azure

Con la cuenta de almacenamiento creada en Obtenga información acerca de las diferencias de sintaxis de la CLI de Azure en Bash, PowerShell y Cmd, obtenga el valor primaryEndpoints de la nueva cuenta de almacenamiento.

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

Salida del diccionario JSON de la consola:

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

Obtención de objetos JSON individuales

Especifique una lista delimitada por comas de las propiedades de la cuenta de almacenamiento para devolver propiedades individuales en una matriz (lista).

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

Salida de la matriz JSON de la consola:

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

Cambiar el nombre de propiedades

Cambie el nombre de las propiedades mediante corchetes ({}) y una lista delimitada por comas. Los nuevos nombres de propiedad no pueden contener espacios. En este ejemplo se devuelve la salida en formato table.

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

Salida de la tabla de consola. La primera letra de cada columna se escribe en mayúsculas en --output table:

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

Filtrar los resultados de la consulta

Combine lo que ha aprendido sobre las comillas con lo que acaba de aprender sobre --query. Estos ejemplos aplican un filtro.

Bash
PowerShell

En Bash, no puede tener un espacio antes o después del signo igual (=). Puede optar por usar comillas alrededor del valor de la variable, por lo que msdocs-tutorial-rg-00000000 y "msdocs-tutorial-rg-00000000" son correctas.

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 le permite crear variables con o sin espacios alrededor del signo igual (=), por lo que rgName="msdocs-tutorial-rg-00000000" y rgName = "msdocs-tutorial-rg-00000000" son ambas correctas. Sin embargo, en PowerShell, debe usar comillas alrededor del valor de la variable.

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

Creación de un nuevo recurso de Azure que almacena la salida en una variable

El aprendizaje para almacenar la salida de comandos en una variable es beneficioso al crear recursos de Azure que generen secretos que se deben proteger. Por ejemplo, al crear una entidad de servicio, restablecer una credencial u obtener un secreto de Azure Key Vault, la salida del comando debe protegerse.

Cree una instancia de Azure Key Vault y un secreto que devuelva la salida del comando a una variable. El nombre de Azure Key Vault debe ser único globalmente, por lo que el identificador $RANDOM se usa en este ejemplo. Para más reglas de nomenclatura de Azure Key Vault, consulte Códigos de error comunes para Azure Key Vault.

Estos ejemplos usan echo para comprobar los valores de variable porque se trata de un tutorial de enseñanza. No use echo para los valores de secreto y contraseña en entornos de nivel de producción.

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

Obtener el contenido de un archivo JSON y almacenarlo en una variable

Esta sección siguiente es una "tarea de extensión" para un tutorial de incorporación. Sin embargo, para administrar los recursos de Azure en entornos de desarrollo, fase y producción, a menudo es necesario leer un archivo de configuración.

¿Está listo para ampliar las aptitudes de la CLI de Azure? Cree un archivo JSON que contenga el siguiente JSON o el contenido del archivo que prefiera. Guarde el archivo de texto en la unidad local. Si trabaja en Azure Cloud Shell, use el icono de upload/download files de la barra de menús para almacenar el archivo de texto en la unidad de almacenamiento en la nube.

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

Almacene el contenido del archivo JSON en una variable para su uso adicional en los comandos de la CLI de Azure. En este ejemplo, cambie msdocs-tutorial.json por el nombre del archivo. No guarde el comando echo en scripts de nivel de producción, ya que la salida se guarda en el archivo de registro.

Bash
PowerShell

Este script de Bash se ha probado en Azure Cloud Shell y depende de jq de Bash que debe instalarse en su entorno.

# 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

¿Acaba de recibir un error de "comando jq no encontrado"? Esto se debe a que este script depende del comando jq de Bash. Instale jq en su entorno o ejecute este script en Azure Cloud Shell.

Este script de PowerShell se probó en Windows PowerShell y 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

Ahora tiene un nombre secreto de Azure Key Vault específico del entorno almacenado en una variable y puede usarlo para conectarse a los recursos de Azure. Este mismo método es adecuado para las direcciones IP de las máquinas virtuales de Azure y las cadenas de conexión de SQL Server cuando desea reutilizar los scripts de la CLI de Azure.

Obtenga más detalles

¿Desea obtener más detalles sobre uno de los temas tratados en este paso del tutorial? Use los vínculos de esta tabla para obtener más información.

Asunto	Más información
Variables	Consulte ejemplos avanzados en Uso correcto de la CLI de Azure: Paso de valores a otro comando
	Lea una buena introducción a las variables en Uso de variables en los comandos de la CLI de Azure.
Consultas	Busque una amplia gama de ejemplos en Cómo consultar la salida del comando de la CLI de Azure mediante una consulta JMESPath.
	Profundice en Bash mediante `--query` en Aprendizaje de Bash mediante la CLI de Azure.
Azure Key Vault	Acerca de Azure Key Vault
	Acceso a las claves, certificados y secretos de Key Vault con un control de acceso basado en rol de Azure.
	Códigos de error comunes para Azure Key Vault
PowerShell	Vínculos de referencia: Get-content, Where-Object, Select-Object

siguiente paso

Ahora que comprende cómo usar variables para almacenar la salida del comando de la CLI de Azure y los valores de propiedad JSON, continúe con el paso siguiente para aprender a usar scripts para eliminar recursos de Azure.

Eliminación de recursos de Azure a escala mediante un script

Compartir a través de