déployer une application python fastapi sur aws ecs fargate avec docker et github actions

Dans ce tutoriel technique, nous verrons comment déployer une application Python FastAPI sur AWS ECS Fargate en tirant parti de Docker et d’un workflow GitHub Actions. Vous apprendrez à créer une image optimisée, la publier sur Amazon ECR, automatiser votre CI/CD et lancer votre service conteneurisé sans gérer de serveurs.

déployer une application python fastapi sur aws ecs fargate

prérequis techniques

• Un projet FastAPI minimal (Python 3.9+)
• Un compte AWS avec droits ECS & ECR
• Docker installé localement (doc Docker)
• AWS CLI configurée (profil IAM avec permissions ECS/ECR)
• Un repo GitHub pour héberger votre code

étape 1 : dockeriser votre application FastAPI

# Dockerfile
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000","--workers","4"]

Ce Dockerfile génère une image légère (~120 Mo). Les workers UVicorn assurent une meilleure concurrence.

étape 2 : créer et publier l’image sur Amazon ECR

1. Créer un repository ECR :

   aws ecr create-repository --repository-name fastapi-app --region eu-west-1

2. Authentifier Docker :

   aws ecr get-login-password --region eu-west-1 | docker login --username AWS --password-stdin .dkr.ecr.eu-west-1.amazonaws.com

3. Builder et pousser :

   docker build -t fastapi-app .
   docker tag fastapi-app:latest .dkr.ecr.eu-west-1.amazonaws.com/fastapi-app:latest
   docker push .dkr.ecr.eu-west-1.amazonaws.com/fastapi-app:latest
   

étape 3 : configurer un workflow GitHub Actions

# .github/workflows/deploy.yml
name: CI/CD FastAPI to ECS

on:
  push:
    branches: [main]

jobs:
  build_and_push:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Configure AWS Credentials
        uses: aws-actions/configure-aws-credentials@v2
        with:
          aws-region: eu-west-1
          role-to-assume: arn:aws:iam::${{ secrets.AWS_ACCOUNT_ID }}:role/CI-CD-Role
      - name: Login to ECR
        run: aws ecr get-login-password | docker login --username AWS --password-stdin ${{ secrets.AWS_ACCOUNT_ID }}.dkr.ecr.eu-west-1.amazonaws.com
      - name: Build and Push Docker image
        run: |
          docker build -t fastapi-app .
          docker tag fastapi-app:latest ${{ secrets.AWS_ACCOUNT_ID }}.dkr.ecr.eu-west-1.amazonaws.com/fastapi-app:latest
          docker push ${{ secrets.AWS_ACCOUNT_ID }}.dkr.ecr.eu-west-1.amazonaws.com/fastapi-app:latest
      - name: Deploy to ECS
        run: |
          aws ecs update-service --cluster fastapi-cluster --service fastapi-service \
            --force-new-deployment

Ce pipeline auto-mate du build jusqu’au déploiement sur votre service Fargate.

étape 4 : déployer sur ECS Fargate

1. Créer un cluster Fargate :

   aws ecs create-cluster --cluster-name fastapi-cluster

2. Définir une task :

   aws ecs register-task-definition \
         --family fastapi-task \
         --network-mode awsvpc \
         --execution-role-arn arn:aws:iam::...:role/ecsTaskExecutionRole \
         --cpu "256" --memory "512" \
         --requires-compatibilities FARGATE \
         --container-definitions '[{
           "name":"fastapi-app",
           "image":".dkr.ecr.eu-west-1.amazonaws.com/fastapi-app:latest",
           "portMappings":[{"containerPort":8000,"protocol":"tcp"}]
         }]'
   

3. Créer le service :

   aws ecs create-service \
         --cluster fastapi-cluster \
         --service-name fastapi-service \
         --task-definition fastapi-task \
         --launch-type FARGATE \
         --network-configuration '{
           "awsvpcConfiguration":{
             "subnets":["subnet-xxxx"],"assignPublicIp":"ENABLED"
           }
         }' \
         --desired-count 2
   

bonnes pratiques et optimisation

• Utiliser des health checks HTTP pour une haute disponibilité.
• Minimiser la taille de l’image (multi-stage builds).
• Activer auto scaling CPU/mémoire pour maîtriser le budget AWS.
• Surveiller les logs avec CloudWatch ou intégrer un ELK stack (voir intégration IA).

conclusion

Vous savez désormais comment mettre en place un pipeline de bout en bout pour déployer votre API FastAPI sur AWS ECS Fargate. Cette approche maximise l’isolation, la scalabilité et réduit la maintenance serveur. Pour un audit personnalisé ou un accompagnement, n’hésitez pas à nous contacter.