Concepts Fondamentaux

provider "aws" {
  region = "eu-west-1"
}

resource "aws_instance" "mon_serveur" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

module "vpc" {
  source = "terraform-aws-modules/vpc/aws"
  version = "3.0.0"
  # ... paramètres ...
}

terraform {
  backend "s3" {
    bucket = "mon-bucket-tfstate"
    key    = "prod/terraform.tfstate"
    region = "eu-west-1"
  }
}

Pourquoi utiliser des modules ?

Les modules permettent de :

• Réutiliser des configurations (ex: un VPC standardisé).
• Simplifier la maintenance (modifier un module = mise à jour partout).
• Partager des architectures entre équipes (via un registry public ou privé).

Blocs Principaux

provider "aws" {
  region = "eu-west-1"
  profile = "mon-profil"
}

resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

variable "instance_type" {
  description = "Type d'instance EC2"
  type        = string
  default     = "t2.micro"
}

output "instance_ip" {
  value = aws_instance.web.public_ip
}

locals {
  instance_name = "mon-serveur-${terraform.workspace}"
}

Utilisation Avancée

resource "aws_instance" "web" {
  count         = 3
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
  tags = {
    Name = "web-server-${count.index}"
  }
}

variable "users" {
  type = map(string)
  default = {
    alice = "admin"
    bob   = "user"
  }
}

resource "aws_iam_user" "example" {
  for_each = var.users
  name     = each.key
  tags = {
    Role = each.value
  }
}

resource "aws_instance" "web" {
  depends_on = [aws_db_instance.mon_db]
  # ...
}

resource "aws_instance" "web" {
  lifecycle {
    ignore_changes = [tags]
    prevent_destroy = true
  }
}

Intégration Continue

Pour automatiser le déploiement de ton infrastructure, tu peux intégrer Terraform dans un pipeline CI/CD (GitHub Actions, GitLab CI, etc.).

# Exemple de pipeline GitHub Actions pour Terraform
name: Terraform CI

on:
  push:
    branches: [ main ]
  pull_request:

jobs:
  terraform:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v2

      - name: Terraform Init
        run: terraform init

      - name: Terraform Validate
        run: terraform validate

      - name: Terraform Plan
        run: terraform plan -no-color

      - name: Terraform Apply (Auto-merge only)
        if: github.event_name == 'push'
        run: terraform apply -auto-approve

Éviter les Dérives (Drift)

# Exemple de politique IAM pour protéger une instance EC2
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Deny",
      "Action": [
        "ec2:TerminateInstances",
        "ec2:StopInstances",
        "ec2:ModifyInstanceAttribute"
      ],
      "Resource": "arn:aws:ec2:*:*:instance/*",
      "Condition": {
        "StringNotLike": {
          "aws:RequestTag/Terraform": "true"
        }
      }
    }
  ]
}

Scénario

Problème : Tu as créé une instance EC2 manuellement dans la console AWS, mais elle n'est pas déclarée dans ton code Terraform. terraform plan ne détecte pas cette ressource → dérive !

Outils Disponibles

Terraform fournit des commandes pour inspecter et modifier l'état (tfstate). À utiliser avec prudence !

# Affiche l'état actuel au format lisible
terraform show

# Liste toutes les ressources dans l'état
terraform state list

# Affiche les détails d'une ressource spécifique
terraform state show aws_instance.mon_serveur

# Supprime une ressource de l'état (sans la détruire dans le cloud)
terraform state rm aws_instance.mon_serveur

# Déplace une ressource dans l'état (ex: renommage)
terraform state mv aws_instance.ancien_nom aws_instance.nouveau_nom

# Remplace un provider dans l'état (ex: mise à jour de version)
terraform state replace-provider registry.terraform.io/hashicorp/aws registry.terraform.io/hashicorp/aws/4.0.0

Documentation Officielle

Dans la documentation de chaque ressource (ex: aws_instance), les attributs sont classés en 3 catégories :

resource "aws_instance" "web" {
  # Required
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"

  # Optional
  tags = {
    Name = "mon-serveur"
  }

  # Computed (read-only, définis automatiquement par AWS)
  # public_ip = "54.123.45.67"  # ❌ Ne pas définir manuellement !
}

# Pour utiliser un attribut computed :
output "instance_public_ip" {
  value = aws_instance.web.public_ip  # ✅ OK : lecture seule
}

Contexte

Tu veux déployer un site web statique (portfolio) avec :

• Une image Docker basée sur Nginx (portfolio:1.3.0).
• Une infrastructure légère et économique.
• Un accès public via une IP ou un nom de domaine.

Besoin :

• Un VPC avec un sous-réseau public.
• Un IAM Role pour permettre à ECS d'accéder aux ressources AWS.
• Un service ECS (ou une instance EC2) pour héberger ton container.
• Un Load Balancer ou une IP publique pour exposer le site.

Problème : Changement d'IP Publique

Après un redémarrage de ton instance EC2 (sans Elastic IP ni Load Balancer), son IP publique change. Terraform détecte ce changement lors du prochain plan.

# Exemple de correction pour une IP publique changée
# 1. Vérifie le changement
terraform plan

# 2. Applique les changements (Terraform mettra à jour l'état automatiquement)
terraform apply

# Si la ressource a été recréée manuellement :
# 1. Supprime l'ancienne référence dans l'état
terraform state rm aws_instance.mon_ec2

# 2. Importe la nouvelle ressource
terraform import aws_instance.mon_ec2 i-0435a04ca22d472ee

# 3. Vérifie que tout est synchronisé
terraform plan