Anzeige
Anzeige
Anzeige
Anzeige
Anzeige
Anzeige
Lesedauer 5 Min.

Module – Wiederverwendung über Projekte hinweg

Dieser Beitrag zeigt den Aufbau eines Moduls, die Einbindung über den module-Block sowie die Konfiguration von Alias-Pfaden über die Datei bicepconfig.json, mit der sich Modulreferenzen deutlich lesbarer gestalten lassen.
Module.jpg
© KI-generiert, Gemini

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.

Neueste Beiträge

System-Thinking für Agenten - Projektanforderungen an Entwickler in Zeiten von KI, Teil 4
Der Agent schlug vor, die Geschäftslogik in den Controller zu verlagern. Technisch korrekt, architektonisch eine Katastrophe. Drei Szenarien zeigen, warum Architekturentscheidungen die Bastion bleiben, die Entwickler nicht delegieren können.
6 Minuten
19. Nov 2026
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

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