使用 AWS CDK 构建 CodePipeline 流水线:将 Docker 镜像自动构建并部署到 ECS Fargate

原创2026-10-14 13:44:131,634 阅读

使用 AWS CDK 构建 CodePipeline 流水线:将 Docker 镜像自动构建并部署到 ECS Fargate

导读

本文基于 aws-cdk-examples 仓库中的 python/codepipeline-build-deploy-github-manual 示例,讲解如何用 AWS CDK(Python)一次性编排出"GitHub 源码拉取 → CodeBuild 构建 Docker 镜像并推送 ECR → CodeDeploy 蓝绿部署到 ECS Fargate"的完整 CI/CD 流水线。读完本文,你将掌握该示例的架构设计、每个 CDK 构造(Construct)的作用、关键配置文件(buildspec.yaml、appspec.yaml、taskdef.json)的占位符替换机制,以及从本地部署到线上验证的完整实操流程。

示例概述:一条端到端的容器 CI/CD 流水线

在快节奏的开发环境中,CI/CD(持续集成与持续交付)流水线被广泛用于自动构建、测试与部署应用变更,使新功能与缺陷修复能够跨账户、跨环境快速上线。该示例正是这一理念在 AWS 上的落地实现:

  • CodePipeline 负责编排整个流水线,包含 Source(源码)、Build(构建)、Deploy(部署)三个阶段;
  • CodeBuild 在构建阶段根据 buildspec.yaml 执行 Docker 构建,并把镜像推送到 ECR;
  • CodeDeploy 通过蓝绿部署方式,将新版本任务定义滚动替换到 ECS Fargate 服务上;
  • ECS + Fargate 以无服务器方式托管容器应用,容器通过公共 Application Load Balancer(ALB)对外提供服务;
  • 此外还用到 Lambda(作为自定义资源在部署初期触发首次镜像构建)与 ECR(存放镜像)。

流水线名称为 ImageBuildDeployPipeline,源码来源是手动创建的 GitHub 仓库(GitHub 凭据以 Secrets Manager 密文保存),这正是示例名称中 "github-manual" 的含义。

前置条件

在动手部署前,需要准备以下环境与资源:

  1. Python 3.6+,用于运行 CDK Python 应用。
  2. AWS CDK v2.x(Python 版本),示例依赖声明于 requirements.txt:
    aws-cdk-lib>=2.262.0,<3.0.0
    constructs>=10.5.0,<11.0.0
    
  3. GitHub 账户,并创建 Personal Access Token(PAT)。测试场景下只需勾选 repo 权限即可授予对仓库的完整访问权。
  4. 将 GitHub PAT 存入 AWS Secrets Manager。先用 AWS CLI 完成 AWS 账户认证,再执行以下命令(该密文后续会被 CodePipeline 与 CodeBuild 用来向 GitHub 鉴权):
    $ GITHUB_ACCESS_TOKEN='your Github access token'
    $ REGION=us-east-1
    $ aws secretsmanager create-secret --name github-access-token-secret --description "Github access token" --secret-string $GITHUB_ACCESS_TOKEN --region $REGION
    

    注意:示例代码中固定引用了密文名 github-access-token-secret(见下文源码解析),创建 Secret 时必须使用完全一致的名称。

  5. 准备你的 GitHub 仓库:
    • 创建一个新的 GitHub 仓库并克隆到本地;
    • 将本示例 app/ 目录下的所有文件与目录复制到该仓库根目录。

复制完成后,你的 GitHub 仓库应具有如下结构(README 中给出的标准布局):

.
├── Dockerfile
├── README.md
├── appspec.yaml
├── buildspec.yaml
├── site-assets
│   ├── about.html
│   ├── contact.html
│   ├── error.html
│   ├── index.html
│   └── styles.css
└── taskdef.json

2 directories, 10 files

示例目录结构速览

该示例在仓库中的完整布局如下(相对仓库根目录):

python/codepipeline-build-deploy-github-manual/
├── app/                        # 待复制进 GitHub 仓库的应用代码
│   ├── Dockerfile              # Nginx 容器镜像定义
│   ├── appspec.yaml            # CodeDeploy 蓝绿部署的应用规范模板
│   ├── buildspec.yaml          # CodeBuild 构建指令
│   ├── taskdef.json            # ECS 任务定义模板(含占位符)
│   ├── README.md
│   └── site-assets/            # 静态站点资源(4 个 HTML + 1 个 CSS)
├── codepipeline_build_deploy/
│   ├── __init__.py
│   └── codepipeline_build_deploy_stack.py   # 核心 CDK 堆栈
├── lambda/
│   └── trigger-build.js        # 触发首次 CodeBuild 的 Lambda 函数
├── tests/unit/
│   ├── __init__.py
│   └── test_codepipeline_build_deploy_stack.py  # 单元测试
├── app.py                      # CDK 应用入口
├── cdk.json
├── requirements.txt            # 运行时依赖
└── requirements-dev.txt        # 测试依赖(pytest)

其中 app.py 是 CDK 应用入口,实例化 CodepipelineBuildDeployStack(app.py):

#!/usr/bin/env python3
import os

import aws_cdk as cdk

from codepipeline_build_deploy.codepipeline_build_deploy_stack import CodepipelineBuildDeployStack


app = cdk.App()
CodepipelineBuildDeployStack(app, "CodepipelineBuildDeployStack",
    # 默认不指定 env,堆栈与环境无关(environment-agnostic)
    # 如需固定部署账户/区域,可取消注释下一行:
    #env=cdk.Environment(account=os.getenv('CDK_DEFAULT_ACCOUNT'), region=os.getenv('CDK_DEFAULT_REGION')),
    )

app.synth()

堆栈源码解析:从 ECR 到 CodePipeline

核心逻辑集中在 codepipeline_build_deploy_stack.py(约 270 行),下面按资源创建顺序逐段拆解。

1. ECR 镜像仓库

# Creates an Elastic Container Registry (ECR) image repository
image_repo = ecr.Repository(self, "ImageRepo")

CDK 会为该仓库自动生成名称,后续 CodeBuild 通过环境变量拿到 repository_name 与 repository_uri 完成推送。

2. Fargate 任务定义

fargate_task_def = ecs.FargateTaskDefinition(self, "FargateTaskDef")
fargate_task_def.add_container(
    "Container",
    container_name="web",
    image=ecs.ContainerImage.from_ecr_repository(image_repo),
    port_mappings=[{"containerPort": 80}]
)

任务定义直接引用 ECR 仓库作为容器镜像来源,容器名固定为 web(与 appspec.yaml、taskdef.json 中的 ContainerName/name 字段保持一致),对外暴露 80 端口。

3. CodeBuild 构建项目

build_image = codebuild.Project(
    self, "BuildImage",
    build_spec=codebuild.BuildSpec.from_source_filename("buildspec.yaml"),
    source=codebuild.Source.git_hub(
        owner="github_user",    # TODO: Replace with your GitHub username
        repo="repo_name",       # TODO: Replace with your GitHub repository name
        branch_or_ref="main",
    ),
    environment=codebuild.BuildEnvironment(privileged=True),
    environment_variables={
        "AWS_ACCOUNT_ID": codebuild.BuildEnvironmentVariable(value=os.getenv('CDK_DEFAULT_ACCOUNT') or ""),
        "REGION": codebuild.BuildEnvironmentVariable(value=os.getenv('CDK_DEFAULT_REGION') or ""),
        "IMAGE_TAG": codebuild.BuildEnvironmentVariable(value="latest"),
        "IMAGE_REPO_NAME": codebuild.BuildEnvironmentVariable(value=image_repo.repository_name),
        "REPOSITORY_URI": codebuild.BuildEnvironmentVariable(value=image_repo.repository_uri),
        "TASK_DEFINITION_ARN": codebuild.BuildEnvironmentVariable(value=fargate_task_def.task_definition_arn),
        "TASK_ROLE_ARN": codebuild.BuildEnvironmentVariable(value=fargate_task_def.task_role.role_arn),
        "EXECUTION_ROLE_ARN": codebuild.BuildEnvironmentVariable(value=fargate_task_def.execution_role.role_arn)
    }
)

几个关键点:

  • privileged=True:Docker-in-Docker 构建所必需,否则 docker build 无法在 CodeBuild 环境内执行;
  • BuildSpec.from_source_filename("buildspec.yaml"):构建指令直接取自 GitHub 仓库根目录下的 buildspec.yaml;
  • 环境变量把账户、区域、镜像仓库信息以及任务定义的 ARN 与角色 ARN注入构建过程,供 buildspec.yaml 后续完成镜像推送与模板占位符替换;
  • 构建环境变量中的 TASK_DEFINITION_ARN/TASK_ROLE_ARN/EXECUTION_ROLE_ARN 均来自 CDK 合成的 Fargate 任务定义,保证了 CodeDeploy 最终引用的任务定义与 CDK 创建的一致。

随后通过 image_repo.grant_pull_push(build_image) 向 CodeBuild 项目授予 ECR 拉取/推送权限。

4. Lambda 触发器:解决"先有鸡还是先有蛋"

trigger_code_build = lambda_.Function(
    self, "BuildLambda",
    architecture=lambda_.Architecture.ARM_64,
    code=lambda_.Code.from_asset("lambda"),
    handler="trigger-build.handler",
    runtime=lambda_.Runtime.NODEJS_18_X,
    environment={
        "CODEBUILD_PROJECT_NAME": build_image.project_name,
        "REGION": os.getenv('CDK_DEFAULT_REGION') or ""
    },
    initial_policy=[
        iam.PolicyStatement(
            effect=iam.Effect.ALLOW,
            actions=["codebuild:StartBuild"],
            resources=[build_image.project_arn]
        )
    ]
)

该函数运行 Node.js 18(ARM_64 架构),源码位于 lambda/trigger-build.js,逻辑非常直接:

const {
  CodeBuildClient,
  StartBuildCommand,
} = require("@aws-sdk/client-codebuild");

exports.handler = async (event) => {
  const region = process.env.REGION;
  const buildProjectName = process.env.CODEBUILD_PROJECT_NAME;

  const codebuild = new CodeBuildClient({ region: region });
  const buildCommand = new StartBuildCommand({ projectName: buildProjectName });

  console.log("Triggering CodeBuild Project...");
  const buildResponse = await codebuild.send(buildCommand);
  console.log(buildResponse);

  return {
    statusCode: 200,
    body: "CodeBuild Project building...",
  };
};

再通过 AwsCustomResource(custom_resources)在堆栈创建(on_create)与更新(on_update)时以 Event 方式异步调用该 Lambda:

trigger_lambda = custom.AwsCustomResource(
    self, "BuildLambdaTrigger",
    install_latest_aws_sdk=True,
    policy=custom.AwsCustomResourcePolicy.from_statements([
        iam.PolicyStatement(
            effect=iam.Effect.ALLOW,
            actions=["lambda:InvokeFunction"],
            resources=[trigger_code_build.function_arn],
        )
    ]),
    on_create={
        "service": "Lambda",
        "action": "invoke",
        "physical_resource_id": custom.PhysicalResourceId.of("id"),
        "parameters": {
            "FunctionName": trigger_code_build.function_name,
            "InvocationType": "Event",
        },
    },
    on_update={
        "service": "Lambda",
        "action": "invoke",
        "parameters": {
            "FunctionName": trigger_code_build.function_name,
            "InvocationType": "Event",
        },
    }
)

这样设计的动机:CodeDeploy 蓝绿部署时,ALB 的监听器会先指向蓝色(blue)目标组;如果该目标组中没有任何可用目标(EC2/IP 地址),部署会一直无法完成。因此堆栈在创建 ECS 集群与 VPC 之前,先通过这条自定义资源触发一次 CodeBuild 构建,把首个镜像推送进 ECR,从而让 Fargate 服务启动时能够拉到镜像并注册进蓝色目标组。这一依赖关系在源码中也有显式表达:

# Deploys the cluster VPC after the initial image build triggers
cluster_vpc.node.add_dependency(trigger_lambda)

5. VPC、安全组与蓝绿目标组

cluster_vpc = ec2.Vpc(
    self, "ClusterVpc",
    ip_addresses=ec2.IpAddresses.cidr(cidr_block="10.75.0.0/16")
)

target_group_blue = elb.ApplicationTargetGroup(
    self, "BlueTargetGroup",
    target_group_name="alb-blue-tg",
    target_type=elb.TargetType.IP,
    port=80,
    vpc=cluster_vpc
)

target_group_green = elb.ApplicationTargetGroup(
    self, "GreenTargetGroup",
    target_group_name="alb-green-tg",
    target_type=elb.TargetType.IP,
    port=80,
    vpc=cluster_vpc
)
  • VPC 使用 10.75.0.0/16 的 CIDR,由 CDK 自动创建子网、路由等;
  • 蓝色与绿色目标组都采用 TargetType.IP(Fargate 任务以私有 IP 注册)、端口 80;
  • ALB 安全组放行全部 IPv4 对 80 端口的入站流量:
albSg.add_ingress_rule(
    peer=ec2.Peer.any_ipv4(),
    connection=ec2.Port.tcp(80),
    description="Allows access on port 80/http",
    remote_rule=False
)

ALB 本身为 internet_facing=True 的公共负载均衡器,默认监听器(80 端口)把流量转发给蓝色目标组。

6. ECS Fargate 服务与 CodeDeploy 控制器

fargate_service = ecs.FargateService(
    self, "FargateService",
    desired_count=1,
    service_name="fargate-frontend-service",
    task_definition=fargate_task_def,
    cluster=ecs.Cluster(
        self, "EcsCluster",
        enable_fargate_capacity_providers=True,
        vpc=cluster_vpc
    ),
    deployment_controller=ecs.DeploymentController(
        type=ecs.DeploymentControllerType.CODE_DEPLOY
    ),
)

fargate_service.attach_to_application_target_group(target_group_blue)

核心是 DeploymentControllerType.CODE_DEPLOY:把 ECS 服务的部署控制权交给 CodeDeploy,这样 ECS 原生滚动部署会被禁用,改由 CodeDeploy 驱动蓝绿切换。单元测试 test_codepipeline_build_deploy_stack.py 正是对此的断言:

def test_deployment_controller_set():
    app = core.App()
    stack = CodepipelineBuildDeployStack(app, "codepipeline-build-deploy")
    template = assertions.Template.from_stack(stack)

    # Checks if the ECS Deployment Controller is set to AWS CodeDeploy
    template.has_resource_properties("AWS::ECS::Service", {
        "DeploymentController": {
            "Type": "CODE_DEPLOY"
        }
    })

7. CodePipeline 三阶段流水线

流水线包含 Source、Build、Deploy 三个阶段,外加一个 CodeBuild 的 GitHub 凭据构造:

source_artifact = pipeline.Artifact("SourceArtifact")
build_artifact = pipeline.Artifact("BuildArtifact")

# Source 阶段:从 GitHub 拉取源码
source_stage = pipeline.StageProps(
    stage_name="Source",
    actions=[
        pipelineactions.GitHubSourceAction(
            action_name="GitHub",
            owner='github_user',    # TODO: Replace with your GitHub username
            repo='repo_name',       # TODO: Replace with your GitHub repository name
            branch="main",
            oauth_token=SecretValue.secrets_manager("github-access-token-secret"),
            output=source_artifact,
        )
    ]
)

# Build 阶段:CodeBuild 构建并推送 Docker 镜像
build_stage = pipeline.StageProps(
    stage_name="Build",
    actions=[
        pipelineactions.CodeBuildAction(
            action_name="DockerBuildPush",
            input=pipeline.Artifact("SourceArtifact"),
            project=build_image,
            outputs=[build_artifact]
        )
    ]
)

# Deploy 阶段:CodeDeploy 蓝绿部署到 ECS Fargate
deploy_stage = pipeline.StageProps(
    stage_name="Deploy",
    actions=[
        pipelineactions.CodeDeployEcsDeployAction(
            action_name="EcsFargateDeploy",
            app_spec_template_input=build_artifact,
            task_definition_template_input=build_artifact,
            deployment_group=deployment_group
        )
    ]
)

# 向 CodeBuild 存储 GitHub 凭据
codebuild.GitHubSourceCredentials(self, "CodeBuildGitHubCreds",
    access_token=SecretValue.secrets_manager("github-access-token-secret")
)

pipeline.Pipeline(
    self, "BuildDeployPipeline",
    pipeline_name="ImageBuildDeployPipeline",
    stages=[source_stage, build_stage, deploy_stage]
)

要点:

  • GitHubSourceAction 通过 SecretValue.secrets_manager("github-access-token-secret") 读取前置条件中创建的 Secrets Manager 密文完成 GitHub 鉴权;
  • CodeDeployEcsDeployAction 的 app_spec_template_input 与 task_definition_template_input 都指向构建阶段的产物 build_artifact,即 buildspec.yaml 在 artifacts 段输出的 appspec.yaml 与 taskdef.json;
  • 对应的 EcsDeploymentGroup 配置了蓝绿部署所需的监听器与两个目标组:
deployment_group = codedeploy.EcsDeploymentGroup(
    self, "CodeDeployGroup",
    service=fargate_service,
    blue_green_deployment_config=codedeploy.EcsBlueGreenDeploymentConfig(
        listener=alb_listener,
        blue_target_group=target_group_blue,
        green_target_group=target_group_green
    )
)

最后,堆栈通过 CfnOutput 输出 ALB 的公网地址,供部署后访问验证:

CfnOutput(
    self, "PublicAlbEndpoint",
    value=f"http://{public_alb.load_balancer_dns_name}"
)

应用侧文件:构建与部署模板的占位符机制

Dockerfile

示例应用是一个 Nginx 容器,基础镜像取自 Amazon ECR Public:

FROM public.ecr.aws/nginx/nginx:stable-alpine

COPY ./site-assets/ /usr/share/nginx/html

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

静态资源(index.html、about.html、contact.html、error.html、styles.css)会被直接拷贝进 Nginx 的 HTML 目录。

buildspec.yaml:一次完成构建、推送与模板渲染

version: 0.2

phases:
  pre_build:
    commands:
      - echo Logging in to Amazon ECR...
      - aws --version
      - aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com
  build:
    commands:
      - echo Building the Docker image...
      - docker build -t $IMAGE_REPO_NAME:$IMAGE_TAG .
      - docker tag $IMAGE_REPO_NAME:$IMAGE_TAG $AWS_ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/$IMAGE_REPO_NAME:$IMAGE_TAG
  post_build:
    commands:
      - echo Pushing the Docker image...
      - docker push $AWS_ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/$IMAGE_REPO_NAME:$IMAGE_TAG
      - echo Container image to be used $REPOSITORY_URI:$IMAGE_TAG
      - sed -i "s|REPOSITORY_URI|${REPOSITORY_URI}|g" taskdef.json
      - sed -i "s|IMAGE_TAG|${IMAGE_TAG}|g" taskdef.json
      - sed -i "s|TASK_ROLE_ARN|${TASK_ROLE_ARN}|g" taskdef.json
      - sed -i "s|EXECUTION_ROLE_ARN|${EXECUTION_ROLE_ARN}|g" taskdef.json
      - sed -i "s|TASK_DEFINITION_ARN|${TASK_DEFINITION_ARN}|g" appspec.yaml
      - cat appspec.yaml && cat taskdef.json
artifacts:
  files:
    - "appspec.yaml"
    - "taskdef.json"

三个阶段的作用:

  • pre_build:调用 aws ecr get-login-password 获取 ECR 登录口令并完成 docker login,这一步解决了 privileged=True 之外最重要的镜像推送鉴权问题;
  • build:docker build -t $IMAGE_REPO_NAME:$IMAGE_TAG . 构建镜像,再用 docker tag 打上完整的 ECR 地址标签;
  • post_build:docker push 推送镜像;随后用一串 sed -i "s|占位符|真实值|g" 把模板文件里的占位符替换为真实值:
    • taskdef.json 中的 REPOSITORY_URI、IMAGE_TAG、TASK_ROLE_ARN、EXECUTION_ROLE_ARN;
    • appspec.yaml 中的 TASK_DEFINITION_ARN;
    • 最后 cat 打印两个文件,便于在 CodeBuild 日志中核对渲染结果;
  • artifacts:只把渲染后的 appspec.yaml 与 taskdef.json 作为流水线产物传递给 Deploy 阶段。

所有变量均来自 CDK 堆栈注入的环境变量(见上文第 3 节),这使构建产物始终与当前堆栈资源保持一一对应。

taskdef.json 与 appspec.yaml:CodeDeploy 的输入模板

taskdef.json 是 ECS 任务定义模板,部署前由 sed 填充真实值:

{
  "containerDefinitions": [
    {
      "name": "web",
      "image": "REPOSITORY_URI:IMAGE_TAG",
      "portMappings": [
        {
          "containerPort": 80,
          "protocol": "tcp"
        }
      ],
      "essential": true
    }
  ],
  "taskRoleArn": "TASK_ROLE_ARN",
  "executionRoleArn": "EXECUTION_ROLE_ARN",
  "family": "codedeploy-sample",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "256",
  "memory": "512"
}

可读出的规格信息:Fargate 兼容、awsvpc 网络模式、256 CPU / 512 MB 内存、容器名 web、80 端口 TCP。

appspec.yaml 描述 CodeDeploy 蓝绿部署时如何更新目标服务:

version: 0.0
Resources:
  - TargetService:
      Type: AWS::ECS::Service
      Properties:
        TaskDefinition: "TASK_DEFINITION_ARN"
        LoadBalancerInfo:
          ContainerName: "web"
          ContainerPort: "80"

部署时 CodeDeploy 会据此为新任务定义创建绿色任务集、完成健康检查后把流量从蓝色目标组切到绿色目标组。

部署步骤

在满足前置条件(含 Secrets Manager 密文与 GitHub 仓库就绪)后,按以下顺序操作:

  1. 进入示例目录 python/codepipeline-build-deploy-github-manual;
  2. 修改 codepipeline_build_deploy_stack.py 中的 GitHub 信息。注意:全文件共有两处需要替换(第 45 行 CodeBuild 的 Source.git_hub 与第 206 行 CodePipeline 的 GitHubSourceAction):
    owner='github_user',    # TODO: Replace with your GitHub username
    repo='repo_name',   # TODO: Replace with your GitHub repository name
    
    两处都要改成你自己的 GitHub 用户名与仓库名,否则流水线无法访问源码;
  3. pip install -r requirements.txt 安装 CDK 依赖;
  4. cdk synth 生成并审查 CloudFormation 模板;
  5. cdk diff 对比本地变更与已部署资源的差异;
  6. pytest 运行 tests/unit/test_codepipeline_build_deploy_stack.py 中的单元测试(详见下文);
  7. cdk deploy 将堆栈部署到你已认证的 AWS 账户。

部署输出

部署成功后,CDK 会输出一个公共端点,即 Application Load Balancer(ALB) 的 DNS 地址,例如 http://xyz123.us-east-1.elb.amazonaws.com。

验证与测试

通过 ALB 验证应用

用 ALB 公网地址访问容器内 Nginx 提供的多个页面进行冒烟测试:

  • /index.html —— 首页
  • /about.html —— 关于页
  • /contact.html —— 联系页
  • /error.html —— 错误页

运行单元测试

pip install -r requirements-dev.txt
pytest

requirements-dev.txt 仅声明 pytest==9.0.3。测试文件共包含三个用例,除上文提到的部署控制器断言外,还验证了:

触发流水线

进入 AWS CodePipeline 控制台,选择名为 ImageBuildDeployPipeline 的流水线,点击 Release change(发布变更)即可手动触发一次完整的端到端执行,可依次观察 Source → Build → Deploy 各阶段的状态流转。

在 AWS 控制台核对已部署服务

部署完成后可在控制台逐一查看以下资源:

  • CodePipeline 流水线
  • CodeBuild 构建项目
  • CodeDeploy 应用(含部署组)
  • ECS 集群
  • ECS 服务(运行于 Fargate)
  • ECR 镜像仓库
  • Lambda 函数

从源码结构看整体依赖关系

综合堆栈源码可以梳理出完整的资源依赖链路,便于排查问题:

  1. 首次镜像构建链路:AwsCustomResource(BuildLambdaTrigger) 在堆栈创建/更新时调用 BuildLambda → StartBuildCommand 启动 CodeBuild 项目 → CodeBuild 从 GitHub 拉取 app/ 内容、构建并推送镜像到 ECR;cluster_vpc.node.add_dependency(trigger_lambda) 保证 VPC/集群等资源在首次构建触发之后才创建;
  2. 运行时链路:GitHub 提交(或手动 Release change)→ CodePipeline Source 阶段 → Build 阶段(CodeBuild 重新构建镜像、渲染 taskdef.json/appspec.yaml 并输出为制品)→ Deploy 阶段(CodeDeploy 依据制品对 fargate-frontend-service 执行蓝绿部署);
  3. 对外服务链路:公共 ALB(80 端口监听器)→ 蓝色目标组 → Fargate 任务(awsvpc 模式下的私有 IP)→ Nginx 容器。

后续可做的改进方向

该示例本身是一个可稳定运行的最小闭环,README 也给出了在生产环境中进一步强化的建议清单:

  • 在 CodePipeline 工作流中添加人工审批动作(manual approval actions),让关键发布需要人工确认;
  • 使用 CodeDeploy 实现跨账户部署(deploy to multiple accounts);
  • 为 ECR 仓库配置跨账户或跨区域复制(replication),提升镜像分发能力与可用性;
  • 使用 AWS WAF(Web Application Firewall) 保护公共 ALB,抵御恶意流量与攻击;
  • 通过 AWS Certificate Manager(ACM) 为 ALB 启用 SSL/TLS,提供 HTTPS 访问;
  • 配置 Route 53 域名,将自有域名路由到 ALB,替代裸 DNS 地址。

小结

python/codepipeline-build-deploy-github-manual 是一个结构清晰、开箱即用的 CDK Python 示例:它以约 270 行堆栈代码 + 5 个应用配置文件,完整复现了"GitHub 手动仓库 + CodePipeline + CodeBuild + CodeDeploy + ECS Fargate + ECR + Lambda"的容器 CI/CD 最佳实践。其中值得借鉴的设计包括:用 Lambda 自定义资源解决首次镜像构建的依赖闭环、用环境变量 + sed 占位符替换实现构建产物模板渲染、用 CodeDeploy 蓝绿部署控制器接管 ECS 服务发布,以及配套的 pytest 单元测试对关键配置的回归保障。你可以直接 clone 仓库、替换 GitHub 用户名与仓库名后部署,作为后续生产级流水线的起点。

登录后查看全文
aws-cdk-examples