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)

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 d'Azure AD sans aucun secret stocké. GitHub émet un token JWT pour le workflow, Azure AD 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 la Federated Credential pour le deploy (branche main)
az ad app federated-credential create \
  --id $OBJECT_ID \
  --parameters '{
    "name": "github-main",
    "issuer": "https://token.actions.githubusercontent.com",
    "subject": "repo:mon-org/mon-repo:ref:refs/heads/main",
    "audiences": ["api://AzureADTokenExchange"]
  }'

# 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: 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"
  }
}

Donner à l'App Registration les droits Storage Blob Data Contributor sur le container de state. L'accès OIDC s'applique aussi pour le backend.

É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 garantis#

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