Praxislabor — DOP-C02 AWS Certified DevOps Engineer Professional

Übersicht

Voraussetzungen

Schritte

1. 1.Terraform-Version und AWS-Region auswählen

   Standardeinstieg. Die Code*-Dienste sind regional – wählen Sie die Region, die Ihre Quell-Repositories und Zielumgebungen gemeinsam nutzen. Für das Lab wird standardmäßig us-east-1 verwendet.

   Kopieren

   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.Ein CodeCommit-Repository mit einer Starter-Buildspec erstellen

   Ressourcen:

   • AWS CodeCommit

   CodeCommit ist der AWS Git-Host. DOP-C02 testet die Code*-Suite End-to-End als eine eng integrierte Lösung – die häufigsten Prüfungsfragen stellen, welche AWS-native Dienstkombination ein bestimmtes Ergebnis erzielt, und die Antwort beginnt fast immer mit CodeCommit.

   Der default_branch = "main" entspricht modernen Git-Standards (CodeCommit erstellte historisch master). Das von uns erstellte Repository ist nach apply leer; in der realen Nutzung würden Sie Ihren ersten Commit mit einer buildspec.yml und appspec.yml im Stammverzeichnis pushen – das sind die Dateien, die CodeBuild (Schritt 3) und CodeDeploy (Schritt 4) bei jedem Pipeline-Lauf lesen.

   Kopieren

   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.Ein CodeBuild-Projekt einrichten, das bei jedem Push kompiliert und testet

   Ressourcen:

   • AWS CodeBuild
   • AWS IAM

   CodeBuild führt die Build- und Testschritte aus Ihrer buildspec.yml aus. DOP-C02 testet hier den Kompromiss zwischen „verwaltetem Image und benutzerdefiniertem Image“ – verwaltete Images sind wartungsfrei, aber langsamer im Start; benutzerdefinierte Images bieten einen schnelleren Kaltstart und reproduzierbare Toolchains. Das Lab verwendet das verwaltete Image aws/codebuild/standard:7.0, das Node, Python, Java, Go, .NET, Ruby sofort unterstützt.

   Die IAM-Rolle erteilt CodeBuild die Berechtigung, in CloudWatch Logs (für die Build-Ausgabe) zu schreiben, die Quelle von CodeCommit zu lesen und Artefakte in den S3-Bucket aus Schritt 1 zu schreiben. LINUX_CONTAINER + BUILD_GENERAL1_SMALL ist die günstigste Stufe mit 0,005 $ pro Build-Minute.

   Kopieren

   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.CodeDeploy mit einer Blue/Green-Bereitstellungsgruppe verbinden

   Ressourcen:

   • AWS CodeDeploy
   • AWS IAM

   CodeDeploy übernimmt den eigentlichen Rollout – auf EC2, Lambda oder ECS. DOP-C02 testet die Bereitstellungsstrategie-Achse wiederholt: AllAtOnce (am günstigsten, am riskantesten), HalfAtATime, OneAtATime, CodeDeployDefault.LambdaCanary10Percent5Minutes (das Lambda-Canary-Muster) und CodeDeployDefault.ECSAllAtOnce. Wir wählen für das Lab die Lambda-Compute-Plattform, weil sie keine tatsächlich existierenden EC2-Instanzen erfordert – das hält das Lab kostengünstig und eng begrenzt.

   Die Bereitstellungskonfiguration CodeDeployDefault.LambdaAllAtOnce ist die einfachste der Lambda-Strategien. In der Produktion ist LambdaCanary10Percent5Minutes die am häufigsten empfohlene DOP-C02-Antwort für risikominimierte Bereitstellungen: Sie verlagert 10 % des Datenverkehrs auf die neue Version, wartet 5 Minuten auf CloudWatch-Alarme und verlagert dann den Rest, wenn nichts ausgelöst wird.

   Kopieren

   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.Quelle → Build → Bereitstellung mit CodePipeline verbinden und anschließend einen Synthetics Canary hinzufügen

   Ressourcen:

   • AWS CodePipeline
   • Amazon CloudWatch Synthetics

   CodePipeline ist der Orchestrator, der die vorherigen drei Schritte in einem einzigen Graphen verbindet: Quellcode von CodeCommit, Build mit CodeBuild, Bereitstellung mit CodeDeploy. Jeder Übergang ist ein Hook-Point – Sie können manuelle Genehmigungen, parallele Teststufen und Benachrichtigungen zwischen beliebigen zwei Stufen hinzufügen. Die DOP-C02-Domäne Konfigurationsmanagement und IaC testet diese Stufen- und Aktionsstruktur wiederholt.

   Sobald die Pipeline existiert, haben Sie CI/CD. Der letzte Teil – CloudWatch Synthetics – schließt den Kreis der Deployment-Beobachtbarkeit: Ein Canary ist ein verwaltetes Headless-Browser-Skript (Puppeteer-basiert), das nach einem Zeitplan ausgeführt wird und Erfolg/Misserfolg an CloudWatch meldet. Die DOP-C02-Domäne Monitoring und Logging stützt sich stark auf dieses Muster: eine Änderung bereitstellen → Canary fängt die Regression innerhalb von Minuten ab → CodeDeploy Auto-Rollback (das wir in Schritt 4 eingerichtet haben) wird durch den CloudWatch-Alarm des Canary ausgelöst.

   Das Canary-Skript unten fragt https://example.com alle 5 Minuten ab; in der Produktion würden Sie es auf den Health-Endpunkt Ihrer Anwendung richten, mit Zusicherungen auf den Antworttext und die Header, nicht nur HTTP 200.

   Kopieren

   # ── 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)"
     }
   }

Bereinigung