AWS Deployment Patterns

Ce skill couvre les patterns canoniques pour déployer sur AWS en s'appuyant sur les 3 MCP servers officiels AWS Labs déclarés dans plugins/atum-workflows/.mcp.json.

MCP servers AWS disponibles :

• awsknowledge (HTTP https://knowledge-mcp.global.api.aws) — accès live à toute la doc AWS officielle
• awspricing (uvx) — données de pricing temps-réel pour tous les services AWS
• awsiac (uvx) — génération IaC (CloudFormation, CDK, Terraform) avec best practices

Prérequis utilisateur : uvx installé (Python pip install uv) + AWS CLI v2 configuré (aws configure) + IAM credentials valides.

1. Decision tree — quel service AWS pour quel besoin ?

Type de workload
├── Web app full-stack (Next.js, React, Vue, Angular)
│   ├── Static + serverless API → AWS Amplify Hosting + Amplify backend
│   ├── Containerized → ECS Fargate + ALB
│   └── Server-rendered + scaling → Elastic Beanstalk (legacy) ou App Runner (moderne)
├── API REST / GraphQL / Webhooks
│   ├── Serverless → API Gateway + Lambda
│   ├── Containers → ECS Fargate + ALB ou App Runner
│   └── Performance critique → EC2 + ALB (control total)
├── Static website
│   └── S3 + CloudFront (avec OAC, pas OAI legacy)
├── Background jobs / queues
│   ├── Lambda + SQS (event-driven)
│   ├── Lambda + EventBridge Scheduler (cron)
│   ├── ECS Fargate scheduled tasks
│   └── Step Functions pour workflows complexes
├── Database
│   ├── Postgres / MySQL / MariaDB → RDS
│   ├── Postgres serverless → Aurora Serverless v2
│   ├── NoSQL key-value massif → DynamoDB
│   ├── Cache → ElastiCache (Redis cluster mode enabled)
│   └── Time-series → Timestream
├── Storage
│   ├── Objects → S3 (Intelligent-Tiering par défaut)
│   ├── Files NFS → EFS (Elastic File System)
│   └── Archive → S3 Glacier Deep Archive
├── ML / AI
│   ├── Training + inference → SageMaker
│   ├── Foundation models hosted → Amazon Bedrock
│   └── Pre-trained APIs → Rekognition / Comprehend / Transcribe / Polly
├── Networking
│   ├── DNS → Route 53
│   ├── CDN → CloudFront
│   ├── VPC peering multi-account → Transit Gateway
│   └── On-prem ↔ AWS → Direct Connect ou Site-to-Site VPN
└── Migration
    └── AWS Migration Hub + Application Migration Service (MGN)

2. Authentication — OIDC depuis GitHub Actions (recommandé)

# .github/workflows/deploy-aws.yml
permissions:
  id-token: write   # OIDC
  contents: read

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: arn:aws:iam::123456789012:role/github-deploy-role
          aws-region: eu-west-3

      - run: aws s3 sync ./dist s3://my-bucket/
      - run: aws cloudfront create-invalidation --distribution-id E123456 --paths "/*"

Setup côté AWS :

1. Créer un OIDC provider IAM pointant vers token.actions.githubusercontent.com
2. Créer un IAM role avec trust policy autorisant le repo GitHub spécifique
3. Attribuer les policies IAM minimales nécessaires (least privilege)
4. Plus de long-lived AWS_ACCESS_KEY_ID dans GitHub Secrets

3. Lambda + API Gateway (serverless API)

// handler.ts
import { APIGatewayProxyHandler } from 'aws-lambda'

export const handler: APIGatewayProxyHandler = async (event) => {
  const name = event.queryStringParameters?.name || 'world'
  return {
    statusCode: 200,
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ message: `Hello ${name}` }),
  }
}

# AWS SAM template.yaml
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  HelloFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./
      Handler: handler.handler
      Runtime: nodejs20.x
      MemorySize: 256
      Timeout: 10
      Architectures: [arm64]  # ARM = -20% cost
      Environment:
        Variables:
          NODE_ENV: production
      Events:
        ApiEvent:
          Type: HttpApi  # API Gateway v2 (HTTP API, moins cher que REST)
          Properties:
            Path: /hello
            Method: get

sam build && sam deploy --guided

4. ECS Fargate (containers managed)

# 1. Push image vers ECR
aws ecr create-repository --repository-name my-api
docker tag my-api:latest 123456789012.dkr.ecr.eu-west-3.amazonaws.com/my-api:1.0.0
aws ecr get-login-password | docker login --username AWS --password-stdin 123456789012.dkr.ecr.eu-west-3.amazonaws.com
docker push 123456789012.dkr.ecr.eu-west-3.amazonaws.com/my-api:1.0.0

# 2. Task definition + service via CDK / Terraform / Console

// Avec AWS CDK (TypeScript)
import { Stack, StackProps } from 'aws-cdk-lib'
import { Construct } from 'constructs'
import * as ecs from 'aws-cdk-lib/aws-ecs'
import * as ec2 from 'aws-cdk-lib/aws-ec2'
import * as ecs_patterns from 'aws-cdk-lib/aws-ecs-patterns'

export class ApiStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props)

    const vpc = new ec2.Vpc(this, 'Vpc', { maxAzs: 3, natGateways: 1 })
    const cluster = new ecs.Cluster(this, 'Cluster', { vpc })

    new ecs_patterns.ApplicationLoadBalancedFargateService(this, 'Api', {
      cluster,
      cpu: 512,
      memoryLimitMiB: 1024,
      desiredCount: 2,
      taskImageOptions: {
        image: ecs.ContainerImage.fromRegistry('123456789012.dkr.ecr.eu-west-3.amazonaws.com/my-api:1.0.0'),
        containerPort: 8080,
      },
      publicLoadBalancer: true,
    })
  }
}

npx cdk deploy

5. RDS / Aurora Serverless v2

// CDK
import * as rds from 'aws-cdk-lib/aws-rds'

const cluster = new rds.DatabaseCluster(this, 'Db', {
  engine: rds.DatabaseClusterEngine.auroraPostgres({
    version: rds.AuroraPostgresEngineVersion.VER_15_5,
  }),
  serverlessV2MinCapacity: 0.5,
  serverlessV2MaxCapacity: 4,
  writer: rds.ClusterInstance.serverlessV2('writer'),
  readers: [rds.ClusterInstance.serverlessV2('reader1', { scaleWithWriter: true })],
  vpc,
  vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_ISOLATED },
  storageEncrypted: true,
  backupRetention: cdk.Duration.days(14),
  cloudwatchLogsExports: ['postgresql'],
  performanceInsightRetention: rds.PerformanceInsightRetention.LONG_TERM,
})

Best practices :

• Toujours storageEncrypted: true
• Toujours dans private subnet (jamais publique)
• Aurora Serverless v2 pour les workloads variables (scale 0.5 → 16 ACUs)
• RDS multi-AZ en prod
• enableCloudwatchLogsExports: ['postgresql']

6. S3 + CloudFront (static hosting)

import * as s3 from 'aws-cdk-lib/aws-s3'
import * as cf from 'aws-cdk-lib/aws-cloudfront'
import * as origins from 'aws-cdk-lib/aws-cloudfront-origins'

const bucket = new s3.Bucket(this, 'SiteBucket', {
  publicReadAccess: false,
  blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
  encryption: s3.BucketEncryption.S3_MANAGED,
  enforceSSL: true,
  versioned: true,
})

const distribution = new cf.Distribution(this, 'SiteDistribution', {
  defaultBehavior: {
    origin: origins.S3BucketOrigin.withOriginAccessControl(bucket),  // OAC, pas OAI
    viewerProtocolPolicy: cf.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
    cachePolicy: cf.CachePolicy.CACHING_OPTIMIZED,
  },
  defaultRootObject: 'index.html',
  errorResponses: [
    { httpStatus: 404, responseHttpStatus: 200, responsePagePath: '/index.html' },  // SPA
  ],
})

7. DynamoDB single-table design

const table = new dynamodb.Table(this, 'AppTable', {
  partitionKey: { name: 'PK', type: dynamodb.AttributeType.STRING },
  sortKey: { name: 'SK', type: dynamodb.AttributeType.STRING },
  billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
  pointInTimeRecovery: true,
  encryption: dynamodb.TableEncryption.AWS_MANAGED,
  removalPolicy: cdk.RemovalPolicy.RETAIN,
})

// GSIs
table.addGlobalSecondaryIndex({
  indexName: 'GSI1',
  partitionKey: { name: 'GSI1PK', type: dynamodb.AttributeType.STRING },
  sortKey: { name: 'GSI1SK', type: dynamodb.AttributeType.STRING },
})

Single-table design : un seul DynamoDB pour toute l'app, avec PK/SK polymorphes. Pattern documenté par Rick Houlihan (AWS).

8. SageMaker (ML)

// Endpoint pour inference
const model = new sagemaker.CfnModel(this, 'Model', {
  executionRoleArn: role.roleArn,
  primaryContainer: {
    image: '763104351884.dkr.ecr.eu-west-3.amazonaws.com/pytorch-inference:2.1.0-gpu-py310',
    modelDataUrl: 's3://my-models/model.tar.gz',
  },
})

const endpointConfig = new sagemaker.CfnEndpointConfig(this, 'EndpointConfig', {
  productionVariants: [{
    modelName: model.attrModelName,
    variantName: 'AllTraffic',
    instanceType: 'ml.g5.xlarge',
    initialInstanceCount: 1,
  }],
})

new sagemaker.CfnEndpoint(this, 'Endpoint', {
  endpointConfigName: endpointConfig.attrEndpointConfigName,
})

Cost : SageMaker peut être coûteux. Préférer Bedrock pour les LLM hosted, SageMaker uniquement pour custom training.

9. AWS Migration Hub (GCP/Azure → AWS)

Workflow recommandé :

1. Discovery : awsknowledge MCP guide la découverte des ressources sources (GCP/Azure)
2. Architecture mapping : awsiac MCP génère les équivalents IaC AWS
3. Cost analysis : awspricing MCP estime le TCO post-migration
4. Execution : Application Migration Service (MGN) pour les VMs, DataSync pour les fichiers, DMS pour les DBs

10. Cost optimization

• Savings Plans Compute (1y / 3y, all Lambda + Fargate + EC2) : -27% à -66%
• Reserved Instances RDS / ElastiCache : -30% à -75%
• Spot Instances pour batch / CI / dev : -70% à -90%
• Graviton (ARM) sur Lambda / Fargate / RDS : -20%
• S3 Intelligent-Tiering par défaut (auto-tiering)
• NAT Gateway elimination : VPC Endpoints pour S3/DynamoDB (gratuit), Interface Endpoints pour les autres
• CloudFront au lieu d'egress direct → -30 à -50% sur le bandwidth
• Compute Optimizer régulièrement consulté
• Tagging strict pour Cost Allocation Reports

11. Anti-patterns

1. Long-lived AWS_ACCESS_KEY_ID dans GitHub Secrets → utiliser OIDC
2. AdministratorAccess sur les rôles → least privilege
3. RDS dans subnet public → toujours private
4. S3 public par défaut → toujours BlockPublicAccess: BLOCK_ALL
5. NAT Gateway pour S3 → utiliser VPC Endpoints (gratuit)
6. Lambda dans VPC sans Endpoints → cold starts énormes + NAT cost
7. Pas de Reserved Instances → overpaying sur baseline
8. EBS volumes orphelins non supprimés → coût silencieux
9. CloudWatch Logs sans retention → croissance illimitée
10. Pas de tagging → Cost Allocation Report inutilisable
11. DynamoDB Provisioned sans autoscaling → throttling ou overprovision
12. Pas de Multi-AZ sur RDS prod → downtime garanti

Checklist livraison

• OIDC GitHub Actions configuré
• IAM least privilege avec policies custom
• VPC avec private subnets pour les DBs
• VPC endpoints pour S3/DynamoDB
• RDS multi-AZ + encrypted at rest
• S3 BlockPublicAccess + versioning + lifecycle
• CloudFront avec OAC (pas OAI)
• CloudWatch alarms + Application Insights
• Tagging strategy
• Cost budgets + alerting
• Backups testés
• DR plan documenté
• Compute Optimizer review trimestrielle

Quand déléguer

• K8s sur EKS → skill kubernetes-patterns (ce plugin)
• IaC Terraform → skill terraform-patterns (ce plugin)
• Architecture cloud → skill cloud-architecture (ce plugin)
• Sécurité AWS → agent security-expert (atum-compliance)
• Pentesting AWS → agent penetration-tester (atum-compliance)

Ressources

• https://docs.aws.amazon.com/
• https://github.com/awslabs/agent-plugins (source, MCP servers)
• https://github.com/awslabs/mcp (AWS Labs MCP servers repo)
• https://aws.amazon.com/architecture/well-architected/
• https://github.com/awsdocs/aws-doc-sdk-examples