Azure Verified Modules met Bicep, DevOps Pipelines & GitHub Actions

Soorten modules in AVM 

AVM-modules zijn samenstelbare bouwblokken die groepen resources omvatten , toegewijd aan één taak.

Er zijn twee modules die gebruikt worden om Azure resources consistent in te zetten:

1. Pattern Modules
2. Resource Modules

Deze worden verder uitgelegd in de onderstaande tabel:

Waarom Azure Verified Modules (AVM) gebruiken?

AVM versnelt de levering van gemigreerde en cloud-native applicaties en hun ondersteunende infrastructuur, betrouwbaar, consistent en op schaal.

Kortom, Azure Verified Modules bieden:

• Standaardisatie: Door Microsoft gevalideerde templates zorgen voor compliance met best practices. 
• Modulariteit: Inkapselen van infrastructuur elementen in herbruikbare modules. 
• Beveiliging en Compliance: AVM bevat ingebouwde beleidsregels en vangrails. 
• Schaalbaarheid: Hergebruik modules in meerdere omgevingen en teams. 
• Snellere doorlooptijd naar ACR: AVM zorgt voor een snellere doorlooptijd naar ACR en verbetert de kwaliteit.

Als je met meerdere teams werkt, is het hebben van source control een must voor elke organisatie. Het houdt code georganiseerd, consistent en goed beheerd. 

Een AVM-gebaseerde Bicep implementatie structureren

Hieronder staat een mapstructuur als voorbeeld om je CI/CD netjes en georganiseerd te houden.

Folder structuur 

Een goed georganiseerd AVM-gebaseerd Bicep project zou deze structuur moeten volgen:

/infra
 ├── bicepparam
 │ ├── dev.bicepparam
 │ ├── acc.bicepparam
 │ ├── prod.bicepparam
 ├── main.bicep
 ├── azure-pipelines.yml
 ├── .github/workflows/deploy.yml 

Een Azure Verified Module gebruiken in main.bicep

Hier is een voorbeeld van hoe je een Azure Verified Module direct in je main.bicep bestand kunt gebruiken om een resource group met gestandaardiseerde parameters te deployen.

targetScope = 'subscription'

@description('Customer Name (max 15 characters to prevent long resource names)')
@minLength(3)
@maxLength(15)
param customerName string

@description('Deployment Location')
param location string

@description('Location Short Code (2-4 characters, e.g., "weu" for West Europe)')
@minLength(2)
@maxLength(4)
param locationShortCode string

@description('Environment Type')
@allowed([
  'dev'
  'acc'
  'prod'
])
param environmentType string

// Resource Group Naming Convention
var resourceGroupName = 'rg-${customerName}-${environmentType}-${locationShortCode}'

// Storage Account Name
@description('Storage Account Name (must be unique, 3-24 characters, lowercase)')
@minLength(3)
@maxLength(24)
param storageAccountName string

// Azure Verified Modules - Start Here
module createResourceGroup 'br/public:avm/res/resources/resource-group:0.4.1' = {
  name: 'create-resource-group'
  params: {
    name: resourceGroupName
    location: location
  }
}

module storageAccount 'br/public:avm/res/storage/storage-account:0.17.0' = {
  name: 'create-storage-account'
  scope: resourceGroup(resourceGroupName)
  params: {
    name: storageAccountName
    location: location
    kind: 'StorageV2'
    skuName: 'Standard_LRS'
  }
}

Omgevings-specifieke parameters

(bicepparam/dev.bicepparam)

using './main.bicep'

param customerName = 'contoso'
param location = 'westeurope'
param locationShortCode = 'weu'
param environmentType = 'dev'
param storageAccountName = 'stcontosodevweu' // must be lowercase and static

AVM-modules deployen met Azure DevOps Pipelines

Als je Azure DevOps gebruikt, kun je de deployment van Azure Verified Modules automatiseren met een pipeline gedefinieerd in azure-pipelines.yml.

Hier is een voorbeeld:

Pipeline YAML (azure-pipelines.yml)

name: Infrastructure Deployment
trigger:
  - main

pool:
  vmImage: ubuntu-latest

parameters:
  - name: subscriptionId
    displayName: Subscription Id
    type: string
    default: ''
  - name: environmentType
    displayName: Deployment Environment
    type: string
    default: dev
    values:
      - dev
      - acc
      - prd

steps:
  - task: AzureResourceManagerTemplateDeployment@3
    inputs:
      azureResourceManagerConnection: '<azureResourceConnectionId>'
      deploymentScope: Subscription
      subscriptionId: ${{ parameters.subscriptionId }}
      location: westeurope
      templateLocation: 'Linked artifact'
      csmFile: './infra/main.bicep'
      csmParametersFile: 'infra/bicepparam/${{ parameters.environmentType }}.bicepparam'
      deploymentMode: Incremental

GitHub Actions

Als jouw organisatie liever GitHub Actions gebruikt, dan kunnen we je helpen. Hier is een voorbeeld workflow.

AVM Modules Deployen met GitHub Actions Workflow YAML (.github/workflows/deploy.yml)

name: Infrastructure Deployment

on:
  workflow_dispatch:
    inputs:
      subscriptionId:
        description: Azure Subscription ID
        required: true
      environment:
        description: Deployment Environment
        required: true
        type: choice
        options:
          - dev
          - acc
          - prd

permissions:
  id-token: write

jobs:
  deploy:
    runs-on: ubuntu-latest
    env:
      AZURE_SUBSCRIPTION_ID: ${{ inputs.subscriptionId }}
      AZURE_ENVIRONMENT: ${{ inputs.environment }}
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Azure Login
        uses: azure/login@v1
        with:
          client-id: ${{ secrets.AZURE_CLIENT_ID }}
          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
          subscription-id: ${{ env.AZURE_SUBSCRIPTION_ID }}

      - name: Deploy Bicep Template
        uses: azure/arm-deploy@v1
        with:
          subscriptionId: ${{ env.AZURE_SUBSCRIPTION_ID }}
          scope: 'subscription'
          region: 'westeurope'
          template: './infra/main.bicep'
          parameters: './infra/bicepparam/${{ env.AZURE_ENVIRONMENT }}.bicepparam'
          deploymentMode: 'Incremental'

Best Practices voor AVM Deployment

Hoewel het gebruik van de Azure Verified Modules de beste manier is , laten we eens kijken naar een aantal best practices met betrekking tot authenticatie en validatie:

Best practice 1: Authenticatie best practices

• Gebruik OIDC (OpenID Connect) voor GitHub Actions in plaats van Service Principal wachtwoord. [GitHub Docs - OIDC] 
• Gebruik Managed Identity voor Azure DevOps waar mogelijk. [Microsoft Learn – Workload Identity Service] 

Best practice 2: Valideer voor deployment

• Run az bicep build om module syntax te valideren voor deployment.
• Gebruik az deployment sub what-if om preview changes vooraf te bekijken voordat je ze toepast. 

Best practice 3: Herbruikbaarheid en schaalbaarheid

• Sla modules op in een Azure Bicep Registry voor gecentraliseerd beheer. 
• Gebruik AVM om gebruik te maken van vooraf geteste, best-practice modules in plaats van eigen modules.

Conclusie 

We hebben besproken hoe AVM en CI/CD de implementatie kunnen automatiseren en schalen en je infrastructuur in Azure meer modulair, herbruikbaar en compliant kunnen maken. 

Door AVM Bicep-modules te gebruiken in CI/CD-workflows, kun je een schaalbare, compliant en onderhoudbare cloud infrastructuur creëren en tegelijkertijd de efficiëntie en beveiliging verbeteren.