Meta description : Claude Code + Terraform : agent terminal IaC, CLAUDE.md, fmt/validate/plan, lab AWS S3 à 0 €, never-apply sans validation humaine — guide FR DevOps 2026.

À la fin de ce tutoriel, vous saurez piloter Claude Code sur un dépôt Terraform : pourquoi l’IaC se prête aux agents, installer la stack lab, scaffolder un repo AWS minimal, écrire un CLAUDE.md non négociable, enchaîner des prompts P0 (générer, refactor for_each, expliquer un plan, review sécu), appliquer edit → fmt → validate → plan → revue humaine, et éviter secrets, prompt injection et always-allow sur apply.

Niveau : Intermédiaire · Temps estimé : 55–75 min · Versions cibles : Claude Code récent · Terraform ≥ 1.9 (ex. 1.16.x) · AWS provider ~> 5.0 · AWS CLI v2 · Dernière vérification : 2026-09-11

Slug : claude-code-terraform · Série : IA Outils 2026 (pont → parcours Terraform) · P0 : Claude Code sur IaC · Pages sœurs : claude-code-demarrer, claude-code-claude-md, claude-code-slash-commands, claude-code-mcp, codex-vs-claude-code, installer-terraform, terraform-workflow

← Démarrer Claude Code · CLAUDE.md · → Installer Terraform · Workflow · Hub : IA parcours DevOps 2026

Statut : densifié P0 — prêt publication Tutoriels

Prérequis

• [ ] Claude Code : démarrer — CLI claude OK (Pro / Max / Team ; ~20 $/mois Pro — vérifier pricing vendor)
• [ ] Notions CLAUDE.md et slash commands
• [ ] Installer Terraform : binaire ≥ 1.9 ; Overview + Workflow
• [ ] AWS CLI v2 + profil lab (aws sts get-caller-identity) — Region ex. eu-west-3
• [ ] Terminal macOS / Linux / WSL ; Git de lab sans secrets
• [ ] Coût : tokens Claude + 0 € AWS en plan only ; bucket lab ≈ Free Tier si apply puis destroy

Pont P0 IA Outils 2026 → Terraform : l’agent écrit/explique le HCL ; vous restez responsable du state et de l’apply.

Ce que nous allons construire

Lab Claude Code × Terraform (P0 IaC)
  ├── Stack : claude + terraform ≥ 1.9 + AWS CLI profil lab
  ├── Repo ~/lab-claude-tf
  │     ├── versions.tf / providers.tf / main.tf / variables.tf / outputs.tf
  │     ├── CLAUDE.md (règles non négociables)
  │     └── .gitignore (state, .terraform/, tfvars secrets)
  ├── Session : générer · for_each · expliquer plan · review sécu
  ├── Workflow : edit → fmt → validate → plan → revue humaine
  └── Patterns : modules, envs, remote state S3, MCP optionnel + sécurité

(Schéma — alt : « Claude Code édite le HCL, lance fmt/validate/plan ; apply réservé à l’humain ».)

Étape 1 — Pourquoi Claude Code + Terraform

Terraform produit des diffs (plan) et un state cloud. Un agent terminal sur .tf est puissant si le risque est cadré.

Propriété IaC	Opportunité agent	Risque si mal cadré
HCL versionné	Génération, refactor, revue PR	Diffs énormes non reviewables
terraform plan	Explication + détection d’écarts	Confondre plan et apply
State local / remote	Lire outputs / diagnostic	Fuite de secrets via le state
Providers cloud	Scaffold AWS rapide	apply prod, coûts, blast radius

Angle DEH 2026 : Claude Code = junior IaC rapide. Vous restez senior : lire le plan, refuser l’apply silencieux, zéro clé dans le HCL — Codex vs Claude Code.

Étape 2 — Install express et vérifs lab

# Claude Code — doc : code.claude.com
curl -fsSL https://claude.ai/install.sh | bash
claude --version

# Terraform ≥ 1.9 (détail : /installer-terraform/)
terraform version

export AWS_PROFILE=lab
aws sts get-caller-identity

Attendu : claude OK, Terraform 1.9+, identité lab. Sans apply → 0 € cloud.

Étape 3 — Scaffold du repo lab

mkdir -p ~/lab-claude-tf && cd ~/lab-claude-tf && git init

.gitignore :

.terraform/
*.tfstate
*.tfstate.*
crash.log
override.tf
*_override.tf
*.tfvars
!example.tfvars
.claude/settings.local.json

versions.tf :

terraform {
  required_version = ">= 1.9.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

providers.tf :

provider "aws" {
  region = var.aws_region
  # Auth : AWS_PROFILE / SSO / env — jamais access_key dans le HCL
  default_tags {
    tags = {
      ManagedBy = "terraform"
      Project   = var.project_name
    }
  }
}

variables.tf :

variable "aws_region" {
  type        = string
  description = "Region AWS du lab"
  default     = "eu-west-3"
}

variable "project_name" {
  type        = string
  description = "Tag Project + préfixe noms"
  default     = "lab-claude-tf"
}

variable "bucket_suffix" {
  type        = string
  description = "Suffixe unique pour le nom S3 global"
}

main.tf — option A (0 €) data sources only :

data "aws_caller_identity" "current" {}
data "aws_region" "current" {}

Option B — bucket privé (apply optionnel, destroy obligatoire) :

resource "aws_s3_bucket" "lab" {
  bucket = "${var.project_name}-${var.bucket_suffix}"
}

resource "aws_s3_bucket_public_access_block" "lab" {
  bucket                  = aws_s3_bucket.lab.id
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

outputs.tf : account_id / region depuis les data sources ; si option B, ajoutez bucket_name.

terraform init && terraform fmt -check && terraform validate && terraform plan

Succès : AWS 5.x, validate OK, plan lisible. Pas d’apply sans décision explicite.

Étape 4 — CLAUDE.md dédié Terraform

À la racine (méthode : CLAUDE.md) :

# Lab Terraform — consignes agent

## Stack
- Terraform ≥ 1.9, provider hashicorp/aws ~> 5.0
- Region via `var.aws_region` ; tags ManagedBy=terraform, Project=…
- Auth AWS : profil / env / SSO uniquement

## Autorisé par défaut
- terraform fmt / fmt -check, validate, plan (-out=tfplan), init si besoin

## Interdits (non négociables)
- Jamais terraform apply / destroy sans demande explicite humaine du tour courant
- Jamais secrets, access keys, tokens dans .tf / tfvars commités / logs
- Pas de provisioner local-exec / remote-exec dangereux
- Pas d’always-allow sur apply ; pas de modif backend/state sans revue
- Branches lab/* ou feature/* — pas de push main

## Style & revue
- fmt avant « terminé » ; préférer for_each et modules
- Après édition : fmt → validate → plan ; résumer +/−/~ en français

cd ~/lab-claude-tf && claude

/init si le fichier manque ; sinon chargez ces règles courtes et vérifiables.

Étape 5 — Session : prompts P0

Générer un module

Crée modules/s3_private (main/variables/outputs) : bucket + public_access_block.
Root : for_each sur var.buckets (map). Pas d’apply. Lance fmt + validate + plan.

Refactor for_each

Refactor main.tf : for_each sur var.buckets, mêmes default_tags. Montre le diff puis plan.

Expliquer un plan

Voici la sortie terraform plan (colle). Résume en FR : +/−/~ , risques coût/sécu, checks avant apply.

Review sécurité

Review HCL : ACL publiques, policies larges, secrets, provisioners, backend.
Findings P0/P1 + correctifs. Aucun apply.

Pilotez via slash commands ; MCP optionnel : Claude Code MCP.

Étape 6 — Workflow sûr

Étape	Qui	Action
Edit	Agent + vous	Diffs HCL sur branche lab
Format / validate	Agent ou vous	terraform fmt puis validate
Plan	Agent ou vous	terraform plan -out=tfplan
Revue	Humain	+/−/~ , IAM, coût, tags
Apply / destroy	Humain (lab)	apply tfplan puis destroy en fin

L’agent accélère ; il n’approuve pas l’apply. En CI : artifact tfplan + apply reviewé (workflow, backend S3).

Étape 7 — Patterns 2026

• Modules typés — Modules bases
• Variables / outputs + validation — Variables
• Envs : dossiers envs/dev|prod (ou workspaces)
• Remote state : l’agent propose le backend ; vous validez — State backend S3
• Boucles — for_each
• MCP docs registry/AWS pour limiter les hallucinations d’arguments

Prompt type : « Propose envs/dev + module partagé, sans toucher au backend ; example.tfvars sans secrets. »

Étape 8 — Sécurité

Risque	Contrôle
Secrets dans le HCL	Profil/SSO ; SSM/Secrets Manager ; .tfvars gitignorés
State sensible	Backend chiffré ; jamais commit *.tfstate
Prompt injection (README/module tiers)	Dépôts trustés ; Prompt injection
Always-allow apply / shell	Permissions strictes ; confirmation à chaque apply
Blast radius	Compte/profil lab + budget AWS

Traitez l’agent comme un collègue shell : least privilege, revue humaine. P0 : never-apply sans OK humain, secrets hors Git/chat, backend remote seulement après revue, compte lab isolé pour tout apply/destroy.

Critères de décision (Claude Code × Terraform)

Validez à l’écrit avant session :

1. Périmètre lab : profil AWS lab uniquement ; pas de state prod ni backend CI métier.
2. Never-apply : CLAUDE.md interdit apply/destroy sans OK humain du tour ; pas d’always-allow.
3. Secrets hors HCL : AWS_PROFILE / SSO / OIDC ; jamais de clés dans .tf, tfvars commités ou chat.
4. Gates : fmt → validate → plan lisible (+ TFLint/Checkov advisory en PR).
5. Blast radius : tags Project/Env/ManagedBy, Region explicite, budget alert AWS.
6. Alternative IDE : Copilot pour un fichier ponctuel — Copilot IaC, Codex vs Claude Code.

Si un critère échoue, ne lancez pas l’agent : corrigez d’abord.

Checklist lab (45–60 min)

• [ ] claude --version + terraform version (≥ 1.9) + aws sts get-caller-identity (profil lab)
• [ ] Repo avec .gitignore (state, .terraform/, *.tfvars) + CLAUDE.md never-apply
• [ ] Option A (0 €) : init → fmt → validate → plan sans apply
• [ ] Prompts P0 : générer module → expliquer plan → review sécu (pins ~> 5.0, pas de secrets)
• [ ] Option B : apply humain puis destroy en fin ; commits sur lab/* seulement

Erreurs fréquentes

Symptôme	Cause	Correctif
Agent lance apply	CLAUDE.md flou / always-allow	Interdit explicite + OK humain par apply
No valid credential sources	AWS_PROFILE absent du shell agent	Exporter le profil avant claude
Plan destroy inattendu	Rename / clé for_each changée	state mv ou revue avant apply
Secrets dans le diff	tfvars / outputs sensibles	Gitignore ; masquer ; rotation si fuite
fmt -check rouge	fmt oublié	Règle CLAUDE.md + pre-commit
Argument provider inventé	Modèle hors doc	Extrait registry / MCP ; pin ~> 5.0
State conflit multi-postes	Pas de backend remote	Backend S3 après le solo
Apply « silencieux »	Confirmation contournée	Permissions strictes ; relire chaque commande
Diff PR illisible	Trop de fichiers d’un coup	Borner le prompt ; commits atomiques

FAQ

Claude Code remplace-t-il un ingénieur Terraform ?
Non. Il accélère scaffold, refactors et explications. State, IAM et apply restent humains.

Autoriser terraform apply en always-allow ?
Non. Chaque apply = approbation humaine. Interdit dans CLAUDE.md ; pas de permissions shell trop larges.

CLAUDE.md racine ou par module ?
Racine pour never-apply, pins, Region ; notes courtes par module si besoin — CLAUDE.md.

Plan only suffit-il ?
Oui. Data sources = 0 €. Bucket + destroy une fois le plan OK (workflow).

Codex ou Claude Code pour Terraform ?
Les deux. Claude Code : terminal + CLAUDE.md ; Codex : batch sandbox — comparatif.

Secrets hors contexte agent ?
Exporter AWS_PROFILE avant claude ; gitignorer *.tfvars / *.tfstate ; jamais coller de clés. En CI : OIDC AWS.

Plan avec destroys inattendus ?
Stop. Faire expliquer le diff (rename, for_each, drift) ; state mv seulement après revue humaine.

Quiz (5 questions)

1. Rôle de Claude Code sur Terraform ?
– A. Remplacer plan, review et apply
– B. Accélérer HCL ; apply réservé à l’humain
– C. Apply auto en prod

2. Non négociable dans CLAUDE.md lab ?
– A. Always-allow sur apply
– B. Interdit apply/destroy sans OK humain ; pas de secrets dans le HCL
– C. Clés AWS en dur

3. Workflow sûr après édition agent ?
– A. apply puis plan
– B. fmt → validate → plan → revue → apply (lab)
– C. destroy avant chaque plan

4. Auth AWS pour le lab agent ?
– A. Access key dans providers.tf
– B. Profil / SSO (AWS_PROFILE=lab) avant la session
– C. Committer des secrets en .tfvars

5. Face à un plan destroy massif ?
– A. apply -auto-approve
– B. Stop, expliquer le diff, corriger / state mv après revue
– C. Supprimer le bucket state

Réponses : 1‑B · 2‑B · 3‑B · 4‑B · 5‑B

Pour aller plus loin / Suite du parcours

1. Claude Code démarrer · CLAUDE.md · Slash commands · MCP
2. Installer Terraform · Workflow · Variables · Modules · Backend S3
3. Prompt injection · Copilot IaC · OpenTofu vs Terraform · IA parcours 2026

Maillage IA Outils 2026 ↔ Terraform

← Précédent	Démarrer Claude Code · CLAUDE.md
→ Terraform	Installer · Workflow
Latéral	Copilot IaC · Codex vs Claude Code · OIDC AWS
Hub	IA parcours 2026 · Terraform

# Si apply option B : destroy puis éventuellement supprimer le repo
cd ~/lab-claude-tf && terraform destroy

---

Sources vérifiées (2026-09-11) : docs Claude Code (code.claude.com), install claude.ai/install.sh, HashiCorp Terraform (developer.hashicorp.com/terraform), provider AWS 5.x (registry.terraform.io/providers/hashicorp/aws). Pricing Claude Pro ~20 $/mois — revalider vendors. Pas de clés en clair (placeholders sk-ant-… hors CLI seulement).

Meta publication (Rank Math / SEO) — HOLD

• Title SEO : Claude Code + Terraform : agent terminal pour l’IaC (lab 2026)
• Meta description (≤ 160) : Claude Code + Terraform : agent terminal IaC, CLAUDE.md, fmt/validate/plan, lab AWS S3 à 0 €, never-apply sans validation humaine — guide FR DevOps 2026.
• Focus keyphrase : Claude Code Terraform
• KW secondaires : CLAUDE.md Terraform, terraform plan agent, IaC AI 2026, fmt validate plan
• URL cible : https://devopelastichayway.com/tutoriels/claude-code-terraform/
• Schemas : Article + HowTo + FAQ
• Cover : assets/web/devopelastichayway/cover-claude-code-terraform-1200x630.webp
• Catégorie : IA · Série : IA Outils 2026 · Pont : Terraform
• Slug : claude-code-terraform
• Statut : densifié P0 — publish page Tutoriels parent 5463