io.cloudshiftdev.awscdk.services.ecs.patterns.QueueProcessingFargateService.kt Maven / Gradle / Ivy
@file:Suppress("RedundantVisibilityModifier","RedundantUnitReturnType","RemoveRedundantQualifierName","unused","UnusedImport","ClassName","REDUNDANT_PROJECTION","DEPRECATION")
package io.cloudshiftdev.awscdk.services.ecs.patterns
import io.cloudshiftdev.awscdk.Duration
import io.cloudshiftdev.awscdk.common.CdkDslMarker
import io.cloudshiftdev.awscdk.services.applicationautoscaling.ScalingInterval
import io.cloudshiftdev.awscdk.services.ec2.ISecurityGroup
import io.cloudshiftdev.awscdk.services.ec2.IVpc
import io.cloudshiftdev.awscdk.services.ec2.SubnetSelection
import io.cloudshiftdev.awscdk.services.ecs.CapacityProviderStrategy
import io.cloudshiftdev.awscdk.services.ecs.ContainerImage
import io.cloudshiftdev.awscdk.services.ecs.DeploymentCircuitBreaker
import io.cloudshiftdev.awscdk.services.ecs.DeploymentController
import io.cloudshiftdev.awscdk.services.ecs.FargatePlatformVersion
import io.cloudshiftdev.awscdk.services.ecs.FargateService
import io.cloudshiftdev.awscdk.services.ecs.FargateTaskDefinition
import io.cloudshiftdev.awscdk.services.ecs.HealthCheck
import io.cloudshiftdev.awscdk.services.ecs.ICluster
import io.cloudshiftdev.awscdk.services.ecs.LogDriver
import io.cloudshiftdev.awscdk.services.ecs.PropagatedTagSource
import io.cloudshiftdev.awscdk.services.ecs.RuntimePlatform
import io.cloudshiftdev.awscdk.services.ecs.Secret
import io.cloudshiftdev.awscdk.services.sqs.IQueue
import kotlin.Boolean
import kotlin.Number
import kotlin.String
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import kotlin.jvm.JvmName
import io.cloudshiftdev.constructs.Construct as CloudshiftdevConstructsConstruct
import software.constructs.Construct as SoftwareConstructsConstruct
/**
* Class to create a queue processing Fargate service.
*
* Example:
*
* ```
* Cluster cluster;
* cluster.enableFargateCapacityProviders();
* QueueProcessingFargateService queueProcessingFargateService =
* QueueProcessingFargateService.Builder.create(this, "Service")
* .cluster(cluster)
* .memoryLimitMiB(512)
* .image(ContainerImage.fromRegistry("test"))
* .capacityProviderStrategies(List.of(CapacityProviderStrategy.builder()
* .capacityProvider("FARGATE_SPOT")
* .weight(2)
* .build(), CapacityProviderStrategy.builder()
* .capacityProvider("FARGATE")
* .weight(1)
* .build()))
* .build();
* ```
*/
public open class QueueProcessingFargateService(
cdkObject: software.amazon.awscdk.services.ecs.patterns.QueueProcessingFargateService,
) : QueueProcessingServiceBase(cdkObject) {
public constructor(scope: CloudshiftdevConstructsConstruct, id: String) :
this(software.amazon.awscdk.services.ecs.patterns.QueueProcessingFargateService(scope.let(CloudshiftdevConstructsConstruct.Companion::unwrap),
id)
)
public constructor(
scope: CloudshiftdevConstructsConstruct,
id: String,
props: QueueProcessingFargateServiceProps,
) :
this(software.amazon.awscdk.services.ecs.patterns.QueueProcessingFargateService(scope.let(CloudshiftdevConstructsConstruct.Companion::unwrap),
id, props.let(QueueProcessingFargateServiceProps.Companion::unwrap))
)
public constructor(
scope: CloudshiftdevConstructsConstruct,
id: String,
props: QueueProcessingFargateServiceProps.Builder.() -> Unit,
) : this(scope, id, QueueProcessingFargateServiceProps(props)
)
/**
* The Fargate service in this construct.
*/
public open fun service(): FargateService = unwrap(this).getService().let(FargateService::wrap)
/**
* The Fargate task definition in this construct.
*/
public open fun taskDefinition(): FargateTaskDefinition =
unwrap(this).getTaskDefinition().let(FargateTaskDefinition::wrap)
/**
* A fluent builder for
* [io.cloudshiftdev.awscdk.services.ecs.patterns.QueueProcessingFargateService].
*/
@CdkDslMarker
public interface Builder {
/**
* Specifies whether the task's elastic network interface receives a public IP address.
*
* If true, each task will receive a public IP address.
*
* Default: false
*
* @param assignPublicIp Specifies whether the task's elastic network interface receives a
* public IP address.
*/
public fun assignPublicIp(assignPublicIp: Boolean)
/**
* A list of Capacity Provider strategies used to place a service.
*
* Default: - undefined
*
* @param capacityProviderStrategies A list of Capacity Provider strategies used to place a
* service.
*/
public
fun capacityProviderStrategies(capacityProviderStrategies: List)
/**
* A list of Capacity Provider strategies used to place a service.
*
* Default: - undefined
*
* @param capacityProviderStrategies A list of Capacity Provider strategies used to place a
* service.
*/
public fun capacityProviderStrategies(vararg
capacityProviderStrategies: CapacityProviderStrategy)
/**
* Whether to enable the deployment circuit breaker.
*
* If this property is defined, circuit breaker will be implicitly
* enabled.
*
* Default: - disabled
*
* @param circuitBreaker Whether to enable the deployment circuit breaker.
*/
public fun circuitBreaker(circuitBreaker: DeploymentCircuitBreaker)
/**
* Whether to enable the deployment circuit breaker.
*
* If this property is defined, circuit breaker will be implicitly
* enabled.
*
* Default: - disabled
*
* @param circuitBreaker Whether to enable the deployment circuit breaker.
*/
@kotlin.Suppress("INAPPLICABLE_JVM_NAME")
@JvmName("d1a13a051c572cfab0cbb890f588ab5c5792f47fc440c95396da62370d106383")
public fun circuitBreaker(circuitBreaker: DeploymentCircuitBreaker.Builder.() -> Unit)
/**
* 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.
*
* Default: - create a new cluster; if both cluster and vpc are omitted, a new VPC will be
* created for you.
*
* @param cluster The name of the cluster that hosts the service.
*/
public fun cluster(cluster: ICluster)
/**
* 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.
*
* Default: - CMD value built into container image.
*
* @param command The command that is passed to the container.
*/
public fun command(command: List)
/**
* 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.
*
* Default: - CMD value built into container image.
*
* @param command The command that is passed to the container.
*/
public fun command(vararg command: String)
/**
* Optional name for the container added.
*
* This name is not used when `taskDefinition` is provided.
*
* Default: - QueueProcessingContainer
*
* @param containerName Optional name for the container added.
*/
public fun containerName(containerName: String)
/**
* 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.
*
* Default: 300 seconds
*
* [Documentation](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_StepScalingPolicyConfiguration.html)
* @param cooldown Grace period after scaling activity in seconds.
*/
public fun cooldown(cooldown: Duration)
/**
* 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.
*
* Default: 256
*
* @param cpu The number of cpu units used by the task.
*/
public fun cpu(cpu: Number)
/**
* The target CPU utilization percentage for CPU based scaling strategy when enabled.
*
* Default: - 50
*
* @param cpuTargetUtilizationPercent The target CPU utilization percentage for CPU based
* scaling strategy when enabled.
*/
public fun cpuTargetUtilizationPercent(cpuTargetUtilizationPercent: Number)
/**
* 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)
*
* Default: - Rolling update (ECS)
*
* @param deploymentController Specifies which deployment controller to use for the service.
*/
public fun deploymentController(deploymentController: DeploymentController)
/**
* 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)
*
* Default: - Rolling update (ECS)
*
* @param deploymentController Specifies which deployment controller to use for the service.
*/
@kotlin.Suppress("INAPPLICABLE_JVM_NAME")
@JvmName("f12de726142aa9f89b123b40e7b7aa9bb1ac170f001fe65b6bd0999e41c15aaa")
public fun deploymentController(deploymentController: DeploymentController.Builder.() -> Unit)
/**
* Flag to disable CPU based auto scaling strategy on the service.
*
* Default: - false
*
* @param disableCpuBasedScaling Flag to disable CPU based auto scaling strategy on the service.
*
*/
public fun disableCpuBasedScaling(disableCpuBasedScaling: Boolean)
/**
* 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)
*
* Default: false
*
* @param enableEcsManagedTags Specifies whether to enable Amazon ECS managed tags for the tasks
* within the service.
*/
public fun enableEcsManagedTags(enableEcsManagedTags: Boolean)
/**
* Whether ECS Exec should be enabled.
*
* Default: - false
*
* @param enableExecuteCommand Whether ECS Exec should be enabled.
*/
public fun enableExecuteCommand(enableExecuteCommand: Boolean)
/**
* Flag to indicate whether to enable logging.
*
* Default: true
*
* @param enableLogging Flag to indicate whether to enable logging.
*/
public fun enableLogging(enableLogging: Boolean)
/**
* The environment variables to pass to the container.
*
* The variable `QUEUE_NAME` with value `queue.queueName` will
* always be passed.
*
* Default: 'QUEUE_NAME: queue.queueName'
*
* @param environment The environment variables to pass to the container.
*/
public fun environment(environment: Map)
/**
* 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.
*
* Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
*
* @param ephemeralStorageGiB The amount (in GiB) of ephemeral storage to be allocated to the
* task.
*/
public fun ephemeralStorageGiB(ephemeralStorageGiB: Number)
/**
* The name of a family that the task definition is registered to.
*
* A family groups multiple versions of a task definition.
*
* Default: - Automatically generated name.
*
* @param family The name of a family that the task definition is registered to.
*/
public fun family(family: String)
/**
* The health check command and associated configuration parameters for the container.
*
* Default: - Health check configuration from container.
*
* @param healthCheck The health check command and associated configuration parameters for the
* container.
*/
public fun healthCheck(healthCheck: HealthCheck)
/**
* The health check command and associated configuration parameters for the container.
*
* Default: - Health check configuration from container.
*
* @param healthCheck The health check command and associated configuration parameters for the
* container.
*/
@kotlin.Suppress("INAPPLICABLE_JVM_NAME")
@JvmName("da5a7971c845e3598a76c1861d1848d91dcb77e996123167092de622a2b12b39")
public fun healthCheck(healthCheck: HealthCheck.Builder.() -> Unit)
/**
* The image used to start a container.
*
* For `QueueProcessingFargateService`, either `image` or `taskDefinition` must be specified,
* but not both.
* For `QueueProcessingEc2Service`, `image` is required.
*
* Default: - the image of the task definition is used for Fargate, required otherwise
*
* @param image The image used to start a container.
*/
public fun image(image: ContainerImage)
/**
* The log driver to use.
*
* Default: - AwsLogDriver if enableLogging is true
*
* @param logDriver The log driver to use.
*/
public fun logDriver(logDriver: LogDriver)
/**
* 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.
*
* Default: - default from underlying service.
*
* @param maxHealthyPercent 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.
*/
public fun maxHealthyPercent(maxHealthyPercent: Number)
/**
* 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.
*
* Default: 3
*
* @param maxReceiveCount The maximum number of times that a message can be received by
* consumers.
*/
public fun maxReceiveCount(maxReceiveCount: Number)
/**
* Maximum capacity to scale to.
*
* Default: 2
*
* @param maxScalingCapacity Maximum capacity to scale to.
*/
public fun maxScalingCapacity(maxScalingCapacity: Number)
/**
* 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.
*
* Default: 512
*
* @param memoryLimitMiB The amount (in MiB) of memory used by the task.
*/
public fun memoryLimitMiB(memoryLimitMiB: Number)
/**
* 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.
*
* Default: - default from underlying service.
*
* @param minHealthyPercent 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.
*/
public fun minHealthyPercent(minHealthyPercent: Number)
/**
* Minimum capacity to scale to.
*
* Default: 1
*
* @param minScalingCapacity Minimum capacity to scale to.
*/
public fun minScalingCapacity(minScalingCapacity: Number)
/**
* 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.
*
* Default: Latest
*
* @param platformVersion The platform version on which to run your service.
*/
public fun platformVersion(platformVersion: FargatePlatformVersion)
/**
* 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.
*
* Default: - none
*
* @param propagateTags Specifies whether to propagate the tags from the task definition or the
* service to the tasks in the service.
*/
public fun propagateTags(propagateTags: PropagatedTagSource)
/**
* 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)
*
* Default: 'SQSQueue with CloudFormation-generated name'
*
* @param queue A queue for which to process items from.
*/
public fun queue(queue: IQueue)
/**
* The number of seconds that Dead Letter Queue retains a message.
*
* If the queue construct is specified, retentionPeriod should be omitted.
*
* Default: Duration.days(14)
*
* @param retentionPeriod The number of seconds that Dead Letter Queue retains a message.
*/
public fun retentionPeriod(retentionPeriod: Duration)
/**
* The runtime platform of the task definition.
*
* Default: - If the property is undefined, `operatingSystemFamily` is LINUX and
* `cpuArchitecture` is X86_64
*
* @param runtimePlatform The runtime platform of the task definition.
*/
public fun runtimePlatform(runtimePlatform: RuntimePlatform)
/**
* The runtime platform of the task definition.
*
* Default: - If the property is undefined, `operatingSystemFamily` is LINUX and
* `cpuArchitecture` is X86_64
*
* @param runtimePlatform The runtime platform of the task definition.
*/
@kotlin.Suppress("INAPPLICABLE_JVM_NAME")
@JvmName("eeb750a6d0db3fb1b949f8821bd6ba56805bc3c6e80afa9135f07aa0bba7bd7f")
public fun runtimePlatform(runtimePlatform: RuntimePlatform.Builder.() -> Unit)
/**
* 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)
*
* Default: [{ upper: 0, change: -1 },{ lower: 100, change: +1 },{ lower: 500, change: +5 }]
*
* @param scalingSteps The intervals for scaling based on the SQS queue's
* ApproximateNumberOfMessagesVisible metric.
*/
public fun scalingSteps(scalingSteps: List)
/**
* 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)
*
* Default: [{ upper: 0, change: -1 },{ lower: 100, change: +1 },{ lower: 500, change: +5 }]
*
* @param scalingSteps The intervals for scaling based on the SQS queue's
* ApproximateNumberOfMessagesVisible metric.
*/
public fun scalingSteps(vararg scalingSteps: ScalingInterval)
/**
* The secret to expose to the container as an environment variable.
*
* Default: - No secret environment variables.
*
* @param secrets The secret to expose to the container as an environment variable.
*/
public fun secrets(secrets: Map)
/**
* The security groups to associate with the service.
*
* If you do not specify a security group, a new security group is created.
*
* Default: - A new security group is created.
*
* @param securityGroups The security groups to associate with the service.
*/
public fun securityGroups(securityGroups: List)
/**
* The security groups to associate with the service.
*
* If you do not specify a security group, a new security group is created.
*
* Default: - A new security group is created.
*
* @param securityGroups The security groups to associate with the service.
*/
public fun securityGroups(vararg securityGroups: ISecurityGroup)
/**
* The name of the service.
*
* Default: - CloudFormation-generated name.
*
* @param serviceName The name of the service.
*/
public fun serviceName(serviceName: String)
/**
* The task definition to use for tasks in the service. TaskDefinition or TaskImageOptions must
* be specified, but not both.
*
* [disable-awslint:ref-via-interface]
*
* Default: - none
*
* @param taskDefinition The task definition to use for tasks in the service. TaskDefinition or
* TaskImageOptions must be specified, but not both.
*/
public fun taskDefinition(taskDefinition: FargateTaskDefinition)
/**
* The subnets to associate with the service.
*
* Default: - Public subnets if `assignPublicIp` is set, otherwise the first available one of
* Private, Isolated, Public, in that order.
*
* @param taskSubnets The subnets to associate with the service.
*/
public fun taskSubnets(taskSubnets: SubnetSelection)
/**
* The subnets to associate with the service.
*
* Default: - Public subnets if `assignPublicIp` is set, otherwise the first available one of
* Private, Isolated, Public, in that order.
*
* @param taskSubnets The subnets to associate with the service.
*/
@kotlin.Suppress("INAPPLICABLE_JVM_NAME")
@JvmName("23c2e8ff83ca375d76ffdcb2c21cca961b4b2585533f4b396c10695a163b8626")
public fun taskSubnets(taskSubnets: SubnetSelection.Builder.() -> Unit)
/**
* 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.
*
* Default: Duration.seconds(30)
*
* @param visibilityTimeout Timeout of processing a single message.
*/
public fun visibilityTimeout(visibilityTimeout: Duration)
/**
* 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.
*
* Default: - uses the VPC defined in the cluster or creates a new VPC.
*
* @param vpc The VPC where the container instances will be launched or the elastic network
* interfaces (ENIs) will be deployed.
*/
public fun vpc(vpc: IVpc)
}
private class BuilderImpl(
scope: SoftwareConstructsConstruct,
id: String,
) : Builder {
private val cdkBuilder:
software.amazon.awscdk.services.ecs.patterns.QueueProcessingFargateService.Builder =
software.amazon.awscdk.services.ecs.patterns.QueueProcessingFargateService.Builder.create(scope,
id)
/**
* Specifies whether the task's elastic network interface receives a public IP address.
*
* If true, each task will receive a public IP address.
*
* Default: false
*
* @param assignPublicIp Specifies whether the task's elastic network interface receives a
* public IP address.
*/
override fun assignPublicIp(assignPublicIp: Boolean) {
cdkBuilder.assignPublicIp(assignPublicIp)
}
/**
* A list of Capacity Provider strategies used to place a service.
*
* Default: - undefined
*
* @param capacityProviderStrategies A list of Capacity Provider strategies used to place a
* service.
*/
override
fun capacityProviderStrategies(capacityProviderStrategies: List) {
cdkBuilder.capacityProviderStrategies(capacityProviderStrategies.map(CapacityProviderStrategy.Companion::unwrap))
}
/**
* A list of Capacity Provider strategies used to place a service.
*
* Default: - undefined
*
* @param capacityProviderStrategies A list of Capacity Provider strategies used to place a
* service.
*/
override fun capacityProviderStrategies(vararg
capacityProviderStrategies: CapacityProviderStrategy): Unit =
capacityProviderStrategies(capacityProviderStrategies.toList())
/**
* Whether to enable the deployment circuit breaker.
*
* If this property is defined, circuit breaker will be implicitly
* enabled.
*
* Default: - disabled
*
* @param circuitBreaker Whether to enable the deployment circuit breaker.
*/
override fun circuitBreaker(circuitBreaker: DeploymentCircuitBreaker) {
cdkBuilder.circuitBreaker(circuitBreaker.let(DeploymentCircuitBreaker.Companion::unwrap))
}
/**
* Whether to enable the deployment circuit breaker.
*
* If this property is defined, circuit breaker will be implicitly
* enabled.
*
* Default: - disabled
*
* @param circuitBreaker Whether to enable the deployment circuit breaker.
*/
@kotlin.Suppress("INAPPLICABLE_JVM_NAME")
@JvmName("d1a13a051c572cfab0cbb890f588ab5c5792f47fc440c95396da62370d106383")
override fun circuitBreaker(circuitBreaker: DeploymentCircuitBreaker.Builder.() -> Unit): Unit =
circuitBreaker(DeploymentCircuitBreaker(circuitBreaker))
/**
* 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.
*
* Default: - create a new cluster; if both cluster and vpc are omitted, a new VPC will be
* created for you.
*
* @param cluster The name of the cluster that hosts the service.
*/
override fun cluster(cluster: ICluster) {
cdkBuilder.cluster(cluster.let(ICluster.Companion::unwrap))
}
/**
* 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.
*
* Default: - CMD value built into container image.
*
* @param command The command that is passed to the container.
*/
override fun command(command: List) {
cdkBuilder.command(command)
}
/**
* 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.
*
* Default: - CMD value built into container image.
*
* @param command The command that is passed to the container.
*/
override fun command(vararg command: String): Unit = command(command.toList())
/**
* Optional name for the container added.
*
* This name is not used when `taskDefinition` is provided.
*
* Default: - QueueProcessingContainer
*
* @param containerName Optional name for the container added.
*/
override fun containerName(containerName: String) {
cdkBuilder.containerName(containerName)
}
/**
* 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.
*
* Default: 300 seconds
*
* [Documentation](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_StepScalingPolicyConfiguration.html)
* @param cooldown Grace period after scaling activity in seconds.
*/
override fun cooldown(cooldown: Duration) {
cdkBuilder.cooldown(cooldown.let(Duration.Companion::unwrap))
}
/**
* 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.
*
* Default: 256
*
* @param cpu The number of cpu units used by the task.
*/
override fun cpu(cpu: Number) {
cdkBuilder.cpu(cpu)
}
/**
* The target CPU utilization percentage for CPU based scaling strategy when enabled.
*
* Default: - 50
*
* @param cpuTargetUtilizationPercent The target CPU utilization percentage for CPU based
* scaling strategy when enabled.
*/
override fun cpuTargetUtilizationPercent(cpuTargetUtilizationPercent: Number) {
cdkBuilder.cpuTargetUtilizationPercent(cpuTargetUtilizationPercent)
}
/**
* 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)
*
* Default: - Rolling update (ECS)
*
* @param deploymentController Specifies which deployment controller to use for the service.
*/
override fun deploymentController(deploymentController: DeploymentController) {
cdkBuilder.deploymentController(deploymentController.let(DeploymentController.Companion::unwrap))
}
/**
* 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)
*
* Default: - Rolling update (ECS)
*
* @param deploymentController Specifies which deployment controller to use for the service.
*/
@kotlin.Suppress("INAPPLICABLE_JVM_NAME")
@JvmName("f12de726142aa9f89b123b40e7b7aa9bb1ac170f001fe65b6bd0999e41c15aaa")
override
fun deploymentController(deploymentController: DeploymentController.Builder.() -> Unit):
Unit = deploymentController(DeploymentController(deploymentController))
/**
* Flag to disable CPU based auto scaling strategy on the service.
*
* Default: - false
*
* @param disableCpuBasedScaling Flag to disable CPU based auto scaling strategy on the service.
*
*/
override fun disableCpuBasedScaling(disableCpuBasedScaling: Boolean) {
cdkBuilder.disableCpuBasedScaling(disableCpuBasedScaling)
}
/**
* 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)
*
* Default: false
*
* @param enableEcsManagedTags Specifies whether to enable Amazon ECS managed tags for the tasks
* within the service.
*/
override fun enableEcsManagedTags(enableEcsManagedTags: Boolean) {
cdkBuilder.enableEcsManagedTags(enableEcsManagedTags)
}
/**
* Whether ECS Exec should be enabled.
*
* Default: - false
*
* @param enableExecuteCommand Whether ECS Exec should be enabled.
*/
override fun enableExecuteCommand(enableExecuteCommand: Boolean) {
cdkBuilder.enableExecuteCommand(enableExecuteCommand)
}
/**
* Flag to indicate whether to enable logging.
*
* Default: true
*
* @param enableLogging Flag to indicate whether to enable logging.
*/
override fun enableLogging(enableLogging: Boolean) {
cdkBuilder.enableLogging(enableLogging)
}
/**
* The environment variables to pass to the container.
*
* The variable `QUEUE_NAME` with value `queue.queueName` will
* always be passed.
*
* Default: 'QUEUE_NAME: queue.queueName'
*
* @param environment The environment variables to pass to the container.
*/
override fun environment(environment: Map) {
cdkBuilder.environment(environment)
}
/**
* 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.
*
* Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
*
* @param ephemeralStorageGiB The amount (in GiB) of ephemeral storage to be allocated to the
* task.
*/
override fun ephemeralStorageGiB(ephemeralStorageGiB: Number) {
cdkBuilder.ephemeralStorageGiB(ephemeralStorageGiB)
}
/**
* The name of a family that the task definition is registered to.
*
* A family groups multiple versions of a task definition.
*
* Default: - Automatically generated name.
*
* @param family The name of a family that the task definition is registered to.
*/
override fun family(family: String) {
cdkBuilder.family(family)
}
/**
* The health check command and associated configuration parameters for the container.
*
* Default: - Health check configuration from container.
*
* @param healthCheck The health check command and associated configuration parameters for the
* container.
*/
override fun healthCheck(healthCheck: HealthCheck) {
cdkBuilder.healthCheck(healthCheck.let(HealthCheck.Companion::unwrap))
}
/**
* The health check command and associated configuration parameters for the container.
*
* Default: - Health check configuration from container.
*
* @param healthCheck The health check command and associated configuration parameters for the
* container.
*/
@kotlin.Suppress("INAPPLICABLE_JVM_NAME")
@JvmName("da5a7971c845e3598a76c1861d1848d91dcb77e996123167092de622a2b12b39")
override fun healthCheck(healthCheck: HealthCheck.Builder.() -> Unit): Unit =
healthCheck(HealthCheck(healthCheck))
/**
* The image used to start a container.
*
* For `QueueProcessingFargateService`, either `image` or `taskDefinition` must be specified,
* but not both.
* For `QueueProcessingEc2Service`, `image` is required.
*
* Default: - the image of the task definition is used for Fargate, required otherwise
*
* @param image The image used to start a container.
*/
override fun image(image: ContainerImage) {
cdkBuilder.image(image.let(ContainerImage.Companion::unwrap))
}
/**
* The log driver to use.
*
* Default: - AwsLogDriver if enableLogging is true
*
* @param logDriver The log driver to use.
*/
override fun logDriver(logDriver: LogDriver) {
cdkBuilder.logDriver(logDriver.let(LogDriver.Companion::unwrap))
}
/**
* 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.
*
* Default: - default from underlying service.
*
* @param maxHealthyPercent 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.
*/
override fun maxHealthyPercent(maxHealthyPercent: Number) {
cdkBuilder.maxHealthyPercent(maxHealthyPercent)
}
/**
* 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.
*
* Default: 3
*
* @param maxReceiveCount The maximum number of times that a message can be received by
* consumers.
*/
override fun maxReceiveCount(maxReceiveCount: Number) {
cdkBuilder.maxReceiveCount(maxReceiveCount)
}
/**
* Maximum capacity to scale to.
*
* Default: 2
*
* @param maxScalingCapacity Maximum capacity to scale to.
*/
override fun maxScalingCapacity(maxScalingCapacity: Number) {
cdkBuilder.maxScalingCapacity(maxScalingCapacity)
}
/**
* 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.
*
* Default: 512
*
* @param memoryLimitMiB The amount (in MiB) of memory used by the task.
*/
override fun memoryLimitMiB(memoryLimitMiB: Number) {
cdkBuilder.memoryLimitMiB(memoryLimitMiB)
}
/**
* 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.
*
* Default: - default from underlying service.
*
* @param minHealthyPercent 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.
*/
override fun minHealthyPercent(minHealthyPercent: Number) {
cdkBuilder.minHealthyPercent(minHealthyPercent)
}
/**
* Minimum capacity to scale to.
*
* Default: 1
*
* @param minScalingCapacity Minimum capacity to scale to.
*/
override fun minScalingCapacity(minScalingCapacity: Number) {
cdkBuilder.minScalingCapacity(minScalingCapacity)
}
/**
* 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.
*
* Default: Latest
*
* @param platformVersion The platform version on which to run your service.
*/
override fun platformVersion(platformVersion: FargatePlatformVersion) {
cdkBuilder.platformVersion(platformVersion.let(FargatePlatformVersion.Companion::unwrap))
}
/**
* 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.
*
* Default: - none
*
* @param propagateTags Specifies whether to propagate the tags from the task definition or the
* service to the tasks in the service.
*/
override fun propagateTags(propagateTags: PropagatedTagSource) {
cdkBuilder.propagateTags(propagateTags.let(PropagatedTagSource.Companion::unwrap))
}
/**
* 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)
*
* Default: 'SQSQueue with CloudFormation-generated name'
*
* @param queue A queue for which to process items from.
*/
override fun queue(queue: IQueue) {
cdkBuilder.queue(queue.let(IQueue.Companion::unwrap))
}
/**
* The number of seconds that Dead Letter Queue retains a message.
*
* If the queue construct is specified, retentionPeriod should be omitted.
*
* Default: Duration.days(14)
*
* @param retentionPeriod The number of seconds that Dead Letter Queue retains a message.
*/
override fun retentionPeriod(retentionPeriod: Duration) {
cdkBuilder.retentionPeriod(retentionPeriod.let(Duration.Companion::unwrap))
}
/**
* The runtime platform of the task definition.
*
* Default: - If the property is undefined, `operatingSystemFamily` is LINUX and
* `cpuArchitecture` is X86_64
*
* @param runtimePlatform The runtime platform of the task definition.
*/
override fun runtimePlatform(runtimePlatform: RuntimePlatform) {
cdkBuilder.runtimePlatform(runtimePlatform.let(RuntimePlatform.Companion::unwrap))
}
/**
* The runtime platform of the task definition.
*
* Default: - If the property is undefined, `operatingSystemFamily` is LINUX and
* `cpuArchitecture` is X86_64
*
* @param runtimePlatform The runtime platform of the task definition.
*/
@kotlin.Suppress("INAPPLICABLE_JVM_NAME")
@JvmName("eeb750a6d0db3fb1b949f8821bd6ba56805bc3c6e80afa9135f07aa0bba7bd7f")
override fun runtimePlatform(runtimePlatform: RuntimePlatform.Builder.() -> Unit): Unit =
runtimePlatform(RuntimePlatform(runtimePlatform))
/**
* 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)
*
* Default: [{ upper: 0, change: -1 },{ lower: 100, change: +1 },{ lower: 500, change: +5 }]
*
* @param scalingSteps The intervals for scaling based on the SQS queue's
* ApproximateNumberOfMessagesVisible metric.
*/
override fun scalingSteps(scalingSteps: List) {
cdkBuilder.scalingSteps(scalingSteps.map(ScalingInterval.Companion::unwrap))
}
/**
* 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)
*
* Default: [{ upper: 0, change: -1 },{ lower: 100, change: +1 },{ lower: 500, change: +5 }]
*
* @param scalingSteps The intervals for scaling based on the SQS queue's
* ApproximateNumberOfMessagesVisible metric.
*/
override fun scalingSteps(vararg scalingSteps: ScalingInterval): Unit =
scalingSteps(scalingSteps.toList())
/**
* The secret to expose to the container as an environment variable.
*
* Default: - No secret environment variables.
*
* @param secrets The secret to expose to the container as an environment variable.
*/
override fun secrets(secrets: Map) {
cdkBuilder.secrets(secrets.mapValues{Secret.unwrap(it.value)})
}
/**
* The security groups to associate with the service.
*
* If you do not specify a security group, a new security group is created.
*
* Default: - A new security group is created.
*
* @param securityGroups The security groups to associate with the service.
*/
override fun securityGroups(securityGroups: List) {
cdkBuilder.securityGroups(securityGroups.map(ISecurityGroup.Companion::unwrap))
}
/**
* The security groups to associate with the service.
*
* If you do not specify a security group, a new security group is created.
*
* Default: - A new security group is created.
*
* @param securityGroups The security groups to associate with the service.
*/
override fun securityGroups(vararg securityGroups: ISecurityGroup): Unit =
securityGroups(securityGroups.toList())
/**
* The name of the service.
*
* Default: - CloudFormation-generated name.
*
* @param serviceName The name of the service.
*/
override fun serviceName(serviceName: String) {
cdkBuilder.serviceName(serviceName)
}
/**
* The task definition to use for tasks in the service. TaskDefinition or TaskImageOptions must
* be specified, but not both.
*
* [disable-awslint:ref-via-interface]
*
* Default: - none
*
* @param taskDefinition The task definition to use for tasks in the service. TaskDefinition or
* TaskImageOptions must be specified, but not both.
*/
override fun taskDefinition(taskDefinition: FargateTaskDefinition) {
cdkBuilder.taskDefinition(taskDefinition.let(FargateTaskDefinition.Companion::unwrap))
}
/**
* The subnets to associate with the service.
*
* Default: - Public subnets if `assignPublicIp` is set, otherwise the first available one of
* Private, Isolated, Public, in that order.
*
* @param taskSubnets The subnets to associate with the service.
*/
override fun taskSubnets(taskSubnets: SubnetSelection) {
cdkBuilder.taskSubnets(taskSubnets.let(SubnetSelection.Companion::unwrap))
}
/**
* The subnets to associate with the service.
*
* Default: - Public subnets if `assignPublicIp` is set, otherwise the first available one of
* Private, Isolated, Public, in that order.
*
* @param taskSubnets The subnets to associate with the service.
*/
@kotlin.Suppress("INAPPLICABLE_JVM_NAME")
@JvmName("23c2e8ff83ca375d76ffdcb2c21cca961b4b2585533f4b396c10695a163b8626")
override fun taskSubnets(taskSubnets: SubnetSelection.Builder.() -> Unit): Unit =
taskSubnets(SubnetSelection(taskSubnets))
/**
* 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.
*
* Default: Duration.seconds(30)
*
* @param visibilityTimeout Timeout of processing a single message.
*/
override fun visibilityTimeout(visibilityTimeout: Duration) {
cdkBuilder.visibilityTimeout(visibilityTimeout.let(Duration.Companion::unwrap))
}
/**
* 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.
*
* Default: - uses the VPC defined in the cluster or creates a new VPC.
*
* @param vpc The VPC where the container instances will be launched or the elastic network
* interfaces (ENIs) will be deployed.
*/
override fun vpc(vpc: IVpc) {
cdkBuilder.vpc(vpc.let(IVpc.Companion::unwrap))
}
public fun build(): software.amazon.awscdk.services.ecs.patterns.QueueProcessingFargateService =
cdkBuilder.build()
}
public companion object {
public operator fun invoke(
scope: CloudshiftdevConstructsConstruct,
id: String,
block: Builder.() -> Unit = {},
): QueueProcessingFargateService {
val builderImpl = BuilderImpl(CloudshiftdevConstructsConstruct.unwrap(scope), id)
return QueueProcessingFargateService(builderImpl.apply(block).build())
}
internal
fun wrap(cdkObject: software.amazon.awscdk.services.ecs.patterns.QueueProcessingFargateService):
QueueProcessingFargateService = QueueProcessingFargateService(cdkObject)
internal fun unwrap(wrapped: QueueProcessingFargateService):
software.amazon.awscdk.services.ecs.patterns.QueueProcessingFargateService =
wrapped.cdkObject as
software.amazon.awscdk.services.ecs.patterns.QueueProcessingFargateService
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy