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.
Sommaire
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 :
- PR workflow : déclenché sur chaque PR, exécute
terraform planet poste le résultat en commentaire sur la PR - Deploy workflow : déclenché sur merge dans
main, exécuteterraform applyavec 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 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 à
mainuniquement
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).