fix(ecs-patterns): Fix Network Load Balancer Port assignments in ECS Patterns

packages/@aws-cdk/aws-ecs-patterns/lib/base/network-load-balanced-service-base.ts

@@ -347,7 +347,7 @@ export abstract class NetworkLoadBalancedServiceBase extends CoreConstruct {
     const loadBalancer = props.loadBalancer ?? new NetworkLoadBalancer(this, 'LB', lbProps);
     const listenerPort = props.listenerPort ?? 80;
     const targetProps = {
-      port: 80,
+      port: props.taskImageOptions?.containerPort ?? 80,
     };
 
     this.listener = loadBalancer.addListener('PublicListener', { port: listenerPort });

packages/@aws-cdk/aws-ecs-patterns/lib/base/network-multiple-target-groups-service-base.ts

@@ -374,7 +374,7 @@ export abstract class NetworkMultipleTargetGroupsServiceBase extends CoreConstru
   protected registerECSTargets(service: BaseService, container: ContainerDefinition, targets: NetworkTargetProps[]): NetworkTargetGroup {
     for (const targetProps of targets) {
       const targetGroup = this.findListener(targetProps.listener).addTargets(`ECSTargetGroup${container.containerName}${targetProps.containerPort}`, {
-        port: 80,
+        port: targetProps.containerPort ?? 80,
         targets: [
           service.loadBalancerTarget({
             containerName: container.containerName,

packages/@aws-cdk/aws-ecs-patterns/test/fargate/integ.multiple-network-load-balanced-fargate-service.expected.json

@@ -458,7 +458,7 @@
     "myServicelb2listener2ECSTargetGroupweb90Group6841F924": {
       "Type": "AWS::ElasticLoadBalancingV2::TargetGroup",
       "Properties": {
-        "Port": 80,
+        "Port": 90,
         "Protocol": "TCP",
         "TargetType": "ip",
         "VpcId": {

packages/@aws-cdk/aws-ecs-patterns/test/fargate/integ.special-listener.expected.json

@@ -404,7 +404,7 @@
     "FargateNlbServiceLBPublicListenerECSGroup7501571D": {
       "Type": "AWS::ElasticLoadBalancingV2::TargetGroup",
       "Properties": {
-        "Port": 80,
+        "Port": 2015,
         "Protocol": "TCP",
         "TargetType": "ip",
         "VpcId": {

packages/@aws-cdk/aws-ecs-patterns/test/fargate/load-balanced-fargate-service-v2.test.ts

@@ -1,9 +1,10 @@
 import { Match, Template } from '@aws-cdk/assertions';
 import { Vpc } from '@aws-cdk/aws-ec2';
 import * as ecs from '@aws-cdk/aws-ecs';
+import { ContainerImage } from '@aws-cdk/aws-ecs';
 import { CompositePrincipal, Role, ServicePrincipal } from '@aws-cdk/aws-iam';
 import { Duration, Stack } from '@aws-cdk/core';
-import { ApplicationMultipleTargetGroupsFargateService, NetworkMultipleTargetGroupsFargateService, ApplicationLoadBalancedFargateService } from '../../lib';
+import { ApplicationLoadBalancedFargateService, ApplicationMultipleTargetGroupsFargateService, NetworkLoadBalancedFargateService, NetworkMultipleTargetGroupsFargateService } from '../../lib';
 
 describe('When Application Load Balancer', () => {
   test('test Fargate loadbalanced construct with default settings', () => {
@@ -661,4 +662,75 @@ describe('When Network Load Balancer', () => {
       });
     }).toThrow(/You must specify one of: taskDefinition or image/);
   });
+
+  test('test Fargate networkloadbalanced construct with custom Port', () => {
+    // GIVEN
+    const stack = new Stack();
+    const vpc = new Vpc(stack, 'VPC');
+    const cluster = new ecs.Cluster(stack, 'Cluster', { vpc });
+
+    new NetworkLoadBalancedFargateService(stack, 'NLBService', {
+      cluster: cluster,
+      memoryLimitMiB: 1024,
+      cpu: 512,
+      taskImageOptions: {
+        image: ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
+        containerPort: 81,
+      },
+      listenerPort: 8181,
+    });
+
+    Template.fromStack(stack).hasResourceProperties('AWS::ElasticLoadBalancingV2::TargetGroup', {
+      Port: 81,
+      Protocol: 'TCP',
+      TargetType: 'ip',
+      VpcId: {
+        Ref: 'VPCB9E5F0B4',
+      },
+    });
+  });
+
+  test('test Fargate multinetworkloadbalanced construct with custom Port', () => {
+    // GIVEN
+    const stack = new Stack();
+    const vpc = new Vpc(stack, 'VPC');
+    const cluster = new ecs.Cluster(stack, 'Cluster', { vpc });
+
+    new NetworkMultipleTargetGroupsFargateService(stack, 'Service', {
+      cluster,
+      taskImageOptions: {
+        image: ecs.ContainerImage.fromRegistry('test'),
+      },
+    });
+
+
+    new NetworkMultipleTargetGroupsFargateService(stack, 'NLBService', {
+      cluster: cluster,
+      memoryLimitMiB: 1024,
+      cpu: 512,
+      taskImageOptions: {
+        image: ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
+      },
+      loadBalancers: [
+        {
+          name: 'lb1',
+          listeners: [
+            { name: 'listener1', port: 8181 },
+          ],
+        },
+      ],
+      targetGroups: [{
+        containerPort: 81,
+      }],
+    });
+
+    Template.fromStack(stack).hasResourceProperties('AWS::ElasticLoadBalancingV2::TargetGroup', {
+      Port: 81,
+      Protocol: 'TCP',
+      TargetType: 'ip',
+      VpcId: {
+        Ref: 'VPCB9E5F0B4',
+      },
+    });
+  });
 });