हैड्स-ऑन लैब — DOP-C02 AWS Certified DevOps Engineer Professional

अवलोकन

पूर्व-आवश्यकताएं

चरण

1. 1.हमारा टेराफॉर्म संस्करण और AWS क्षेत्र चुनें

   मानक शुरुआत। Code* सेवाएँ क्षेत्रीय हैं — वह क्षेत्र चुनें जिसे आपके स्रोत रेपो और लक्ष्य वातावरण साझा करते हैं। लैब के लिए us-east-1 पर डिफ़ॉल्ट।

   कॉपी

   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.एक स्टार्टर बिल्डस्पेक के साथ एक कोडकमिट रिपॉजिटरी बनाएँ

   प्रोविज़न:

   • AWS CodeCommit

   कोडकमिट AWS गिट होस्ट है। DOP-C02 कोड* सूट को एक कसकर एकीकृत कहानी के रूप में एंड-टू-एंड का परीक्षण करता है — सबसे आम परीक्षा प्रश्न पूछते हैं कि कौन सा AWS-देशी सेवा संयोजन एक दिए गए परिणाम को प्राप्त करता है, और उत्तर लगभग हमेशा कोडकमिट से शुरू होता है।

   default_branch = "main" आधुनिक गिट डिफॉल्ट्स से मेल खाता है (कोडकमिट ने ऐतिहासिक रूप से master बनाया था)। apply के बाद हम जो रेपो बनाते हैं वह खाली होता है; वास्तविक उपयोग में आप buildspec.yml और appspec.yml के साथ अपनी पहली कमिट को रूट पर पुश करेंगे — ये वे फ़ाइलें हैं जिन्हें कोडबिल्ड (चरण 3) और कोडडिप्लॉय (चरण 4) प्रत्येक पाइपलाइन रन पर पढ़ते हैं।

   कॉपी

   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.एक कोडबिल्ड प्रोजेक्ट सेट करें जो हर पुश पर संकलित और परीक्षण करता है

   प्रोविज़न:

   • AWS CodeBuild
   • AWS IAM

   कोडबिल्ड आपकी buildspec.yml से बिल्ड और टेस्ट चरणों को चलाता है। DOP-C02 यहाँ प्रबंधित-छवि बनाम कस्टम-छवि ट्रेड-ऑफ का परीक्षण करता है — प्रबंधित छवियाँ शून्य-रखरखाव वाली होती हैं लेकिन शुरू होने में धीमी होती हैं; कस्टम छवियाँ आपको तेज़ कोल्ड-स्टार्ट और दोहराने योग्य टूलचेन देती हैं। लैब प्रबंधित aws/codebuild/standard:7.0 छवि का उपयोग करती है, जिसमें Node, Python, Java, Go, .NET, Ruby आउट ऑफ़ द बॉक्स शामिल हैं।

   IAM भूमिका कोडबिल्ड को क्लाउडवॉच लॉग्स में लिखने (बिल्ड आउटपुट के लिए), कोडकमिट से स्रोत पढ़ने, और चरण 1 से S3 बकेट में कलाकृतियों को लिखने की अनुमति देती है। LINUX_CONTAINER + BUILD_GENERAL1_SMALL $0.005/बिल्ड-मिनट पर सबसे सस्ता टियर है।

   कॉपी

   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.ब्लू/ग्रीन डिप्लॉयमेंट ग्रुप के साथ कोडडिप्लॉय को कनेक्ट करें

   प्रोविज़न:

   • AWS CodeDeploy
   • AWS IAM

   कोडडिप्लॉय वास्तविक रोलआउट को संभालता है — EC2, लैम्ब्डा, या ECS पर। DOP-C02 परिनियोजन-रणनीति धुरी का बार-बार परीक्षण करता है: AllAtOnce (सबसे सस्ता, सबसे डरावना), HalfAtATime, OneAtATime, CodeDeployDefault.LambdaCanary10Percent5Minutes (लैम्ब्डा कैनरी पैटर्न), और CodeDeployDefault.ECSAllAtOnce। हम लैब के लिए लैम्ब्डा कंप्यूट प्लेटफॉर्म चुनते हैं क्योंकि इसके लिए EC2 इंस्टेंस की वास्तविक रूप से आवश्यकता नहीं होती है — यह लैब को सस्ता और कसकर केंद्रित रखता है।

   परिनियोजन कॉन्फ़िगरेशन CodeDeployDefault.LambdaAllAtOnce लैम्ब्डा रणनीतियों में सबसे सरल है। उत्पादन में, जोखिम-कम करने वाले परिनियोजनों के लिए LambdaCanary10Percent5Minutes सबसे अधिक बार अनुशंसित DOP-C02 उत्तर है: यह ट्रैफ़िक का 10% नए संस्करण में स्थानांतरित करता है, क्लाउडवॉच अलार्म के लिए 5 मिनट इंतजार करता है, फिर यदि कोई समस्या नहीं होती है तो शेष को स्थानांतरित करता है।

   कॉपी

   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.कोडपाइपलाइन के साथ स्रोत → बिल्ड → डिप्लॉय को जोड़ें, फिर एक सिंथेटिक्स कैनरी जोड़ें

   प्रोविज़न:

   • AWS CodePipeline
   • Amazon CloudWatch Synthetics

   कोडपाइपलाइन वह ऑर्केस्ट्रेटर है जो पिछले तीन चरणों को एक एकल ग्राफ में जोड़ता है: कोडकमिट से स्रोत, कोडबिल्ड के साथ बिल्ड, कोडडिप्लॉय के साथ डिप्लॉय। हर संक्रमण एक हुक पॉइंट है — आप किसी भी दो चरणों के बीच मैन्युअल अनुमोदन, समानांतर परीक्षण चरण और सूचनाएं जोड़ सकते हैं। DOP-C02 का कॉन्फ़िगरेशन प्रबंधन और IaC डोमेन इस चरण-और-कार्य संरचना का बार-बार परीक्षण करता है।

   एक बार पाइपलाइन मौजूद होने पर, आपके पास CI/CD होता है। अंतिम टुकड़ा — क्लाउडवॉच सिंथेटिक्स — परिनियोजन अवलोकन क्षमता पर लूप को बंद करता है: एक कैनरी एक प्रबंधित हेडलेस-ब्राउज़र स्क्रिप्ट (पपेटियर-आधारित) है जो एक शेड्यूल पर चलती है और क्लाउडवॉच को सफलता/विफलता की रिपोर्ट करती है। DOP-C02 का मॉनिटरिंग और लॉगिंग डोमेन इस पैटर्न पर बहुत अधिक निर्भर करता है: एक बदलाव को परिनियोजित करें → कैनरी मिनटों के भीतर प्रतिगमन को पकड़ लेता है → कोडडिप्लॉय ऑटो-रोलबैक (जिसे हमने चरण 4 में जोड़ा था) कैनरी के क्लाउडवॉच अलार्म से ट्रिगर होता है।

   नीचे दिया गया कैनरी स्क्रिप्ट हर 5 मिनट में https://example.com को पोल करता है; उत्पादन में आप इसे अपने एप्लिकेशन के हेल्थ एंडपॉइंट पर इंगित करेंगे, जिसमें प्रतिक्रिया निकाय और हेडर्स पर दावे होंगे, न कि केवल HTTP 200।

   कॉपी

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

क्लीनअप (Cleanup)