Variables dans Bicep

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

Une variable ne peut pas avoir le même nom qu’un paramètre, un module ou une ressource. Vous pouvez ajouter un ou plusieurs éléments décoratifs pour chaque variable. Pour plus d’informations, consultez Utiliser des décorateurs.

Variables non typées

Lorsque vous définissez une variable sans spécifier de type de données, le type est déduit de la valeur. La syntaxe de définition d’une variable non typée est la suivante :

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

Dans l’exemple suivant, la valeur d’une variable est définie sur une chaîne.

var stringVar = 'preset variable'

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

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

La sortie de l’exemple précédent retourne :

{
  "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.

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

output uniqueStorageName string = storageName

L’exemple précédent retourne une valeur comme la sortie suivante :

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

Variables typées

À compter de Bicep CLI version 0.36.X, Bicep prend en charge les variables typées, où vous déclarez explicitement le type de données d’une variable pour garantir la sécurité du type et améliorer la clarté du code. Avantages des variables typées :

• Détection d’erreurs : le compilateur Bicep valide que les valeurs affectées correspondent au type déclaré, interceptant les erreurs au début.
• Clarté du code : les types explicites indiquent clairement le type de données qu’une variable contient.
• Prise en charge d’IntelliSense : les outils tels que Visual Studio Code fournissent une meilleure autocomplétion et une validation pour les variables typées.
• Sécurité de refactorisation : garantit que les modifications apportées aux affectations de variables ne rompent pas par inadvertance les attentes de type.

Pour définir une variable typée, utilisez le var mot clé suivi du nom de la variable, du type et de la valeur affectée :

var <variable-name> <data-type> = <variable-value>

Les exemples suivants montrent comment définir des variables typées :

var resourceName string = 'myResource'
var instanceCount int = 3
var isProduction bool = true
var tags object = { environment: 'dev' }
var subnets array = ['subnet1', 'subnet2']

Pour object les types, vous pouvez définir un schéma pour appliquer une structure spécifique. Le compilateur garantit que l’objet respecte le schéma défini.

var config {
  name: string
  count: int
  enabled: bool
} = {
  name: 'myApp'
  count: 5
  enabled: true
}

L’exemple suivant utilise des variables typées avec des décorateurs pour appliquer des contraintes :

@description('The environment to deploy to')
@allowed(['dev', 'test', 'prod'])
param environment string = 'dev'

var instanceCount int = environment == 'prod' ? 5 : 2
var resourcePrefix string = 'app'
var tags {
  environment: string
  deployedBy: string 
} = {
  environment: environment
  deployedBy: 'Bicep'
}

resource storage 'Microsoft.Storage/storageAccounts@2025-06-01' = {
  name: '${resourcePrefix}storage${instanceCount}'
  location: 'westus'
  tags: tags
  kind: 'Storage'
  sku: {
    name: 'Standard_LRS'
  }
}

Dans cet exemple :

• instanceCount est typé comme int et utilise une expression conditionnelle.
• resourcePrefix est typé en tant que string.
• tags est typé comme object avec une structure spécifique.

Utiliser des boucles itératives

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.

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 :

[
  {
    "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 placés au-dessus des déclarations de variables. Le tableau suivant présente les éléments décoratifs disponibles pour les variables.

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.

Descriptif

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

@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.

Exporter

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

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.

@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

• Pour plus d’informations sur les propriétés disponibles pour les variables, consultez Présentation de la structure et de la syntaxe des fichiers Bicep.
• Pour en savoir plus sur l’utilisation de la syntaxe de boucle, consultez Boucles itératives dans Bicep.