Terraform : déployer son premier bucket S3 en 10 minutes

Créer un bucket S3 depuis la console AWS prend quelques clics. Mais le jour où il faut recréer la même chose dans un autre compte, pour un autre projet ou après une erreur, on ne se souvient plus des réglages. C’est exactement le problème que règle l’Infrastructure as Code : on décrit l’infrastructure dans des fichiers, et un outil la crée pour nous, toujours de la même façon.

Dans ce premier tutoriel Epsilon Cloud, nous allons utiliser Terraform pour créer un bucket Amazon S3 propre et sécurisé, le vérifier, puis le supprimer. Comptez une dizaine de minutes.

Ce que vous allez apprendre

  • Écrire un premier fichier Terraform (main.tf)
  • Comprendre le cycle init → plan → apply → destroy
  • Appliquer trois bonnes pratiques S3 : versioning, chiffrement et blocage de l’accès public

Prérequis

  • Un compte AWS. S3 coûte quasiment rien pour ce test, et l’offre gratuite le couvre généralement.
  • Un utilisateur IAM avec des droits sur S3. N’utilisez jamais les clés du compte root.
  • L’AWS CLI installée et configurée avec aws configure (clé d’accès, clé secrète, région, par exemple eu-west-3 pour Paris).
  • Terraform installé (version 1.5 ou plus). Vérifiez avec terraform -version.

Étape 1 : préparer le dossier du projet

mkdir terraform-s3-demo
cd terraform-s3-demo

Terraform lit tous les fichiers .tf du dossier courant. Un seul fichier main.tf suffit pour commencer.

Étape 2 : écrire le fichier main.tf

Créez le fichier main.tf et collez-y ce code :

terraform {
  required_version = ">= 1.5"

  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 6.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~> 3.0"
    }
  }
}

provider "aws" {
  region = "eu-west-3" # Paris
}

# Suffixe aléatoire : un nom de bucket doit être unique dans le monde entier
resource "random_id" "suffix" {
  byte_length = 4
}

resource "aws_s3_bucket" "demo" {
  bucket = "epsilon-cloud-demo-${random_id.suffix.hex}"

  tags = {
    Projet      = "epsilon-cloud"
    Environment = "demo"
    ManagedBy   = "terraform"
  }
}

# Bonne pratique 1 : garder l'historique des fichiers
resource "aws_s3_bucket_versioning" "demo" {
  bucket = aws_s3_bucket.demo.id

  versioning_configuration {
    status = "Enabled"
  }
}

# Bonne pratique 2 : chiffrer les données au repos
resource "aws_s3_bucket_server_side_encryption_configuration" "demo" {
  bucket = aws_s3_bucket.demo.id

  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm = "AES256"
    }
  }
}

# Bonne pratique 3 : interdire tout accès public
resource "aws_s3_bucket_public_access_block" "demo" {
  bucket = aws_s3_bucket.demo.id

  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

output "bucket_name" {
  value = aws_s3_bucket.demo.bucket
}

Ce qu’il faut retenir de ce code :

  • Le bloc terraform fixe les versions de Terraform et des providers (les plugins qui parlent à AWS).
  • Le bloc provider "aws" indique la région où créer les ressources.
  • Chaque bloc resource décrit un objet à créer. Les réglages du bucket (versioning, chiffrement, accès public) sont des ressources séparées qui pointent vers le bucket avec aws_s3_bucket.demo.id.
  • Le bloc output affiche le nom du bucket à la fin du déploiement.

Étape 3 : initialiser le projet

terraform init

Terraform télécharge les providers AWS et Random dans un dossier caché .terraform. Vous devez voir le message Terraform has been successfully initialized!

Profitez-en pour formater et vérifier votre code :

terraform fmt
terraform validate

Étape 4 : prévisualiser avec plan

terraform plan

Cette commande ne crée rien : elle montre ce que Terraform va faire. Le résumé doit annoncer Plan: 5 to add, 0 to change, 0 to destroy (le suffixe aléatoire, le bucket et ses trois réglages). Prenez l’habitude de toujours lire le plan avant d’appliquer : c’est votre filet de sécurité.

Étape 5 : déployer avec apply

terraform apply

Terraform réaffiche le plan et demande confirmation. Tapez yes. Après quelques secondes, vous obtenez le nom du bucket, par exemple bucket_name = "epsilon-cloud-demo-a1b2c3d4".

Terraform a aussi créé un fichier terraform.tfstate : c’est sa mémoire de ce qui existe réellement. Ne le modifiez jamais à la main, et ne le versionnez pas dans Git (il peut contenir des informations sensibles).

Étape 6 : vérifier que tout fonctionne

# Lister vos buckets
aws s3 ls

# Envoyer un fichier de test
echo "Bonjour Epsilon Cloud" > test.txt
aws s3 cp test.txt s3://$(terraform output -raw bucket_name)/

# Vérifier son contenu
aws s3 ls s3://$(terraform output -raw bucket_name)/

Dans la console AWS, ouvrez le bucket : l’onglet Propriétés affiche le versioning activé et le chiffrement SSE-S3, et l’onglet Autorisations confirme que tout accès public est bloqué.

Étape 7 : tout supprimer proprement

Un bucket qui contient des fichiers ne peut pas être supprimé. Et comme le versioning est activé, il faut aussi supprimer les anciennes versions. Le plus simple pour ce test est de vider le bucket depuis la console AWS (bouton Vider), puis de lancer :

terraform destroy

Tapez yes : les 5 ressources sont supprimées. Votre compte AWS revient exactement à son état de départ, et c’est toute la force de Terraform.

Astuce : pour un environnement de test que vous créez et supprimez souvent, vous pouvez ajouter force_destroy = true dans la ressource aws_s3_bucket. Terraform videra alors le bucket lui-même au moment du destroy. À éviter en production : une seule commande effacerait toutes vos données.

Les erreurs les plus fréquentes

  • BucketAlreadyExists : le nom est déjà pris ailleurs dans le monde. Le suffixe aléatoire évite ce problème.
  • No valid credential sources found : l’AWS CLI n’est pas configurée. Relancez aws configure.
  • AccessDenied : votre utilisateur IAM n’a pas les droits sur S3. Vérifiez ses permissions.
  • BucketNotEmpty au moment du destroy : videz le bucket (versions comprises) ou utilisez force_destroy en test.

Et ensuite ?

Vous savez maintenant décrire, déployer et supprimer une ressource AWS avec Terraform. Les prochaines étapes naturelles : sortir les valeurs en dur dans des variables, stocker le fichier d’état dans un backend distant (un bucket S3 justement), puis automatiser le tout dans un pipeline CI/CD. Ce seront les sujets des prochains articles d’Epsilon Cloud.

Une question ou un blocage pendant le tutoriel ? Écrivez-moi depuis la page Contact.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *