aws_elasticloadbalancingv2: Can't interact with the Network or Application Target Group from EcsTarget

[BwL1289]

Describe the feature

Maybe I've missed something, but if you do something like the following:

ecs_target = ecs.EcsTarget(
    container_name="container_name",
    container_port=80,
    new_target_group_id="TargetGroup80",
    listener=ecs.ListenerConfig.network_listener(
        listener=nlb_listener_80,
        port=80,
        deregistration_delay=Duration.seconds(10),
    ),
)

# Register the target with the target group
nlb_flask_fargate_service.service.register_load_balancer_targets(ecs_target)

There's no way to further interact with the lb.NetworkTargetGroup or lb.ApplicationTargetGroup.

If you try to import the TargetGroup via the following, you need the full ARN which the above EcsTarget construct doesn't give you (just the new_group_id)

def import_80_target_group(self) -> None:
    target_group_80 = lb.NetworkTargetGroup.from_target_group_attributes(
        self,
        "TargetGroup80Imported",
        target_group_arn=ecs_target.new_target_group_id,
        load_balancer_arns=nlb_flask_fargate_service.load_balancer.load_balancer_arn,
)

Use Case

Add custom metrics / monitoring / alarms / scaling to the target group:

target_group_80.metrics.custom(metric_name="RequestCount", period=Duration.minutes(1)).create_alarm(
    self,
    "HighNumRequestsAlarm",
     evaluation_periods=1,
     threshold=20,
     comparison_operator=cw.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
     alarm_description="ECS Scale up on Number of Incoming Requests if number of requests is greater than 20 in a minute",
)

scaling.scale_on_metric(
    "TargetResponseTimeScaling",
    metric=self.flask_nlb_fargate_service.target_group.metrics.target_response_time(),
    scaling_steps=[
        appscaling.ScalingInterval(lower=0, change=-1),  # Decreases tasks if requests are low.
        appscaling.ScalingInterval(lower=10.0, change=+1),  # Scale out if response time > 10s, add a task
       appscaling.ScalingInterval(lower=20.0, change=+2),  # Scale out more if > 20s, add 2 tasks
],
    adjustment_type=appscaling.AdjustmentType.CHANGE_IN_CAPACITY,
)

Proposed Solution

Expose the underlying TargetGroup construct via a property on EcsTarget or at least the full ARN.

Other Information

No response

Acknowledgements

• I may be able to implement this feature request
• This feature might incur a breaking change

CDK version used

2.180.0

Environment details (OS name and version, etc.)

MacOS

[pahud]

Root Cause Analysis

In the BaseService class in base-service.ts, the registerLoadBalancerTargets method creates and configures target groups through the listener's addTargets method:

aws-cdk/packages/aws-cdk-lib/aws-ecs/lib/base/base-service.ts

Lines 1256 to 1264 in 2dc5d70

	public registerLoadBalancerTargets(...targets: EcsTarget[]) {
	for (const target of targets) {
	target.listener.addTargets(target.newTargetGroupId, {
	containerName: target.containerName,
	containerPort: target.containerPort,
	protocol: target.protocol,
	}, this);
	}
	}

However, there's no mechanism to return or expose the created target group back to the user. The target group is created internally through the listener's addTargets method (from NetworkListener or ApplicationListener classes), but the created target group isn't stored in the EcsTarget object or returned to the caller.

In the NetworkListener class, the addTargets method creates a new NetworkTargetGroup but doesn't provide a way for that created group to be referenced back through the EcsTarget:

public addTargets(id: string, props: AddNetworkTargetsProps): NetworkTargetGroup {
  // ...
  const group = new NetworkTargetGroup(this, id + 'Group', {
    // properties...
  });
  
  this.addTargetGroups(id, group);
  
  return group;  // Return value isn't captured in EcsTarget
}

Proposed Solution

The issue could be addressed by either:

1. Modifying the EcsTarget interface to include an optional property that gets populated with the created target group
2. Having registerLoadBalancerTargets return a mapping of target group IDs to the created target group objects
3. Exposing the full ARN of the created target group in the EcsTarget object
4. The cleanest solution might be adding a property to EcsTarget that gets populated with the resulting target group, which would allow users to:

# After registering
target_group = ecs_target.targetGroup  # New property
target_group.metrics.custom(...)  # Now possible

This would be a non-breaking change that would significantly improve usability for monitoring and scaling use cases.

Adding this a p2 and we welcome PRs.