An EC2 service running on an ECS cluster fronted by an application load balancer.

ApplicationLoadBalancedEc2Service

The number of cpu units used by the task.

Valid values, which determines your range of valid values for the memory parameter:

256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB

512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB

1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB

2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments

4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments

This default is set in the underlying FargateTaskDefinition construct.

The hard limit (in MiB) of memory to present to the container.

If your container attempts to exceed the allocated memory, the container
is terminated.

At least one of memoryLimitMiB and memoryReservationMiB is required.

memoryLimitMiB

The soft limit (in MiB) of memory to reserve for the container.

When system memory is under contention, Docker attempts to keep the
container memory within the limit. If the container requires more memory,
it can consume up to the value specified by the Memory property or all of
the available memory on the container instance—whichever comes first.

At least one of memoryLimitMiB and memoryReservationMiB is required.

memoryReservationMiB

The placement constraints to use for tasks in the service.

For more information, see
[Amazon ECS Task Placement Constraints](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html).

placementConstraints

The placement strategies to use for tasks in the service.

For more information, see
[Amazon ECS Task Placement Strategies](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-strategies.html).

placementStrategies

The task definition to use for tasks in the service. TaskDefinition or TaskImageOptions must be specified, but not both..

[disable-awslint:ref-via-interface]

taskDefinition

A list of Capacity Provider strategies used to place a service.

capacityProviderStrategies

Certificate Manager certificate to associate with the load balancer.

Setting this option will set the load balancer protocol to HTTPS.

certificate

Whether to enable the deployment circuit breaker.

If this property is defined, circuit breaker will be implicitly
enabled.

circuitBreaker

The options for configuring an Amazon ECS service to use service discovery.

cloudMapOptions

The name of the cluster that hosts the service.

If a cluster is specified, the vpc construct should be omitted. Alternatively, you can omit both cluster and vpc.

cluster

Specifies which deployment controller to use for the service.

For more information, see
[Amazon ECS Deployment Types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html)

deploymentController

The desired number of instantiations of the task definition to keep running on the service.

The minimum value is 1

desiredCount

The domain name for the service, e.g. "api.example.com.".

domainName

The Route53 hosted zone for the domain, e.g. "example.com.".

domainZone

Specifies whether to enable Amazon ECS managed tags for the tasks within the service.

For more information, see
[Tagging Your Amazon ECS Resources](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html)

enableECSManagedTags

enableExecuteCommand

The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing target health checks after a task has first started.

healthCheckGracePeriod

The load balancer idle timeout, in seconds.

Can be between 1 and 4000 seconds

idleTimeout

ipAddressType

Listener port of the application load balancer that will serve traffic to the service.

listenerPort

The application load balancer that will serve traffic to the service.

The VPC attribute of a load balancer must be specified for it to be used
to create a new service with this pattern.

[disable-awslint:ref-via-interface]

loadBalancer

loadBalancerName

The maximum number of tasks, specified as a percentage of the Amazon ECS service's DesiredCount value, that can run in a service during a deployment.

maxHealthyPercent

The minimum number of tasks, specified as a percentage of the Amazon ECS service's DesiredCount value, that must continue to run and remain healthy during a deployment.

minHealthyPercent

Determines whether or not the Security Group for the Load Balancer's Listener will be open to all traffic by default.

openListener

Specifies whether to propagate the tags from the task definition or the service to the tasks in the service.

Tags can only be propagated to the tasks within the service during service creation.

propagateTags

The protocol for connections from clients to the load balancer.

The load balancer port is determined from the protocol (port 80 for
HTTP, port 443 for HTTPS).  If HTTPS, either a certificate or domain
name and domain zone must also be specified.

protocol

protocolVersion

Determines whether the Load Balancer will be internet-facing.

publicLoadBalancer

Specifies whether the Route53 record should be a CNAME, an A record using the Alias feature or no record at all.

This is useful if you need to work with DNS systems that do not support alias records.

recordType

Specifies whether the load balancer should redirect traffic on port 80 to the {@link listenerPort} to support HTTP->HTTPS redirects.

This is only valid if the protocol of the ALB is HTTPS.

redirectHTTP

serviceName

The security policy that defines which ciphers and protocols are supported by the ALB Listener.

sslPolicy

The protocol for connections from the load balancer to the ECS tasks.

The default target port is determined from the protocol (port 80 for
HTTP, port 443 for HTTPS).

targetProtocol

The properties required to create a new task definition.

TaskDefinition or TaskImageOptions must be specified, but not both.

taskImageOptions

The VPC where the container instances will be launched or the elastic network interfaces (ENIs) will be deployed.

If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster.

A Fargate service running on an ECS cluster fronted by an application load balancer.

ApplicationLoadBalancedFargateService

Determines whether the service will be assigned a public IP address.

assignPublicIp

The minimum number of CPU units to reserve for the container.

containerCpu

The amount (in MiB) of memory to present to the container.

If your container attempts to exceed the allocated memory, the container
is terminated.

containerMemoryLimitMiB

The health check command and associated configuration parameters for the container.

healthCheck

The security groups to associate with the service.

If you do not specify a security group, a new security group is created.

securityGroups

The subnets to associate with the service.

taskSubnets

The number of cpu units used by the task.

Valid values, which determines your range of valid values for the memory parameter:

256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB

512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB

1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB

2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments

4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments

8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments

16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments

This default is set in the underlying FargateTaskDefinition construct.

The amount (in GiB) of ephemeral storage to be allocated to the task.

The minimum supported value is `21` GiB and the maximum supported value is `200` GiB.

Only supported in Fargate platform version 1.4.0 or later.

ephemeralStorageGiB

The amount (in MiB) of memory used by the task.

This field is required and you must use one of the following values, which determines your range of valid values
for the cpu parameter:

512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25 vCPU)

1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values: 512 (.5 vCPU)

2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU)

Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available cpu values: 2048 (2 vCPU)

Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU)

Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) - Available cpu values: 8192 (8 vCPU)

Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) - Available cpu values: 16384 (16 vCPU)

This default is set in the underlying FargateTaskDefinition construct.

The platform version on which to run your service.

If one is not specified, the LATEST platform version is used by default. For more information, see
[AWS Fargate Platform Versions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
in the Amazon Elastic Container Service Developer Guide.

platformVersion

The runtime platform of the task definition.

runtimePlatform

The task definition to use for tasks in the service. TaskDefinition or TaskImageOptions must be specified, but not both.

[disable-awslint:ref-via-interface]

ApplicationMultipleTargetGroupsEc2Service

The minimum number of CPU units to reserve for the container.

Valid values, which determines your range of valid values for the memory parameter:

The amount (in MiB) of memory to present to the container.

If your container attempts to exceed the allocated memory, the container
is terminated.

At least one of memoryLimitMiB and memoryReservationMiB is required.

The soft limit (in MiB) of memory to reserve for the container.

When system memory is under heavy contention, Docker attempts to keep the
container memory to this soft limit. However, your container can consume more
memory when it needs to, up to either the hard limit specified with the memory
parameter (if applicable), or all of the available memory on the container
instance, whichever comes first.

At least one of memoryLimitMiB and memoryReservationMiB is required.

Note that this setting will be ignored if TaskImagesOptions is specified

The task definition to use for tasks in the service. Only one of TaskDefinition or TaskImageOptions must be specified.

[disable-awslint:ref-via-interface]

The desired number of instantiations of the task definition to keep running on the service.

The application load balancer that will serve traffic to the service.

loadBalancers

targetGroups

The properties required to create a new task definition.

Only one of TaskDefinition or TaskImageOptions must be specified.

ApplicationMultipleTargetGroupsFargateService

An EC2 service running on an ECS cluster fronted by a network load balancer.

NetworkLoadBalancedEc2Service

The type of IP addresses to use.

If you want to add a UDP or TCP_UDP listener to the load balancer,
you must choose IPv4.

Listener certificate list of ACM cert ARNs.

If you provide a certificate, the listener's protocol will be TLS.
If not, the listener's protocol will be TCP.

listenerCertificate

Listener port of the network load balancer that will serve traffic to the service.

The network load balancer that will serve traffic to the service.

If the load balancer has been imported, the vpc attribute must be specified
in the call to fromNetworkLoadBalancerAttributes().

[disable-awslint:ref-via-interface]

The properties required to create a new task definition.

One of taskImageOptions or taskDefinition must be specified.

A Fargate service running on an ECS cluster fronted by a network load balancer.

NetworkLoadBalancedFargateService

NetworkMultipleTargetGroupsEc2Service

The soft limit (in MiB) of memory to reserve for the container.

When system memory is under heavy contention, Docker attempts to keep the
container memory to this soft limit. However, your container can consume more
memory when it needs to, up to either the hard limit specified with the memory
parameter (if applicable), or all of the available memory on the container
instance, whichever comes first.

At least one of memoryLimitMiB and memoryReservationMiB is required.

Note that this setting will be ignored if TaskImagesOptions is specified.

The network load balancer that will serve traffic to the service.

NetworkMultipleTargetGroupsFargateService

Class to create a queue processing EC2 service.

QueueProcessingEc2Service

containerName

Gpu count for container in task definition.

Set this if you want to use gpu based instances.

gpuCount

The hard limit (in MiB) of memory to present to the container.

If your container attempts to exceed the allocated memory, the container
is terminated.

At least one of memoryLimitMiB and memoryReservationMiB is required for non-Fargate services.

The soft limit (in MiB) of memory to reserve for the container.

When system memory is under contention, Docker attempts to keep the
container memory within the limit. If the container requires more memory,
it can consume up to the value specified by the Memory property or all of
the available memory on the container instance—whichever comes first.

At least one of memoryLimitMiB and memoryReservationMiB is required for non-Fargate services.

The command that is passed to the container.

If you provide a shell command as a single string, you have to quote command-line arguments.

command

Grace period after scaling activity in seconds.

Subsequent scale outs during the cooldown period are squashed so that only
the biggest scale out happens.

Subsequent scale ins during the cooldown period are ignored.

cooldown

The target CPU utilization percentage for CPU based scaling strategy when enabled.

cpuTargetUtilizationPercent

Flag to disable CPU based auto scaling strategy on the service.

disableCpuBasedScaling

Flag to indicate whether to enable logging.

enableLogging

The environment variables to pass to the container.

The variable `QUEUE_NAME` with value `queue.queueName` will
always be passed.

environment

The name of a family that the task definition is registered to.

A family groups multiple versions of a task definition.

family

The image used to start a container.

For `QueueProcessingFargateService`, either `image` or `taskDefinition` must be specified, but not both.
For `QueueProcessingEc2Service`, `image` is required.

image

logDriver

The maximum number of times that a message can be received by consumers.

When this value is exceeded for a message the message will be automatically sent to the Dead Letter Queue.

If the queue construct is specified, maxReceiveCount should be omitted.

maxReceiveCount

maxScalingCapacity

minScalingCapacity

A queue for which to process items from.

If specified and this is a FIFO queue, the queue name must end in the string '.fifo'. See
[CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)

queue

The number of seconds that Dead Letter Queue retains a message.

If the queue construct is specified, retentionPeriod should be omitted.

retentionPeriod

The intervals for scaling based on the SQS queue's ApproximateNumberOfMessagesVisible metric.

Maps a range of metric values to a particular scaling behavior. See
[Simple and Step Scaling Policies for Amazon EC2 Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-scaling-simple-step.html)

scalingSteps

The secret to expose to the container as an environment variable.

secrets

Timeout of processing a single message.

After dequeuing, the processor has this much time to handle the message and delete it from the queue
before it becomes visible again for dequeueing by another processor. Values must be between 0 and (12 hours).

If the queue construct is specified, visibilityTimeout should be omitted.

visibilityTimeout

Class to create a queue processing Fargate service.

QueueProcessingFargateService

Specifies whether the task's elastic network interface receives a public IP address.

If true, each task will receive a public IP address.

Optional name for the container added.

This name is not used when `taskDefinition` is provided.

A scheduled EC2 task that will be initiated off of CloudWatch Events.

ScheduledEc2Task

The properties to define if using an existing TaskDefinition in this construct.

ScheduledEc2TaskDefinitionOptions or ScheduledEc2TaskImageOptions must be defined, but not both.

scheduledEc2TaskDefinitionOptions

The properties to define if the construct is to create a TaskDefinition.

ScheduledEc2TaskDefinitionOptions or ScheduledEc2TaskImageOptions must be defined, but not both.

scheduledEc2TaskImageOptions

The schedule or rate (frequency) that determines when CloudWatch Events runs the rule.

For more information, see
[Schedule Expression Syntax for Rules](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html)
in the Amazon CloudWatch User Guide.

schedule

desiredTaskCount

enabled

Specifies whether to propagate the tags from the task definition to the task.

If no value is specified, the tags are not propagated.

ruleName

Existing security groups to use for your service.

In what subnets to place the task's ENIs.

(Only applicable in case the TaskDefinition is configured for AwsVpc networking)

subnetSelection

The metadata that you apply to the task to help you categorize and organize them.

Each tag consists of a key and an optional value, both of which you define.

ScheduledFargateTask

The properties to define if using an existing TaskDefinition in this construct.

ScheduledFargateTaskDefinitionOptions or ScheduledFargateTaskImageOptions must be defined, but not both.

scheduledFargateTaskDefinitionOptions

The properties to define if the construct is to create a TaskDefinition.

ScheduledFargateTaskDefinitionOptions or ScheduledFargateTaskImageOptions must be defined, but not both.

AWS ecs Patterns

L2 Constructs12