Uso de la CLI de Azure en un lenguaje de scripting de Bash

Artículo
06/29/2024

Los comandos de referencia de la CLI de Azure pueden ejecutarse en varios lenguajes de scripting. Si eres nuevo en Bash y también en Azure CLI, este artículo es un gran lugar para comenzar tu viaje de aprendizaje. Trabaje con este artículo de forma muy parecida a lo que haría para aprender a usar la CLI de Azure en un lenguaje de scripting de Bash con facilidad.

En este artículo aprenderá a:

Consultar los resultados como diccionarios JSON o matrices
Dar formato a la salida como JSON, tabla o TSV
Consultar, filtrar y dar formato a valores individuales y múltiples
Usar la sintaxis if/exists/then y case
Usar bucles for
Usar los comandos grep, sed, paste y bc
Rellenar y usar variables de entorno y del shell

Si no tiene una suscripción a Azure, cree una cuenta gratuita de Azure antes de empezar.

Inicio de Bash

Inicie Bash mediante Azure Cloud Shell o una instalación local de la CLI de Azure. Este artículo asume que estás ejecutando Bash usando Azure Cloud Shell o ejecutando Azure CLI localmente en un contenedor docker.

Consulta de resultados de diccionario

Un comando que siempre devuelve un único objeto devuelve un diccionario JSON. Los diccionarios son objetos sin ordenar a los que se accede con claves. Para este artículo, vamos a empezar consultando el objeto Account mediante el comando Account Show.

az account show
az account show --output json # JSON is the default format

La siguiente salida del diccionario JSON tiene algunos campos omitidos para mayor brevedad y se quita la información de identificación.

bash-5.1# az account show
{
  "environmentName": "AzureCloud",
  "isDefault": true,
  "managedByTenants": [],
  "name": "My test subscription",
  "state": "Enabled",
  "user": {
    "name": "user@contoso.com",
    "type": "user"
  }
}

Aplicar formato a la salida como YAML

Use el argumento --output yaml (o -o yaml) para dar a la salida formato yaml, un formato de serialización de datos de texto sin formato. YAML suele ser más fácil de leer que JSON y se corresponde fácilmente con ese formato. Algunas aplicaciones y los comandos de la CLI aceptan YAML como entrada de configuración, en lugar de JSON.

az account show --output yaml

Para más información sobre cómo dar formato a la salida como yaml, consulte Formato de salida YAML.

Aplicar formato a la salida como una tabla

Use el argumento --output table (o -o table) para dar formato a la salida como una tabla ASCII. Los objetos anidados no se incluyen en la tabla de salida, pero se pueden filtrar como parte de una consulta.

az account show --output table

Para más información sobre cómo dar formato a la salida como una tabla, consulte Formato de salida de tabla.

Consulta y aplicación de formato para valores únicos y valores anidados

Las consultas siguientes muestran la consulta de valores únicos, incluidos los valores anidados, en una salida de diccionario JSON. La consulta final de este conjunto muestra la aplicación de formato a la salida mediante el argumento -o tsv. Este argumento devuelve los resultados como valores separados por caracteres de tabulador y nueva línea. Esta acción es útil para eliminar las comillas en el valor devuelto - que es útil para consumir la salida en otros comandos y herramientas que necesitan para procesar el texto de alguna forma (como se demuestra más adelante en este artículo).

az account show --query name # Querying a single value
az account show --query name -o tsv # Removes quotation marks from the output

az account show --query user.name # Querying a nested value
az account show --query user.name -o tsv # Removes quotation marks from the output

Consulta y formato de propiedades de matrices

En la consulta siguiente se muestra cómo obtener propiedades en una matriz JSON. Obtención de las propiedades de la suscripción, que se muestran como una tabla de suscripciones.

az account list --query "[].{subscription_id:id, name:name, isDefault:isDefault}" -o table

Esta consulta devuelve resultados similares a los siguientes:

Subscription_id                       Name                                               IsDefault
------------------------------------  -------------------------------------------------  -----------
11111111-3ddc-45ce-8334-c7b28a9e1c3a  C & L Azure developer experience content projects  False
22222222-8f1c-409b-af1e-8e2e65d9b90a  DevCenter - Infrastructure - Dogfood               False
33333333-c080-42a7-8973-1aa853ab4df3  Babel                                              False

Consulta y aplicación de formato para varios valores, incluidos los valores anidados

Para obtener más de una propiedad, coloque las expresiones entre corchetes [ ] (una lista de selección múltiple) como una lista separada por comas. Las consultas siguientes muestran la consulta de varios valores de una salida de diccionario JSON mediante varios formatos de salida.

az account show --query [name,id,user.name] # return multiple values
az account show --query [name,id,user.name] -o table # return multiple values as a table

Para más información sobre cómo devolver varios valores, consulte Obtener varios valores.

Cambio de nombre de las propiedades en una consulta

Las consultas siguientes muestran el uso del operador { } (hash de selección múltiple) para obtener un diccionario en lugar de una matriz al consultar varios valores. También muestra cómo cambiar el nombre de las propiedades en el resultado de la consulta.

az account show --query "{SubscriptionName: name, SubscriptionId: id, UserName: user.name}" # Rename the values returned
az account show --query "{SubscriptionName: name, SubscriptionId: id, UserName: user.name}" -o table # Rename the values returned in a table

Para más información sobre cómo cambiar el nombre de las propiedades de una consulta, revise Cambio del nombre de las propiedades en una consulta.

Consulta de valores booleanos

Se supone que los valores booleanos son true, por lo que la sintaxis de consulta "[?isDefault]" del comando az account list devuelve la suscripción predeterminada actual. Para obtener los valores false, debe usar un carácter de escape, como \.

Las siguientes consultas muestran la consulta de todas las cuentas de una suscripción, la posible devolución de una matriz JSON si existen varias suscripciones para una cuenta determinada y, a continuación, la consulta de qué cuenta es la suscripción predeterminada. También demuestra la consulta de las cuentas que no son la suscripción por defecto. Estas consultas se basan en lo que ha aprendido anteriormente para filtrar y dar formato a los resultados. Por último, la consulta final muestra cómo almacenar los resultados de la consulta en una variable.

az account list
az account list --query "[?isDefault]" # Returns the default subscription
az account list --query "[?isDefault]" -o table # Returns the default subscription as a table
az account list --query "[?isDefault].[name,id]" # Returns the name and id of the default subscription
az account list --query "[?isDefault].[name,id]" -o table # Returns the name and id of the default subscription as a table
az account list --query "[?isDefault].{SubscriptionName: name, SubscriptionId: id}" -o table # Returns the name and id of the default subscription as a table with friendly names

az account list --query "[?isDefault == \`false\`]" # Returns all non-default subscriptions, if any
az account list --query "[?isDefault == \`false\`].name" -o table # Returns all non-default subscriptions, if any, as a table

az account list --query "[?isDefault].id" -o tsv # Returns the subscription id without quotation marks
subscriptionId="$(az account list --query "[?isDefault].id" -o tsv)" # Captures the subscription id as a variable.
echo $subscriptionId # Returns the contents of the variable.
az account list --query "[? contains(name, 'Test')].id" -o tsv # Returns the subscription id of a non-default subscription containing the substring 'Test'
subscriptionId="$(az account list --query "[? contains(name, 'Test')].id" -o tsv) # Captures the subscription id as a variable. 
az account set -s $subscriptionId # Sets the current active subscription

Para más información sobre el filtrado de matrices y la consulta de valores booleanos, consulte Filtrado de matrices con expresiones booleanas.
Para más información sobre el uso de variables, consulte Uso de variables en comandos de la CLI de Azure.
Para más información sobre cómo trabajar con suscripciones, consulte Administración de suscripciones de Azure con la CLI de Azure.

Creación de objetos mediante variables y selección aleatoria

Establecimiento de un valor aleatorio para su uso en comandos posteriores

Establecer y usar un valor aleatorio para su uso en las variables le permite ejecutar scripts varias veces sin conflictos de nomenclatura. Los conflictos de nomenclatura se producen porque un valor debe ser único en el servicio o porque un objeto que eliminó todavía existe en Azure hasta que se complete el proceso de eliminación.

$RANDOM es una función de Bash (no una constante) que devuelve un número entero de 16 bits con signo aleatorio (de 0 a 32767). El comando let es un comando de Bash integrado para evaluar expresiones aritméticas. Con el comando siguiente, se crea un valor suficientemente único para la mayoría de los propósitos.

let "randomIdentifier=$RANDOM*$RANDOM"

Trabajar con caracteres de espacio y comillas

Los espacios se usan para separar comandos, opciones y argumentos. Use comillas para indicar al shell de Bash que omita todos los caracteres especiales, de los cuales un espacio en blanco es un carácter especial. Cuando el shell de Bash ve la primera comilla, omite los caracteres especiales hasta la comilla de cierre. Sin embargo, a veces querrá que el shell de Bash analice determinados caracteres especiales, como signos de dólar, comillas inversas y barras diagonales inversas. En este escenario, use comillas dobles.

Los siguientes comandos utilizan el comando az group create para ilustrar el uso de comillas simples y dobles. Estos comandos se usan para controlar espacios y evaluar caracteres especiales al trabajar con variables y crear un objeto.

resourceGroup='msdocs-learn-bash-$randomIdentifier'
echo $resourceGroup # The $ is ignored in the creation of the $resourceGroup variable
resourceGroup="msdocs-learn-bash-$randomIdentifier"
echo $resourceGroup # The $randomIdentifier is evaluated when defining the $resourceGroup variable
location="East US" # The space is ignored when defining the $location variable
echo The value of the location variable is $location # The value of the $location variable is evaluated
echo "The value of the location variable is $location" # The value of the $location variable is evaluated
echo "The value of the location variable is \$location" # The value of the $location variable is not evaluated
echo 'The value of the location variable is $location' # The value of the $location variable is not evaluated
az group create --name $resourceGroup --location $location # Notice that the space in the $location variable is not ignored and the command fails as it treats the value after the space as a new command 
az group create --name $resourceGroup --location "$location" # Notice that the space in the $location variable is ignored and the location argument accepts the entire string as the value

En la salida del diccionario JSON, revise las propiedades del grupo de recursos creado.

Uso de If Then Else para determinar si una variable es NULL

Utilice != para evaluar cadenas y -ne para evaluar números. La siguiente instrucción If Then Else evalúa si se ha establecido la variable $resourceGroup. En caso afirmativo, devuelve el valor de la variable. En caso negativo, establece la variable.

if [ $resourceGroup != '' ]; then
   echo $resourceGroup
else
   resourceGroup="msdocs-learn-bash-$randomIdentifier"
fi

Uso de If Then para crear o eliminar un grupo de recursos

El siguiente script crea un nuevo grupo de recursos sólo si aún no existe uno con el nombre especificado.

if [ $(az group exists --name $resourceGroup) = false ]; then 
   az group create --name $resourceGroup --location "$location" 
else
   echo $resourceGroup
fi

El siguiente script elimina un grupo de recursos existente si ya existe uno con el nombre especificado. Puede usar el argumento --no-wait para devolver el control sin esperar a que se complete el comando. Sin embargo, para este artículo, queremos esperar a que se elimine el grupo de recursos antes de continuar. Para más información sobre las operaciones asincrónicas, consulte Sugerencias para usar correctamente la CLI de Azure: operaciones asincrónicas. Mostraremos el uso del argumento --no-wait al final de este artículo.

if [ $(az group exists --name $resourceGroup) = true ]; then 
   az group delete --name $resourceGroup -y # --no-wait
else
   echo The $resourceGroup resource group does not exist
fi

Uso de Grep para determinar si existe un grupo de recursos y crear el grupo de recursos si no existe

El siguiente comando canaliza la salida del comando az group list al comando grep. Si el grupo de recursos especificado no existe, el comando crea el grupo de recursos con las variables definidas anteriormente.

az group list --output tsv | grep $resourceGroup -q || az group create --name $resourceGroup --location "$location"

Uso de la instrucción CASE para determinar si existe un grupo de recursos y crear el grupo de recursos si no existe

La siguiente instrucción CASE crea un nuevo grupo de recursos solo si aún no existe uno con el nombre especificado. Si existe uno con el nombre especificado, la instrucción CASE indica en la salida que el grupo de recursos existe.

var=$(az group list --query "[? contains(name, '$resourceGroup')].name" --output tsv)
case $resourceGroup in
$var)
echo The $resourceGroup resource group already exists.;;
*)
az group create --name $resourceGroup --location "$location";;
esac

Uso de bucles for y consulta de matrices

En esta sección del artículo, crearemos una cuenta de almacenamiento y utilizaremos bucles for para crear blobs y contenedores. También se mostrará la consulta de matrices JSON y el trabajo con variables de entorno.

Crear cuenta de almacenamiento

El siguiente comando utiliza el comando az storage account create para crear una cuenta de almacenamiento que utilizaremos al crear contenedores de almacenamiento.

storageAccount="learnbash$randomIdentifier"
az storage account create --name $storageAccount --location "$location" --resource-group $resourceGroup --sku Standard_LRS --encryption-services blob

Obtenga las claves de cuenta de almacenamiento.

Los siguientes comandos usan el comando az storage account keys list para devolver los valores de la clave de la cuenta de almacenamiento. A continuación, almacenamos un valor de clave en una variable para su uso al crear contenedores de almacenamiento.

az storage account keys list --resource-group $resourceGroup --account-name $storageAccount --query "[].value" -o tsv # returns both storage account key values

az storage account keys list --resource-group $resourceGroup --account-name $storageAccount --query "[0].value" -o tsv # returns a single storage account key value

accountKey=$(az storage account keys list --resource-group $resourceGroup --account-name $storageAccount --query "[0].value" -o tsv)

echo $accountKey

Creación de contenedores de almacenamiento

Comenzamos utilizando az storage container create para crear un único contenedor de almacenamiento y luego utilizamos az storage container list para consultar el nombre del contenedor creado.

container="learningbash"
az storage container create --account-name $storageAccount --account-key $accountKey --name $container

az storage container list --account-name $storageAccount --account-key $accountKey --query [].name

Carga de datos en el contenedor

El siguiente script crea tres archivos de ejemplo mediante un bucle for.

for i in `seq 1 3`; do
    echo $randomIdentifier > container_size_sample_file_$i.txt
done

El script siguiente usa el comando az storage blob upload-batch para cargar los blobs en el contenedor de almacenamiento.

az storage blob upload-batch \
    --pattern "container_size_sample_file_*.txt" \
    --source . \
    --destination $container \
    --account-key $accountKey \
    --account-name $storageAccount

El script siguiente usa el comando az storage blob list para enumerar los blobs del contenedor.

az storage blob list \
    --container-name $container \
    --account-key $accountKey \
    --account-name $storageAccount \
    --query "[].name"

El siguiente script muestra el número total de bytes en el contenedor de almacenamiento.

bytes=`az storage blob list \
    --container-name $container \
    --account-key $accountKey \
    --account-name $storageAccount \
    --query "[*].[properties.contentLength]" \
    --output tsv | paste -s -d+ | bc`

echo "Total bytes in container: $bytes"
echo $bytes

Creación de varios contenedores mediante bucles

A continuación, creamos múltiples contenedores utilizando un bucle demostrando un par de maneras de escribir el bucle.

for i in `seq 1 4`; do 
az storage container create --account-name $storageAccount --account-key $accountKey --name learnbash-$i
done

for value in {5..8}
for (( i=5; i<10; i++));
do
az storage container create --account-name $storageAccount --account-key $accountKey --name learnbash-$i
done

az storage container list --account-name $storageAccount --account-key $accountKey --query [].name

Uso de EXPORT para definir variables de entorno

En los scripts anteriores del contenedor de almacenamiento, especificamos el nombre de la cuenta y la clave de cuenta con cada comando. En su lugar, puede almacenar las credenciales de autenticación mediante las variables de entorno correspondientes: AZURE_STORAGE_ACCOUNT y AZURE_STORAGE_KEY. Para realizar esta acción, use EXPORT.

export AZURE_STORAGE_ACCOUNT=$storageAccount
export AZURE_STORAGE_KEY=$accountKey
az storage container list # Uses the environment variables to display the list of containers.

El siguiente script crea una cadena de metadatos y, a continuación, usa el comando az storage container metadata update para actualizar un contenedor con esa cadena, de nuevo mediante las variables de entorno.

metadata="key=value pie=delicious" # Define metadata
az storage container metadata update \
    --name $container \
    --metadata $metadata # Update the metadata
az storage container metadata show \
    --name $containerName # Show the metadata

El siguiente comando usa el comando az storage container delete para eliminar un único contenedor con nombre y, a continuación, eliminar varios contenedores en un bucle.

az storage container delete \
    --name $container

Obtenga una lista de contenedores que contienen un prefijo específico y almacene los resultados en una variable.

containerPrefix="learnbash"
containerList=$(az storage container list \
    --query "[].name" \
    --prefix $containerPrefix \
    --output tsv)

Elimine la lista de contenedores en un bucle mediante el argumento --prefix.

for row in $containerList
do
    tmpName=$(echo $row | sed -e 's/\r//g')
    az storage container delete \
    --name $tmpName 
done

Control de errores

Para salir inmediatamente de un script si un comando devuelve un estado distinto de cero, ejecute el siguiente comando:

set -e

Para obtener más información sobre la configuración de las opciones del shell y otras ayudas, ejecute los siguientes comandos:

help set
help help

Limpieza de recursos

Después de completar este artículo, elimine el grupo de recursos y todos los recursos que contiene. Utilice el argumento --no-wait.

if [ $(az group exists --name $resourceGroup) = true ]; then 
   az group delete --name $resourceGroup -y  --no-wait
else
   echo The $resourceGroup resource group does not exist
fi

Consulte también

Tutorial: Aprender a usar la CLI de Azure
Uso correcto de la CLI de Azure
Cómo consultar la salida de un comando de la CLI de Azure mediante una consulta JMESPath
Buscar muestras y artículos publicados de la CLI de Azure

Compartir a través de