Module – Wiederverwendung über Projekte hinweg
Infrastructure as Code mit Azure Bicep, Teil 5
Nachdem die vorangegangene Folge der Serie zu Infrastructure as Code mit Azure Bicep benutzerdefinierte Funktionen für wiederkehrende Logik behandelt hat, geht es in diesem Beitrag um die nächste Ebene der Wiederverwendung: Module. Ab einer bestimmten Komplexität wird ein einzelnes Bicep-Template unhandlich. Storage, Netzwerk, App Service und Monitoring würden alle in derselben Datei landen, obwohl sie fachlich unterschiedliche Verantwortlichkeiten abbilden. Module lösen dieses Problem: Sie kapseln Ressourcenblöcke in einer eigenen Datei und lassen sich anschließend aus einem übergeordneten Template heraus referenzieren.
Aufbau eines Moduls
Ein Modul ist technisch gesehen eine gewöhnliche Bicep-Datei mit eigenen Parametern und Outputs. Der einzige Unterschied liegt darin, wie die Datei später eingebunden wird. Ein Schlüsselwort module oder ähnlich gibt es nicht – zumindest bei der Definition.
param location string
param environment string
resource storage 'Microsoft.Storage/storageAccounts@2023-05-01' = {
name: 'stmod${environment}${uniqueString(resourceGroup().id)}'
location: location
sku: {
name: 'Standard_LRS'
}
kind: 'StorageV2'
}
output storageAccountName string = storage.name
Diese Datei kann eigenständig kompiliert und getestet werden, genauso wie jedes andere Bicep-Template. Genau das macht Module so praktisch: Sie bleiben unabhängig testbar und lassen sich trotzdem in größere Deployments einbetten.
Einbindung über den module-Block
Im übergeordneten Orchestrierungs-Template wird das Modul über den module-Block referenziert. Dabei werden Name, Pfad und Parameter angegeben:
module storageModule './05-bicep-module-storage.module.bicep' = {
name: 'storageModuleDeployment'
params: {
location: location
environment: environment
}
}
output storageAccountName string = storageModule.outputs.storageAccountName
Der Rückgabewert des Moduls steht über storageModule.outputs zur Verfügung und lässt sich im übergeordneten Template genauso weiterverwenden wie jeder andere Wert.
Module unterstützen zudem dieselben Schleifen- und Bedingungskonstrukte wie Ressourcen: Ein module-Block lässt sich mit for mehrfach instanzieren und mit einem vorangestellten if bedingt bereitstellen, genau wie im Teil zu Schleifen und Bedingungen gezeigt.
Ein Modul lässt sich lokal über einen Dateipfad referenzieren, wie oben, oder remote über eine Azure Container Registry mit dem Präfix br: beziehungsweise eine Template Spec mit dem Präfix ts:. Lokale Pfade eignen sich für Module im selben Repository, ACR und Template Specs für die Verteilung über mehrere Projekte und Teams.
Ein Modul in eine ACR veröffentlichen
Damit ein Modul remote referenzierbar wird, muss es zunächst veröffentlicht werden, hier in eine ACR:
az bicep publish --file 05-bicep-module-storage.module.bicep --target br:myregistry.azurecr.io/bicep/modules/storage:v1
Alias-Konfiguration für lesbare Modulpfade
Bei Modulen aus einer Registry oder aus Template Specs werden die vollständigen Referenzen schnell unübersichtlich. Über eine bicepconfig.json-Datei lassen sich dafür Alias-Namen definieren, die anstelle der langen Pfade und Ressourcen-IDs verwendet werden.
{
"moduleAliases": {
"br": {
"CoreModules": {
"registry": "myregistry.azurecr.io",
"modulePath": "bicep/modules"
}
},
"ts": {
"CoreSpecs": {
"subscription": "<subscription-id>",
"resourceGroup": "rg-template-specs"
}
}
}
}
Ein br-Alias vereinfacht den Zugriff auf Module, die zentral in einer Azure Container Registry gepflegt werden, referenziert über br/CoreModules:storage:v1. Ein ts-Alias zeigt auf eine Resource Group mit Template Specs und wird über ts/CoreSpecs:storage:v1 referenziert. Für Teams mit mehreren Repositories ist das ein Gewinn an Übersichtlichkeit, weil sich Registry-Adresse oder Template-Spec-Resource-Group zentral pflegen lassen, ohne jede Modulreferenz einzeln anzupassen.
Referenziert wird das Modul anschließend über den Registry-Pfad statt einem Dateipfad, verkürzt über den br-Alias als br/CoreModules:storage:v1.
Vollständiges Beispiel (remote)
Nachdem das Modul veröffentlicht wurde, sieht die Referenz im Hauptdeployment so aus (ohne Alias):
param location string = resourceGroup().location
param environment string = 'dev'
module storageModule 'br:myregistry.azurecr.io/bicep/modules/storage:v1' = {
name: 'storageModuleDeployment'
params: {
location: location
environment: environment
}
}Wie groß sollte ein Modul sein?
Die richtige Granularität liegt zwischen zwei Extremen. Ein Modul, das nur eine einzelne Ressource ohne zusätzliche Logik kapselt, bringt kaum Mehrwert gegenüber der direkten Ressourcendefinition und erzeugt nur zusätzliche Indirektion. Am anderen Ende steht das Alleskönner-Modul, das eine komplette Umgebung mit Netzwerk, Storage, Compute und Monitoring in einer Datei bündelt – schwer testbar, schwer wiederverwendbar und bei jeder Änderung ein Risiko für alle enthaltenen Ressourcen.
Ein gut geschnittenes Modul deckt stattdessen genau eine fachliche Verantwortlichkeit ab – eigenständig testbar, unabhängig versionierbar und ohne unnötigen Ballast wiederverwendbar.
Warum ist das wichtig?
Module trennen fachliche Verantwortlichkeiten und ermöglichen es Teams, parallel an unterschiedlichen Ressourcenblöcken zu arbeiten. Ein einmal geschriebenes Modul lässt sich zudem in mehreren Projekten wiederverwenden, wodurch Namenskonventionen, Sicherheitseinstellungen oder Tagging-Strategien zentral gepflegt werden.
Deployment mit Azure CLI
Für das Deployment ist das Orchestrierungstemplate relevant, in welchem die Module referenziert werden:
az deployment group create --name module-demo --resource-group rg-bicep-demo --template-file 05-bicep-module-main.bicep
Best Practices
- Module erhalten einen klaren, fachlichen Namen und decken genau eine Verantwortlichkeit ab.
- Parameter und Outputs eines Moduls werden bewusst minimal gehalten, um die Schnittstelle einfach zu halten.
- Alias-Konfigurationen in bicepconfig.json werden projektweit einheitlich gepflegt.
- Module werden eigenständig geprüft, bevor sie in ein übergeordnetes Template eingebunden werden.
Häufige Fehler
- Module übernehmen zu viele unterschiedliche Ressourcenarten und verlieren dadurch ihre klare Abgrenzung.
- Registry-Pfade werden ohne br-Alias direkt hartcodiert, wodurch eine geänderte Registry-Adresse viele Referenzen gleichzeitig bricht.
- Outputs eines Moduls werden nicht konsequent genutzt, sodass Werte im übergeordneten Template erneut berechnet werden.
Fazit
Module schaffen eine klare Struktur für größere Bicep-Projekte und lassen sich über Alias-Konfigurationen komfortabel referenzieren.
Im nächsten Teil der Serie wird gezeigt, wie sich Deployments über Azure DevOps automatisieren lassen, sodass Templates nicht mehr manuell, sondern über eine Pipeline bereitgestellt werden.