使用 AWS CDK 构建 CodePipeline 流水线:将 Docker 镜像自动构建并部署到 ECS Fargate
使用 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" 的含义。
前置条件
在动手部署前,需要准备以下环境与资源:
- Python 3.6+,用于运行 CDK Python 应用。
- AWS CDK v2.x(Python 版本),示例依赖声明于 requirements.txt:
aws-cdk-lib>=2.262.0,<3.0.0 constructs>=10.5.0,<11.0.0 - GitHub 账户,并创建 Personal Access Token(PAT)。测试场景下只需勾选
repo权限即可授予对仓库的完整访问权。 - 将 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 时必须使用完全一致的名称。 - 准备你的 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 仓库就绪)后,按以下顺序操作:
- 进入示例目录
python/codepipeline-build-deploy-github-manual; - 修改 codepipeline_build_deploy_stack.py 中的 GitHub 信息。注意:全文件共有两处需要替换(第 45 行 CodeBuild 的
Source.git_hub与第 206 行 CodePipeline 的GitHubSourceAction):
两处都要改成你自己的 GitHub 用户名与仓库名,否则流水线无法访问源码;owner='github_user', # TODO: Replace with your GitHub username repo='repo_name', # TODO: Replace with your GitHub repository name pip install -r requirements.txt安装 CDK 依赖;cdk synth生成并审查 CloudFormation 模板;cdk diff对比本地变更与已部署资源的差异;pytest运行 tests/unit/test_codepipeline_build_deploy_stack.py 中的单元测试(详见下文);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。测试文件共包含三个用例,除上文提到的部署控制器断言外,还验证了:
- 80 端口放行:ALB 安全组入站规则允许
0.0.0.0/0访问 TCP 80(test_codepipeline_build_deploy_stack.py); - S3 桶公共访问受限:流水线内部使用的 S3 制品桶启用了完整的
PublicAccessBlockConfiguration(test_codepipeline_build_deploy_stack.py),可见该示例默认遵循最小权限与安全加固实践。
触发流水线
进入 AWS CodePipeline 控制台,选择名为 ImageBuildDeployPipeline 的流水线,点击 Release change(发布变更)即可手动触发一次完整的端到端执行,可依次观察 Source → Build → Deploy 各阶段的状态流转。
在 AWS 控制台核对已部署服务
部署完成后可在控制台逐一查看以下资源:
- CodePipeline 流水线
- CodeBuild 构建项目
- CodeDeploy 应用(含部署组)
- ECS 集群
- ECS 服务(运行于 Fargate)
- ECR 镜像仓库
- Lambda 函数
从源码结构看整体依赖关系
综合堆栈源码可以梳理出完整的资源依赖链路,便于排查问题:
- 首次镜像构建链路:
AwsCustomResource(BuildLambdaTrigger)在堆栈创建/更新时调用BuildLambda→StartBuildCommand启动 CodeBuild 项目 → CodeBuild 从 GitHub 拉取app/内容、构建并推送镜像到 ECR;cluster_vpc.node.add_dependency(trigger_lambda)保证 VPC/集群等资源在首次构建触发之后才创建; - 运行时链路:GitHub 提交(或手动 Release change)→ CodePipeline Source 阶段 → Build 阶段(CodeBuild 重新构建镜像、渲染
taskdef.json/appspec.yaml并输出为制品)→ Deploy 阶段(CodeDeploy 依据制品对fargate-frontend-service执行蓝绿部署); - 对外服务链路:公共 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 用户名与仓库名后部署,作为后续生产级流水线的起点。