Iteratív hurkok a Bicepben

Ez a cikk bemutatja, hogyan használhatja a szintaxist a for gyűjtemény elemeinek iterálására. Ez a funkció a 0.3.1-től kezdődően támogatott. Hurkok használatával több példányt is meghatározhat egy erőforrásból, modulból, változóból, tulajdonságból vagy kimenetből. Ciklusokkal elkerülheti a Bicep-fájl ismétlődő szintaxisát, és dinamikusan beállíthatja a létrehozáshoz szükséges példányok számát az üzembe helyezés során. A rövid útmutatót a következő rövid útmutatóban tekintheti meg: Több példány létrehozása.

Ha hurkokat szeretne használni több erőforrás vagy modul létrehozásához, minden példánynak egyedi értékkel kell rendelkeznie a névtulajdonsághoz. A nevek létrehozásához használhatja az index értékét vagy egyedi értékeit tömbökben vagy gyűjteményekben.

Képzési erőforrások

Ha lépésről lépésre szeretne többet megtudni a hurkokról, tekintse meg a rugalmas Bicep-sablonok kondíciók és hurkok használatával történő összeállítását ismertető témakört.

Hurok szintaxisa

A hurkok a következőkkel deklarálhatók:

• Egész szám index használata. Ez a beállítás akkor működik, ha a forgatókönyv a következő: "Ennyi példányt szeretnék létrehozni". A tartományfüggvény egy egész számokból álló tömböt hoz létre, amely a kezdőindexnél kezdődik, és tartalmazza a megadott elemek számát. A cikluson belül az egész számindex használatával módosíthatja az értékeket. További információ: Egész szám index.

  [for <index> in range(<startIndex>, <numberOfElements>): {
    ...
  }]
  

• Tömb elemeinek használata. Ez a beállítás akkor működik, ha a forgatókönyv a következő: "Példányt szeretnék létrehozni egy tömb minden eleméhez." A cikluson belül az aktuális tömbelem értékével módosíthatja az értékeket. További információ: Tömbelemek.

  [for <item> in <collection>: {
    ...
  }]
  

• Szótárobjektum elemeinek használata. Ez a beállítás akkor működik, ha a forgatókönyv a következő: "Példányt szeretnék létrehozni egy objektum minden eleméhez." Az Elemek függvény tömbté alakítja az objektumot. A cikluson belül az objektum tulajdonságaival értékeket hozhat létre. További információ: Szótárobjektum.

  [for <item> in items(<object>): {
    ...
  }]
  

• Egész szám index és tömb elemeinek használata. Ez a beállítás akkor működik, ha a forgatókönyv a következő: "Példányt szeretnék létrehozni egy tömb minden eleméhez, de az aktuális indexre is szükségem van egy másik érték létrehozásához." További információ: Huroktömb és index.

  [for (<item>, <index>) in <collection>: {
    ...
  }]
  

• Feltételes üzembe helyezés hozzáadása. Ez a beállítás akkor működik, ha a forgatókönyv a következő: "Több példányt szeretnék létrehozni, de minden példány esetében csak akkor szeretnék üzembe helyezni, ha egy feltétel igaz." További információ: Ciklus feltétellel.

  [for <item> in <collection>: if(<condition>) {
    ...
  }]
  

Hurokkorlátok

A Ciklusok használata a Bicepben az alábbi korlátozásokkal rendelkezik:

• A Bicep-hurkok csak az üzembe helyezés kezdetén meghatározható értékekkel működnek.
• A hurok iterációi nem lehetnek negatívak, vagy nem haladhatják meg a 800 iterációt.
• Beágyazott gyermekerőforrásokkal nem lehet visszacsukni egy erőforrást. Módosítsa a gyermekerőforrásokat felső szintű erőforrásokra. Tekintse meg a gyermekerőforrás iterációja című témakört.
• Ha több tulajdonságszinten szeretne ciklust létrehozni, használja a lambda leképezési függvényt.

Egész szám indexe

Az indexek egyszerű példájához hozzon létre egy olyan változót, amely sztringtömböt tartalmaz.

param itemCount int = 5

var stringArray = [for i in range(0, itemCount): 'item${(i + 1)}']

output arrayResult array = stringArray

A kimenet egy tömböt ad vissza a következő értékekkel:

[
  "item1",
  "item2",
  "item3",
  "item4",
  "item5"
]

A következő példa létrehozza a paraméterben storageCount megadott tárfiókok számát. Minden tárfiókhoz három tulajdonságot ad vissza.

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

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

output storageInfo array = [for i in range(0, storageCount): {
  id: storageAcct[i].id
  blobEndpoint: storageAcct[i].properties.primaryEndpoints.blob
  status: storageAcct[i].properties.statusOfPrimary
}]

Figyelje meg, hogy az index i a tárfiók erőforrásnevének létrehozásához használatos.

A következő példa többször is üzembe helyez egy modult.

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

var baseName = 'store${uniqueString(resourceGroup().id)}'

module stgModule './storageAccount.bicep' = [for i in range(0, storageCount): {
  name: '${i}deploy${baseName}'
  params: {
    storageName: '${i}${baseName}'
    location: location
  }
}]

output storageAccountEndpoints array = [for i in range(0, storageCount): {
  endpoint: stgModule[i].outputs.storageEndpoint
}]

Tömbelemek

Az alábbi példa egy tárfiókot hoz létre a storageNames paraméterben megadott nevekhez. Vegye figyelembe, hogy az egyes erőforráspéldányok névtulajdonságának egyedinek kell lennie.

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

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

A következő példa egy tömbön végigvesz egy tulajdonság definiálásához. Két alhálózatot hoz létre egy virtuális hálózaton belül. Vegye figyelembe, hogy az alhálózatneveknek egyedinek kell lenniük.

param rgLocation string = resourceGroup().location

var subnets = [
  {
    name: 'api'
    subnetPrefix: '10.144.0.0/24'
  }
  {
    name: 'worker'
    subnetPrefix: '10.144.1.0/24'
  }
]

resource vnet 'Microsoft.Network/virtualNetworks@2020-07-01' = {
  name: 'vnet'
  location: rgLocation
  properties: {
    addressSpace: {
      addressPrefixes: [
        '10.144.0.0/20'
      ]
    }
    subnets: [for subnet in subnets: {
      name: subnet.name
      properties: {
        addressPrefix: subnet.subnetPrefix
      }
    }]
  }
}

Tömb és index

Az alábbi példa a tömbelemet és az indexértéket is használja a tárfiók definiálásakor.

param storageAccountNamePrefix string

var storageConfigurations = [
  {
    suffix: 'local'
    sku: 'Standard_LRS'
  }
  {
    suffix: 'geo'
    sku: 'Standard_GRS'
  }
]

resource storageAccountResources 'Microsoft.Storage/storageAccounts@2022-09-01' = [for (config, i) in storageConfigurations: {
  name: '${storageAccountNamePrefix}${config.suffix}${i}'
  location: resourceGroup().location
  sku: {
    name: config.sku
  }
  kind: 'StorageV2'
}]

A következő példa egy tömb és egy index elemeit is felhasználja az új erőforrások információinak kimenetére.

param location string = resourceGroup().location
param orgNames array = [
  'Contoso'
  'Fabrikam'
  'Coho'
]

resource nsg 'Microsoft.Network/networkSecurityGroups@2020-06-01' = [for name in orgNames: {
  name: 'nsg-${name}'
  location: location
}]

output deployedNSGs array = [for (name, i) in orgNames: {
  orgName: name
  nsgName: nsg[i].name
  resourceId: nsg[i].id
}]

Szótárobjektum

Ha egy szótárobjektum elemeit szeretné iterálni, használja az elemek függvényt, amely tömbté alakítja az objektumot. value A tulajdonság használatával lekérheti az objektumok tulajdonságait. Vegye figyelembe, hogy az nsg-erőforrásneveknek egyedinek kell lenniük.

param nsgValues object = {
  nsg1: {
    name: 'nsg-westus1'
    location: 'westus'
  }
  nsg2: {
    name: 'nsg-east1'
    location: 'eastus'
  }
}

resource nsg 'Microsoft.Network/networkSecurityGroups@2020-06-01' = [for nsg in items(nsgValues): {
  name: nsg.value.name
  location: nsg.value.location
}]

Ciklus feltétellel

Erőforrások és modulok esetén hozzáadhat egy if ciklusszintaxissal rendelkező kifejezést a gyűjtemény feltételes üzembe helyezéséhez.

Az alábbi példa egy feltételutasítással kombinált ciklust mutat be. Ebben a példában egyetlen feltétel lesz alkalmazva a modul összes példányára.

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

var baseName = 'store${uniqueString(resourceGroup().id)}'

module stgModule './storageAccount.bicep' = [for i in range(0, storageCount): if(createNewStorage) {
  name: '${i}deploy${baseName}'
  params: {
    storageName: '${i}${baseName}'
    location: location
  }
}]

A következő példa bemutatja, hogyan alkalmazhat egy olyan feltételt, amely a tömb aktuális elemére jellemző.

resource parentResources 'Microsoft.Example/examples@2020-06-06' = [for parent in parents: if(parent.enabled) {
  name: parent.name
  properties: {
    children: [for child in parent.children: {
      name: child.name
      setting: child.settingValue
    }]
  }
}]

Üzembe helyezés kötegekben

Alapértelmezés szerint az Azure-erőforrások párhuzamosan vannak üzembe helyezve. Amikor egy ciklus használatával több erőforrástípusú példányt hoz létre, a példányok egyszerre lesznek üzembe helyezve. A létrehozásuk sorrendje nem garantált. A Bicep-fájlban lévő 800 erőforrás teljes korlátján kívül nincs korlátozva a párhuzamosan üzembe helyezett erőforrások száma.

Előfordulhat, hogy nem szeretné egyszerre frissíteni egy erőforrástípus összes példányát. Éles környezet frissítésekor például érdemes lehet a frissítéseket átmeneti állapotba helyezni, hogy egyszerre csak egy bizonyos szám legyen frissítve. Megadhatja, hogy a példányok egy részhalmaza egyszerre legyen kötegelve és üzembe helyezve. A többi példány megvárja, amíg a köteg befejeződik.

Egy erőforrás példányainak soros üzembe helyezéséhez adja hozzá a batchSize dekorátort. Állítsa az értékét az egyidejűleg üzembe helyezendő példányok számára. A ciklus korábbi példányai függőséget hoznak létre, így az nem indít el egy köteget, amíg az előző köteg be nem fejeződik.

param location string = resourceGroup().location

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

A szekvenciális üzembe helyezéshez állítsa a köteg méretét 1-esre.

A batchSize dekoratőr a sys névtérben található. Ha meg kell különböztetnie ezt a dekoratőrt egy másik, azonos nevű elemtől, akkor a dekoratőrt a sys előtaggal kell előtagolnia:@sys.batchSize(2)

Gyermekerőforrás iterációja

Beágyazott gyermekerőforráshoz nem használhat hurkot. Ha egy gyermekerőforrás egynél több példányát szeretné létrehozni, módosítsa a gyermekerőforrást egy legfelső szintű erőforrásra.

Tegyük fel például, hogy egy fájlszolgáltatást és fájlmegosztást általában beágyazott erőforrásként definiál egy tárfiókhoz.

resource stg 'Microsoft.Storage/storageAccounts@2022-09-01' = {
  name: 'examplestorage'
  location: resourceGroup().location
  kind: 'StorageV2'
  sku: {
    name: 'Standard_LRS'
  }
  resource service 'fileServices' = {
    name: 'default'
    resource share 'shares' = {
      name: 'exampleshare'
    }
  }
}

Egynél több fájlmegosztás létrehozásához helyezze át a tárfiókon kívülre. A szülőerőforrással való kapcsolatot a tulajdonságon keresztül határozhatja parent meg.

Az alábbi példa bemutatja, hogyan hozhat létre tárfiókot, fájlszolgáltatást és több fájlmegosztást:

resource stg 'Microsoft.Storage/storageAccounts@2022-09-01' = {
  name: 'examplestorage'
  location: resourceGroup().location
  kind: 'StorageV2'
  sku: {
    name: 'Standard_LRS'
  }
}

resource service 'Microsoft.Storage/storageAccounts/fileServices@2021-06-01' = {
  name: 'default'
  parent: stg
}

resource share 'Microsoft.Storage/storageAccounts/fileServices/shares@2021-06-01' = [for i in range(0, 3): {
  name: 'exampleshare${i}'
  parent: service
}]

Referenciaerőforrás-/modulgyűjtemények

Az ARM-sablonfüggvény references egy erőforráscsoport futtatókörnyezeti állapotát képviselő objektumtömböt ad vissza. A Bicepben nincs explicit hivatkozási függvény. Ehelyett a szimbolikus gyűjteményhasználat közvetlenül történik, és a kódlétrehozás során a Bicep lefordítja azt egy ARM-sablonra, amely az ARM-sablonhivatkozások függvényt használja. Ahhoz a fordítási funkcióhoz, amely a referenciafüggvény használatával arm-sablonokká alakítja a szimbolikus gyűjteményeket, a Bicep CLI 0.20.X-es vagy újabb verzióját kell használnia. Emellett a bicepconfig.json fájlban meg kell jeleníteni a symbolicNameCodegen beállítást, és be kell állítani a következőre true: .

A két minta kimenete egész szám indexben a következőképpen írható:

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

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

output storageInfo array = map(storageAcct, store => {
  blobEndpoint: store.properties.primaryEndpoints
  status: store.properties.statusOfPrimary
})

output storageAccountEndpoints array = map(storageAcct, store => store.properties.primaryEndpoints)

Ez a Bicep-fájl a következő ARM JSON-sablonba lesz lefordítva, amely a függvényt references használja:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "languageVersion": "1.10-experimental",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]"
    },
    "storageCount": {
      "type": "int",
      "defaultValue": 2
    }
  },
  "resources": {
    "storageAcct": {
      "copy": {
        "name": "storageAcct",
        "count": "[length(range(0, parameters('storageCount')))]"
      },
      "type": "Microsoft.Storage/storageAccounts",
      "apiVersion": "2022-09-01",
      "name": "[format('{0}storage{1}', range(0, parameters('storageCount'))[copyIndex()], uniqueString(resourceGroup().id))]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "Standard_LRS"
      },
      "kind": "Storage"
    }
  },
  "outputs": {
    "storageInfo": {
      "type": "array",
      "value": "[map(references('storageAcct', 'full'), lambda('store', createObject('blobEndpoint', lambdaVariables('store').properties.primaryEndpoints, 'status', lambdaVariables('store').properties.statusOfPrimary)))]"
    },
    "storageAccountEndpoints": {
      "type": "array",
      "value": "[map(references('storageAcct', 'full'), lambda('store', lambdaVariables('store').properties.primaryEndpoints))]"
    }
  }
}

Vegye figyelembe, hogy az előző ARM JSON-sablonban a következőre kell állítani1.10-experimental, languageVersion és az erőforráselem tömb helyett objektum.

Következő lépések

• A Bicep-fájlok létrehozásáról további információt a fájlban talál.