Guide pratique pour utiliser Azure CLI dans un environnement Bash

  • Article

Les commandes de référence Azure CLI peuvent s’exécuter dans plusieurs environnements d’interpréteur de commandes différents, mais Microsoft Docs utilise principalement l’environnement Bash. Si vous débutez avec Bash et également avec Azure CLI, cet article est un excellent endroit pour commencer votre parcours d’apprentissage. Parcourez cet article comme vous le feriez dans un tutoriel, et vous apprendrez comment utiliser Azure CLI dans un environnement Bash.

Dans cet article, vous apprendrez comment :

  • Résultats de requête en tant que dictionnaires ou tableaux JSON
  • Mettre en forme la sortie en tant que JSON, tableaux ou TSV
  • Interroger, filtrer et mettre en forme des valeurs uniques et multiples
  • Utiliser « si/existe/puis » la syntaxe de cas
  • Utiliser des boucles « pour »
  • Utiliser des commandes « grep », « sed », « coller » 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.

Lancer Bash

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

Interroger les résultats du dictionnaire

Une commande qui retourne toujours un seul objet retourne 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 de dictionnaire JSON suivante contient certains champs omis à des fins de concision. L’identification des informations a également été supprimée ou générique.

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

Mettre en forme la sortie en tant que 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 utilisent YAML en tant qu’entrée de configuration, plutôt que 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.

Mettre en forme la sortie en tant que table

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 Format de sortie « table ».

Interroger et mettre en forme des 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 onglets et nouvelles lignes. Cela est utile pour supprimer des guillemets dans la valeur retournée, ainsi que pour consommer la sortie dans d’autres commandes et outils qui doivent traiter le texte sous une certain forme (comme nous allons le démontrer 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 de propriétés à partir de tableaux

La requête suivante illustre l’obtention de propriétés dans un tableau JSON. Obtenez 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 renvoie 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

Interroger et mettre en forme plusieurs valeurs, y compris les valeurs imbriquées

Pour récupérer plusieurs propriétés, placez des expressions entre crochets [ ] (une liste à sélection multiple) sous la forme d’une 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.

Renommer les propriétés dans une requête

Les requêtes suivantes illustrent l’utilisation de l’opérateur { } (code de hachage à sélection multiple) pour obtenir un dictionnaire au lieu d’un tableau lors de l’interrogation de plusieurs valeurs. Il montre également les propriétés de changement de nom 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.

Interroger des valeurs booléennes

Les valeurs booléennes sont supposées être vraies, de sorte que la syntaxe de requête "[?isDefault]" de la commande az account list 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 retour 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 l’interrogation des comptes qui ne sont pas l’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 la randomisation

Définir une valeur aléatoire à utiliser dans les commandes suivantes

Définir et utiliser 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’attribution des noms peuvent se produire, car 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 nombre entier signé 16 bits aléatoire (de 0 à 32767). La commande let est une commande Bash intégrée pour évaluer les expressions arithmétiques. Utiliser la commande suivante permet de créer une valeur suffisamment unique à la plupart des fins.

let "randomIdentifier=$RANDOM*$RANDOM"

Utiliser des espaces et 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 l’espace blanc. Lorsque l’interpréteur de commandes Bash voit le premier guillemet, il ignore les caractères spéciaux jusqu’au guillemet fermant. Toutefois, parfois, vous voulez que l’interpréteur de commandes Bash analyse certains caractères spéciaux, tels que les signes dollar, les apostrophes ouvrantes 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 des guillemets simples et doubles. Ces commandes sont utilisées pour gérer les espaces et évaluer les 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 qui vient d’être créé.

Utilisation de If Then Else (Si Alors Sinon) pour déterminer si la variable est Null

Pour évaluer les chaînes, utiliser != et évaluer l’utilisation des nombres -ne. L’instruction If Then Else (Si Alors Sinon) suivante évalue si la variable $resourceGroup a été définie. Si tel est le cas, elle retourne la valeur de la variable. Si ce n’est pas le cas, elle définit la variable.

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

Utilisation de If Then (Si Alors) pour créer ou supprimer un groupe de ressources

Le script suivant crée un groupe de ressources uniquement si aucun groupe portant le nom spécifié n’existe.

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

Le script suivant supprime un groupe de ressources existant si un groupe portant le nom spécifié existe déjà. Vous pouvez utiliser l’argument --no-wait pour renvoyer le contrôle sans attendre que la commande soit terminée. Toutefois, pour cet article, nous voulons attendre que le groupe de ressources soit supprimé avant de continuer. Pour plus d’informations sur les opérations asynchrones, consultez Opérations asynchrones. Nous illustrerons 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

Utiliser Grep pour déterminer si un groupe de ressources existe et créer le groupe de ressources si ce n’est pas le cas

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

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

Utiliser l’instruction CASE pour déterminer si un groupe de ressources existe et créer le groupe de ressources si ce n’est pas le cas

L’instruction CASE suivante crée un groupe de ressources uniquement si aucun groupe portant le nom spécifié n’existe. S’il en existe déjà un portant le nom spécifié, l’instruction CASE fait écho au groupe de ressources.

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

Utiliser les boucles Pour et interroger les tableaux

Dans cette section de l’article, nous allons créer un compte de stockage, puis utiliser pour les boucles Pour de façon à créer des blob et des conteneurs. Nous allons également illustrer l’interrogation des 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 utiliserons 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 allons commencer par utiliser la commande az storage container create pour créer un conteneur de stockage unique, puis utiliser la liste de conteneurs az storage de façon à 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

Télécharger des données vers le conteneur

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

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 lister les objets BLOB dans le conteneur de stockage.

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

Le script suivant affiche les octets totaux 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 allons créer plusieurs conteneurs à l’aide d’une boucle illustrant quelques 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, puis 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 d’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 non 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 rubriques d’aide, exécutez les commandes suivantes :

help set
help help

Nettoyer les ressources

Lorsque vous avez terminé cet article, 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