Lire en anglais

Partager via

Variables dans Bicep

  • Article

Cet article décrit comment définir et utiliser des variables dans votre fichier Bicep. Vous utilisez des variables pour simplifier le développement de vos fichiers Bicep. Au lieu de répéter des expressions complexes tout au long de votre fichier Bicep, vous définissez une variable qui contient l’expression complexe. Ensuite, vous utilisez cette variable en fonction des besoins dans votre fichier Bicep.

Resource Manager résout les variables avant de démarrer les opérations de déploiement. Chaque fois que la variable est utilisée dans le fichier Bicep, Resource Manager la remplace par la valeur résolue.

Vous êtes limité à 512 variables dans un fichier Bicep. Pour plus d’informations, consultez Limites du modèle.

Définir des variables

La syntaxe permettant de définir une variable est la suivante :

Bicep 
@<decorator>(<argument>)
var <variable-name> = <variable-value>

Une variable ne peut pas avoir le même nom qu’un paramètre, un module ou une ressource.

Notez que vous ne spécifiez pas de type de données pour la variable. Le type est déduit de la valeur. Dans l’exemple suivant, la valeur d’une variable est définie sur une chaîne.

Bicep 
var stringVar = 'example value'

Vous pouvez utiliser la valeur d’un paramètre ou d’une autre variable lors de la construction de la variable.

Bicep 
param inputValue string = 'deployment parameter'

var stringVar = 'preset variable'
var concatToVar =  '${stringVar}AddToVar'
var concatToParam = '${inputValue}AddToParam'

output addToVar string = concatToVar
output addToParam string = concatToParam

L’exemple précédent renvoie :

JSON 
{
  "addToParam": {
    "type": "String",
    "value": "deployment parameterAddToParam"
  },
  "addToVar": {
    "type": "String",
    "value": "preset variableAddToVar"
  }
}

Vous pouvez utiliser les fonctions Bicep pour construire la valeur de la variable. L’exemple suivant utilise des fonctions Bicep pour créer une valeur de chaîne pour un nom de compte de stockage.

Bicep 
param storageNamePrefix string = 'stg'
var storageName = '${toLower(storageNamePrefix)}${uniqueString(resourceGroup().id)}'

output uniqueStorageName string = storageName

L’exemple suivant retourne une valeur telle que la suivante :

JSON 
"uniqueStorageName": {
  "type": "String",
  "value": "stghzuunrvapn6sw"
}

Vous pouvez utiliser des boucles itératives lors de la définition d’une variable. L’exemple suivant crée un tableau d’objets avec trois propriétés.

Bicep 
param itemCount int = 3

var objectArray = [for i in range(0, itemCount): {
  name: 'myDataDisk${(i + 1)}'
  diskSizeGB: '1'
  diskIndex: i
}]

output arrayResult array = objectArray

La sortie retourne un tableau avec les valeurs suivantes :

JSON 
[
  {
    "name": "myDataDisk1",
    "diskSizeGB": "1",
    "diskIndex": 0
  },
  {
    "name": "myDataDisk2",
    "diskSizeGB": "1",
    "diskIndex": 1
  },
  {
    "name": "myDataDisk3",
    "diskSizeGB": "1",
    "diskIndex": 2
  }
]

Pour plus d’informations sur les types de boucles que vous pouvez utiliser avec des variables, consultez Boucles itératives dans Bicep.

Utiliser des éléments décoratifs

Les éléments décoratifs sont écrits au format @expression et sont placés au-dessus des déclarations de variables. Le tableau suivant présente les éléments décoratifs disponibles pour les variables.

Élément décoratif Argument Description
description string Fournissez des descriptions pour la variable.
export Aucune Indique que la variable est disponible pour l’importation par un autre fichier Bicep.

Les éléments décoratifs se trouvent dans l’espace de noms sys. Si vous devez différencier un élément décoratif d'un autre élément portant le même nom, faites précéder l’élément décoratif de sys. Par exemple, si votre fichier Bicep contient une variable nommée description, vous devez ajouter l’espace de noms sys lors de l’utilisation de l’élément décoratif description.

Description

Pour ajouter une explication, ajoutez une description aux déclarations de variable. Par exemple :

Bicep 
@description('Create a unique storage account name.')
var storageAccountName = uniqueString(resourceGroup().id)

Du texte au format Markdown peut être utilisé pour le texte de description.

Export

Utilisez @export() pour partager la variable avec d’autres fichiers Bicep. Pour plus d’informations, consultez Exporter des variables, des types et des fonctions.

Utiliser des variables

L’exemple suivant montre comment utiliser la variable pour une propriété de ressource. Vous faites référence à la valeur de la variable en indiquant le nom de la variable : storageName.

Bicep 
param rgLocation string
param storageNamePrefix string = 'STG'

var storageName = '${toLower(storageNamePrefix)}${uniqueString(resourceGroup().id)}'

resource demoAccount 'Microsoft.Storage/storageAccounts@2023-04-01' = {
  name: storageName
  location: rgLocation
  kind: 'Storage'
  sku: {
    name: 'Standard_LRS'
  }
}

output stgOutput string = storageName

Étant donné que les noms de compte de stockage doivent utiliser des minuscules, la variable storageName utilise la fonction toLower pour mettre la valeur storageNamePrefix en minuscules. La fonction uniqueString crée une valeur unique à partir de l’ID du groupe de ressources. Les valeurs sont concaténées en une chaîne.

Variables de configuration

Vous pouvez définir des variables qui contiennent des valeurs associées pour la configuration d’un environnement. Vous définissez la variable en tant qu’objet avec les valeurs. L’exemple suivant illustre un objet qui contient des valeurs pour deux environnements : test et prod. Transmettez l’une de ces valeurs au cours du déploiement.

Bicep 
@allowed([
  'test'
  'prod'
])
param environmentName string

var environmentSettings = {
  test: {
    instanceSize: 'Small'
    instanceCount: 1
  }
  prod: {
    instanceSize: 'Large'
    instanceCount: 4
  }
}

output instanceSize string = environmentSettings[environmentName].instanceSize
output instanceCount int = environmentSettings[environmentName].instanceCount

Étapes suivantes