# NetworkLoadBalancedTaskImageProps

Options for configuring a new container.

- Source: [`aws-ecs-patterns/lib/base/network-multiple-target-groups-service-base.ts`](https://github.com/aws/aws-cdk/blob/v2.277.0/packages/aws-cdk-lib/aws-ecs-patterns/lib/base/network-multiple-target-groups-service-base.ts#L119)

## Example

TypeScript:

```ts
// Two network load balancers, each with their own listener and target group.
declare const cluster: ecs.Cluster;
const loadBalancedEc2Service = new ecsPatterns.NetworkMultipleTargetGroupsEc2Service(this, 'Service', {
  cluster,
  memoryLimitMiB: 256,
  taskImageOptions: {
    image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample"),
  },
  loadBalancers: [
    {
      name: 'lb1',
      listeners: [
        {
          name: 'listener1',
        },
      ],
    },
    {
      name: 'lb2',
      listeners: [
        {
          name: 'listener2',
        },
      ],
    },
  ],
  targetGroups: [
    {
      containerPort: 80,
      listener: 'listener1',
    },
    {
      containerPort: 90,
      listener: 'listener2',
    },
  ],
});
```

Python:

```python
# Two network load balancers, each with their own listener and target group.
# cluster: ecs.Cluster

load_balanced_ec2_service = ecs_patterns.NetworkMultipleTargetGroupsEc2Service(self, "Service",
    cluster=cluster,
    memory_limit_mi_b=256,
    task_image_options=ecsPatterns.NetworkLoadBalancedTaskImageProps(
        image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")
    ),
    load_balancers=[ecsPatterns.NetworkLoadBalancerProps(
        name="lb1",
        listeners=[ecsPatterns.NetworkListenerProps(
            name="listener1"
        )
        ]
    ), ecsPatterns.NetworkLoadBalancerProps(
        name="lb2",
        listeners=[ecsPatterns.NetworkListenerProps(
            name="listener2"
        )
        ]
    )
    ],
    target_groups=[ecsPatterns.NetworkTargetProps(
        container_port=80,
        listener="listener1"
    ), ecsPatterns.NetworkTargetProps(
        container_port=90,
        listener="listener2"
    )
    ]
)
```

Java:

```java
// Two network load balancers, each with their own listener and target group.
Cluster cluster;

NetworkMultipleTargetGroupsEc2Service loadBalancedEc2Service = NetworkMultipleTargetGroupsEc2Service.Builder.create(this, "Service")
        .cluster(cluster)
        .memoryLimitMiB(256)
        .taskImageOptions(NetworkLoadBalancedTaskImageProps.builder()
                .image(ContainerImage.fromRegistry("amazon/amazon-ecs-sample"))
                .build())
        .loadBalancers(List.of(NetworkLoadBalancerProps.builder()
                .name("lb1")
                .listeners(List.of(NetworkListenerProps.builder()
                        .name("listener1")
                        .build()))
                .build(), NetworkLoadBalancerProps.builder()
                .name("lb2")
                .listeners(List.of(NetworkListenerProps.builder()
                        .name("listener2")
                        .build()))
                .build()))
        .targetGroups(List.of(NetworkTargetProps.builder()
                .containerPort(80)
                .listener("listener1")
                .build(), NetworkTargetProps.builder()
                .containerPort(90)
                .listener("listener2")
                .build()))
        .build();
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.Lib
// Two network load balancers, each with their own listener and target group.
Cluster cluster;

var loadBalancedEc2Service = new NetworkMultipleTargetGroupsEc2Service(this, "Service", new NetworkMultipleTargetGroupsEc2ServiceProps {
    Cluster = cluster,
    MemoryLimitMiB = 256,
    TaskImageOptions = new NetworkLoadBalancedTaskImageProps {
        Image = ContainerImage.FromRegistry("amazon/amazon-ecs-sample")
    },
    LoadBalancers = new [] { new NetworkLoadBalancerProps {
        Name = "lb1",
        Listeners = new [] { new NetworkListenerProps {
            Name = "listener1"
        } }
    }, new NetworkLoadBalancerProps {
        Name = "lb2",
        Listeners = new [] { new NetworkListenerProps {
            Name = "listener2"
        } }
    } },
    TargetGroups = new [] { new NetworkTargetProps {
        ContainerPort = 80,
        Listener = "listener1"
    }, new NetworkTargetProps {
        ContainerPort = 90,
        Listener = "listener2"
    } }
});
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
// Two network load balancers, each with their own listener and target group.
var cluster Cluster

loadBalancedEc2Service := ecsPatterns.NewNetworkMultipleTargetGroupsEc2Service(this, jsii.String("Service"), &NetworkMultipleTargetGroupsEc2ServiceProps{
	Cluster: Cluster,
	MemoryLimitMiB: jsii.Number(256),
	TaskImageOptions: &NetworkLoadBalancedTaskImageProps{
		Image: ecs.ContainerImage_FromRegistry(jsii.String("amazon/amazon-ecs-sample")),
	},
	LoadBalancers: []NetworkLoadBalancerProps{
		&NetworkLoadBalancerProps{
			Name: jsii.String("lb1"),
			Listeners: []NetworkListenerProps{
				&NetworkListenerProps{
					Name: jsii.String("listener1"),
				},
			},
		},
		&NetworkLoadBalancerProps{
			Name: jsii.String("lb2"),
			Listeners: []NetworkListenerProps{
				&NetworkListenerProps{
					Name: jsii.String("listener2"),
				},
			},
		},
	},
	TargetGroups: []NetworkTargetProps{
		&NetworkTargetProps{
			ContainerPort: jsii.Number(80),
			Listener: jsii.String("listener1"),
		},
		&NetworkTargetProps{
			ContainerPort: jsii.Number(90),
			Listener: jsii.String("listener2"),
		},
	},
})
```

## Properties

- `containerName`: string = none — The container name value to be specified in the task definition.

- `containerPorts`: number[] = [80] — A list of port numbers on the container that is bound to the user-specified or automatically assigned host port.

  If you are using containers in a task with the awsvpc or host network mode, exposed ports should be specified using containerPort.
  If you are using containers in a task with the bridge network mode and you specify a container port and not a host port,
  your container automatically receives a host port in the ephemeral port range.

  Port mappings that are automatically assigned in this way do not count toward the 100 reserved ports limit of a container instance.

  For more information, see
  [hostPort](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PortMapping.html#ECS-Type-PortMapping-hostPort).

- `dockerLabels`: { [key: string]: string } — A key/value map of labels to add to the container.

  **Default:** No labels.

- `enableLogging`: boolean = true — Flag to indicate whether to enable logging.

- `environment`: { [key: string]: string } — The environment variables to pass to the container.

  **Default:** No environment variables.

- `executionRole`: [IRole](/cdk/api/v2/docs/aws-cdk-lib.aws_iam.IRole.html) — The name of the task execution IAM role that grants the Amazon ECS container agent permission to call AWS APIs on your behalf.

  **Default:** No value

- `family`: string — The name of a family that this task definition is registered to.

  **Default:** Automatically generated name.

  A family groups multiple versions of a task definition.

- `image`: [ContainerImage](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerImage.html) (required) = none — The image used to start a container.

  Image or taskDefinition must be specified, but not both.

- `logDriver`: [LogDriver](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.LogDriver.html) — The log driver to use.

  **Default:** AwsLogDriver if enableLogging is true

- `secrets`: { [key: string]: [Secret](/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.Secret.html) } — The secrets to expose to the container as an environment variable.

  **Default:** No secret environment variables.

- `taskRole`: [IRole](/cdk/api/v2/docs/aws-cdk-lib.aws_iam.IRole.html) — The name of the task IAM role that grants containers in the task permission to call AWS APIs on your behalf.

  **Default:** A task role is automatically created for you.
