Aprenda sobre las diferencias de sintaxis entre la CLI de Azure en Bash, PowerShell y Cmd

  • Artículo

Los comandos de la CLI de Azure se pueden ejecutar tanto en entornos de Bash, PowerShelly el shell de comandos de Windows (Cmd). Sin embargo, existen leves diferencias de scripting. En este paso del tutorial, aprenderá sobre los primeros valores de parámetros de formato y de la cuenta de Azure Storage para los tres entornos.

Requisitos previos

  • Ha completado los requisitos previos para preparar el entorno.
  • Tiene acceso a un grupo de recursos con permiso de contributor o superior en un nivel de grupo de recursos.

Tenga en cuenta los caracteres de continuación de línea

La mayoría de la documentación de la CLI de Azure se escribe y prueba en Bash mediante Azure Cloud Shell. Uno de los primeros aspectos que debe recordar al copiar la sintaxis de la CLI de Azure es comprobar los caracteres de continuación de línea para el entorno elegido, ya que no son intercambiables.

Entorno Carácter de continuación de línea
Bash Barra diagonal inversa (\)
PowerShell Tilde aguda (`)
Cmd Caret (^)

Sugerencia

El botón Copiar de la esquina superior derecha de los bloques de código de la CLI de Azure quita la barra diagonal inversa (\) y la tilde aguda (`) de forma predeterminada. Si desea copiar un bloque de código con formato, use el teclado o el mouse para seleccionar y copiar el ejemplo.

Comprender las diferencias de sintaxis al usar variables

La sintaxis para usar variables varía ligeramente entre entornos. Esta es una comparación:

Caso de uso Bash PowerShell Cmd
Creación de variables variableName=varValue $variableName="varValue" set variableName=varValue
Uso de la variable como valor de parámetro nombre_de_variable $variableName %variableName%
Uso de la variable en el parámetro --query '$variableName' '$variableName' '$variableName'

Hay varias maneras diferentes de mostrar información de variables en la pantalla de la consola, pero echo funciona en la mayoría de las circunstancias. Esta es una comparación:

  • Bash: echo $varResourceGroup
  • PowerShell: echo $varResourceGroup
  • Cmd: echo %varResourceGroup%

En el paso tres, Rellenar variables para su uso en scripts, se trabaja en ejemplos detallados de sintaxis de variables.

Aprenda sobre las diferencias entre los entornos

Cada parámetro de la CLI de Azure es una cadena. Sin embargo, cada entorno tiene sus propias reglas para controlar comillas simples y dobles, espacios y valores de parámetro.

Valor de cadena CLI de Azure PowerShell Cmd
Texto 'text' o "text" 'text' o "text" "text"
Número \`50\` ``50`` `50`
Booleano \`true\` ``false`` 'true'
Date '2021-11-15' '2021-11-15' '2021-11-15'
JSON '{"key":"value"}' o "{"key":"value"}" '{"key":"value"}' "{"key":"value"}"

Muchos parámetros de la CLI de Azure aceptan una lista de valores separados por espacios. Esto afecta a las comillas.

  • Lista separada por espacios sin comillas: --parameterName firstValue secondValue
  • Lista separada por espacios con comillas: --parameterName "firstValue" "secondValue"
  • Valores que contienen un espacio: --parameterName "value1a value1b" "value2a value2b" "value3"

Si no está seguro de cómo el entorno evaluará la cadena, muestre el valor de una cadena en la consola o use --debug como se explica en Depuración de comandos de referencia de la CLI de Azure.

Creación de una cuenta de almacenamiento para aplicar lo que ha aprendido

En el resto de este paso del tutorial, se muestran las reglas de comillas en los comandos de la CLI de Azure y se usa el grupo de recursos creado en Preparación del entorno para la CLI de Azure. Sustituya <msdocs-tutorial-rg-00000000> por el nombre del grupo de recursos.

Cree una cuenta de almacenamiento de Azure para usarla en este tutorial. En este ejemplo, se asigna un identificador aleatorio al nombre de la cuenta de almacenamiento, pero si desea usar otro nombre, consulte Información general de la cuenta de almacenamiento para obtener información sobre las reglas de nombre de la cuenta de almacenamiento.

El ejemplo de script a continuación muestra la sintaxis específica del entorno para lo siguiente:

  • Continuación de línea
  • Uso de variables
  • Identificadores aleatorios
  • El comando echo
# Variable block
let "randomIdentifier=$RANDOM*$RANDOM"
location=eastus
resourceGroup="<msdocs-tutorial-rg-00000000>"
storageAccount="msdocssa$randomIdentifier"

# Create a storage account.
echo "Creating storage account $storageAccount in resource group $resourceGroup"
az storage account create --name $storageAccount \
                          --resource-group $resourceGroup \
                          --location $location \
                          --sku Standard_RAGRS \
                          --kind StorageV2 \
                          --output json

La CLI de Azure muestra más de 100 líneas de JSON como salida cuando se crea una nueva cuenta de almacenamiento. La siguiente salida del diccionario JSON tiene campos omitidos por brevedad.

{
"accessTier": "Hot",
"allowBlobPublicAccess": false,
"creationTime": "yyyy-mm-ddT19:14:26.962501+00:00",
"enableHttpsTrafficOnly": true,
"id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/ msdocs-tutorial-rg-00000000/providers/Microsoft.Storage/storageAccounts/msdocssa00000000",
"keyCreationTime": {
  "key1": "yyyy-mm-ddT19:14:27.103127+00:00",
  "key2": "yyyy-mm-ddT19:14:27.103127+00:00"
},
"kind": "StorageV2",
"location": "eastus",
"name": "msdocssa00000000",
"primaryEndpoints": {
  "blob": "https://msdocssa00000000.blob.core.windows.net/"
},
"primaryLocation": "eastus",
"provisioningState": "Succeeded",
"resourceGroup": "msdocs-tutorial-rg-00000000",
"sku": {
  "name": "Standard_RAGRS",
  "tier": "Standard"
},
"statusOfPrimary": "available",
"statusOfSecondary": "available",
"tags": {},
"type": "Microsoft.Storage/storageAccounts"
}

Creación de etiquetas para practicar las diferencias entre comillas

Con az storage account update, agregue etiquetas para ayudarle a identificar la cuenta de almacenamiento y aprender sobre las diferencias entre comillas. Estos ejemplos de script muestran la sintaxis específica del entorno para lo siguiente:

  • Valores que contienen espacios
  • Comillas para espacios en blanco
  • Escape de caracteres especiales
  • Usar variables

El parámetro --tags acepta una lista de valores clave:valor separados por espacios. Sustituya <msdocs-tutorial-rg-00000000> por el nombre del grupo de recursos y <msdocssa00000000> por el nombre de la cuenta de almacenamiento de Azure.

# Create new tags. This syntax works with or without quotes around each key-value pair.
az storage account update --name <msdocssa00000000> \
                          --resource-group <msdocs-tutorial-rg-00000000> \
                          --tags Team=t1 Environment=e1

# Create new tags containing spaces. You must use quotes.
az storage account update --name <msdocssa00000000> \
                          --resource-group <msdocs-tutorial-rg-00000000> \
                          --tags "Floor number=f1" "Cost center=cc1"

# Create a new tag with an empty value.
az storage account update --name <msdocssa00000000> \
                          --resource-group <msdocs-tutorial-rg-00000000> \
                          --tags "Department="''""

# Create a new tag containing special characters resulting in "Path": "$G:\\myPath".
az storage account update --name <msdocssa00000000> \
                          --resource-group <msdocs-tutorial-rg-00000000> \
                          --tags "Path=\$G:\myPath"

# Create a tag from a variable.
newTag="tag1=tag value with spaces"
az storage account update --name <msdocssa00000000> \
                          --resource-group <msdocs-tutorial-rg-00000000> \
                          --tags "$newTag"

Si no desea sobrescribir etiquetas anteriores mientras trabaja en este paso del tutorial, use el comando az tag update y establezca el parámetro --operation en merge.

# Get the resource ID of your storage account.
saID=$(az resource show --resource-group <msdocs-tutorial-rg-00000000> \
                        --name <msdocssa00000000> \
                        --resource-type Microsoft.Storage/storageAccounts \
                        --query "id" \
                        --output tsv)

echo My storage account ID is $saID

# Append new tags.
az tag update --resource-id $saID \
              --operation merge \
              --tags <tagName>=<tagValue>

# Get a list of all tags.
az tag list --resource-id $saID

Comparación de scripts más específicos del entorno

Observe estas diferencias de script con más detalle. En estos ejemplos, se muestran las diferencias de comillas para lo siguiente:

  • Pasar una cadena JSON como un valor de parámetro
  • Filtrar resultados con el parámetro --query
    • Números
    • Valores booleanos
    • Fechas

Ejemplo de un parámetro que contiene una cadena JSON. Este script se da para futuras referencias, ya que no estamos trabajando con az rest en este tutorial.

az rest --method patch \
        --url https://management.azure.com/subscriptions/<mySubscriptionID>/resourceGroups/<myResourceGroup>/providers/Microsoft.HybridCompute/machines/<machineName>?api-version=yyyy-mm-dd-preview \
        --resource https://management.azure.com/ \
        --headers Content-Type=application/json \
        --body '{"properties": {"agentUpgrade": {"enableAutomaticUpgrade": false}}}'

Ejemplo de filtrado para un valor numérico. A menos que tenga una máquina virtual en la suscripción actual, este ejemplo se da para referencia futura.

az vm list --resource-group <myResourceGroup> \
           --query "[?storageProfile.osDisk.diskSizeGb >=\`50\`].{Name:name, admin:osProfile.adminUsername, DiskSize:storageProfile.osDisk.diskSizeGb}" \
           --output table

Ejemplo de filtrado de un valor booleano mediante la cuenta de almacenamiento creada en este tutorial.

az storage account list --resource-group <msdocs-tutorial-rg-00000000> \
    --query "[?allowBlobPublicAccess == \`true\`].id"

Ejemplo de filtrado de una fecha mediante la cuenta de almacenamiento creada en este tutorial.

# include time
az storage account list --resource-group <msdocs-tutorial-rg-00000000> \
    --query "[?creationTime >='2021-11-15T19:14:27.103127+00:00'].{saName:name, saID: id, sku: sku.name}"

# exclude time
az storage account list --resource-group <msdocs-tutorial-rg-00000000> \
    --query "[?creationTime >='2021-11-15'].{saName:name, saID: id, sku: sku.name}"

# subtract days and use a variable
saDate=$(date +%F -d "-30days")
az storage account list --resource-group <msdocs-tutorial-rg-00000000> \
    --query "[?creationTime >='$saDate'].{saName:name, saID: id, sku: sku.name}"

Depuración de comandos de referencia de la CLI de Azure

Uso del parámetro --debug

La CLI de Azure ofrece un parámetro --debug que se puede usar con cualquier comando. La salida de depuración es extensa, pero proporciona más información sobre los errores de ejecución. Use el comando clear de Bash para quitar la salida de la consola entre pruebas.

En estos ejemplos, se muestran los argumentos reales recibidos por la CLI de Azure en la sintaxis de Python.

Este ejemplo es correcto tanto en Bash como en PowerShell.

az '{"key":"value"}' --debug

Observe lo que interpreta la CLI de Azure en la línea Command arguments de la salida.

Command arguments: ['{"key":"value"}', '--debug']

Este segundo ejemplo, también es correcto. Use el comando clear de Bash para quitar la salida de la consola entre pruebas.

clear
az "{\"key\":\"value\"}" --debug

Command arguments: ['{"key":"value"}', '--debug']

Los dos ejemplos siguientes son incorrectos ya que Bash interpreta comillas y espacios.

Formato incorrecto Problema Salida de la consola
az {"key":"value"} --debug Faltan comillas simples o caracteres de escape Argumentos de comando: ['{key:value}', '--debug']
az {"key": "value"} --debug Faltan comillas simples o caracteres de escape, y contiene espacios adicionales Argumentos de comando: ['{key:', 'value}', '--debug']

Uso del comando echo

Aunque --debug indica exactamente qué interpreta la CLI de Azure, una segunda opción es devolver el valor de una expresión a la consola. Este método es útil al comprobar los resultados de --query, que se tratan en detalle en Rellenar variables para su uso en scripts.

strExpression='{"key":"value"}'
echo $strExpression

{"key":"value"}

Solución de problemas

Estos son errores comunes cuando una sintaxis de comandos de referencia de la CLI de Azure no está escrita correctamente:

  • "Bad request ...{algo} is invalid" puede deberse a un espacio, el uso de comillas simples o dobles, o a la falta de una comilla.

  • "Unexpected token..." se ve cuando hay un espacio o comillas adicionales.

  • El error "Invalid jmespath_type value" suele provenir de comillas incorrectas en el parámetro --query.

  • "Variable reference is not valid" se recibe cuando una cadena no tiene el formato correcto a menudo debido a la concatenación o a un carácter de escape que falta.

  • "Unrecognized arguments" suele deberse a un carácter de continuación de línea incorrecto.

  • "Missing expression after unary operator" se observa cuando falta un carácter de continuación de línea.

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
Diferencias de scripting Comillas en Bash
Comillas en PowerShell
Problemas de comillas con PowerShell
Sugerencias para la línea de comandos de Windows
Parámetros Uso de comillas en parámetros de la CLI de Azure
Encuentre más ejemplos de sintaxis de Bash, PowerShell y Cmd en Salida del comando Query mediante JMESPath

siguiente paso

Ahora que ha aprendido sobre la sintaxis de la CLI de Azure para Bash, PowerShell y Cmd, continúe con el paso siguiente para aprender a extraer valores en una variable.

Rellenar variables para su uso en scripts