Controlar execução do loop e aninhar loops

Concluído

Usando o poderoso recurso de loops de cópia, você pode criar modelos dinâmicos e flexíveis. É importante entender como controlar a maneira como os loops são executados quando eles criam recursos e como usar loops para definir propriedades de recursos e loops de aninhamento.

Nesta unidade, você aprenderá a controlar a execução de loops de cópia e como usar loops de propriedade de recurso e loops aninhados no Bicep.

Observação

Os comandos nesta unidade são mostrados para ilustrar conceitos. Não execute os comandos ainda. Você praticará o que aprendeu aqui em breve.

Execução de loop de controle

Por padrão, o Azure Resource Manager cria recursos de loops em paralelo e em uma ordem não determinística. Quando você criou loops nos exercícios anteriores, ambos os servidores lógicos do SQL do Azure foram criados simultaneamente. Isso ajuda a reduzir o tempo de implantação geral, pois todos os recursos dentro do loop são implantados simultaneamente.

Em alguns casos, no entanto, talvez seja necessário implantar recursos em loops sequencialmente, em vez de em paralelo, ou implantar pequenos lotes de alterações juntas em paralelo. Por exemplo, se você tiver muitos aplicativos do Serviço de Aplicativo do Azure em seu ambiente de produção, talvez queira implantar alterações em apenas um número pequeno deles por vez para impedir que as atualizações reiniciem todos simultaneamente.

Você pode controlar a maneira como os loops de cópia são executados no Bicep usando o decorador @batchSize. Coloque o decorador na declaração de recurso ou de módulo com a palavra-chave for.

Vejamos um exemplo de definição de Bicep para um conjunto de aplicativos do Serviço de Aplicativo sem o decorador @batchSize:

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

Todos os recursos nesse loop serão implantados simultaneamente, em paralelo:

Agora, vamos aplicar o decorador @batchSize com um valor de 2:

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

Quando você implantar o modelo, o Bicep implantará em lotes de dois:

Observação

O Bicep aguarda a conclusão de cada lote completo antes de ir para o próximo. No exemplo anterior, se a implantação de app2 for concluída antes da de app1, o Bicep aguardará até que a implantação de app1 seja finalizada antes de começar a implantar app3.

Você também pode dizer ao Bicep para executar o loop sequencialmente definindo o @batchSize como 1:

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

Quando você implanta o modelo, o Bicep aguarda a finalização de cada implantação de recurso antes de iniciar a próxima:

Usar loops com propriedades de recurso

Você pode usar loops para ajudar a definir as propriedades do recurso. Por exemplo, ao implantar uma rede virtual, você precisa especificar as respectivas sub-redes. Uma sub-rede precisa ter duas informações importantes: um nome e um prefixo de endereço. Você pode usar um parâmetro com uma matriz de objetos para especificar sub-redes diferentes para cada ambiente:

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

Neste exemplo, observe que o loop for aparece dentro da definição de recurso, em torno do valor da propriedade subnets.

Loops aninhados

Alguns cenários exigem que você use um loop dentro de outro loop, ou loop aninhado. Você pode criar loops aninhados usando o Bicep.

Para sua empresa de brinquedos de urso, você precisa implantar redes virtuais em todos os países/regiões em que o brinquedo será lançado. Cada rede virtual precisa de um espaço de endereço diferente e duas sub-redes. Vamos começar implantando as redes virtuais em um 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'
      ]
    }
  }
}]

Esse loop implanta as redes virtuais para cada local e define o addressPrefix para a rede virtual usando o índice de loop para garantir que cada rede virtual obtenha um prefixo de endereço diferente.

Você pode usar um loop aninhado para implantar as sub-redes em cada rede virtual:

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

O loop aninhado usa a função range() para criar duas sub-redes.

Ao implantar o modelo, você obterá as seguintes redes virtuais e sub-redes:

Nome da rede virtual	Location	Prefixo de endereço	Sub-redes
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