Variablen in Bicep

Dieser Artikel beschreibt, wie Sie Variablen in Ihrer Bicep-Datei definieren und verwenden. Sie verwenden Variablen, um die Entwicklung Ihrer Bicep-Dateien zu vereinfachen. Anstatt komplizierte Ausdrücke in der Bicep-Datei zu wiederholen, definieren Sie eine Variable, die den komplizierten Ausdruck enthält. Anschließend verwenden Sie diese Variable nach Bedarf in der gesamten Bicep-Datei.

Resource Manager löst Variablen vor Beginn der Bereitstellungsvorgänge auf. Jedes Vorkommen der Variablen in der Bicep-Datei wird von Resource Manager durch den aufgelösten Wert ersetzt. Die Anzahl der Variablen in einer Bicep-Datei ist auf 512 beschränkt. Weitere Informationen finden Sie unter Vorlagengrenzwerte.

Definieren von Variablen

Eine Variable darf nicht denselben Namen wie ein Parameter, ein Modul oder eine Ressource haben. Sie können für jede Variable ein oder mehrere Decorator-Zeichen hinzufügen. Weitere Informationen finden Sie unter Verwenden von Decorator-Elementen.

Nicht typisierte Variablen

Wenn Sie eine Variable ohne Angabe eines Datentyps definieren, wird der Typ vom Wert abgeleitet. Die Syntax zum Definieren einer nicht typisierten Variablen lautet:

@<decorator>(<argument>)
var <variable-name> = <variable-value>

Im folgenden Beispiel wird eine Variable auf eine Zeichenfolge festgelegt.

var stringVar = 'preset variable'

Sie können beim Erstellen der Variablen den Wert eines Parameters oder einer anderen Variablen verwenden.

param inputValue string = 'deployment parameter'

var stringVar = 'preset variable'
var concatToVar =  '${stringVar}AddToVar'
var concatToParam = '${inputValue}AddToParam'

output addToVar string = concatToVar
output addToParam string = concatToParam

Die Ausgabe aus dem vorherigen Beispiel gibt Folgendes zurück:

{
  "addToParam": {
    "type": "String",
    "value": "deployment parameterAddToParam"
  },
  "addToVar": {
    "type": "String",
    "value": "preset variableAddToVar"
  }
}

Sie können Bicep-Funktionen verwenden, um den Variablenwert zu erstellen. Im folgenden Beispiel werden Bicep-Funktionen verwendet, um einen Zeichenfolgenwert für einen Speicherkontonamen zu erstellen.

param storageNamePrefix string = 'stg'
var storageName = '${toLower(storageNamePrefix)}${uniqueString(resourceGroup().id)}'

output uniqueStorageName string = storageName

Im obigen Beispiel wird ein Wert ähnlich der folgendem Ausgabe zurückgegeben:

"uniqueStorageName": {
  "type": "String",
  "value": "stghzuunrvapn6sw"
}

Typierte Variablen

Ab Bicep CLI Version 0.36.X unterstützt Biceptypierte Variablen, wobei Sie explizit den Datentyp einer Variablen deklarieren, um die Typsicherheit zu gewährleisten und die Codeschärfe zu verbessern. Die Vorteile von typierten Variablen:

• Fehlererkennung: Der Bicep-Compiler überprüft, ob zugewiesene Werte dem deklarierten Typ entsprechen und Fehler frühzeitig abfangen.
• Codeklaratur: Explizite Typen machen deutlich, welche Art von Daten eine Variable enthält.
• IntelliSense-Unterstützung: Tools wie Visual Studio Code bieten eine bessere AutoVervollständigen und Validierung für typierte Variablen.
• Refaktorisierungssicherheit: Stellt sicher, dass Änderungen an Variablenzuweisungen nicht versehentlich die Typenerwartungen verletzen.

Um eine typierte Variable zu definieren, verwenden Sie das var Schlüsselwort gefolgt vom Variablennamen, dem Typ und dem zugewiesenen Wert:

var <variable-name> <data-type> = <variable-value>

Die folgenden Beispiele zeigen, wie Typvariablen definiert werden:

var resourceName string = 'myResource'
var instanceCount int = 3
var isProduction bool = true
var tags object = { environment: 'dev' }
var subnets array = ['subnet1', 'subnet2']

Für object Typen können Sie ein Schema definieren, um eine bestimmte Struktur zu erzwingen. Der Compiler stellt sicher, dass das Objekt dem definierten Schema entspricht.

var config {
  name: string
  count: int
  enabled: bool
} = {
  name: 'myApp'
  count: 5
  enabled: true
}

Im folgenden Beispiel werden typierte Variablen mit Dekoratoren verwendet, um Einschränkungen zu erzwingen:

@description('The environment to deploy to')
@allowed(['dev', 'test', 'prod'])
param environment string = 'dev'

var instanceCount int = environment == 'prod' ? 5 : 2
var resourcePrefix string = 'app'
var tags {
  environment: string
  deployedBy: string 
} = {
  environment: environment
  deployedBy: 'Bicep'
}

resource storage 'Microsoft.Storage/storageAccounts@2025-06-01' = {
  name: '${resourcePrefix}storage${instanceCount}'
  location: 'westus'
  tags: tags
  kind: 'Storage'
  sku: {
    name: 'Standard_LRS'
  }
}

In diesem Beispiel:

• instanceCount wird als int eingegeben und verwendet einen bedingten Ausdruck.
• resourcePrefix wird als string eingegeben.
• tags wird mit einer bestimmten Struktur als object eingegeben.

Iterative Schleifen verwenden

Sie können iterative Schleifen verwenden, wenn Sie eine Variable definieren. Im folgenden Beispiel wird ein Array von Objekten mit drei Eigenschaften erstellt.

param itemCount int = 3

var objectArray = [for i in range(0, itemCount): {
  name: 'myDataDisk${(i + 1)}'
  diskSizeGB: '1'
  diskIndex: i
}]

output arrayResult array = objectArray

Die Ausgabe gibt ein Array mit den folgenden Elementen zurück:

[
  {
    "name": "myDataDisk1",
    "diskSizeGB": "1",
    "diskIndex": 0
  },
  {
    "name": "myDataDisk2",
    "diskSizeGB": "1",
    "diskIndex": 1
  },
  {
    "name": "myDataDisk3",
    "diskSizeGB": "1",
    "diskIndex": 2
  }
]

Weitere Informationen zu den Schleifentypen, die Sie mit Variablen verwenden können, finden Sie unter Iterative Schleifen in Bicep.

Verwenden von Decorator-Elementen

Decorators werden im Format @expression geschrieben und oberhalb von Variabeldeklarationen platziert. In der folgenden Tabelle werden die für Variablen verfügbaren Decorators angezeigt.

Decorators sind im sys Namensraum. Wenn Sie einen Decorator von einem anderen Element mit dem gleichen Namen unterscheiden müssen, stellen Sie dem Decorator sys voran. Zum Beispiel, wenn Ihre Bicep Datei eine Variable mit dem Namen description enthält, müssen Sie den sys Namespace hinzufügen, wenn Sie den description-Decorator verwenden.

BESCHREIBUNG

Um eine Erklärung hinzuzufügen, fügen Sie der Variablendeklaration eine Beschreibung hinzu. Beispiel:

@description('Create a unique storage account name.')
var storageAccountName = uniqueString(resourceGroup().id)

Mit Markdown formatierter Text kann für den Beschreibungstext verwendet werden.

Exportieren

Verwenden Sie @export(), um die Variable mit anderen Bicep-Dateien zu teilen. Weitere Informationen finden Sie unter Exportieren von Variablen, Typen und Funktionen.

Konfigurationsvariablen

Sie können Variablen definieren, die zugehörige Werte zum Konfigurieren einer Umgebung enthalten. Die Variable wird als ein Objekt mit den Werten definiert. Das folgende Beispiel zeigt ein Objekt, das Werte für zwei Umgebungen enthält: test und prod. Sie übergeben einen dieser Werte während der Bereitstellung.

@allowed([
  'test'
  'prod'
])
param environmentName string

var environmentSettings = {
  test: {
    instanceSize: 'Small'
    instanceCount: 1
  }
  prod: {
    instanceSize: 'Large'
    instanceCount: 4
  }
}

output instanceSize string = environmentSettings[environmentName].instanceSize
output instanceCount int = environmentSettings[environmentName].instanceCount

Nächste Schritte

• Weitere Informationen zu den verfügbaren Eigenschaften für Variablen finden Sie unter Verstehen der Struktur und Syntax von Bicep-Dateien.
• Informationen zur Verwendung der Schleifensyntax finden Sie unter Iterative Schleifen in Bicep.