如何在AWS CDK中配置80端口监听器转发至容器8080端口

你当前代码存在几处关键问题，以下是修正后的完整实现，以及核心配置要点：

核心配置逻辑 #

• TargetGroup：已正确设置port=8080，与容器暴露的端口匹配，target_type='ip'适配Fargate的awsvpc网络模式
• ELB监听器：需绑定到你创建的应用负载均衡，而非错误引用TargetGroup的负载均衡ARN
• ECS服务：load_balancers中的container_name必须与容器定义中的name完全一致

修正后的完整代码 #

app_cluster = _ecs.Cluster(self, 'Cluster', cluster_name='app-cluster', vpc=default_vpc)

app_env_vars = [
            _ecs.CfnTaskDefinition.KeyValuePairProperty(
                name='API_ENABLED',
                value='true'
            )]

app_container_definitions = [
            _ecs.CfnTaskDefinition.ContainerDefinitionProperty(
                name='container-name',
                image='ubuntu:20',
                repository_credentials=_ecs.CfnTaskDefinition.RepositoryCredentialsProperty(
                    credentials_parameter="arn:aws:secretsmanager:eu-west-1:2222243:secret:prod/credentials-TTR3d"),
                essential=True,
                cpu=0,
                memory=1024,
                memory_reservation=1024,
                log_configuration=_ecs.CfnTaskDefinition.LogConfigurationProperty(
                    log_driver='awslogs',
                    options={'awslogs-stream-prefix': 'ecs',
                             'awslogs-group': app_log_group.log_group_name,
                             'awslogs-region': 'eu-west-1'},
                ),
                port_mappings=[
                    _ecs.CfnTaskDefinition.PortMappingProperty(
                        container_port=8080,
                        host_port=8080,
                        protocol='tcp'
                    )],
                environment=app_env_vars)]

app_task_definition = _ecs.CfnTaskDefinition(self, 'TaskDefinition',
                                                             family='task-prod',
                                                             memory='2048',
                                                             network_mode='awsvpc',
                                                             requires_compatibilities=['FARGATE'],
                                                             execution_role_arn=role_ecs_task.role_arn,
                                                             cpu='512',
                                                             tags=[aws_cdk.CfnTag(
                                                                 key='Environment',
                                                                 value='prod'
                                                             )],
                                                             container_definitions=app_container_definitions)

app_target_group = _elbv2.CfnTargetGroup(self, 'TargetGroup',
                                                         name='target-group',
                                                         health_check_enabled=True,
                                                         health_check_interval_seconds=60,
                                                         health_check_timeout_seconds=30,
                                                         healthy_threshold_count=5,
                                                         unhealthy_threshold_count=5,
                                                         health_check_path='/health',
                                                         target_type='ip',
                                                         protocol='HTTP',
                                                         port=8080,
                                                         vpc_id=default_vpc.vpc_id
                                                         )

app_application_load_balancer = _elbv2.CfnLoadBalancer(self, "LB",
                                                                       subnets=default_vpc.select_subnets(
                                                                           subnet_type=_ec2.SubnetType.PUBLIC).subnet_ids,
                                                                       name='app-lb',
                                                                       type='application',
                                                                       security_groups=[app_container.security_group_id],
                                                                       scheme='internet-facing')

app_service = _ecs.CfnService(self, 'Service',
                                              cluster=app_cluster.cluster_arn,
                                              task_definition=app_task_definition.attr_task_definition_arn,
                                              service_name='app-service',
                                              desired_count=1,
                                              launch_type=_ecs.LaunchType.FARGATE.name,
                                              network_configuration=_ecs.CfnService.NetworkConfigurationProperty(
                                                  awsvpc_configuration=_ecs.CfnService.AwsVpcConfigurationProperty(
                                                      subnets=default_vpc.select_subnets(
                                                          subnet_type=_ec2.SubnetType.PUBLIC).subnet_ids,
                                                      # 可选属性
                                                      assign_public_ip="ENABLED",
                                                      security_groups=[
                                                          app_container.security_group_id]
                                                  )
                                              ),
                                              load_balancers=[_ecs.CfnService.LoadBalancerProperty(
                                                  container_port=8080,
                                                  container_name='container-name',  # 修正：与容器定义名称一致
                                                  target_group_arn=app_target_group.attr_target_group_arn
                                              )]
                                              )

# 修正后的监听器配置
app_listener = _elbv2.CfnListener(
    self, 'Listener',
    port=80,
    protocol='HTTP',  # 显式指定协议，避免默认值问题
    default_actions=[
        _elbv2.CfnListener.ActionProperty(
            type='forward',
            target_group_arn=app_target_group.attr_target_group_arn
        )
    ],
    load_balancer_arn=app_application_load_balancer.attr_load_balancer_arn  # 修正：绑定到正确的负载均衡ARN
)

关键修正点 #

1. ECS服务容器名称匹配：将load_balancers中的container_name从app-broker改为container-name，与容器定义中的名称完全一致
2. 监听器负载均衡ARN修正：把infuse_ocpi_target_group.attr_load_balancer_arns替换为app_application_load_balancer.attr_load_balancer_arn，绑定到你创建的应用负载均衡
3. 显式指定监听器协议：添加protocol='HTTP'，明确监听器使用HTTP协议，避免依赖默认值导致的潜在问题

内容的提问来源于stack exchange，提问作者Rony Tesler