Funktionen – Wiederkehrende Logik kapseln
Infrastructure as Code mit Azure Bicep, Teil 4
Nach Schleifen und Bedingungen in der vorangegangenen Folge der Serie zu Infrastructure as Code mit Azure Bicep folgt nun mit Funktionen der nächste Baustein für wiederverwendbare Bicep-Logik. Namenskonventionen, Tag-Strukturen oder Berechnungslogik tauchen in vielen Templates an mehreren Stellen auf. Statt denselben Ausdruck mehrfach zu wiederholen, bietet Bicep eingebaute sowie benutzerdefinierte Funktionen an. Sie kapseln eine Berechnung an einer Stelle und lassen sich anschließend überall im Template referenzieren.
Eingebaute Funktionen als Grundlage
Bicep bringt bereits eine große Zahl eingebauter Funktionen mit, etwa uniqueString(), resourceGroup() oder toUpper(). Diese Funktionen decken viele Standardfälle ab und werden direkt in Ausdrücken verwendet. Grob lassen sie sich in Kategorien einteilen: String-Funktionen wie toLower() oder substring(), Array- und Objekt-Funktionen wie concat() oder union(), Deployment-Kontext-Funktionen wie resourceGroup() oder subscription() sowie Logik- und Vergleichsfunktionen wie contains() oder empty().
var storageName = toLower('st${uniqueString(resourceGroup().id)}')
Viele eingebaute Funktionen sind keine Bicep-Erfindung, sondern direkt von den ARM-Template-Funktionen übernommen: Jede Bicep-Funktion entspricht einer gleichnamigen oder sehr ähnlichen ARM-Funktion, da Bicep zur Deployment-Zeit ohnehin in ARM-JSON übersetzt wird. Wer bereits mit ARM-Templates gearbeitet hat, findet die vertraute Funktionsbibliothek großteils wieder, mitunter aber mit schlankerer Syntax. Statt concat() kann eine String-Interpolation genutzt werden, oder statt if() wird ein Ternary Operator verwendet.
Für wiederkehrende, projektspezifische Logik reichen die eingebauten Funktionen jedoch häufig nicht aus. An dieser Stelle kommen benutzerdefinierte Funktionen ins Spiel.
Benutzerdefinierte Funktionen mit dem func-Keyword
Eine eigene Funktion wird mit dem Schlüsselwort func definiert. Sie erhält typisierte Parameter und einen Rückgabetyp, arbeitet aber ausschließlich mit den übergebenen Werten, ohne auf Ressourcen im Template zuzugreifen.
@export()
func buildResourceName(prefix string, environment string, suffix string) string =>
toLower('${prefix}-${environment}-${suffix}')
Der Decorator @export() markiert die Funktion als wiederverwendbar für andere Bicep-Dateien, die diese Datei über import einbinden. Innerhalb derselben Datei steht die Funktion ohnehin sofort zur Verfügung.
Einsatz der Funktion im Template
Die Funktion wird wie jede andere Funktion aufgerufen und liefert einen Wert zurück, der direkt weiterverwendet werden kann.
var appServiceName = buildResourceName('app', environment, uniqueString(resourceGroup().id))
Damit ist die Logik an genau einer Stelle im Template definiert. Ändert sich später das Schema, muss lediglich die Funktion angepasst werden, statt jede betroffene Stelle einzeln zu korrigieren.
Vollständiges Beispiel
Das folgende Beispiel definiert ein Infrastructure-as-Code-Template. Dabei setzt eine benutzerdefinierte Funktion den Ressourcennamen dynamisch aus Präfix, Umgebung und einer eindeutigen Zeichenfolge zusammen:
@export()
func buildResourceName(prefix string, environment string, suffix string) string =>
toLower('${prefix}-${environment}-${suffix}')
param environment string = 'dev'
param location string = resourceGroup().location
var appServicePlanName = buildResourceName('plan', environment, uniqueString(resourceGroup().id))
resource appServicePlan 'Microsoft.Web/serverfarms@2023-01-01' = {
name: appServicePlanName
location: location
sku: {
name: 'B1'
tier: 'Basic'
}
}
output appServicePlanName string = appServicePlanName //oder direkt der Funktionsaufruf
Prinzipiell würden aber Funktionen und Ressourcen nicht zusammen in einem Template definiert werden.
Funktionen und Ergebnisse testen
Bevor eine Funktion produktiv verwendet wird, lohnt sich ein isolierter Blick auf ihr Ergebnis. Ein einfacher und zuverlässiger Weg dafür ist die Kompilierung des Templates mit anschließender Prüfung der Outputs.
bicep build 04-bicep-funktionen.example.bicep az deployment group create --name function-demo --resource-group rg-bicep-demo --template-file 04-bicep-funktionen.example.bicep --query "properties.outputs.appServicePlanName"
Der bicep build-Schritt deckt bereits Syntaxfehler in der Funktion auf. Der anschließende Deployment-Aufruf mit --query zeigt den tatsächlich berechneten Namen und macht sichtbar, ob die Funktion das erwartete Ergebnis liefert. Alternativ zur CLI-Abfrage lassen sich Outputs nach einem Deployment auch sehr komfortabel über das Bicep Deployment Pane in VS Code einsehen, ohne einen eigenen --query-Ausdruck zu formulieren. Für wiederkehrende Prüfungen lässt sich dieser Ablauf problemlos in ein Testskript überführen, das mehrere Parameterkombinationen automatisiert durchläuft und die Ausgaben vergleicht.
Warum ist das wichtig?
Ohne benutzerdefinierte Funktionen wird Berechnungslogik häufig als Kopie in mehreren Variablen wiederholt. Das erhöht das Risiko, dass bei einer späteren Anpassung nicht alle Stellen konsistent aktualisiert werden. Funktionen schaffen hier eine einzige, klar benannte Quelle für eine bestimmte Logik und erleichtern gleichzeitig die gezielte Überprüfung des Ergebnisses.
Best Practices
- Funktionen bleiben pur: kein Zugriff auf Ressourcen, nur Berechnung aus übergebenen Parametern.
- Aussagekräftige Funktionsnamen erleichtern das Verständnis an der Aufrufstelle.
- Wiederverwendbare Funktionen werden mit @export() versehen, damit sie über mehrere Dateien hinweg konsistent bleiben.
- Funktionen werden an zentraler Stelle definiert.
- Rückgabewerte werden über Outputs sichtbar gemacht, damit sich das Ergebnis vor dem produktiven Einsatz prüfen lässt.
Häufige Fehler
- Zu komplexe Funktionen mit verschachtelter Logik werden schwer nachvollziehbar.
- Funktionsergebnisse werden nie isoliert geprüft, sodass Fehler erst spät im Deployment auffallen.
Fazit
Benutzerdefinierte Funktionen bringen Struktur in wiederkehrende Berechnungslogik und lassen sich über Outputs gezielt überprüfen, bevor sie produktiv zum Einsatz kommen.
Im nächsten Teil der Serie folgt der logische nächste Schritt: Module, mit denen sich ganze Ressourcenblöcke kapseln und projektübergreifend wiederverwenden lassen.