Partager via

Démarrage rapide : créer plusieurs instances de ressource dans Bicep

  • Article

Découvrez comment utiliser différentes syntaxes for pour créer plusieurs instances de ressource dans Bicep. Même si cet article ne montre que la création de plusieurs instances de ressource, les mêmes méthodes peuvent être utilisées pour définir des copies de module, de variable, de propriété ou de sortie. Pour en savoir plus, consultez Boucle Bicep.

Cet article contient les rubriques suivantes :

Prérequis

Si vous ne disposez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

Pour configurer votre environnement pour le développement Bicep, consultez Installer les outils bicep. Au terme de cette procédure, vous disposerez de Visual Studio Code et de l'extension Bicep. Vous disposez également de la dernière version d’Azure CLI ou du dernier module Azure PowerShell.

Créer une instance unique

Dans cette section, vous définissez un fichier Bicep pour la création d’un compte de stockage, puis vous déployez le fichier Bicep. Les sections suivantes fournissent des exemples de code Bicep pour différentes syntaxes for. Vous pouvez utiliser la même méthode de déploiement pour déployer et tester ces exemples. Si votre déploiement échoue, cela est probablement dû à l’une des deux causes suivantes :

  • Le nom du compte de stockage est trop long. Les noms de compte de stockage doivent avoir entre 3 et 24 caractères, uniquement des lettres minuscules et des chiffres.
  • Le nom du compte de stockage n’est pas unique. Le nom de votre compte de stockage doit être unique dans Azure.

Le fichier Bicep suivant définit un compte de stockage :

param rgLocation string = resourceGroup().location

resource createStorage 'Microsoft.Storage/storageAccounts@2022-09-01' = {
  name: 'storage${uniqueString(resourceGroup().id)}'
  location: rgLocation
  sku: {
    name: 'Standard_LRS'
  }
  kind: 'StorageV2'
}

Enregistrez le fichier Bicep localement, puis utilisez Azure CLI ou Azure PowerShell pour le déployer :

resourceGroupName = "{provide-a-resource-group-name}"
templateFile="{provide-the-path-to-the-bicep-file}"

az group create --name $resourceGroupName --location eastus

az deployment group create --resource-group $resourceGroupName --template-file $templateFile

Utiliser un index d’entiers

Une boucle for avec un index est utilisée dans l’exemple suivant pour créer deux comptes de stockage :

param rgLocation string = resourceGroup().location
param storageCount int = 2

resource createStorages 'Microsoft.Storage/storageAccounts@2022-09-01' = [for i in range(0, storageCount): {
  name: '${i}storage${uniqueString(resourceGroup().id)}'
  location: rgLocation
  sku: {
    name: 'Standard_LRS'
  }
  kind: 'StorageV2'
}]

output names array = [for i in range(0,storageCount) : {
  name: createStorages[i].name
} ]

Le numéro d’index est utilisé dans le nom du compte de stockage. Après avoir déployé le fichier Bicep, vous obtenez deux comptes de stockage semblables à ce qui suit :

Utiliser un index d’entiers avec 0 comme nombre de départ

Dans range(), le premier nombre est le numéro de départ, tandis que le deuxième nombre est le nombre de fois que la boucle s’exécute. Ainsi, si vous utilisez range(3,2), vous obtenez également deux comptes de stockage :

Utiliser un index d’entiers avec 3 comme nombre de départ

Le résultat de l’exemple précédent montre comment référencer les ressources créées dans une boucle. Le résultat ressemble à ce qui suit :

"outputs": {
  "names": {
    "type": "Array",
    "value": [
      {
        "name": "0storage52iyjssggmvue"
      },
      {
        "name": "1storage52iyjssggmvue"
      }
    ]
  }
},

Utiliser des éléments de tableau

Vous pouvez parcourir un tableau. L’exemple suivant montre un tableau de chaînes.

param rgLocation string = resourceGroup().location
param storageNames array = [
  'contoso'
  'fabrikam'
]

resource createStorages 'Microsoft.Storage/storageAccounts@2022-09-01' = [for name in storageNames: {
  name: '${name}str${uniqueString(resourceGroup().id)}'
  location: rgLocation
  sku: {
    name: 'Standard_LRS'
  }
  kind: 'StorageV2'
}]

La boucle utilise toutes les chaînes du tableau dans les noms des comptes de stockage. En l’occurrence, elle crée deux comptes de stockage :

Utiliser un tableau de chaînes

Vous pouvez également parcourir un tableau d’objets. La boucle non seulement personnalise les noms des comptes de stockage, mais configure également les références SKU.

param rgLocation string = resourceGroup().location
param storages array = [
  {
    name: 'contoso'
    skuName: 'Standard_LRS'
  }
  {
    name: 'fabrikam'
    skuName: 'Premium_LRS'
  }
]

resource createStorages 'Microsoft.Storage/storageAccounts@2022-09-01' = [for storage in storages: {
  name: '${storage.name}obj${uniqueString(resourceGroup().id)}'
  location: rgLocation
  sku: {
    name: storage.skuName
  }
  kind: 'StorageV2'
}]

La boucle crée deux comptes de stockage. La référence SKU du compte de stockage dont le nom commence par fabrikam est Premium_LRS.

Utiliser un tableau de chaînes

Utiliser un tableau et un index

Dans les mêmes cas, vous pouvez combiner une boucle de tableau avec une boucle d’index. L’exemple suivant montre comment utiliser le tableau et le numéro d’index pour la convention de nommage.

param rgLocation string = resourceGroup().location
param storageNames array = [
  'contoso'
  'fabrikam'
]

resource createStorages 'Microsoft.Storage/storageAccounts@2022-09-01' = [for (name, i) in storageNames: {
  name: '${i}${name}${uniqueString(resourceGroup().id)}'
  location: rgLocation
  sku: {
    name: 'Standard_LRS'
  }
  kind: 'StorageV2'
}]

Après avoir déployé l’exemple précédent, vous créez deux comptes de stockage similaires à ce qui suit :

Utiliser un tableau de chaînes et un numéro d’index

Utiliser un objet dictionnaire

Pour effectuer une itération sur des éléments d’un objet dictionnaire, utilisez la fonction items qui convertit l’objet en tableau. Utilisez la propriété value pour obtenir les propriétés sur les objets.

param rgLocation string = resourceGroup().location

param storageConfig object = {
  storage1: {
    name: 'contoso'
    skuName: 'Standard_LRS'
  }
  storage2: {
    name: 'fabrikam'
    skuName: 'Premium_LRS'
  }
}

resource createStorages 'Microsoft.Storage/storageAccounts@2022-09-01' = [for config in items(storageConfig): {
  name: '${config.value.name}${uniqueString(resourceGroup().id)}'
  location: rgLocation
  sku: {
    name: config.value.skuName
  }
  kind: 'StorageV2'
}]

La boucle crée deux comptes de stockage. La référence SKU du compte de stockage dont le nom commence par fabrikam est Premium_LRS.

Utiliser un objet de dictionnaire

Boucle avec condition

Pour des ressources et modules, vous pouvez ajouter une expression if avec la syntaxe de boucle pour déployer la collection de manière conditionnelle.

param rgLocation string = resourceGroup().location
param storageCount int = 2
param createNewStorage bool = true

resource createStorages 'Microsoft.Storage/storageAccounts@2022-09-01' = [for i in range(0, storageCount): if(createNewStorage) {
  name: '${i}storage${uniqueString(resourceGroup().id)}'
  location: rgLocation
  sku: {
    name: 'Standard_LRS'
  }
  kind: 'StorageV2'
}]

Pour plus d’informations, consultez Déploiement conditionnel dans Bicep.

Nettoyer les ressources

Lorsque les ressources Azure ne sont plus nécessaires, utilisez Azure CLI ou le module Azure PowerShell afin de supprimer le groupe de ressources qui a été utilisé pour ce guide de démarrage rapide.

resourceGroupName = "{provide-the-resource-group-name}"

az group delete --name $resourceGroupName

Étapes suivantes

Modules Learn sur Bicep