lumikha

4 min de lecture

Pipeline CI/CD IaC : GitHub Actions + Terraform de la PR au déploiement sécurisé

Authentification OIDC vers Azure sans secret, plan commenté en PR, apply automatique sur merge, gestion des environments GitHub pour les gates d'approbation.

Construire un pipeline CI/CD pour Terraform qui soit à la fois sécurisé (pas de secrets stockés dans GitHub), utile (plan visible avant merge), et robuste (apply contrôlé) demande quelques choix architecturaux précis. Voici une approche terrain qui fonctionne en production.

Architecture du pipeline#

Le pipeline se décompose en deux workflows distincts :

  1. PR workflow : déclenché sur chaque PR, exécute terraform plan et poste le résultat en commentaire sur la PR
  2. Deploy workflow : déclenché sur merge dans main, exécute terraform apply avec une gate d'approbation manuelle pour la production
Push PR → terraform fmt check → terraform validate → terraform plan → commentaire PR
Merge main → terraform apply (dev auto) → gate approbation → terraform apply (prod)

Schéma du pipeline Terraform : sur une pull request, fmt, validate et plan, puis commentaire PR mis à jour ; après le merge sur main, apply dev (environment: dev), approbation par les Required reviewers, puis apply prod (environment: prod) avec concurrency: terraform-prod. À droite, l'échange OIDC : le runner GitHub obtient un token OIDC (sub = repo:…:pull_request ou repo:…:environment:prod), Microsoft Entra ID le valide via la federated credential et rend un token d'accès Azure pour la subscription et le Storage du tfstate

Authentification OIDC vers Azure : plus de secrets#

L'approche classique stocke un Service Principal (client_id, client_secret, tenant_id, subscription_id) dans les secrets GitHub. C'est fonctionnel mais les secrets peuvent être compromis, doivent être renouvelés, et leur gestion est une surface d'attaque.

La fédération OIDC permet à GitHub Actions de s'authentifier directement auprès de Microsoft Entra ID (ex-Azure AD) sans aucun secret stocké. GitHub émet un token JWT pour le workflow, Entra ID le valide auprès de GitHub, et retourne un token d'accès Azure.

Configurer la Federated Credential Azure#

# Créer une App Registration (ou utiliser une Managed Identity)
APP_ID=$(az ad app create --display-name "github-terraform-ci" --query appId -o tsv)
OBJECT_ID=$(az ad app show --id $APP_ID --query id -o tsv)

# Créer la Federated Credential pour la PR (branches de feature)
az ad app federated-credential create \
  --id $OBJECT_ID \
  --parameters '{
    "name": "github-pr",
    "issuer": "https://token.actions.githubusercontent.com",
    "subject": "repo:mon-org/mon-repo:pull_request",
    "audiences": ["api://AzureADTokenExchange"]
  }'

# Créer les Federated Credentials pour le deploy : un job qui déclare
# `environment:` reçoit un token dont le subject est l'environment,
# pas la branche (repo:mon-org/mon-repo:environment:<nom>)
for ENV in dev prod; do
  az ad app federated-credential create \
    --id $OBJECT_ID \
    --parameters '{
      "name": "github-env-'"$ENV"'",
      "issuer": "https://token.actions.githubusercontent.com",
      "subject": "repo:mon-org/mon-repo:environment:'"$ENV"'",
      "audiences": ["api://AzureADTokenExchange"]
    }'
done

# Attribuer le rôle Contributor sur la subscription (ou scope plus fin)
az role assignment create \
  --assignee $APP_ID \
  --role Contributor \
  --scope /subscriptions/$SUBSCRIPTION_ID

Dans les secrets GitHub du repository (pas de credentials, uniquement des IDs) :

AZURE_CLIENT_ID: <APP_ID>
AZURE_TENANT_ID: <TENANT_ID>
AZURE_SUBSCRIPTION_ID: <SUBSCRIPTION_ID>

Workflow PR : plan commenté#

# .github/workflows/terraform-plan.yml
name: Terraform Plan

on:
  pull_request:
    branches: [main]
    paths:
      - 'infrastructure/**'

permissions:
  id-token: write      # Obligatoire pour OIDC
  contents: read
  pull-requests: write # Pour poster des commentaires

jobs:
  plan:
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: infrastructure/environments/prod

    steps:
      - uses: actions/checkout@v4

      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v3
        with:
          terraform_version: "~1.9"

      - name: Azure Login (OIDC)
        uses: azure/login@v2
        with:
          client-id: ${{ secrets.AZURE_CLIENT_ID }}
          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

      - name: Terraform Init
        run: terraform init

      - name: Terraform Format Check
        run: terraform fmt -check -recursive

      - name: Terraform Validate
        run: terraform validate

      - name: Terraform Plan
        id: plan
        run: |
          set -o pipefail   # sans ça, le code retour serait celui de tee et le plan ne serait jamais en échec
          terraform plan -no-color -out=tfplan 2>&1 | tee plan_output.txt
        continue-on-error: true  # On veut poster le commentaire même si plan échoue

      - name: Post Plan Comment
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const planOutput = fs.readFileSync('infrastructure/environments/prod/plan_output.txt', 'utf8');
            const status = '${{ steps.plan.outcome }}' === 'success' ? '✅' : '❌';

            const comment = `## Terraform Plan ${status}

            \`\`\`hcl
            ${planOutput.substring(0, 60000)}
            \`\`\`

            *Workflow: \`${{ github.workflow }}\` | Run: [${{ github.run_id }}](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})*`;

            // Chercher un commentaire existant pour le mettre à jour
            const { data: comments } = await github.rest.issues.listComments({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
            });
            const existingComment = comments.find(c => c.body.includes('## Terraform Plan'));

            if (existingComment) {
              await github.rest.issues.updateComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                comment_id: existingComment.id,
                body: comment
              });
            } else {
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: context.issue.number,
                body: comment
              });
            }

      - name: Fail if Plan Failed
        if: steps.plan.outcome == 'failure'
        run: exit 1

Workflow Deploy : apply avec gate#

# .github/workflows/terraform-apply.yml
name: Terraform Apply

on:
  push:
    branches: [main]
    paths:
      - 'infrastructure/**'

permissions:
  id-token: write
  contents: read

jobs:
  apply-dev:
    runs-on: ubuntu-latest
    environment: dev   # Pas de gate de validation manuelle pour dev
    defaults:
      run:
        working-directory: infrastructure/environments/dev
    steps:
      - uses: actions/checkout@v4
      - uses: hashicorp/setup-terraform@v3
        with:
          terraform_version: "~1.9"
      - uses: azure/login@v2
        with:
          client-id: ${{ secrets.AZURE_CLIENT_ID }}
          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID_DEV }}
      - run: terraform init
      - run: terraform apply -auto-approve

  apply-prod:
    runs-on: ubuntu-latest
    needs: apply-dev
    environment: prod   # Gate d'approbation manuelle configurée dans GitHub Settings
    defaults:
      run:
        working-directory: infrastructure/environments/prod
    steps:
      - uses: actions/checkout@v4
      - uses: hashicorp/setup-terraform@v3
        with:
          terraform_version: "~1.9"
      - uses: azure/login@v2
        with:
          client-id: ${{ secrets.AZURE_CLIENT_ID }}
          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID_PROD }}
      - run: terraform init
      - run: terraform apply -auto-approve

Configurer l'Environment GitHub avec gate d'approbation#

Dans GitHub → Settings → Environments → prod :

  • Required reviewers : ajouter les personnes ou équipes qui doivent approuver le déploiement en prod
  • Deployment branches : restreindre à main uniquement

Gestion du state Terraform#

Le state Terraform doit être stocké dans un backend distant partagé. Sur Azure, le backend Storage Account est le plus courant :

terraform {
  backend "azurerm" {
    resource_group_name  = "rg-tfstate"
    storage_account_name = "tfstatemonorg"
    container_name       = "tfstate"
    key                  = "prod.terraform.tfstate"
    use_azuread_auth     = true   # accès au blob par Entra ID (RBAC) plutôt que par clé du Storage Account
  }
}

Donner à l'App Registration les droits Storage Blob Data Contributor sur le container de state : avec use_azuread_auth = true, le backend s'authentifie avec la même identité OIDC au lieu de récupérer la clé du Storage Account.

Éviter les apply concurrents#

Sur un repository actif, deux merges rapprochés peuvent déclencher deux apply simultanés qui corrompent le state. GitHub Actions ne gère pas ça nativement — utiliser la concurrency option :

concurrency:
  group: terraform-prod
  cancel-in-progress: false   # false = attendre, pas annuler

Avec cancel-in-progress: false, le second workflow attend que le premier se termine avant de démarrer.

Piège : le plan de la PR n'est pas garanti#

Le plan exécuté sur la PR et l'apply exécuté sur merge peuvent produire des plans différents si d'autres changements ont été mergés entre temps. C'est inévitable sans verrouillage exclusif du repository. Pour minimiser le risque : garder des PRs courtes, utiliser des branches de feature à durée de vie courte, et activer le verrouillage de state Terraform (activé par défaut avec le backend azurerm).

← Tous les articles