Aller au contenu principal

Exercices et Projets

1 - Exercices pratiques​

Exercice 1 : CodeCommit​

Objectif : Créer et configurer un repository CodeCommit.

# Tâches :
# 1. Créer un repository "my-app"
# 2. Configurer l'authentification HTTPS
# 3. Cloner et pousser du code
# 4. Créer une branche "develop"
# 5. Créer une Pull Request
Solution
# 1. Créer le repo
aws codecommit create-repository --repository-name my-app

# 2. Configurer Git credentials (via IAM Console)
git config --global credential.helper '!aws codecommit credential-helper $@'
git config --global credential.UseHttpPath true

# 3. Cloner et pousser
git clone https://git-codecommit.eu-west-1.amazonaws.com/v1/repos/my-app
cd my-app
echo "# My App" > README.md
git add .
git commit -m "Initial commit"
git push origin main

# 4. Créer develop
git checkout -b develop
git push origin develop

# 5. PR via CLI
aws codecommit create-pull-request \
    --title "Merge develop to main" \
    --targets repositoryName=my-app,sourceReference=develop,destinationReference=main

Exercice 2 : CodeBuild​

Objectif : Créer un projet CodeBuild avec buildspec.yml.

Créez un buildspec.yml qui :

  1. Installe Node.js 18
  2. Exécute npm install
  3. Lance les tests
  4. Build l'application
  5. Génère un rapport de couverture
Solution
# buildspec.yml
version: 0.2

phases:
  install:
    runtime-versions:
      nodejs: 18
    commands:
      - echo "Installing dependencies..."
  
  pre_build:
    commands:
      - npm ci
      - npm run lint
  
  build:
    commands:
      - npm run build
      - npm test -- --coverage
  
  post_build:
    commands:
      - echo "Build completed on $(date)"

artifacts:
  files:
    - dist/**/*
    - package.json
  discard-paths: no

reports:
  coverage:
    files:
      - 'coverage/cobertura-coverage.xml'
    file-format: COBERTURAXML

cache:
  paths:
    - node_modules/**/*

Exercice 3 : ECR et Docker​

Objectif : Push une image Docker vers ECR.

# Tâches :
# 1. Créer un repository ECR
# 2. Build une image Docker
# 3. Tag et push vers ECR
# 4. Configurer une lifecycle policy
Solution
# 1. Créer le repo
aws ecr create-repository \
    --repository-name my-app \
    --image-scanning-configuration scanOnPush=true

# 2 & 3. Build, tag et push
ECR_REPO=123456789.dkr.ecr.eu-west-1.amazonaws.com/my-app

aws ecr get-login-password | docker login --username AWS --password-stdin $ECR_REPO

docker build -t my-app:latest .
docker tag my-app:latest $ECR_REPO:latest
docker push $ECR_REPO:latest

# 4. Lifecycle policy
aws ecr put-lifecycle-policy \
    --repository-name my-app \
    --lifecycle-policy-text '{
        "rules": [{
            "rulePriority": 1,
            "description": "Keep last 10",
            "selection": {
                "tagStatus": "any",
                "countType": "imageCountMoreThan",
                "countNumber": 10
            },
            "action": {"type": "expire"}
        }]
    }'

Exercice 4 : CodePipeline​

Objectif : Créer un pipeline simple avec 3 stages.

Solution (CloudFormation)
AWSTemplateFormatVersion: '2010-09-09'

Resources:
  Pipeline:
    Type: AWS::CodePipeline::Pipeline
    Properties:
      Name: simple-pipeline
      RoleArn: !GetAtt PipelineRole.Arn
      ArtifactStore:
        Type: S3
        Location: !Ref ArtifactBucket
      
      Stages:
        - Name: Source
          Actions:
            - Name: Source
              ActionTypeId:
                Category: Source
                Owner: AWS
                Provider: CodeCommit
                Version: '1'
              Configuration:
                RepositoryName: my-app
                BranchName: main
              OutputArtifacts:
                - Name: SourceArtifact
        
        - Name: Build
          Actions:
            - Name: Build
              ActionTypeId:
                Category: Build
                Owner: AWS
                Provider: CodeBuild
                Version: '1'
              Configuration:
                ProjectName: !Ref BuildProject
              InputArtifacts:
                - Name: SourceArtifact
              OutputArtifacts:
                - Name: BuildArtifact
        
        - Name: Deploy
          Actions:
            - Name: Deploy
              ActionTypeId:
                Category: Deploy
                Owner: AWS
                Provider: S3
                Version: '1'
              Configuration:
                BucketName: !Ref DeployBucket
                Extract: 'true'
              InputArtifacts:
                - Name: BuildArtifact

2 - Projet complet : Application Web​

Description​

Déployez une application web complète avec :

  • Code source dans CodeCommit
  • Build et tests avec CodeBuild
  • Images Docker dans ECR
  • Déploiement ECS avec CodeDeploy
  • Pipeline orchestré par CodePipeline

Architecture​

Structure du projet​

my-web-app/
├── src/
│   └── app.js
├── tests/
│   └── app.test.js
├── Dockerfile
├── buildspec.yml
├── appspec.yml
├── taskdef.json
└── infrastructure/
    └── pipeline.yaml

Fichiers clés​

# Dockerfile
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY src/ ./src/
EXPOSE 3000
CMD ["node", "src/app.js"]
# buildspec.yml
version: 0.2

env:
  variables:
    ECR_REPO: 123456789.dkr.ecr.eu-west-1.amazonaws.com/my-web-app

phases:
  pre_build:
    commands:
      - aws ecr get-login-password | docker login --username AWS --password-stdin $ECR_REPO
      - COMMIT_HASH=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut -c 1-7)
      - IMAGE_TAG=${COMMIT_HASH:-latest}
  
  build:
    commands:
      - npm ci
      - npm test
      - docker build -t $ECR_REPO:$IMAGE_TAG .
  
  post_build:
    commands:
      - docker push $ECR_REPO:$IMAGE_TAG
      - printf '{"ImageURI":"%s"}' $ECR_REPO:$IMAGE_TAG > imageDetail.json

artifacts:
  files:
    - imageDetail.json
    - appspec.yml
    - taskdef.json

Déploiement​

# 1. Déployer l'infrastructure
aws cloudformation deploy \
    --template-file infrastructure/pipeline.yaml \
    --stack-name my-web-app-pipeline \
    --capabilities CAPABILITY_IAM

# 2. Pousser le code
git push origin main

# 3. Le pipeline se déclenche automatiquement

# 4. Surveiller
aws codepipeline get-pipeline-execution \
    --pipeline-name my-web-app-pipeline \
    --pipeline-execution-id <execution-id>

3 - Quiz de révision​

  1. Quelle est la différence entre CodeBuild et CodeDeploy ?

  2. Comment sécuriser les secrets dans un buildspec.yml ?

  3. Qu'est-ce qu'un artifact dans CodePipeline ?

  4. Comment déclencher un pipeline automatiquement ?

  5. Quelle stratégie de déploiement permet un rollback instantané ?

Réponses

  1. CodeBuild compile le code et crée des artifacts. CodeDeploy déploie les artifacts sur les cibles.

  2. Utiliser secrets-manager: ou parameter-store: dans la section env du buildspec.

  3. Fichiers passés entre les stages (source code, build output, etc.).

  4. Via webhooks (GitHub), CloudWatch Events/EventBridge, ou PollForSourceChanges.

  5. Blue/Green deployment permet un rollback instantané en reroutant le trafic.

4 - Certification AWS DevOps Professional​

Domaines couverts​

DomainePoids
SDLC Automation22%
Configuration Management & IaC17%
Monitoring and Logging15%
Policies and Standards10%
Incident and Event Response18%
High Availability and Fault Tolerance18%

Ressources​

Résumé du cours​

Félicitations ! Vous avez complété le cours AWS DevOps.

Vous maîtrisez maintenant :

  • CodeCommit pour le contrôle de source
  • CodeBuild pour les builds et tests
  • CodeDeploy pour les déploiements
  • CodePipeline pour l'orchestration
  • ECR pour les images Docker
  • CloudWatch et X-Ray pour le monitoring
  • Les bonnes pratiques de sécurité et d'architecture

Prochaines étapes​

  • Pratiquer avec des projets réels
  • Passer la certification AWS DevOps Professional
  • Explorer AWS CDK pour l'IaC
  • Étudier EKS pour Kubernetes sur AWS

← Retour à la table des matières