Comment déployer une app sur AWS Fargate en 2026

Introduction

AWS Fargate est un mode de calcul serverless pour Amazon ECS (Elastic Container Service) qui permet de déployer des conteneurs Docker sans provisionner ni gérer de machines sous-jacentes. Contrairement à EC2 où vous gérez les instances, Fargate s'occupe de l'orchestration, du scaling et de la haute disponibilité.

Pourquoi l'utiliser en 2026 ? Les coûts sont prévisibles (paiement à la seconde), l'intégration native avec AWS (VPC, IAM, CloudWatch) simplifie les déploiements microservices, et il supporte jusqu'à 16 vCPU par tâche. Ce tutoriel beginner vous guide pour déployer une app Node.js simple : un serveur HTTP qui répond 'Hello Fargate !'.

À la fin, vous aurez un service ECS scalable sur Fargate, monitoré et accessible via ALB. Temps estimé : 30 min. Coût : <1€ pour un test. Préparez votre compte AWS gratuit tier.

(128 mots)

Prérequis

Compte AWS (avec IAM user CLI, région us-east-1 recommandée)
AWS CLI v2 installée et configurée (aws configure)
Docker Desktop (v24+)
Node.js 20+ et npm
Git cloné localement
Permissions IAM : AmazonEC2ContainerRegistryFullAccess, AmazonECS_FullAccess, IAMFullAccess (pour test beginner)

Créer l'application Node.js

index.js

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello Fargate ! Déployé en 2026 🚀');
});

const port = process.env.PORT || 8080;
server.listen(port, '0.0.0.0', () => {
  console.log(`Serveur sur port ${port}`);
});

Ce code crée un serveur HTTP minimal avec Node.js natif (sans Express pour simplicité). Il écoute sur PORT (injecté par Fargate) ou 8080, et répond un message fixe. Pas de dépendances externes pour un build rapide ; copiez-collez dans un dossier projet.

Préparer package.json

Créez un package.json basique pour le conteneur. Exécutez npm init -y puis ajoutez "start": "node index.js". Pas besoin d'autres deps.

Écrire le Dockerfile

Dockerfile

FROM node:20-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY index.js .

USER node

EXPOSE 8080

CMD ["npm", "start"]

Dockerfile optimisé pour prod : base alpine légère (50MB), install prod only, user non-root pour sécurité Fargate. Multi-stage implicite via RUN npm ci. EXPOSE informe ECS du port sans bind forcé.

Build et push vers ECR

deploy-ecr.sh

#!/bin/bash
REPO_NAME=fargate-demo
AWS_ACCOUNT=$(aws sts get-caller-identity --query Account --output text)
REGION=us-east-1
REPO_URI=${AWS_ACCOUNT}.dkr.ecr.${REGION}.amazonaws.com/${REPO_NAME}

# Créer repo ECR
aws ecr create-repository --repository-name ${REPO_NAME} --region ${REGION}

# Login ECR
docker build -t ${REPO_NAME} .
docker tag ${REPO_NAME}:latest ${REPO_URI}:latest
aws ecr get-login-password --region ${REGION} | docker login --username AWS --password-stdin ${REPO_URI}

docker push ${REPO_URI}:latest
echo "Image poussée : ${REPO_URI}:latest"

Script bash complet et idempotent : crée repo ECR, build/tag/push l'image. Utilise variables dynamiques (compte AWS auto). Rendez exécutable chmod +x deploy-ecr.sh et lancez ./deploy-ecr.sh. Vérifiez avec aws ecr describe-images.

Créer le cluster ECS

Fargate nécessite un cluster ECS vide. Pas de capacity providers manuels en beginner mode.

Définir la Task Definition

task-definition.json

{
  "family": "fargate-demo",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "256",
  "memory": "512",
  "executionRoleArn": "arn:aws:iam::YOUR_ACCOUNT:role/ecsTaskExecutionRole",
  "taskRoleArn": "arn:aws:iam::YOUR_ACCOUNT:role/ecsTaskRole",
  "containerDefinitions": [
    {
      "name": "demo-app",
      "image": "YOUR_ACCOUNT.dkr.ecr.us-east-1.amazonaws.com/fargate-demo:latest",
      "portMappings": [{ "containerPort": 8080, "protocol": "tcp" }],
      "essential": true,
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/fargate-demo",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "ecs"
        }
      }
    }
  ]
}

JSON valide pour aws ecs register-task-definition. Remplacez YOUR_ACCOUNT par votre ID AWS (du script précédent). awsvpc obligatoire pour Fargate (VPC natif). CPU 256=0.25 vCPU, memory 512MB mini. Logs vers CloudWatch auto-créés.

Créer cluster, task et service

deploy-ecs.sh

#!/bin/bash
CLUSTER_NAME=fargate-cluster
SERVICE_NAME=fargate-service
TASK_FAMILY=fargate-demo
REGION=us-east-1
TASK_REV=$(aws ecs describe-task-definition --task-definition ${TASK_FAMILY} --query 'taskDefinition.revision' --output text)

# Créer cluster
aws ecs create-cluster --cluster-name ${CLUSTER_NAME} --capacity-providers FARGATE --default-capacity-provider-strategy capacityProvider=FARGATE --region ${REGION}

# Créer log group
aws logs create-log-group --log-group-name /ecs/fargate-demo --region ${REGION}

# Register task def (si pas déjà)
aws ecs register-task-definition --cli-input-json file://task-definition.json

# Créer service (sans LB pour simplicité ; ajoutez --load-balancers après)
aws ecs create-service --cluster ${CLUSTER_NAME} --service-name ${SERVICE_NAME} --task-definition ${TASK_FAMILY}:${TASK_REV} --desired-count 1 --launch-type FARGATE --platform-version LATEST --network-configuration "awsvpcConfiguration={subnets=[subnet-01234567],securityGroups=[sg-01234567],assignPublicIp=ENABLED}" --region ${REGION}

echo "Service créé. Vérifiez : aws ecs describe-services --cluster ${CLUSTER_NAME} --services ${SERVICE_NAME}"

Script tout-en-un : cluster Fargate, logs, register task, service avec réseau public (remplacez subnet/SG IDs de votre VPC par défaut). Desired-count=1 pour test. Accédez via IP publique générée. Scalez via --desired-count.

Vérifier le déploiement

Exécutez aws ecs list-tasks --cluster fargate-cluster --output table pour l'ARN task. Puis aws ecs describe-tasks --cluster fargate-cluster --tasks arn... pour logs/IP. Cliquez l'IP:8080 → 'Hello Fargate !'.

CloudWatch Logs : /ecs/fargate-demo auto.

Nettoyage des ressources

cleanup.sh

#!/bin/bash
CLUSTER_NAME=fargate-cluster
SERVICE_NAME=fargate-service
REPO_NAME=fargate-demo
REGION=us-east-1

aws ecs update-service --cluster ${CLUSTER_NAME} --service ${SERVICE_NAME} --desired-count 0
aws ecs delete-service --cluster ${CLUSTER_NAME} --service ${SERVICE_NAME}
aws ecs delete-cluster --cluster ${CLUSTER_NAME}
aws ecr delete-repository --repository-name ${REPO_NAME} --force
aws logs delete-log-group --log-group-name /ecs/fargate-demo

echo "Ressources supprimées."

Script cleanup pour éviter les coûts : arrête service, supprime tout. Lancez après test. Vérifiez billing AWS console.

Bonnes pratiques

Utilisez des rôles IAM minimaux : TaskRole pour app, ExecutionRole pour ECR/logs/pull secrets.
Réseau privé : awsvpc avec private subnets + NAT pour prod ; ajoutez ALB pour HTTPS.
Scaling auto : Configurez ECS Service Auto Scaling sur CPU/Mémoire.
Secrets/Env vars : Injectez via task def secrets ou Systems Manager.
Monitoring : Activez CloudWatch Container Insights dès le cluster.

Erreurs courantes à éviter

Subnet/SG invalides : Fargate requiert awsvpc ; vérifiez VPC default a public subnets avec IGW.
Image pull failed : Vérifiez ECR policy ; ajoutez ecsTaskExecutionRole avec ECR pull perms.
Port non exposé : ContainerPort doit matcher app (8080) et healthCheckPath si ALB.
CPU/Memory mismatch : Respectez combos Fargate (256/512, 512/1024, etc.) sinon erreur validation.

Pour aller plus loin

Maîtrisez Fargate en prod :

Docs AWS Fargate
Ajoutez ALB/NLB : tutoriel ECS Load Balancing.
CI/CD : GitHub Actions vers ECR.

Découvrez nos formations Learni Dev sur AWS pour ECS/EKS avancés.