NetworkLoadBalancedTaskImageProps Struct
Options for configuring a new container.
Example
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
# 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
// 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();
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"
} }
});
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
containerNameoptionalstringcontainer_nameoptionalstrcontainerNameoptionalStringContainerNameoptionalstringContainerNameoptional*string= none#The container name value to be specified in the task definition.
containerPortsoptionalnumber[]container_portsoptionaltyping.List[int | float]containerPortsoptionalList<Number>ContainerPortsoptionaldouble[]ContainerPortsoptional*[]*float64= [80]#A list of port numbers on the container that is bound to the user-specified or automatically assigned host port.
notes
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.
dockerLabelsoptional{ [key: string]: string }docker_labelsoptionaltyping.Mapping[str, str]dockerLabelsoptionalMap<String, String>DockerLabelsoptionalIDictionary<string, string>DockerLabelsoptional*map[string]*string#A key/value map of labels to add to the container.
Default: No labels.
enableLoggingoptionalbooleanenable_loggingoptionalboolenableLoggingoptionalBooleanEnableLoggingoptionalboolEnableLoggingoptional*bool= true#Flag to indicate whether to enable logging.
environmentoptional{ [key: string]: string }environmentoptionaltyping.Mapping[str, str]environmentoptionalMap<String, String>EnvironmentoptionalIDictionary<string, string>Environmentoptional*map[string]*string#The environment variables to pass to the container.
Default: No environment variables.
executionRoleoptionalIRoleexecution_roleoptionalIRoleexecutionRoleoptionalIRoleExecutionRoleoptionalIRoleExecutionRoleoptionalIRole#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
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.
imageContainerImageimageContainerImageimageContainerImageImageContainerImageImageContainerImage= nonerequired#The image used to start a container.
Image or taskDefinition must be specified, but not both.
logDriveroptionalLogDriverlog_driveroptionalLogDriverlogDriveroptionalLogDriverLogDriveroptionalLogDriverLogDriveroptionalLogDriver#The log driver to use.
Default: AwsLogDriver if enableLogging is true