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.
Sommaire
Les Azure Verified Modules (AVM) sont les modules Terraform officiels de Microsoft pour déployer des ressources Azure. Ils prennent la suite des anciens Terraform Verified Modules (TFVM) et, côté Bicep, de CARML. 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 propriétaires de module qui sont obligatoirement des employés Microsoft. Chaque module passe par un processus de review et de testing automatisé.
Les AVM sont organisés principalement en deux catégories (il existe aussi des utility modules, plus marginaux) :
- Resource modules : déploient une ressource Azure unique avec toutes ses dépendances optionnelles (ex:
avm-res-containerservice-managedclusterpour 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 # En-tête du README.md (généré par terraform-docs)
└── 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.2.0"
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_data_plane = "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.2.0 autorise les mises à jour de patch (0.2.1, 0.2.2...) mais pas les mises à jour de minor (0.3.0). Attention : ~> 0.2 (sans le patch) autoriserait toutes les versions jusqu'à 1.0.0 exclue.
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.xest acceptable en phase d'adoption, mais passer sur une version fixe (= 0.2.0) 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/etcomplete/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.tfdu module reste souvent nécessaire. - Chaque AVM déclare ses propres contraintes de version sur
azurermetazapi: elles peuvent entrer en conflit avec celles de votre codebase.
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.
