Atelier pratique — DOP-C02 AWS Certified DevOps Engineer Professional

Présentation

Prérequis

Étapes

1. 1.Choisir notre version de Terraform et notre région AWS

   Introduction standard. Les services Code* sont régionaux — choisissez la région que vos dépôts sources et environnements cibles partagent. Par défaut, us-east-1 pour le laboratoire.

   Copier

   terraform {
     required_version = ">= 1.5"
   
     required_providers {
       aws = {
         source  = "hashicorp/aws"
         version = "~> 5.60"
       }
     }
   }
   
   provider "aws" {
     region = "us-east-1"
   
     default_tags {
       tags = {
         Project   = "certlabpro-dop-c02"
         ManagedBy = "terraform"
       }
     }
   }
   
   resource "aws_s3_bucket" "artifacts" {
     bucket_prefix = "certlabpro-dop-c02-artifacts-"
   }
   
   resource "aws_s3_bucket_public_access_block" "artifacts" {
     bucket = aws_s3_bucket.artifacts.id
   
     block_public_acls       = true
     block_public_policy     = true
     ignore_public_acls      = true
     restrict_public_buckets = true
   }

2. 2.Créer un dépôt CodeCommit avec un buildspec de démarrage

   Déploie :

   • AWS CodeCommit

   CodeCommit est l'hôte Git d'AWS. Le DOP-C02 teste la suite Code* de bout en bout comme une histoire étroitement intégrée — les questions d'examen les plus courantes demandent quelle combinaison de services AWS natifs permet d'atteindre un résultat donné, et la réponse commence presque toujours par CodeCommit.

   Le default_branch = "main" correspond aux valeurs par défaut modernes de Git (CodeCommit créait historiquement master). Le dépôt que nous créons est vide après apply ; en utilisation réelle, vous pousseriez votre premier commit avec un buildspec.yml et un appspec.yml à la racine — ce sont les fichiers que CodeBuild (Étape 3) et CodeDeploy (Étape 4) lisent à chaque exécution de pipeline.

   Copier

   resource "aws_codecommit_repository" "app" {
     repository_name = "certlabpro-dop-c02-app"
     description     = "Application source for the DOP-C02 lab pipeline."
     default_branch  = "main"
   }

3. 3.Mettre en place un projet CodeBuild qui compile et teste à chaque push

   Déploie :

   • AWS CodeBuild
   • AWS IAM

   CodeBuild exécute les étapes de build et de test de votre buildspec.yml. Le DOP-C02 teste ici le compromis image gérée versus image personnalisée — les images gérées ne nécessitent aucune maintenance mais démarrent plus lentement ; les images personnalisées offrent un démarrage à froid plus rapide et des chaînes d'outils reproductibles. Le laboratoire utilise l'image gérée aws/codebuild/standard:7.0, qui couvre Node, Python, Java, Go, .NET, Ruby nativement.

   Le rôle IAM donne à CodeBuild l'autorisation d'écrire dans les logs CloudWatch (pour la sortie de build), de lire la source depuis CodeCommit, et d'écrire les artefacts dans le bucket S3 de l'Étape 1. LINUX_CONTAINER + BUILD_GENERAL1_SMALL est le niveau le moins cher à 0,005 $/minute de build.

   Copier

   resource "aws_iam_role" "codebuild" {
     name = "certlabpro-dop-c02-codebuild"
   
     assume_role_policy = jsonencode({
       Version = "2012-10-17"
       Statement = [{
         Effect    = "Allow"
         Principal = { Service = "codebuild.amazonaws.com" }
         Action    = "sts:AssumeRole"
       }]
     })
   }
   
   resource "aws_iam_role_policy" "codebuild" {
     name = "build-permissions"
     role = aws_iam_role.codebuild.id
   
     policy = jsonencode({
       Version = "2012-10-17"
       Statement = [
         {
           Effect   = "Allow"
           Action   = ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"]
           Resource = "*"
         },
         {
           Effect   = "Allow"
           Action   = ["s3:GetObject", "s3:PutObject", "s3:ListBucket"]
           Resource = [aws_s3_bucket.artifacts.arn, "${aws_s3_bucket.artifacts.arn}/*"]
         },
         {
           Effect   = "Allow"
           Action   = "codecommit:GitPull"
           Resource = aws_codecommit_repository.app.arn
         },
       ]
     })
   }
   
   resource "aws_codebuild_project" "build" {
     name         = "certlabpro-dop-c02-build"
     service_role = aws_iam_role.codebuild.arn
   
     source {
       type     = "CODEPIPELINE"
       buildspec = "buildspec.yml"
     }
   
     artifacts {
       type = "CODEPIPELINE"
     }
   
     environment {
       type            = "LINUX_CONTAINER"
       image           = "aws/codebuild/standard:7.0"
       compute_type    = "BUILD_GENERAL1_SMALL"
       privileged_mode = false
     }
   }

4. 4.Configurer CodeDeploy avec un groupe de déploiement bleu/vert

   Déploie :

   • AWS CodeDeploy
   • AWS IAM

   CodeDeploy gère le déploiement réel — vers EC2, Lambda ou ECS. Le DOP-C02 teste l'axe de la stratégie de déploiement à plusieurs reprises : AllAtOnce (le moins cher, le plus risqué), HalfAtATime, OneAtATime, CodeDeployDefault.LambdaCanary10Percent5Minutes (le modèle de canari Lambda), et CodeDeployDefault.ECSAllAtOnce. Nous choisissons la plateforme de calcul Lambda pour le laboratoire car elle ne nécessite pas l'existence d'instances EC2 — ce qui maintient le laboratoire peu coûteux et étroitement ciblé.

   La configuration de déploiement CodeDeployDefault.LambdaAllAtOnce est la plus simple des stratégies Lambda. En production, LambdaCanary10Percent5Minutes est la réponse DOP-C02 la plus fréquemment recommandée pour les déploiements à risque atténué : elle déplace 10 % du trafic vers la nouvelle version, attend 5 minutes pour les alarmes CloudWatch, puis déplace le reste si rien ne se déclenche.

   Copier

   resource "aws_iam_role" "codedeploy" {
     name = "certlabpro-dop-c02-codedeploy"
   
     assume_role_policy = jsonencode({
       Version = "2012-10-17"
       Statement = [{
         Effect    = "Allow"
         Principal = { Service = "codedeploy.amazonaws.com" }
         Action    = "sts:AssumeRole"
       }]
     })
   }
   
   resource "aws_iam_role_policy_attachment" "codedeploy_lambda" {
     role       = aws_iam_role.codedeploy.name
     policy_arn = "arn:aws:iam::aws:policy/service-role/AWSCodeDeployRoleForLambda"
   }
   
   resource "aws_codedeploy_app" "app" {
     name             = "certlabpro-dop-c02-app"
     compute_platform = "Lambda"
   }
   
   resource "aws_codedeploy_deployment_group" "lambda" {
     app_name               = aws_codedeploy_app.app.name
     deployment_group_name  = "default"
     service_role_arn       = aws_iam_role.codedeploy.arn
     deployment_config_name = "CodeDeployDefault.LambdaAllAtOnce"
   
     deployment_style {
       deployment_option = "WITH_TRAFFIC_CONTROL"
       deployment_type   = "BLUE_GREEN"
     }
   
     auto_rollback_configuration {
       enabled = true
       events  = ["DEPLOYMENT_FAILURE"]
     }
   }

5. 5.Lier source → build → deploy avec CodePipeline, puis ajouter un canari Synthetics

   Déploie :

   • AWS CodePipeline
   • Amazon CloudWatch Synthetics

   CodePipeline est l'orchestrateur qui relie les trois étapes précédentes en un seul graphe : source depuis CodeCommit, build avec CodeBuild, déploiement avec CodeDeploy. Chaque transition est un point d'accroche — vous pouvez ajouter des approbations manuelles, des étapes de test parallèles et des notifications entre deux étapes. Le domaine Gestion de la Configuration et IaC du DOP-C02 teste cette structure d'étapes et d'actions à plusieurs reprises.

   Une fois le pipeline existant, vous disposez du CI/CD. La dernière pièce — CloudWatch Synthetics — boucle la boucle sur l'observabilité du déploiement : un canari est un script de navigateur sans tête géré (basé sur Puppeteer) qui s'exécute selon un calendrier et signale le succès/l'échec à CloudWatch. Le domaine Surveillance et Logging du DOP-C02 s'appuie fortement sur ce modèle : déployer un changement → le canari détecte la régression en quelques minutes → le rollback automatique de CodeDeploy (que nous avons configuré à l'Étape 4) se déclenche à partir de l'alarme CloudWatch du canari.

   Le script de canari ci-dessous interroge https://example.com toutes les 5 minutes ; en production, vous le pointeriez vers le point de terminaison de santé de votre application, avec des assertions sur le corps de la réponse et les en-têtes, pas seulement le HTTP 200.

   Copier

   # ── CodePipeline ──────────────────────────────────────────────
   resource "aws_iam_role" "codepipeline" {
     name = "certlabpro-dop-c02-codepipeline"
   
     assume_role_policy = jsonencode({
       Version = "2012-10-17"
       Statement = [{
         Effect    = "Allow"
         Principal = { Service = "codepipeline.amazonaws.com" }
         Action    = "sts:AssumeRole"
       }]
     })
   }
   
   resource "aws_iam_role_policy" "codepipeline" {
     name = "pipeline-permissions"
     role = aws_iam_role.codepipeline.id
   
     policy = jsonencode({
       Version = "2012-10-17"
       Statement = [{
         Effect = "Allow"
         Action = [
           "codecommit:*",
           "codebuild:*",
           "codedeploy:*",
           "s3:*",
           "iam:PassRole",
         ]
         Resource = "*"
       }]
     })
   }
   
   resource "aws_codepipeline" "main" {
     name     = "certlabpro-dop-c02"
     role_arn = aws_iam_role.codepipeline.arn
   
     artifact_store {
       location = aws_s3_bucket.artifacts.bucket
       type     = "S3"
     }
   
     stage {
       name = "Source"
       action {
         name             = "Source"
         category         = "Source"
         owner            = "AWS"
         provider         = "CodeCommit"
         version          = "1"
         output_artifacts = ["source"]
         configuration = {
           RepositoryName = aws_codecommit_repository.app.repository_name
           BranchName     = "main"
         }
       }
     }
   
     stage {
       name = "Build"
       action {
         name             = "Build"
         category         = "Build"
         owner            = "AWS"
         provider         = "CodeBuild"
         version          = "1"
         input_artifacts  = ["source"]
         output_artifacts = ["build"]
         configuration = {
           ProjectName = aws_codebuild_project.build.name
         }
       }
     }
   }
   
   # ── Synthetics canary ─────────────────────────────────────────
   resource "aws_iam_role" "canary" {
     name = "certlabpro-dop-c02-canary"
   
     assume_role_policy = jsonencode({
       Version = "2012-10-17"
       Statement = [{
         Effect    = "Allow"
         Principal = { Service = "lambda.amazonaws.com" }
         Action    = "sts:AssumeRole"
       }]
     })
   }
   
   resource "aws_iam_role_policy_attachment" "canary_logs" {
     role       = aws_iam_role.canary.name
     policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
   }
   
   data "archive_file" "canary_src" {
     type        = "zip"
     output_path = "${path.module}/build/canary.zip"
   
     source {
       filename = "nodejs/node_modules/index.js"
       content  = <<-EOT
         const synthetics = require("Synthetics");
         exports.handler = async () => {
           const page = await synthetics.getPage();
           const res = await page.goto("https://example.com", { waitUntil: "domcontentloaded" });
           if (!res.ok()) throw new Error("Status code " + res.status());
         };
       EOT
     }
   }
   
   resource "aws_synthetics_canary" "endpoint" {
     name                 = "certlabpro-dop-c02-endpoint"
     artifact_s3_location = "s3://${aws_s3_bucket.artifacts.bucket}/canary/"
     execution_role_arn   = aws_iam_role.canary.arn
     handler              = "index.handler"
     zip_file             = data.archive_file.canary_src.output_path
     runtime_version      = "syn-nodejs-puppeteer-9.0"
     start_canary         = true
   
     schedule {
       expression = "rate(5 minutes)"
     }
   }

Nettoyage