Körning av kontrollslingor och kapslingor

Slutförd

Genom att använda funktionen kraftfulla kopieringsloopar kan du skapa dynamiska och flexibla mallar. Det är viktigt att förstå hur du styr hur loopar körs när de skapar resurser och hur du använder loopar för att ange resursegenskaper och kapslingor.

I den här lektionen får du lära dig hur du styr körningen av kopieringsloopar och hur du använder resursegenskapsloopar och kapslade loopar i Bicep.

Kommentar

Kommandona i den här enheten visas för att illustrera begrepp. Kör inte kommandona än. Du kommer att öva på det du lär dig här snart.

Körning av kontrollslinga

Som standard skapar Azure Resource Manager resurser från loopar parallellt och i en icke-deterministisk ordning. När du skapade loopar i föregående övningar skapades båda de logiska Azure SQL-servrarna samtidigt. Detta bidrar till att minska den totala distributionstiden eftersom alla resurser i loopen distribueras samtidigt.

I vissa fall kan du dock behöva distribuera resurser i loopar sekventiellt i stället för parallellt, eller distribuera små batchar med ändringar parallellt. Om du till exempel har många Azure App Service-appar i produktionsmiljön kanske du bara vill distribuera ändringar till ett litet antal i taget för att förhindra att uppdateringarna startas om samtidigt.

Du kan styra hur dina kopieringsloopar körs i Bicep med hjälp av dekoratören @batchSize . Placera dekoratören på resurs- eller moduldeklarationen med nyckelordet for .

Nu ska vi titta på ett exempel på en Bicep-definition för en uppsättning App Service-program utan dekoratören @batchSize :

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

Alla resurser i den här loopen distribueras samtidigt, parallellt:

Nu ska vi använda dekoratören @batchSize med värdet 2:

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

När du distribuerar mallen distribuerar Bicep i batchar med två:

Kommentar

Bicep väntar på att varje fullständig batch ska slutföras innan den går vidare till nästa. Om app2 i föregående exempel slutför distributionen före app1 väntar Bicep tills app1 har slutförts innan den börjar distribuera app3.

Du kan också be Bicep att köra loopen sekventiellt genom att ange @batchSize till 1:

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

När du distribuerar mallen väntar Bicep på att varje resursdistribution ska slutföras innan den startar nästa:

Använda loopar med resursegenskaper

Du kan använda loopar för att ange resursegenskaper. När du till exempel distribuerar ett virtuellt nätverk måste du ange dess undernät. Ett undernät måste ha två viktiga uppgifter: ett namn och ett adressprefix. Du kan använda en parameter med en matris med objekt så att du kan ange olika undernät för varje miljö:

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'
      }
    }]
  }
}

I det här exemplet ser du att loopen for visas i resursdefinitionen runt egenskapsvärdet subnets .

Kapslade loopar

Vissa scenarier kräver att du använder en loop i en annan loop eller en kapslad loop. Du kan skapa kapslade loopar med hjälp av Bicep.

För ditt leksaksföretag med nallebjörnar måste du distribuera virtuella nätverk i varje land/region där leksaken lanseras. Varje virtuellt nätverk behöver ett annat adressutrymme och två undernät. Vi börjar med att distribuera de virtuella nätverken i en loop:

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'
      ]
    }
  }
}]

Den här loopen distribuerar de virtuella nätverken för varje plats och anger addressPrefix för det virtuella nätverket med hjälp av loopindexet för att säkerställa att varje virtuellt nätverk får ett annat adressprefix.

Du kan använda en kapslad loop för att distribuera undernäten i varje virtuellt nätverk:

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'
      }
    }]
  }
}]

Den kapslade loopen range() använder funktionen för att skapa två undernät.

När du distribuerar mallen får du följande virtuella nätverk och undernät:

Virtuellt nätverksnamn	Plats	Adressprefix	Undernät
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