Uitvoering van besturingslussen en nestlussen

Voltooid

Met behulp van de krachtige functie voor kopieerlussen kunt u dynamische en flexibele sjablonen maken. Het is belangrijk om te begrijpen hoe u de manier bepaalt waarop lussen worden uitgevoerd wanneer ze resources maken en hoe u lussen gebruikt om resource-eigenschappen en nestlussen in te stellen.

In deze les leert u hoe u de uitvoering van kopieerlussen beheert en hoe u resource-eigenschapslussen en geneste lussen in Bicep gebruikt.

Notitie

De opdrachten in deze les worden weergegeven om concepten te illustreren. Voer de opdrachten nog niet uit. U oefent wat u hier binnenkort leert.

Uitvoering van besturingslus

Azure Resource Manager maakt standaard resources op basis van lussen parallel en in een niet-deterministische volgorde. Wanneer u lussen in de vorige oefeningen hebt gemaakt, zijn beide logische Azure SQL-servers tegelijkertijd gemaakt. Dit helpt de totale implementatietijd te verminderen, omdat alle resources binnen de lus tegelijk worden geïmplementeerd.

In sommige gevallen moet u echter mogelijk resources in lussen opeenvolgend implementeren in plaats van parallel, of kleine batches met wijzigingen parallel implementeren. Als u bijvoorbeeld veel Azure-app Service-apps in uw productieomgeving hebt, kunt u wijzigingen in slechts een klein aantal tegelijk implementeren om te voorkomen dat alle updates tegelijkertijd opnieuw worden opgestart.

U kunt bepalen hoe uw kopieerlussen worden uitgevoerd in Bicep met behulp van de @batchSize decorator. Plaats de decorator op de resource- of moduledeclaratie met het for trefwoord.

Laten we eens kijken naar een bicep-voorbeelddefinitie voor een set App Service-toepassingen zonder de @batchSize decorator:

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

Alle resources in deze lus worden tegelijkertijd geïmplementeerd, parallel:

Nu gaan we de @batchSize decorator toepassen met een waarde van 2:

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

Wanneer u de sjabloon implementeert, wordt Bicep geïmplementeerd in batches van twee:

Notitie

Bicep wacht tot elke volledige batch is voltooid voordat deze verdergaat met de volgende. Als app2 in het voorgaande voorbeeld de implementatie voor app1 heeft voltooid, wacht Bicep totdat app1 is voltooid voordat app3 wordt geïmplementeerd.

U kunt bicep ook laten weten dat de lus sequentieel moet worden uitgevoerd door het @batchSize volgende in te 1stellen:

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

Wanneer u de sjabloon implementeert, wacht Bicep tot elke resource-implementatie is voltooid voordat de volgende wordt gestart:

Lussen gebruiken met resource-eigenschappen

U kunt lussen gebruiken om resource-eigenschappen in te stellen. Wanneer u bijvoorbeeld een virtueel netwerk implementeert, moet u de subnetten opgeven. Een subnet moet twee belangrijke informatie bevatten: een naam en een adresvoorvoegsel. U kunt een parameter gebruiken met een matrix met objecten, zodat u verschillende subnetten voor elke omgeving kunt opgeven:

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

resource virtualNetwork 'Microsoft.Network/virtualNetworks@2024-05-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'
      }
    }]
  }
}

In dit voorbeeld ziet u dat de for lus binnen de resourcedefinitie wordt weergegeven rond de subnets eigenschapswaarde.

Geneste lussen

Voor sommige scenario's moet u een lus binnen een andere lus of een geneste lus gebruiken. U kunt geneste lussen maken met Bicep.

Voor uw teddybeer speelgoedbedrijf moet u virtuele netwerken implementeren in elk land of elke regio waar het speelgoed wordt gelanceerd. Elk virtueel netwerk heeft een andere adresruimte en twee subnetten nodig. Laten we beginnen met het implementeren van de virtuele netwerken in een lus:

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

var subnetCount = 2

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

Met deze lus worden de virtuele netwerken voor elke locatie geïmplementeerd en wordt het addressPrefix voor het virtuele netwerk ingesteld met behulp van de lusindex om ervoor te zorgen dat elk virtueel netwerk een ander adresvoorvoegsel krijgt.

U kunt een geneste lus gebruiken om de subnetten binnen elk virtueel netwerk te implementeren:

resource virtualNetworks 'Microsoft.Network/virtualNetworks@2024-05-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'
      }
    }]
  }
}]

De geneste lus gebruikt de range() functie om twee subnetten te maken.

Wanneer u de sjabloon implementeert, krijgt u de volgende virtuele netwerken en subnetten:

Naam van virtueel netwerk	Locatie	Adresvoorvoegsel	Subnetten
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