Partager via

Guide pratique pour utiliser Azure CLI dans un langage de script Bash

Les commandes de référence Azure CLI peuvent s’exécuter dans plusieurs langages de script. Si vous débutez avec Bash et l’interface de ligne de commande Azure, cet article est un excellent endroit pour commencer votre parcours d’apprentissage. Suivez cet article comme vous le feriez pour apprendre à utiliser Azure CLI dans un langage de script Bash avec facilité.

Dans cet article, vous allez apprendre à :

  • Résultats de requête sous forme de dictionnaires ou de tableaux JSON
  • Mettre en forme la sortie au format JSON, table ou TSV
  • Interroger, filtrer et mettre en forme des valeurs uniques et multiples
  • Utiliser si/exists/then et la syntaxe de cas
  • Utiliser des boucles for
  • Utiliser des commandes grep, sed, paste et bc
  • Remplir et utiliser des variables d’environnement et d’interpréteur de commandes

Si vous n’en avez pas, créez un compte gratuit Azure avant de commencer.

Démarrage de Bash

Démarrez Bash à l’aide d’Azure Cloud Shell ou d’une installation locale d’Azure CLI. Cet article suppose que vous exécutez Bash à l’aide d’Azure Cloud Shell ou d’Azure CLI localement dans un conteneur Docker.

Recherche de résultats de dictionnaire

Une commande qui retourne toujours un seul objet renvoie un dictionnaire JSON. Les dictionnaires sont des objets non ordonnés accessibles avec des clés. Pour cet article, nous allons commencer par interroger l’objet Account à l’aide de la commande Account Show .

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

La sortie du dictionnaire JSON suivante comporte certains champs omis pour la concision et les informations d’identification sont supprimées.

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

Mise en forme de la sortie au format YAML

Utilisez l’argument --output yaml (ou -o yaml) pour mettre en forme la sortie au format yaml , un format de sérialisation de données en texte brut. YAML est souvent plus simple à lire que JSON et se mappe facilement vers ce format. Certaines applications et commandes CLI prennent YAML comme entrée de configuration, au lieu de JSON.

az account show --output yaml

Pour plus d’informations sur la mise en forme de la sortie en tant que yaml, consultez le format de sortie YAML.

Mise en forme de la sortie en tant que tableau

Utilisez l’argument --output table (ou -o table) pour mettre en forme la sortie en tant que table ASCII. Les objets imbriqués ne sont pas inclus dans le tableau de sortie, mais peuvent toujours être filtrés dans le cadre d’une requête.

az account show --output table

Pour plus d’informations sur la mise en forme de la sortie sous forme de tableau, consultez le format de sortie de table.

Interrogation et mise en forme de valeurs uniques et valeurs imbriquées

Les requêtes suivantes illustrent l’interrogation de valeurs uniques, y compris les valeurs imbriquées dans une sortie de dictionnaire JSON. La requête finale de cet ensemble illustre la mise en forme de la sortie à l’aide de l’argument -o tsv . Cet argument retourne les résultats sous forme de valeurs séparées par des tabulations et des lignes. Cette action est utile pour supprimer des guillemets dans la valeur retournée, ce qui est utile pour consommer la sortie dans d’autres commandes et outils qui doivent traiter le texte sous un certain forme (comme illustré plus loin dans cet article).

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

Interrogation et mise en forme des propriétés à partir de tableaux

La requête suivante illustre l’obtention de propriétés dans un tableau JSON. Obtenir les propriétés de l’abonnement, affichées sous la forme d’une table d’abonnements.

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

Cette requête retourne des résultats similaires à :

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

Interrogation et mise en forme de plusieurs valeurs, y compris les valeurs imbriquées

Pour obtenir plusieurs propriétés, placez des expressions entre crochets [ ] (une liste à sélection multiple) en tant que liste séparée par des virgules. Les requêtes suivantes illustrent l’interrogation de plusieurs valeurs dans une sortie de dictionnaire JSON, à l’aide de plusieurs formats de sortie.

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

Pour plus d’informations sur le retour de plusieurs valeurs, consultez Obtenir plusieurs valeurs.

Renommage des propriétés dans une requête

Les requêtes suivantes illustrent l’utilisation de l’opérateur { } (hachage multiselect) pour obtenir un dictionnaire au lieu d’un tableau lors de l’interrogation de plusieurs valeurs. Il illustre également comment renommer les propriétés dans le résultat de la requête.

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

Pour plus d’informations sur le changement de nom des propriétés dans une requête, consultez Renommer des propriétés dans une requête.

Requête de valeurs booléennes

Les valeurs booléennes sont supposées être vraies. Par conséquent, la "[?isDefault]" syntaxe de requête de la az account list commande retourne l’abonnement par défaut actuel. Pour obtenir les valeurs false, vous devez utiliser un caractère d’échappement, tel que \.

Les requêtes suivantes illustrent l’interrogation de tous les comptes d’un abonnement, potentiellement le renvoi d’un tableau JSON s’il existe plusieurs abonnements pour un compte donné, puis l’interrogation de ce compte est l’abonnement par défaut. Il illustre également la recherche des comptes qui ne sont pas un abonnement par défaut. Ces requêtes s’appuient sur ce que vous avez appris précédemment pour filtrer et mettre en forme les résultats. Enfin, la requête finale illustre le stockage des résultats de la requête dans une 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

Création d’objets à l’aide de variables et de randomisation

Définition d’une valeur aléatoire à utiliser dans les commandes suivantes

La définition et l’utilisation d’une valeur aléatoire pour une utilisation dans des variables vous permet d’exécuter plusieurs fois des scripts sans conflits d’affectation de noms. Les conflits d’affectation de noms se produisent parce qu’une valeur doit être unique sur le service, ou parce qu’un objet que vous avez supprimé existe toujours dans Azure jusqu’à ce que le processus de suppression soit terminé.

$RANDOM est une fonction bash (pas une constante) qui retourne un entier 16 bits signé aléatoire (compris entre 0 et 32767). La let commande est une commande Bash intégrée pour évaluer les expressions arithmétiques. L’utilisation de la commande suivante crée une valeur suffisamment unique à la plupart des fins.

let "randomIdentifier=$RANDOM*$RANDOM"

Utilisation d’espaces et de guillemets

Les espaces sont utilisés pour séparer les commandes, les options et les arguments. Utilisez des guillemets pour indiquer à l’interpréteur de commandes Bash d’ignorer tous les caractères spéciaux dont un espace blanc est un caractère spécial. Lorsque l’interpréteur de commandes Bash voit le premier guillemet, il ignore les caractères spéciaux jusqu’aux guillemets fermants. Toutefois, vous voulez parfois que l’interpréteur de commandes Bash analyse certains caractères spéciaux, tels que les signes dollar, les guillemets précédents et les barres obliques inverses. Pour ce scénario, utilisez des guillemets doubles.

Les commandes suivantes utilisent la commande az group create pour illustrer l’utilisation de guillemets simples et doubles. Ces commandes permettent de gérer des espaces et d’évaluer des caractères spéciaux lors de l’utilisation de variables et de la création d’un objet.

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

Dans la sortie du dictionnaire JSON, passez en revue les propriétés du groupe de ressources créé.

Utilisation de If Then Else pour déterminer si la variable a la valeur Null

Pour évaluer les chaînes, utilisez != et pour évaluer les nombres, utilisez -ne. L’instruction If Then Else suivante évalue si la variable $resourceGroup a été définie. Si c’est le cas, elle retourne la valeur de la variable. Si ce n’est pas le cas, il définit la variable.

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

Utilisation de If Then pour créer ou supprimer un groupe de ressources

Le script suivant crée un groupe de ressources uniquement s’il n'en existe pas déjà un avec le nom spécifié.

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

Le script suivant supprime un nouveau groupe de ressources existant s’il en existe déjà un avec le nom spécifié. Vous pouvez utiliser l’argument --no-wait pour retourner le contrôle sans attendre la fin de la commande. Toutefois, pour cet article, nous souhaitons attendre la suppression du groupe de ressources avant de continuer. Pour plus d’informations sur les opérations asynchrones, consultez Conseils pour utiliser l’interface de ligne de commande Azure avec succès : opérations asynchrones. Nous montrons l’utilisation de l’argument --no-wait à la fin de cet article.

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

Utilisation de Grep pour déterminer si un groupe de ressources existe et créer le groupe de ressources s'il n'existe pas

La commande suivante canalise la sortie de la az group list commande vers la grep commande. Si le groupe de ressources spécifié n’existe pas, la commande crée le groupe de ressources à l’aide des variables définies précédemment.

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

Utilisation de l’instruction CASE pour déterminer si un groupe de ressources existe et créer le groupe de ressources s'il n'existe pas

L’instruction CASE suivante crée un groupe de ressources uniquement si un nom spécifié n’existe pas déjà. Si un élément avec le nom spécifié existe, l'instruction CASE indique que le groupe de ressources 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

Utilisation de boucles for et de requêtes sur des tableaux

Dans cette section de l’article, nous créons un compte de stockage, puis utilisons des boucles pour créer des objets blob et des conteneurs. Nous montrons également l’interrogation de tableaux JSON et l’utilisation de variables d’environnement.

Créer un compte de stockage

La commande suivante utilise la commande az storage account create pour créer un compte de stockage que nous utilisons lors de la création de conteneurs de stockage.

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

Obtenir les clés du compte de stockage

Les commandes suivantes utilisent la commande az storage account keys list pour retourner les valeurs de clé de compte de stockage. Nous stockons ensuite une valeur de clé dans une variable à utiliser lors de la création de conteneurs de stockage.

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

Créer un conteneur de stockage

Nous commençons par utiliser le conteneur az storage create pour créer un conteneur de stockage unique, puis utilisez la liste de conteneurs az storage pour interroger le nom du conteneur créé.

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

Charger des données dans un conteneur

Le script suivant crée trois exemples de fichiers à l’aide d’une boucle for.

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

Le script suivant utilise la commande az storage blob upload-batch pour charger les objets blob dans le conteneur de stockage.

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

Le script suivant utilise la commande az storage blob list pour répertorier les objets blob dans le conteneur.

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

Le script suivant affiche le nombre total d’octets dans le conteneur de stockage.

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

Créer de nombreux conteneurs à l’aide de boucles

Ensuite, nous créons plusieurs conteneurs à l’aide d’une boucle illustrant deux façons d’écrire la boucle.

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

Utiliser EXPORT pour définir des variables d’environnement

Dans les scripts de conteneur de stockage précédents, nous avons spécifié le nom du compte et la clé de compte avec chaque commande. Au lieu de cela, vous pouvez stocker vos informations d’identification d’authentification à l’aide des variables d’environnement correspondantes : AZURE_STORAGE_ACCOUNT et AZURE_STORAGE_KEY. Pour effectuer cette action, utilisez 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.

Le script suivant crée une chaîne de métadonnées, puis utilise la commande az storage container metadata update pour mettre à jour un conteneur avec cette chaîne, à nouveau à l’aide des variables d’environnement.

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

La commande suivante utilise la commande az storage container delete pour supprimer un conteneur nommé unique, puis supprimer plusieurs conteneurs dans une boucle.

az storage container delete \
    --name $container

Obtenez la liste des conteneurs contenant un préfixe spécifique et stockez les résultats dans une variable.

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

Supprimez la liste des conteneurs dans une boucle à l’aide de l’argument --prefix .

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

Gestion des erreurs

Pour quitter un script immédiatement si une commande retourne un état différent de zéro, exécutez la commande suivante :

set -e

Pour plus d’informations sur la définition des options d’interpréteur de commandes et d’autres informations, exécutez les commandes suivantes :

help set
help help

Nettoyer les ressources

Une fois cet article terminé, supprimez le groupe de ressources et toutes les ressources qu’il contient. Utilisez l’argument --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

Voir aussi