lumikha

4 min de lecture

Azure Verified Modules Terraform : les modules officiels Microsoft en pratique

Structure des AVM, versioning, comment les utiliser efficacement, les combler avec azapi pour les gaps, et retour terrain sur l'adoption.

Les Azure Verified Modules (AVM) sont les modules Terraform officiels de Microsoft pour déployer des ressources Azure. Ils remplacent et unifient les anciens modules de la Azure Terraform Verified Modules Library (CTFM). Sur le papier, l'idée est excellente : des modules maintenus par Microsoft, testés, documentés, et cohérents. En pratique, quelques ajustements sont nécessaires.

Qu'est-ce qu'un Azure Verified Module ?#

Un AVM est un module Terraform publié sur le Terraform Registry sous le namespace Azure, maintenu par des équipes Microsoft ou des partenaires certifiés. Chaque module passe par un processus de review et de testing automatisé.

Les AVM sont organisés en deux catégories :

  • Resource modules : déploient une ressource Azure unique avec toutes ses dépendances optionnelles (ex: avm-res-containerservice-managedcluster pour AKS)
  • Pattern modules : combinent plusieurs resources pour un cas d'usage complet (ex: un pattern module pour un cluster AKS complet avec monitoring, RBAC et networking)

Les modules sont disponibles sur registry.terraform.io en cherchant azure/avm-.

Structure d'un AVM#

Tous les AVM suivent la même structure, ce qui facilite la prise en main une fois qu'on l'a apprise une fois :

avm-res-keyvault-vault/
├── main.tf           # Ressource principale
├── variables.tf      # Variables avec descriptions et validations
├── outputs.tf        # Outputs standardisés
├── locals.tf         # Logique interne
├── _header.md        # Documentation auto-générée
└── examples/
    ├── default/      # Exemple minimal
    └── complete/     # Exemple avec toutes les features

Les variables sont structurées de façon consistante entre modules. Les noms des variables complexes (comme private_endpoints) sont identiques d'un module à l'autre — apprendre la structure une fois suffit.

Utiliser un AVM : exemple avec AKS#

module "aks" {
  source  = "Azure/avm-res-containerservice-managedcluster/azurerm"
  version = "~> 0.3"

  name                = "mon-cluster"
  resource_group_name = azurerm_resource_group.main.name
  location            = azurerm_resource_group.main.location

  kubernetes_version  = "1.30"

  default_node_pool = {
    name       = "system"
    vm_size    = "Standard_D4s_v3"
    node_count = 3
    zones      = ["1", "2", "3"]
  }

  # OIDC et Workload Identity
  oidc_issuer_enabled       = true
  workload_identity_enabled = true

  # Réseau
  network_profile = {
    network_plugin      = "azure"
    network_plugin_mode = "overlay"
    network_dataplane   = "cilium"
  }

  # Monitoring
  monitor_metrics = {
    annotations_allowed = null
    labels_allowed      = null
  }

  # Tags
  tags = local.tags
}

Versioning des AVM#

Les AVM suivent le semver. La contrainte ~> 0.3 autorise les mises à jour de patch (0.3.1, 0.3.2...) mais pas les mises à jour de minor (0.4.0).

Quelques points importants sur le versioning AVM :

  • Les modules sont encore en développement actif. Des breaking changes entre minor versions sont possibles, même si l'équipe AVM les documente dans les release notes.
  • Tester les mises à jour de version dans un environnement non-critique avant de les appliquer en production.
  • La version ~> 0.x est acceptable en phase d'adoption, mais passer sur une version fixe (= 0.3.5) pour les environnements de production sensibles.
module "keyvault" {
  source  = "Azure/avm-res-keyvault-vault/azurerm"
  version = "= 0.9.1"   # Version fixe pour la production

  name                = "mon-keyvault"
  resource_group_name = azurerm_resource_group.main.name
  location            = azurerm_resource_group.main.location
  tenant_id           = data.azurerm_client_config.current.tenant_id

  # Private endpoint via la variable intégrée
  private_endpoints = {
    primary = {
      private_dns_zone_resource_ids = [azurerm_private_dns_zone.keyvault.id]
      subnet_resource_id            = azurerm_subnet.endpoints.id
    }
  }
}

Les Private Endpoints dans les AVM#

Un des points forts des AVM : la gestion des Private Endpoints est intégrée dans chaque module via une variable private_endpoints standardisée. Plus besoin de créer séparément la ressource azurerm_private_endpoint — le module le fait.

private_endpoints = {
  pe_storage = {
    name                          = "pe-storage-blob"
    subnet_resource_id            = azurerm_subnet.endpoints.id
    private_dns_zone_resource_ids = [azurerm_private_dns_zone.blob.id]
    subresource_name              = "blob"
  }
}

Combler les gaps avec azapi#

Les AVM sont basés sur le provider azurerm. Ils peuvent donc être en retard sur les dernières features Azure. Quand une feature récente n'est pas encore disponible dans l'AVM, azapi permet de la configurer sans quitter Terraform :

# L'AVM AKS ne supporte pas encore feature X
# On utilise azapi pour configurer cette propriété sur la ressource créée par l'AVM
resource "azapi_update_resource" "aks_feature_x" {
  type        = "Microsoft.ContainerService/managedClusters@2024-09-01"
  resource_id = module.aks.resource_id

  body = {
    properties = {
      featureX = {
        enabled = true
      }
    }
  }
}

azapi_update_resource modifie une ressource existante sans la recréer — parfait pour compléter ce qu'un AVM ne gère pas encore nativement.

Retour terrain#

Ce qui fonctionne bien :

  • La structure cohérente entre modules réduit le temps d'apprentissage
  • Les exemples default/ et complete/ dans chaque module sont bien maintenus et testés
  • La gestion des Private Endpoints intégrée évite beaucoup de boilerplate
  • Les outputs standardisés (resource_id, name, resource) simplifient les références inter-modules

Ce qui demande de l'adaptation :

  • Certains modules sont encore peu matures (peu de versions, peu de retours terrain). Vérifier le nombre d'issues ouvertes sur GitHub avant d'adopter un module.
  • Les modules "pattern" sont moins nombreux et moins matures que les modules "resource". En pratique, on compose souvent ses propres patterns à partir de resource modules.
  • Le niveau d'abstraction peut être trop élevé pour certains besoins : quand on a besoin de contrôle fin sur une propriété, l'AVM peut la cacher derrière une variable mal documentée. Lire le main.tf du module reste souvent nécessaire.
  • La dépendance implicite au provider azurerm peut créer des conflits si votre codebase utilise azapi en version contrainte différente.

Organisation recommandée#

Pour un projet qui adopte les AVM, une structure qui a fait ses preuves :

infrastructure/
├── modules/           # Vos modules internes qui wrappent les AVM
│   ├── aks/
│   │   ├── main.tf    # Appelle module AVM + azapi pour les gaps
│   │   └── variables.tf
│   └── keyvault/
└── environments/
    ├── dev/
    ├── staging/
    └── prod/

Wrapper les AVM dans vos propres modules permet d'encapsuler vos conventions (nommage, tags, defaults) et d'abstraire les mises à jour de version AVM loin des codes d'environments.

← Tous les articles