Anzeige
Anzeige
Anzeige
Anzeige
Anzeige
Anzeige
Lesedauer 5 Min.

Funktionen – Wiederkehrende Logik kapseln

Dieser Beitrag zeigt, wie benutzerdefinierte Funktionen aufgebaut sind, wie sie sich von den eingebauten Bicep-Funktionen unterscheiden und wie sich das Ergebnis einer Funktion vor dem eigentlichen Deployment überprüfen lässt.
Entwicklerin.jpg
© KI-erzeugt, Gemini

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.

Neueste Beiträge

Vom Garagenprojekt zum Milliardengeschäft – der Aufstieg von Open Source
Im September 1991 wurde Linux 0.01 veröffentlicht. 35 Jahre später ist aus dem Projekt eines finnischen Studenten eine der Grundlagen der digitalen Welt geworden.
7 Minuten
18. Nov 2026
Enums mit Komfortfunktion - Best of NuGet, Teil 11
Enums sind in Zeiten von unbegrenztem Speicher und außerhalb des AI-Bereichs so gut wie kostenloser Rechenleistung in den Hintergrund getreten. Mit dem NuGet-Paket Enums.NET steht eine Bibliothek zur Verfügung, die dem vernachlässigten Sprachfeature verschiedenste Komfortfunktionen verleiht.
6 Minuten
16. Nov 2026
Mit Sixel dynamisch Bitmaps erstellen und in die .NET-Konsole rendern - Retro-Hardware mit .NET in Software nachbilden, Teil 3
Der bereits in den 1980ern entwickelte Sixel-Standard ermöglicht uns noch heute, in der Konsole auf einfache Weise Bilder und kleinere Visualisierungen darzustellen – portabel und ohne weitere Abhängigkeiten.
8 Minuten
12. Nov 2026

Das könnte Dich auch interessieren

Laufzeitgewinn messen - Schnellere .NET-CI-Pipelines mit Test Sharding, Teil 4
Mehr Shards können das Feedback beschleunigen, aber auch zugleich die CI-Kosten erhöhen. Ein Vergleich mit zwei Referenzläufen zeigt, wo sich zusätzliche Runner lohnen. Ebenso wichtig ist der Nachweis, dass weiterhin alle vorgesehenen Tests laufen.
6 Minuten
Setup per CLI oder als Stand-alone-Runtime - Infrastructure as Code mit Azure Bicep, Teil 1
Dieser Beitrag erklärt, was Bicep ist, wie das Bicep CLI als zugrunde liegende Engine installiert wird, aus welchen Grundbausteinen ein Template besteht und wie VS Code mit der passenden Erweiterung den Einstieg erleichtert.
5 Minuten
Flexible Templates ohne Wiederholung - Infrastructure as Code mit Azure Bicep, Teil 2
Wie Bicep-Parameter typisiert, eingeschränkt und mit sinnvollen Standardwerten versehen werden und wie Variablen sich nutzen lassen, um aus Parametern abgeleitete Werte zu berechnen, etwa für Namenskonventionen oder umgebungsabhängige SKUs.
5 Minuten
Anzeige
Anzeige
Anzeige
Anzeige
Anzeige