Terraform sur Azure : Guide pratique du débutant sur l'IaC

Si vous vous êtes déjà retrouvé à parcourir le portail Azure en essayant de rassembler manuellement des ressources cloud, je suis passé par là moi aussi, et ça devient vite lassant. C'est là qu'intervient Terraform. Il s'agit d'un outil d'infrastructure en tant que code (IaC) qui vous permet de définir et de gérer votre configuration cloud en quelques lignes de code.

Dans ce tutoriel, nous nous concentrerons sur l'utilisation de Terraform avec Azure. Je vous expliquerai ce qu'est Terraform, comment il fonctionne dans l'écosystème Azure et comment démarrer avec des exemples pratiques. Nous aborderons également quelques bonnes pratiques pour vous aider à mettre en place des déploiements sécurisés et fiables dès le départ.

Si vous êtes nouveau dans l'écosystème Azure, ce cursus sur les fondamentaux d'Azure offre une introduction structurée aux services et principes de base.

Pourquoi utiliser Terraform sur Azure ?

Terraform, développéd par HashiCorp, est un outil IaC open-source qui vous permet de définir et de gérer une infrastructure cloud à l'aide d'une syntaxe déclarative. Associé à Microsoft Azure, il vous permet de créer des ressources telles que des réseaux virtuels, des machines virtuelles et des bases de données dans des fichiers de configuration lisibles par l'homme.

Pourquoi utiliser Terraform avec Azure ? Tout est question de cohérence, d'évolutivité et de rapidité. Qu'il s'agisse de mettre en service une simple VM ou d'orchestrer une application complexe à plusieurs niveaux, Terraform simplifie le processus tout en réduisant les erreurs humaines.

Si vous êtes totalement novice en matière de Terraform, ce guide Terraform pour débutantsexplique les principes fondamentaux et comment commencer à l'utiliser pour l'infrastructure en tant que code.

Concepts de base de Terraform sur Azure

L'intégration de Terraform avec Azure offre une série de fonctionnalités qui rendent la gestion de l'infrastructure intuitive et puissante. Examinons les composants clés et les types de ressources Terraform disponibles.

Gestion déclarative de l'infrastructure

L'approche déclarative de Terraform vous permet de définir ce à quoi votre infrastructure Azure doit ressembler dans des fichiers .tf à l'aide du langage de configuration HashiCorp (HCL). 

Par exemple, vous pouvez spécifier une VM Azure avec sa taille, son emplacement et ses paramètres réseau, et Terraform se charge du comment de sa création. En voici un aperçu :

resource "azurerm_virtual_machine" "example" {
  name                  = "my-vm"
  location              = "East US"
  resource_group_name   = "my-resource-group"
  vm_size               = "Standard_D2s_v3"
  network_interface_ids = [azurerm_network_interface.example.id]
  # ... other necessary configurations like OS disk, admin details
}

La définition ci-dessus garantit l'idempotence - l'exécution du même code plusieurs fois permet d'obtenir le même résultat sans doublons ni erreurs. 

Décortiquons maintenant les concepts fondamentaux de Terraform qui permettent à cette approche déclarative de fonctionner.

État Terraform (.tfstate)

Le fichier terraform.tfstate est le cœur du modèle déclaratif de Terraform. Il s'agit d'un fichier JSON qui enregistre l'état actuel de vos ressources Azure (ce qui est déployé, leurs configurations et leurs relations). 

Lorsque vous exécutez terraform apply, Terraform compare vos fichiers .tf (l'état souhaité) avec le fichier .tfstate (l'état réel) pour déterminer les modifications à apporter. Par exemple, si vous mettez à jour la taille d'une VM dans votre code, Terraform vérifie le fichier .tfstate et ne modifie que cet attribut dans Azure. 

Vous pouvez stocker ce fichier localement, mais pour les équipes, utilisez Azure Blob Storage pour permettre la collaboration et le verrouillage des états afin d'éviter les conflits.

Variables Terraform (.tfvars)

Les variables rendent vos configurations flexibles et réutilisables. Définis dans variables.tf et terraform.tfvars, ils vous permettent de paramétrer des valeurs telles que des noms de ressources ou des régions. 

Par exemple :

# variables.tf
variable "location" {
  type        = string
  default     = "East US"
  description = "The Azure region where resources will be deployed."
}

# terraform.tfvars (for a specific environment, e.g., production)
location = "West US"

# main.tf
resource "azurerm_resource_group" "example" {
  name     = "my-rg"
  location = var.location
}

Le fichier terraform.tfvars remplace les valeurs par défaut, de sorte que vous pouvez déployer le même code dans différentes régions sans modifier les fichiers de base .tf. Il peut être utilisé pour gérer plusieurs environnements (par exemple, dev, prod).

Fichiers de configuration Terraform (.tf)

Ces fichiers contiennent votre code d'infrastructure, qui est écrit en HCL. Ils définissent les ressources, les fournisseurs, les modules, etc. Vous pouvez les organiser en un seul fichier main.tf ou les diviser en plusieurs fichiers (par exemple, variables.tf, outputs.tf, network.tf, compute.tf) pour plus de clarté et une meilleure organisation.

Plan Terraform

Avant d'appliquer les changements, la commande terraform plan montre un aperçu de ce que Terraform va faire - créer, mettre à jour ou supprimer des ressources - en fonction de la différence entre vos fichiers .tf et les fichiers .tfstate. Il s'agit d'une sorte d'essai qui permet de détecter rapidement les problèmes potentiels, en affichant un résumé détaillé des actions proposées.

Appliquer Terraform

La commande terraform apply exécute les modifications identifiées par terraform plan, en mettant à jour Azure pour qu'il corresponde à l'état souhaité et en actualisant le fichier .tfstate. Vous serez invité à confirmer les modifications avant qu'elles ne soient appliquées, ce qui constitue un filet de sécurité.

Espaces de travail

Les espaces de travail Terraform vous permettent de gérer plusieurs environnements (par exemple, dev, staging, prod) avec un seul ensemble de fichiers .tf. Chaque espace de travail dispose de son propre fichier .tfstate, ce qui vous permet de déployer une infrastructure similaire avec différentes configurations (par exemple, différentes tailles de VM pour dev et prod). 

Pour créer un nouvel espace de travail, vous pouvez utiliser :

terraform workspace new production

Vous pouvez ensuite passer à l'espace de travail :

terraform workspace select production

Modules

Les modules sont des paquets réutilisables de code Terraform. Par exemple, vous pouvez créer un module pour un réseau virtuel Azure et le réutiliser dans d'autres projets, ce qui permet de réduire les doublons et de promouvoir la normalisation. Nous aborderons les modules plus en détail dans la section consacrée aux meilleures pratiques.

Ces concepts -.tfstate, .tfvars, et le flux de travail déclaratif - fonctionnent ensemble pour garantir que votre infrastructure Azure est prévisible, reproductible et facile à gérer.

Gestion de l'État et collaboration

Le fichier terraform.tfstate permet de suivre l'état de votre infrastructure. Pour les équipes, le stockage dans Azure Blob Storage est une bonne pratique essentielle pour permettre l'accès partagé et le contrôle des versions. Cette configuration à distance permet à tous les membres de l'équipe de travailler avec une vue cohérente de l'infrastructure. 

Le verrouillage des états, une fonction automatiquement fournie par de nombreux backends distants comme Azure Blob Storage, évite les conflits lorsque plusieurs membres de l'équipe tentent d'exécuter des commandes Terraform simultanément, garantissant ainsi l'intégrité des données.

Voici un exemple de configuration d'un backend Azure Blob Storage :

terraform {
  backend "azurerm" {
    resource_group_name  = "my-terraform-state-rg"
    storage_account_name = "mystorageterraformstate"
    container_name  = "tfstate"
    key  = "production/terraform.tfstate" # Path within the container
  }
}

Avant d'exécuter terraform init avec cette configuration, vous devez créer le compte de stockage Azure et le conteneur manuellement ou via une configuration Terraform distincte. Cette configuration garantit une gestion sécurisée et collaborative des ressources Azure.

L'écosystème des fournisseurs et AzureRM

Le fournisseur azurerm est lepont de Terraformvers Azure, traduisant les HCL en appels d'API pour gérer des services tels que les VM, les réseaux et les bases de données.

Il prend en charge des centaines de types de ressources, de l'informatique (azurerm_linux_virtual_machine, azurerm_windows_virtual_machine) à l'analyse (azurerm_synapse_workspace). Voici quelques-unes de ses caractéristiques :

• Large couverture : Gérez une vaste gamme de services Azure, notamment les machines virtuelles, les comptes de stockage, Azure Kubernetes Service (AKS), Azure SQL Database, Azure Cosmos DB avec MongoDB API, Azure Functions, et bien plus encore. Le fournisseur azurerm est activement développé pour prendre en charge les nouveaux services et fonctionnalités Azure dès qu'ils sont disponibles.
• Fonctions dynamiques : Utilisez les fonctions définies par le fournisseur pour générer des noms uniques (par exemple, azurerm_resource_group.example.name) ou pour obtenir des détails sur les ressources existantes (par exemple, data.azurerm_virtual_network.existing.id). Cela permet des configurations plus dynamiques et plus intelligentes.
• Sources des données : Le fournisseur azurerm exploite les sources de données pour obtenir des informations sur les ressources Azure existantes. Ceci est particulièrement utile lorsque vous devez référencer des ressources qui n'ont pas été provisionnées par votre configuration Terraform actuelle. Par exemple, vous pouvez récupérer les détails d'un réseau virtuel existant pour déployer de nouveaux sous-réseaux ou machines virtuelles sans recréer le réseau virtuel.

Avant de plonger dans Terraform, il est utile de comprendre comment configurer manuellementAzure. Ceguide pour débutants vous présente les éléments essentiels.

Mise en place d'un environnement Terraform-Azure

Mettons la main à la pâte ! Cette section vous guide dans la configuration initiale requise pour utiliser Terraform avec votre abonnement Azure.

Authentification et outils CLI

Pour interagir avec Azure, vous devez d'abord installer et configurerl' interface de ligne de commande Azure (CLI). Le CLI Azure () fournit les outils nécessaires à l'authentification et à la gestion de vos ressources Azure. Une fois installé, connectez-vous à votre compte Azure :

az login

La commande ci-dessus ouvrira une fenêtre de navigateur pour l'authentification interactive. Pour une référence rapidek, cet aide-mémoire Azure CLI peutrationaliser vos flux de travail en ligne de commande.

Pour les déploiements automatisés avec Terraform, en particulier dans les pipelines CI/CD, il est fortement recommandé de créer et d'utiliser des principes de service Azure Active Directory (AAD). Les principes de service constituent un moyen sûr et programmatique pour Terraform de s'authentifier auprès de votre abonnement Azure sans nécessiter de connexions interactives.

Pour créer un principal de service avec le rôle "Contributeur" dans l'étendue de l'abonnement, exécutez :

az ad sp create-for-rbac --name "http://myTerraformServicePrincipal" --role "Contributor" --scopes "/subscriptions/<your-subscription-id>"

La sortie fournira appId, password, et tenant (identifiant du locataire). Vous pouvez ensuite les définir comme variables d'environnement pour Terraform :

export ARM_CLIENT_ID="<appId>"
export ARM_CLIENT_SECRET="<password>"
export ARM_TENANT_ID="<tenant>"
export ARM_SUBSCRIPTION_ID="<your-subscription-id>"

Initialiser un projet

Un projet Terraform typique suit un plan de répertoire structuré, souvent avec des fichiers .tf distincts pour les différents types de ressources ou modules (par exemple, main.tf, variables.tf, outputs.tf, network.tf, compute.tf). 

Pour démarrer un projet Terraform, accédez au répertoire de votre projet et exécutez la commande terraform init. Cette commande initialise le répertoire de travail, télécharge les plugins nécessaires (comme azurerm) et met en place le backend pour la gestion de l'état comme défini dans votre configuration.

mkdir my-azure-terraform-project
cd my-azure-terraform-project
# Create your .tf files here
terraform init

Cette commande prépare votre répertoire pour les opérations Terraform, en s'assurant que tous les plugins nécessaires sont en place.

Provisionnement des ressources Azure

Cette section fournit des exemples pratiques de provisionnement de ressources Azure courantes à l'aide de Terraform, en montrant comment les définir et les déployer par programme.

Réseaux et sous-réseaux virtuels

Terraform excelle dans la définition et le déploiement d'une infrastructure réseau sur Azure. Vous pouvez facilement définir des réseaux virtuels (VNets) et les segmenter en sous-réseaux, en contrôlant les espaces d'adresses IP et l'isolation du réseau. 

La gestion des dépendances inhérente à Terraform garantit que les ressources sont créées dans le bon ordre ; par exemple, les sous-réseaux ne seront provisionnés que lorsque leur VNet parent aura été créé avec succès. En voici un exemple :

resource "azurerm_resource_group" "network_rg" {
  name     = "my-network-rg"
  location = "East US"
}

resource "azurerm_virtual_network" "main_vnet" {
  name                = "my-vnet"
  address_space       = ["10.0.0.0/16"]
  location            = azurerm_resource_group.network_rg.location
  resource_group_name = azurerm_resource_group.network_rg.name
}

resource "azurerm_subnet" "web_subnet" {
  name                 = "web-subnet"
  resource_group_name  = azurerm_resource_group.network_rg.name
  virtual_network_name = azurerm_virtual_network.main_vnet.name
  address_prefixes     = ["10.0.1.0/24"]
}

resource "azurerm_subnet" "app_subnet" {
  name                 = "app-subnet"
  resource_group_name  = azurerm_resource_group.network_rg.name
  virtual_network_name = azurerm_virtual_network.main_vnet.name
  address_prefixes     = ["10.0.2.0/24"]
}

Machines virtuelles avec cloud-init

Le provisionnement des machines virtuelles (VM) avec Terraform est simple. Pour automatiser la configuration post-déploiement et l'installation initiale, vous pouvez utiliser les scripts cloud-init. 

cloud-init vous permet d'injecter des scripts qui s'exécutent au premier démarrage de la VM, permettant des tâches telles que l'installation de logiciels, la configuration d'utilisateurs ou la mise en place de services, directement à partir de votre configuration Terraform.

Voici un exemple de provisionnement d'une VM Linux avec un simple script cloud-init pour installer Nginx :

resource "azurerm_resource_group" "vm_rg" {
  name     = "my-vm-rg"
  location = "East US"
}

resource "azurerm_network_interface" "vm_nic" {
  name                = "my-vm-nic"
  location            = azurerm_resource_group.vm_rg.location
  resource_group_name = azurerm_resource_group.vm_rg.name

  ip_configuration {
    name                          = "internal"
    subnet_id                     = azurerm_subnet.web_subnet.id # Assuming web_subnet defined above
    private_ip_address_allocation = "Dynamic"
    public_ip_address_id          = azurerm_public_ip.vm_public_ip.id
  }
}

resource "azurerm_public_ip" "vm_public_ip" {
  name                = "my-vm-public-ip"
  location            = azurerm_resource_group.vm_rg.location
  resource_group_name = azurerm_resource_group.vm_rg.name
  allocation_method   = "Static"
}

resource "azurerm_linux_virtual_machine" "my_vm" {
  name                  = "my-linux-vm"
  location              = azurerm_resource_group.vm_rg.location
  resource_group_name   = azurerm_resource_group.vm_rg.name
  size                  = "Standard_B2s"
  admin_username        = "azureuser"
  admin_password        = "P@ssw0rd1234!" # In a real scenario, use Azure Key Vault or variables
  network_interface_ids = [azurerm_network_interface.vm_nic.id]

  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }

  source_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "18.04-LTS"
    version   = "latest"
  }

  # cloud-init script to install Nginx
  custom_data = base64encode(<<EOF
#cloud-config
packages:
  - nginx
runcmd:
  - systemctl start nginx
  - systemctl enable nginx
EOF
  )
}

Modularisation de l'infrastructure

Au fur et à mesure que votre infrastructure Azure se développe, la modularisation de vos configurations Terraform devient cruciale pour la réutilisation, la maintenance et l'évolutivité. 

Les modules encapsulent un ensemble de ressources liées et leurs configurations dans des unités réutilisables. Cette section vous guidera dans la structuration de votre code Terraform en modules et vous montrera comment invoquer ces modules dans vos configurations principales, favorisant ainsi une base de code plus propre et mieux organisée.

Exemple : Structure du module (modules/web-app/main.tf) :

# modules/web-app/main.tf
resource "azurerm_app_service_plan" "app_plan" {
  name                = var.app_service_plan_name
  location            = var.location
  resource_group_name = var.resource_group_name
  kind                = "Linux"
  sku {
    tier = "Basic"
    size = "B1"
  }
}

resource "azurerm_app_service" "app_service" {
  name                = var.app_service_name
  location            = var.location
  resource_group_name = var.resource_group_name
  app_service_plan_id = azurerm_app_service_plan.app_plan.id
}

variable "app_service_plan_name" {
  type = string
}

variable "app_service_name" {
  type = string
}

variable "location" {
  type = string
}

variable "resource_group_name" {
  type = string
}

output "app_service_default_hostname" {
  value = azurerm_app_service.app_service.default_host_name
}

Exemple : Invocation du module (main.tf dans le répertoire racine) :

resource "azurerm_resource_group" "app_rg" {
  name     = "my-webapp-rg"
  location = "East US"
}

module "my_web_app" {
  source                = "./modules/web-app" # Path to your module
  app_service_plan_name = "my-webapp-plan"
  app_service_name      = "my-unique-webapp-2025"
  location              = azurerm_resource_group.app_rg.location
  resource_group_name   = azurerm_resource_group.app_rg.name
}

output "webapp_url" {
  value = module.my_web_app.app_service_default_hostname
}

Cette structure permet de réutiliser facilement la logique de déploiement de votre application web dans différents environnements ou projets.

Flux de travail Terraform avancés

Cette section explore des fonctionnalités plus sophistiquées de Terraform qui améliorent la flexibilité et la puissance de vos déploiements d'infrastructure, allant au-delà de l'approvisionnement en ressources de base.

Sources de données et configurations dynamiques

Les sources de données dans Terraform vous permettent de récupérer des informations sur les ressources existantes, qu'elles soient gérées par Terraform ou non. Cette fonction est extrêmement utile pour l'intégration dans une infrastructure préexistante ou pour les recherches dynamiques. 

Associées à des configurations dynamiques (telles que for_each et count), les sources de données permettent d'élaborer des scripts Terraform très souples et adaptatifs, capables de réagir à diverses conditions et à la disponibilité des ressources.

Exemple : Utilisation d'une source de données pour trouver un VNet existant et ajouter un nouveau sous-réseau :

# Data source to fetch an existing Virtual Network
data "azurerm_virtual_network" "existing_vnet" {
  name                = "production-vnet"
  resource_group_name = "production-network-rg"
}

# Create a new subnet within the existing VNet
resource "azurerm_subnet" "new_app_subnet" {
  name                 = "new-app-subnet"
  resource_group_name  = data.azurerm_virtual_network.existing_vnet.resource_group_name
  virtual_network_name = data.azurerm_virtual_network.existing_vnet.name
  address_prefixes     = ["10.0.3.0/24"]
}

Exemple : Création dynamique de plusieurs VM à l'aide de for_each et d'une variable map :

variable "vm_configs" {
  type = map(object({
    size = string
    ip   = string
  }))
  default = {
    "web-server-01" = { size = "Standard_B1s", ip = "10.0.1.10" },
    "web-server-02" = { size = "Standard_B1s", ip = "10.0.1.11" }
  }
}

resource "azurerm_linux_virtual_machine" "web_servers" {
  for_each              = var.vm_configs
  name                  = each.key
  location              = azurerm_resource_group.main_rg.location
  resource_group_name   = azurerm_resource_group.main_rg.name
  size                  = each.value.size
  admin_username        = "azureuser"
  admin_password        = "StrongPassword!123" # Use Key Vault in production
  network_interface_ids = [azurerm_network_interface.web_servers_nic[each.key].id]

  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }

  source_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "18.04-LTS"
    version   = "latest"
  }
}

resource "azurerm_network_interface" "web_servers_nic" {
  for_each            = var.vm_configs
  name                = "${each.key}-nic"
  location            = azurerm_resource_group.main_rg.location
  resource_group_name = azurerm_resource_group.main_rg.name

  ip_configuration {
    name                          = "internal"
    subnet_id                     = azurerm_subnet.web_subnet.id
    private_ip_address_allocation = "Static"
    private_ip_address            = each.value.ip
  }
}

La politique en tant que code avec Sentinel

Pour les organisations exigeant une conformité et une gouvernance strictes, HashiCorp Sentinel fournit un cadre de politique en tant que code qui s'intègre à Terraform Enterprise (ou peut être adapté pour une utilisation personnalisée avec Terraform Cloud). 

Sentinel vous permet de définir des politiques granulaires qui appliquent les meilleures pratiques en matière de sécurité, de coûts et d'exploitation. avant avant que l'infrastructure ne soit approvisionnée.

Par exemple, une politique peut empêcher la création de machines virtuelles dépassant une certaine taille ou s'assurer que toutes les ressources ont des étiquettes spécifiques. Les politiques prédéfinies peuvent renforcer les normes de conformité, empêchant ainsi les déploiements non conformes d'atteindre votre environnement Azure.

Stratégies d'optimisation des coûts

Terraform, en conjonction avec Azure Policy, peut être un outil puissant pour appliquer des contrôles de coûts dans votre environnement Azure. 

En définissant des politiques Azure qui limitent les UGS de ressources, appliquent le marquage pour la répartition des coûts ou empêchent le déploiement de ressources coûteuses, vous pouvez mettre en œuvre des mesures efficaces de réduction des coûts directement dans vos flux de travail IaC. 

Terraform peut également déployer et gérer les politiques Azure, garantissant que vos règles de gouvernance sont contrôlées par version et appliquées de manière cohérente.

Exemple : Déployer une définition de politique Azure avec Terraform :

resource "azurerm_resource_group" "policy_rg" {
  name     = "azure-policy-rg"
  location = "global" # Policies are global resources
}

resource "azurerm_policy_definition" "deny_large_vms" {
  name         = "deny-large-vm-skus"
  policy_type  = "Custom"
  mode         = "All"
  display_name = "Deny creation of large VM SKUs (E-series)"
  description  = "This policy denies the creation of Azure Virtual Machines with SKUs from the E-series for cost management."

  policy_rule = <<POLICY_RULE
{
  "if": {
    "allOf": [
      {
        "field": "type",
        "equals": "Microsoft.Compute/virtualMachines"
      },
      {
        "field": "Microsoft.Compute/virtualMachines/sku.name",
        "like": "Standard_E*"
      }
    ]
  },
  "then": {
    "effect": "deny"
  }
}
POLICY_RULE
}

resource "azurerm_policy_assignment" "deny_large_vms_assignment" {
  name                 = "deny-large-vm-skus-assignment"
  scope                = "/subscriptions/${data.azurerm_subscription.current.id}" # Assign to entire subscription
  policy_definition_id = azurerm_policy_definition.deny_large_vms.id
  display_name         = "Deny large VM SKUs"
}

data "azurerm_subscription" "current" {}

Cette combinaison vous permet d'appliquer automatiquement les politiques de coûts de l'organisation, d'éviter les dépenses excessives et de promouvoir l'efficacité des ressources.

Intégration CI/CD

Cette section se concentre sur l'intégration de Terraform dans vos pipelines d'intégration continue/de livraison continue (CI/CD) pour des déploiements automatisés et fiables, faisant des changements d'infrastructure une partie intégrante du cycle de vie de votre développement logiciel.

Azure DevOps pipelines

Azure DevOps fournit une plateforme robuste pour construire des pipelines CI/CD. Un flux de travail courant comprend

1. Initialiser : terraform init pour télécharger les fournisseurs et configurer le backend.
2. Plan : terraform plan -out pour générer un plan d'exécution et le sauvegarder.
3. Révision (approbation manuelle) : Étape au cours de laquelle le plan généré est examiné par une personne pour approbation avant d'être appliqué.
4. Appliquer : terraform apply tfplan pour exécuter les modifications.

Vous pouvez découvrir comment Azure DevOps prend en charge les flux de travail CI/CD de bout en bout pour le déploiement d'applications dans ce tutoriel pratique.

Actions GitHub

GitHub Actions offre un moyen flexible et puissant d'automatiser vos flux de travail Terraform directement dans vos dépôts GitHub. Il utilise des fichiers YAML pour définir des flux de travail qui répondent à des événements tels que des requêtes "push" ou "pull".

Voici les étapes d'un déploiement Terraform de base à l'aide des actions GitHub :

1. Définir le déclencheur du flux de travail : Généralement, on: push renvoie à une branche spécifique (par exemple, main).
2. Code de paiement : Utilisez actions/checkout@v3.
3. Configurez les informations d'identification Azure : Configurez les variables d'environnement en utilisant les secrets GitHub (par exemple, AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_TENANT_ID, AZURE_SUBSCRIPTION_ID).
4. Installez Terraform : Utilisez hashicorp/setup-terraform@v2.
5. Terraform init : Initialiser le répertoire de travail.
6. Plan Terraform : Créez et éditez le plan d'exécution.
7. Terraform s'applique (conditionnel) : Appliquer les modifications, souvent sous réserve d'une étape d'approbation manuelle ou d'une branche spécifique.

Exemple : YAML pour un workflow d'actions GitHub (.github/workflows/terraform-azure.yml) :

name: 'Terraform Azure CI/CD'

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

env:
  ARM_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
  ARM_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
  ARM_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
  ARM_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
  TF_STATE_RG: 'my-terraform-state-rg'
  TF_STATE_SA: 'mystorageterraformstate'
  TF_STATE_CONTAINER: 'tfstate'
  TF_STATE_KEY: 'production/terraform.tfstate'

jobs:
  terraform:
    name: 'Terraform Actions'
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: './terraform' # Assuming Terraform files are in a 'terraform' folder

    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v2
      - name: Terraform Init
        id: init
        run: terraform init -backend-config="resource_group_name=${{ env.TF_STATE_RG }}" -backend-config="storage_account_name=${{ env.TF_STATE_SA }}" -backend-config="container_name=${{ env.TF_STATE_CONTAINER }}" -backend-config="key=${{ env.TF_STATE_KEY }}"
      - name: Terraform Plan
        id: plan
        run: terraform plan -no-color
      - name: Terraform Apply
        if: github.ref == 'refs/heads/main' && github.event_name == 'push'
        run: terraform apply -auto-approve

Sécurité et conformité

Cette section met l'accent sur les considérations de sécurité et de conformité lorsque vous travaillez avec Terraform sur Azure, en insistant sur les pratiques sécurisées pour les données sensibles et l'accès au réseau.

Intégration de Azure Key Vault

La gestion de données sensibles telles que les clés d'API, les chaînes de connexion, les identifiants de base de données et les certificats dans vos configurations Terraform peut être risquée si elle n'est pas gérée correctement. Azure Key Vault offre une solution sécurisée et centralisée pour le stockage et la gestion des secrets, des clés et des certificats. 

Exemple : Récupération du mot de passe d'une base de données à partir de Key Vault :

# Data source to retrieve an existing Azure Key Vault
data "azurerm_key_vault" "my_key_vault" {
  name                = "my-secure-keyvault"
  resource_group_name = "my-secrets-rg"
}

# Data source to retrieve a specific secret from the Key Vault
data "azurerm_key_vault_secret" "db_password" {
  name         = "DbPassword"
  key_vault_id = data.azurerm_key_vault.my_key_vault.id
}

resource "azurerm_sql_server" "example" {
  administrator_login          = "sqladmin"
  administrator_login_password = data.azurerm_key_vault_secret.db_password.value # Securely retrieve password
}

Cette méthode garantit que les données sensibles ne sont jamais exposées directement dans votre code Terraform ou votre fichier d'état, conformément aux meilleures pratiques en matière de sécurité.

Groupes de sécurité des réseaux (GSN)

Les groupes de sécurité réseau (NSG) sont essentiels pour appliquer les règles de trafic et sécuriser vos réseaux virtuels Azure. Ils agissent comme un pare-feu virtuel, autorisant ou refusant le trafic réseau entrant et sortant vers vos ressources Azure en fonction des règles que vous définissez.

Exemple : Configuration d'une NSG pour une application web :

resource "azurerm_network_security_group" "web_nsg" {
  name                = "web-nsg"
  location            = azurerm_resource_group.network_rg.location
  resource_group_name = azurerm_resource_group.network_rg.name

  security_rule {
    name                       = "AllowHTTPInbound"
    priority                   = 100
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "80"
    source_address_prefix      = "Internet"
    destination_address_prefix = "*"
  }
  security_rule {
    name                       = "AllowSSHInbound"
    priority                   = 120
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "22"
    source_address_prefix      = "YourTrustedIPRange" # IMPORTANT: Restrict to known IPs
    destination_address_prefix = "*"
  }
}

# Associate NSG with a subnet 
resource "azurerm_subnet_network_security_group_association" "web_subnet_nsg_association" {
  subnet_id                 = azurerm_subnet.web_subnet.id
  network_security_group_id = azurerm_network_security_group.web_nsg.id
}

Meilleures pratiques pour les déploiements en entreprise

Cette section présente les meilleures pratiques essentielles pour déployer et gérer Terraform à grande échelle dans un environnement d'entreprise, en se concentrant sur la conception, la maintenance et la surveillance.

Architectures de référence

Pour des déploiements Azure robustes et efficaces, alignez vos configurations Terraformsur le cadre Azure bien architecturé. Cecadre fournit des plans directeurs pour concevoir des solutions cloud de haute qualité, sécurisées et rentables, en guidant vos conceptions Terraform pour la fiabilité, la sécurité, l'optimisation des coûts, l'excellence opérationnelle et l'efficacité des performances.

Hygiène des fichiers de l'État

Le fichier d'état Terraform est la seule source de vérité de votre infrastructure. Assurer son intégrité et sa sécurité en :

• Stockage à distance : Utilisez toujours un backend distant comme Azure Blob Storage pour la gestion collaborative des états.
• Chiffrement et contrôle d'accès : Vérifiez que votre état distant est crypté au repos et appliquez un système Azure RBAC strict pour limiter l'accès.
• Verrouillage de l'état et versionnement : Exploitez le verrouillage d'état intégré pour éviter les conflits et activez le versionnage sur votre conteneur de stockage pour le suivi et la récupération de l'historique.

Surveillance et détection des dérives

Maintenez la cohérence de l'infrastructure en surveillant activement la "dérive de la configuration", c'est-à-dire les écarts non autorisés par rapport à l'état défini par Terraform.

• Détection proactive : Mettez en œuvre des exécutions terraform plan régulières dans vos pipelines CI/CD (par exemple, tous les soirs) pour identifier les changements.
• Surveillance Azure : Utilisez Azure Monitor et Log Analytics pour suivre l'état de santé des ressources et les événements.
• Remédiation automatisée : Développez des processus (manuels ou automatisés) pour réexécuter le site terraform apply afin de remettre les ressources dérivées en conformité avec votre IaC.

Pour mieux surveiller et optimiser votre infrastructure, Azure Monitor fournit des informations précieuses. Ceguide vous explique comment commencer.

Conclusion

Et c'est tout ! Vous avez maintenant vu comment Terraform peut rendre la gestion des ressources Azure beaucoup plus efficace et prévisible. Nous avons examiné comment introduire l'automatisation dans votre flux de travail avec des outils CI/CD comme Azure DevOps et GitHub Actions, et comment assurer la sécurité à l'aide de fonctionnalités comme Azure Key Vault et Network Security Groups.

Nous avons également abordé quelques bonnes pratiques importantes, comme l'utilisation d'architectures de référence, la gestion minutieuse de vos fichiers d'état et le suivi des changements grâce à la surveillance et à la détection des dérives.

Grâce à ces outils et à ces conseils, vous êtes sur la bonne voie pour mettre en place une infrastructure plus fiable et plus évolutive sur Azure.

Vous souhaitez valider vos compétences ? Ces questions d'entretien sur Terraform peuvent vous aider à vous préparer à des opportunités d'emploi ou à des certifications !