Terraform AWS — Launch template et autoscaling group

Une EC2 seule reste un bon exercice, mais ce n’est pas encore un service résilient. Dès que vous devez conserver plusieurs instances disponibles, absorber une variation de charge ou remplacer progressivement une version applicative, vous avez besoin d’un niveau d’abstraction supplémentaire. Dans AWS, ce duo s’appelle launch template plus autoscaling group.

L’idée à retenir avant même d’écrire le code est simple : le launch template décrit à quoi doit ressembler une instance, tandis que l’ASG décide combien d’instances doivent exister en permanence. Ce guide relie explicitement ces deux rôles pour éviter l’impression de manipuler deux objets AWS sans rapport.

Ce que vous allez apprendre

Créer un launch template avec AMI, type d’instance et tags
Créer un ASG avec min/max/desired capacity
Utiliser instance_refresh pour mettre à jour les instances sans interruption
Utiliser random_integer pour forcer les rolling updates
Vérifier les instances créées dans la console AWS

Pourquoi ces deux ressources vont ensemble

Beaucoup de débutants lisent aws_launch_template puis aws_autoscaling_group comme deux chapitres séparés. En réalité, l’un fournit le modèle, l’autre orchestre les copies de ce modèle. Sans template, l’ASG ne sait pas quoi lancer. Sans ASG, le template ne crée rien à lui seul.

Ce guide vous montre donc le couple complet, avec une idée pratique en tête : garder une capacité minimale et mettre à jour progressivement les instances lorsque le modèle change.

Prérequis

Terraform ≥ 1.11
AWS CLI configuré
Compréhension de variables, resources et outputs

Objectif

Construire une infrastructure auto-scalable :

Un launch template = modèle pour les instances
Un ASG qui maintient 2 instances (min=2, max=4)
Observation que l’ASG crée automatiquement les instances

Durée estimée : 15-20 minutes (création d’instances) Coût : Gratuit/quasi-gratuit (t2.micro dans tier gratuit)

Préparation

Créez le répertoire :

mkdir -p ~/terraform-aws-launch-template-asg
cd ~/terraform-aws-launch-template-asg

Étape 1 — Déclarer le provider

Créez versions.tf :

terraform {
  required_version = ">= 1.11.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~> 3.0"
    }
  }
}

provider "aws" {
  region = var.aws_region
}

Notez le provider random — nous l’utiliserons pour forcer les rolling updates.

Étape 2 — Déclarer les variables

Créez variables.tf :

variable "aws_region" {
  type    = string
  default = "us-east-1"
}

variable "instance_type" {
  type    = string
  default = "t2.micro"
}

variable "min_size" {
  type    = number
  default = 2
}

variable "max_size" {
  type    = number
  default = 4
}

variable "desired_capacity" {
  type    = number
  default = 2
}

Étape 3 — Créer le launch template

Créez main.tf :

# Lire l'AMI Ubuntu la plus récente
data "aws_ami" "ubuntu" {
  most_recent = true
  owners      = ["099720109477"]
  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*"]
  }
}

# Utiliser un random_integer pour forcer les rolling updates
resource "random_integer" "launch_template_version" {
  min = 1
  max = 1000
}

# Créer le launch template
resource "aws_launch_template" "lab05_template" {
  name_prefix   = "lab05-template-"
  image_id      = data.aws_ami.ubuntu.id
  instance_type = var.instance_type

  tag_specifications {
    resource_type = "instance"
    tags = {
      Name = "lab05-asg-instance"
    }
  }

  lifecycle {
    create_before_destroy = true
  }
}

Points clés :

name_prefix : génère un nom unique (ex : lab05-template-abc123)
tag_specifications : les instances héritent des tags
create_before_destroy : crée le nouveau template avant de supprimer l’ancien

Étape 4 — Créer l’autoscaling group

Toujours dans main.tf, ajoutez :

# Lire les subnets par défaut
data "aws_subnets" "default" {
  filter {
    name   = "default-for-az"
    values = ["true"]
  }
}

# Créer l'ASG
resource "aws_autoscaling_group" "lab05_asg" {
  name                = "lab05-asg-${random_integer.launch_template_version.result}"
  min_size            = var.min_size
  max_size            = var.max_size
  desired_capacity    = var.desired_capacity
  vpc_zone_identifier = data.aws_subnets.default.ids

  launch_template {
    id      = aws_launch_template.lab05_template.id
    version = "$Latest"
  }

  instance_refresh {
    strategy = "Rolling"
    preferences {
      min_healthy_percentage = 50
    }
  }

  lifecycle {
    create_before_destroy = true
  }

  tag {
    key                 = "Name"
    value               = "lab05-asg-instance"
    propagate_at_launch = true
  }
}

Explications :

Paramètre	Rôle
`min_size`	Minimum d’instances (2)
`max_size`	Maximum d’instances (4)
`desired_capacity`	Cible actuelle (2) = créer 2 instances
`vpc_zone_identifier`	AZs où lancer les instances
`launch_template { version = "$Latest" }`	Utiliser la dernière version du template
`instance_refresh { strategy = "Rolling" }`	Remplacer les instances progressivement
`min_healthy_percentage = 50`	Garder au moins 50% des instances saines pendant l’update

Étape 5 — Définir les outputs

Créez outputs.tf :

output "launch_template_id" {
  value = aws_launch_template.lab05_template.id
}

output "launch_template_name_prefix" {
  value = aws_launch_template.lab05_template.name_prefix
}

output "asg_name" {
  value = aws_autoscaling_group.lab05_asg.name
}

output "asg_min_size" {
  value = aws_autoscaling_group.lab05_asg.min_size
}

output "asg_max_size" {
  value = aws_autoscaling_group.lab05_asg.max_size
}

output "asg_desired_capacity" {
  value = aws_autoscaling_group.lab05_asg.desired_capacity
}

output "asg_availability_zones" {
  value = aws_autoscaling_group.lab05_asg.availability_zones
}

Étape 6 — Variables

Créez terraform.tfvars :

aws_region       = "us-east-1"
instance_type    = "t2.micro"
min_size         = 2
max_size         = 4
desired_capacity = 2

Vérification

Initialiser :
Fenêtre de terminal
```
terraform init
```

Appliquer (⚠️ cela prend 3-4 minutes — création de 2 instances) :

terraform apply -auto-approve

Sortie attendue (fin) :

Apply complete! Resources: 3 added, 0 changed, 0 destroyed.

Outputs:
asg_availability_zones = toset([
  "us-east-1a",
  "us-east-1b",
  "us-east-1c",
  ...
])
asg_desired_capacity = 2
asg_max_size = 4
asg_min_size = 2
asg_name = "lab05-asg-121"
launch_template_id = "lt-06738d00c2e67dafb"
launch_template_name_prefix = "lab05-template-"

Vérifier les instances dans la console AWS :

aws ec2 describe-instances \
  --filters "Name=tag:Name,Values=lab05-asg-instance" \
  --query 'Reservations[*].Instances[*].[InstanceId,State.Name,InstanceType,SubnetId]' \
  --output table

Sortie attendue :

|  i-0abc123...  |  running  |  t2.micro  |  subnet-xx...  |
|  i-0def456...  |  running  |  t2.micro  |  subnet-yy...  |

Voir l’ASG :

aws autoscaling describe-auto-scaling-groups \
  --auto-scaling-group-names lab05-asg-121 \
  --query 'AutoScalingGroups[0].[MinSize,MaxSize,DesiredCapacity,Instances]' \
  --output table

Anatomie

Launch Template vs Auto Scaling Group

Aspect	Launch Template	ASG
Quoi	Modèle pour les instances	Gestionnaire d’instances
Crée des instances ?	❌ Non	✅ Oui
Instances réelles	❌ Non	✅ Oui (plusieurs)
Mise à jour	Nouvelle version	Utilise la nouvelle version

Instance Refresh

Quand le template change, l’ASG peut mettre à jour les instances de deux façons :

instance_refresh {
  strategy = "Rolling"  # ✅ Progressif
  preferences {
    min_healthy_percentage = 50
  }
}

# vs

instance_refresh {
  strategy = "BlueGreen"  # Swap environnements
}

Rolling = remplacer progressivement (moins de downtime) BlueGreen = tout swap à la fois (risqué mais rapide)

Bonnes pratiques

1. Toujours utiliser des templates

# ❌ Ancien style (déprécié)
resource "aws_autoscaling_group" "bad" {
  launch_configuration = aws_launch_configuration.example.id
}

# ✅ Nouveau style
resource "aws_autoscaling_group" "good" {
  launch_template {
    id      = aws_launch_template.example.id
    version = "$Latest"
  }
}

2. Utiliser `create_before_destroy`

lifecycle {
  create_before_destroy = true
}

Cela évite les gaps de 0 instances pendant les updates.

3. Configurer les instance refresh preferences

instance_refresh {
  strategy = "Rolling"
  preferences {
    min_healthy_percentage = 90
    instance_warmup_seconds = 300
  }
}

Cela maintient le service disponible pendant les mises à jour.

4. Tracer les changements de capacity

variable "desired_capacity" {
  description = "Desired number of instances"
  type        = number
  default     = 2
}

# Changez `terraform.tfvars` pour scaler
# desired_capacity = 5  # ASG créera 3 instances supplémentaires

Dépannage

Symptôme	Cause	Solution
ASG créé mais 0 instance	Pas de subnets disponibles	Vérifier `vpc_zone_identifier`
Les instances sont correctes mais ASG unhealthy	Health check failed	Vérifier les security groups et ports
Plan montre “replacement” à chaque `terraform plan`	`random_integer` change	C’est normal — utiliser `lifecycle.ignore_changes` si besoin
Impossible de SSH aux instances	Pas de key pair ni security group	Ajouter `key_name` au template et SSH ingress

Nettoyage

Important : destruction prend 3-4 minutes (arrêt des instances) :

terraform destroy -auto-approve
rm -rf .terraform* terraform.tfstate*

À retenir

Launch template = modèle réutilisable pour les instances
ASG = gestionnaire automatique d’instances (min/max/desired)
Instance refresh = mise à jour progressive des instances
$Latest = toujours utiliser la dernière version du template
create_before_destroy = éviter les gaps de 0 instances
random_integer = utile pour forcer des updates en labs
Scaling = changez desired_capacity pour ajouter/retirer des instances

Prochaines étapes

Import, moved et drift Reprendre une ressource existante puis diagnostiquer les dérives de configuration.

Retour au parcours AWS Revenir au hub Terraform sur AWS.