Contrôler l’exécution d’une boucle et boucles imbriquées

Effectué

En utilisant la puissante fonctionnalité de boucles de copie, vous pouvez créer des modèles dynamiques et flexibles. Il est important de comprendre comment contrôler la façon dont les boucles s’exécutent lors de la création de ressources, et comment utiliser des boucles pour définir des propriétés de ressource et imbriquer des boucles.

Dans cette unité, vous allez apprendre à contrôler l’exécution de boucles de copie et comment utiliser des boucles de propriétés de ressource et des boucles imbriquées dans Bicep.

Remarque

Les commandes de cette unité sont présentées pour illustrer les concepts. N’exécutez pas encore les commandes. Vous allez bientôt mettre en pratique ce que vous apprenez ici.

Contrôle de l’exécution d’une boucle

Par défaut, Azure Resource Manager crée des ressources à partir de boucles en parallèle et dans un ordre non déterministe. Lorsque vous avez créé des boucles dans les exercices précédents, les deux serveurs logiques Azure SQL ont été créés en même temps. Cela permet de réduire le temps de déploiement global, car toutes les ressources de la boucle sont déployées en même temps.

Toutefois, dans certains cas, vous devrez peut-être déployer des ressources dans des boucles séquentiellement plutôt qu’en parallèle, ou déployer de petits lots de modifications en parallèle. Par exemple, si vous avez un grand nombre d’applications Azure App Service dans votre environnement de production, vous souhaiterez peut-être déployer des modifications sur un petit nombre à la fois pour empêcher les mises à jour de les redémarrer toutes en même temps.

Vous pouvez contrôler la façon dont vos boucles de copie s’exécutent dans Bicep à l’aide de l’élément décoratif @batchSize. Placez l’élément décoratif sur la déclaration de ressource ou de module avec le mot clé for.

Examinons un exemple de définition Bicep pour un ensemble d’applications App Service sans l’élément décoratif @batchSize :

resource appServiceApp 'Microsoft.Web/sites@2023-12-01' = [for i in range(1,3): {
  name: 'app${i}'
  // ...
}]

Toutes les ressources de cette boucle seront déployées en même temps, en parallèle :

Nous allons maintenant appliquer l’élément décoratif @batchSize avec la valeur 2 :

@batchSize(2)
resource appServiceApp 'Microsoft.Web/sites@2023-12-01' = [for i in range(1,3): {
  name: 'app${i}'
  // ...
}]

Lorsque vous déployez le modèle, Bicep est déployé par lots de deux :

Notes

Bicep attend la fin de chaque lot avant de passer au suivant. Dans l’exemple précédent, si app2 termine son déploiement avant app1, Bicep attend qu’app1 se termine avant de commencer à déployer app3.

Vous pouvez également indiquer à Bicep d’exécuter la boucle séquentiellement en affectant à @batchSize la valeur 1 :

@batchSize(1)
resource appServiceApp 'Microsoft.Web/sites@2023-12-01' = [for i in range(1,3): {
  name: 'app${i}'
  // ...
}]

Lorsque vous déployez le modèle, Bicep attend que chaque déploiement de ressource se termine avant de commencer le suivant :

Utiliser des boucles avec des propriétés de ressource

Vous pouvez utiliser des boucles pour définir les propriétés des ressources. Par exemple, lorsque vous déployez un réseau virtuel, vous devez spécifier ses sous-réseaux. Un sous-réseau doit comporter deux éléments d’information importants : un nom et un préfixe d’adresse. Vous pouvez utiliser un paramètre avec un tableau d’objets afin de pouvoir spécifier des sous-réseaux différents pour chaque environnement :

param subnetNames array = [
  'api'
  'worker'
]

resource virtualNetwork 'Microsoft.Network/virtualNetworks@2024-01-01' = {
  name: 'teddybear'
  location: resourceGroup().location
  properties: {
    addressSpace: {
      addressPrefixes: [
        '10.0.0.0/16'
      ]
    }
    subnets: [for (subnetName, i) in subnetNames: {
      name: subnetName
      properties: {
        addressPrefix: '10.0.${i}.0/24'
      }
    }]
  }
}

Dans cet exemple, notez que la boucle for apparaît dans la définition de ressource, près de la valeur de propriété subnets.

Boucles imbriquées

Certains scénarios nécessitent l’utilisation d’une boucle à l’intérieur d’une autre boucle, ou d’une boucle imbriquée. Vous pouvez créer des boucles imbriquées à l’aide de Bicep.

Pour votre société d’ours en peluche, vous devez déployer des réseaux virtuels dans chaque pays/région où le jouet doit être lancé. Chaque réseau virtuel a besoin d’un espace d’adressage différent et de deux sous-réseaux. Commençons par déployer les réseaux virtuels dans une boucle :

param locations array = [
  'westeurope'
  'eastus2'
  'eastasia'
]

var subnetCount = 2

resource virtualNetworks 'Microsoft.Network/virtualNetworks@2024-01-01' = [for (location, i) in locations : {
  name: 'vnet-${location}'
  location: location
  properties: {
    addressSpace:{
      addressPrefixes:[
        '10.${i}.0.0/16'
      ]
    }
  }
}]

Cette boucle déploie les réseaux virtuels pour chaque emplacement et définit addressPrefix pour le réseau virtuel à l’aide de l’index de boucle pour garantir que chaque réseau virtuel reçoit un préfixe d’adresse différent.

Vous pouvez utiliser une boucle imbriquée pour déployer les sous-réseaux dans chaque réseau virtuel :

resource virtualNetworks 'Microsoft.Network/virtualNetworks@2024-01-01' = [for (location, i) in locations : {
  name: 'vnet-${location}'
  location: location
  properties: {
    addressSpace:{
      addressPrefixes:[
        '10.${i}.0.0/16'
      ]
    }
    subnets: [for j in range(1, subnetCount): {
      name: 'subnet-${j}'
      properties: {
        addressPrefix: '10.${i}.${j}.0/24'
      }
    }]
  }
}]

La boucle imbriquée utilise la fonction range() pour créer deux sous-réseaux.

Lorsque vous déployez le modèle, vous obtenez les réseaux virtuels et sous-réseaux suivants :

Nom du réseau virtuel	Emplacement	Préfixe de l’adresse	Sous-réseaux
vnet-westeurope	westeurope	10.0.0.0/16	10.0.1.0/24, 10.0.2.0/24
vnet-eastus2	eastus2	10.1.0.0/16	10.1.1.0/24, 10.1.2.0/24
vnet-eastasia	eastasia	10.2.0.0/16	10.2.1.0/24, 10.2.2.0/24