Déploiement sur AWS

Aperçu

Ce guide vous accompagne dans le déploiement de CaseBender sur AWS en utilisant des images Docker préconstruites avec Amazon ECS (Elastic Container Service) et Fargate.

Prérequis

Compte AWS
AWS CLI installé et configuré
Docker installé

Étape 1 : Configuration Initiale

Installer et Configurer AWS CLI

# Utilisation de Homebrew
brew install awscli

# Configurer AWS CLI

aws configure

# Configurer Docker pour ECR

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin $(aws sts get-caller-identity --query Account --output text).dkr.ecr.us-east-1.amazonaws.com

# Installer AWS CLI
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

# Configurer AWS CLI
aws configure

# Configurer Docker pour ECR
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin $(aws sts get-caller-identity --query Account --output text).dkr.ecr.us-east-1.amazonaws.com

# Télécharger et exécuter l'installateur MSI d'AWS CLI
# https://awscli.amazonaws.com/AWSCLIV2.msi

# Configurer AWS CLI
aws configure

# Configurer Docker pour ECR
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin $(aws sts get-caller-identity --query Account --output text).dkr.ecr.us-east-1.amazonaws.com

Étape 2 : Configurer l’Infrastructure AWS

Créer un Bucket S3 pour le Stockage

# Créer un bucket S3
aws s3 create-bucket \
  --bucket casebender-storage \
  --region us-east-1

# Activer le versionnement (optionnel)
aws s3api put-bucket-versioning \
  --bucket casebender-storage \
  --versioning-configuration Status=Enabled

# Créer un utilisateur IAM pour l'accès S3
aws iam create-user --user-name casebender-storage-user

# Créer et attacher une politique
aws iam create-policy \
  --policy-name casebender-storage-policy \
  --policy-document '{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:PutObject",
                "s3:GetObject",
                "s3:DeleteObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::casebender-storage",
                "arn:aws:s3:::casebender-storage/*"
            ]
        }
    ]
}'

# Attacher la politique à l'utilisateur
aws iam attach-user-policy \
  --user-name casebender-storage-user \
  --policy-arn arn:aws:iam::VOTRE_ID_COMPTE:policy/casebender-storage-policy

# Créer des clés d'accès
aws iam create-access-key --user-name casebender-storage-user

Créer un VPC

# Créer un VPC
aws ec2 create-vpc \
  --cidr-block 10.0.0.0/16 \
  --tag-specifications 'ResourceType=vpc,Tags=[{Key=Name,Value=casebender-vpc}]'

# Activer les noms d'hôtes DNS
aws ec2 modify-vpc-attribute \
  --vpc-id <vpc-id> \
  --enable-dns-hostnames

Créer des Sous-réseaux

# Créer des sous-réseaux publics
aws ec2 create-subnet \
  --vpc-id <vpc-id> \
  --cidr-block 10.0.1.0/24 \
  --availability-zone us-east-1a \
  --tag-specifications 'ResourceType=subnet,Tags=[{Key=Name,Value=casebender-public-1a}]'

aws ec2 create-subnet \
  --vpc-id <vpc-id> \
  --cidr-block 10.0.2.0/24 \
  --availability-zone us-east-1b \
  --tag-specifications 'ResourceType=subnet,Tags=[{Key=Name,Value=casebender-public-1b}]'

Configurer RDS (PostgreSQL)

# Créer un groupe de sous-réseaux DB
aws rds create-db-subnet-group \
  --db-subnet-group-name casebender-db-subnet \
  --db-subnet-group-description "Groupe de sous-réseaux pour CaseBender RDS" \
  --subnet-ids "<subnet-1-id>" "<subnet-2-id>"

# Créer une instance RDS
aws rds create-db-instance \
  --db-instance-identifier casebender-db \
  --db-instance-class db.t3.medium \
  --engine postgres \
  --master-username superadmin \
  --master-user-password <votre-mot-de-passe-securise> \
  --allocated-storage 20 \
  --db-subnet-group-name casebender-db-subnet

Configurer ElastiCache (Redis)

# Créer un groupe de sous-réseaux cache
aws elasticache create-cache-subnet-group \
  --cache-subnet-group-name casebender-cache-subnet \
  --cache-subnet-group-description "Groupe de sous-réseaux pour CaseBender Redis" \
  --subnet-ids "<subnet-1-id>" "<subnet-2-id>"

# Créer un cluster Redis
aws elasticache create-cache-cluster \
  --cache-cluster-id casebender-redis \
  --engine redis \
  --cache-node-type cache.t3.micro \
  --num-cache-nodes 1 \
  --cache-subnet-group-name casebender-cache-subnet

Étape 3 : Créer des Dépôts ECR

# Créer des dépôts pour chaque service
aws ecr create-repository --repository-name casebender/app
aws ecr create-repository --repository-name casebender/workflow-processor
aws ecr create-repository --repository-name casebender/misp-processor

# Obtenir l'ID du compte AWS
AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)

# Récupérer les images CaseBender
docker pull casebender/casebender:latest
docker pull casebender/workflow-processor:latest
docker pull casebender/misp-processor:latest

# Taguer les images pour ECR
docker tag casebender/casebender:latest ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/casebender/app:latest
docker tag casebender/workflow-processor:latest ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/casebender/workflow-processor:latest
docker tag casebender/misp-processor:latest ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/casebender/misp-processor:latest

# Pousser les images vers ECR
docker push ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/casebender/app:latest
docker push ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/casebender/workflow-processor:latest
docker push ${AWS_ACCOUNT_ID}.dkr.ecr.us-east-1.amazonaws.com/casebender/misp-processor:latest

Étape 4 : Créer un Cluster ECS

# Créer un cluster ECS
aws ecs create-cluster --cluster-name casebender-cluster

# Créer un rôle d'exécution de tâche
aws iam create-role \
  --role-name ecsTaskExecutionRole \
  --assume-role-policy-document file://task-execution-assume-role.json

# Attacher la politique
aws iam attach-role-policy \
  --role-name ecsTaskExecutionRole \
  --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy

Étape 5 : Créer des Définitions de Tâches

Créez des fichiers JSON de définition de tâche pour chaque service :

{
  "family": "casebender-app",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "1024",
  "memory": "2048",
  "executionRoleArn": "arn:aws:iam::<aws-account-id>:role/ecsTaskExecutionRole",
  "containerDefinitions": [
    {
      "name": "app",
      "image": "<aws-account-id>.dkr.ecr.us-east-1.amazonaws.com/casebender/app:latest",
      "portMappings": [
        {
          "containerPort": 3000,
          "protocol": "tcp"
        }
      ],
      "environment": [
        {
          "name": "POSTGRES_PRISMA_URL",
          "value": "postgresql://superadmin:password@casebender-db.xxxxx.region.rds.amazonaws.com:5432/casebender"
        },
        {
          "name": "REDIS_URL",
          "value": "redis://casebender-redis.xxxxx.region.cache.amazonaws.com:6379"
        },
        {
          "name": "AWS_S3_BUCKET",
          "value": "casebender-storage"
        },
        {
          "name": "AWS_S3_REGION",
          "value": "us-east-1"
        }
      ],
      "secrets": [
        {
          "name": "AUTH_SECRET",
          "valueFrom": "arn:aws:secretsmanager:region:account:secret:auth-secret"
        },
        {
          "name": "AUTH_SALT",
          "valueFrom": "arn:aws:secretsmanager:region:account:secret:auth-salt"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/casebender",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "app"
        }
      }
    }
  ]
}

Enregistrez les définitions de tâches :

# Enregistrer les définitions de tâches
aws ecs register-task-definition --cli-input-json file://app-task-definition.json
aws ecs register-task-definition --cli-input-json file://workflow-processor-task-definition.json
aws ecs register-task-definition --cli-input-json file://misp-processor-task-definition.json

Étape 6 : Créer un Application Load Balancer

# Créer un ALB
aws elbv2 create-load-balancer \
  --name casebender-alb \
  --subnets <subnet-1-id> <subnet-2-id> \
  --security-groups <security-group-id>

# Créer un groupe cible
aws elbv2 create-target-group \
  --name casebender-tg \
  --protocol HTTP \
  --port 3000 \
  --vpc-id <vpc-id> \
  --target-type ip

# Créer un écouteur
aws elbv2 create-listener \
  --load-balancer-arn <alb-arn> \
  --protocol HTTPS \
  --port 443 \
  --certificates CertificateArn=<certificate-arn> \
  --default-actions Type=forward,TargetGroupArn=<target-group-arn>

Étape 7 : Créer des Services ECS

# Créer un service pour l'application principale
aws ecs create-service \
  --cluster casebender-cluster \
  --service-name casebender-app \
  --task-definition casebender-app \
  --desired-count 2 \
  --launch-type FARGATE \
  --network-configuration "awsvpcConfiguration={subnets=[<subnet-1-id>,<subnet-2-id>],securityGroups=[<security-group-id>],assignPublicIp=ENABLED}" \
  --load-balancers "targetGroupArn=<target-group-arn>,containerName=app,containerPort=3000"

# Créer des services pour les processeurs
aws ecs create-service \
  --cluster casebender-cluster \
  --service-name workflow-processor \
  --task-definition casebender-workflow-processor \
  --desired-count 1 \
  --launch-type FARGATE \
  --network-configuration "awsvpcConfiguration={subnets=[<subnet-1-id>,<subnet-2-id>],securityGroups=[<security-group-id>],assignPublicIp=ENABLED}"

aws ecs create-service \
  --cluster casebender-cluster \
  --service-name misp-processor \
  --task-definition casebender-misp-processor \
  --desired-count 1 \
  --launch-type FARGATE \
  --network-configuration "awsvpcConfiguration={subnets=[<subnet-1-id>,<subnet-2-id>],securityGroups=[<security-group-id>],assignPublicIp=ENABLED}"

Étape 8 : Configurer Route 53 (Optionnel)

Si vous utilisez un domaine personnalisé :

# Créer une zone hébergée (si elle n'existe pas)
aws route53 create-hosted-zone \
  --name votredomaine.com \
  --caller-reference $(date +%s)

# Créer un enregistrement A
aws route53 change-resource-record-sets \
  --hosted-zone-id <zone-id> \
  --change-batch '{
    "Changes": [{
      "Action": "CREATE",
      "ResourceRecordSet": {
        "Name": "votredomaine.com",
        "Type": "A",
        "AliasTarget": {
          "HostedZoneId": "<alb-hosted-zone-id>",
          "DNSName": "<alb-dns-name>",
          "EvaluateTargetHealth": true
        }
      }
    }]
  }'

Surveillance et Maintenance

Configurer des Alarmes CloudWatch

# Créer une alarme d'utilisation CPU
aws cloudwatch put-metric-alarm \
  --alarm-name casebender-cpu-alarm \
  --alarm-description "L'utilisation du CPU a dépassé 80%" \
  --metric-name CPUUtilization \
  --namespace AWS/ECS \
  --statistic Average \
  --period 300 \
  --threshold 80 \
  --comparison-operator GreaterThanThreshold \
  --dimensions Name=ClusterName,Value=casebender-cluster \
  --evaluation-periods 2 \
  --alarm-actions <sns-topic-arn>

Consulter les Journaux

# Voir les journaux de service
aws logs get-log-events \
  --log-group-name /ecs/casebender \
  --log-stream-name app/<container-id>

Mettre à Jour les Services

# Mettre à jour le service avec une nouvelle définition de tâche
aws ecs update-service \
  --cluster casebender-cluster \
  --service casebender-app \
  --task-definition casebender-app:NOUVELLE_REVISION

Optimisation des Coûts

Utiliser Fargate Spot pour les charges de travail non critiques
Implémenter l’auto-scaling basé sur les métriques
Choisir des tailles d’instance appropriées
Utiliser des Instances Réservées pour les charges de travail prévisibles

Meilleures Pratiques de Sécurité

Utiliser AWS Secrets Manager pour les données sensibles
Implémenter des règles WAF
Activer les journaux de flux VPC
Audits réguliers des groupes de sécurité
Activer AWS GuardDuty

Prochaines Étapes

Configurer un pipeline CI/CD avec AWS CodePipeline
Configurer des stratégies de sauvegarde
Implémenter la surveillance et les alertes
Revoir les meilleures pratiques de sécurité

​Aperçu

​Prérequis

​Étape 1 : Configuration Initiale

​Installer et Configurer AWS CLI

​Étape 2 : Configurer l’Infrastructure AWS

​Créer un Bucket S3 pour le Stockage

​Créer un VPC

​Créer des Sous-réseaux

​Configurer RDS (PostgreSQL)

​Configurer ElastiCache (Redis)

​Étape 3 : Créer des Dépôts ECR

​Étape 4 : Créer un Cluster ECS

​Étape 5 : Créer des Définitions de Tâches

​Étape 6 : Créer un Application Load Balancer

​Étape 7 : Créer des Services ECS

​Étape 8 : Configurer Route 53 (Optionnel)

​Surveillance et Maintenance

​Configurer des Alarmes CloudWatch

​Consulter les Journaux

​Mettre à Jour les Services

​Optimisation des Coûts

​Meilleures Pratiques de Sécurité

​Prochaines Étapes