feat(ecs-patterns): support disabling CPU-based scaling and custom target utilization

packages/aws-cdk-lib/aws-ecs-patterns/README.md

@@ -295,6 +295,27 @@ const queueProcessingFargateService = new ecsPatterns.QueueProcessingFargateServ
 
 when queue not provided by user, CDK will create a primary queue and a dead letter queue with default redrive policy and attach permission to the task to be able to access the primary queue.
 
+NOTE: This construct add a CPU Based scaling strategy by default, if this is not required in any solution please disable this by setting `disableCpuBasedScaling` to `true`.
+
+```ts
+declare const cluster: ecs.Cluster;
+const queueProcessingFargateService = new ecsPatterns.QueueProcessingFargateService(this, 'Service', {
+  cluster,
+  memoryLimitMiB: 512,
+  image: ecs.ContainerImage.fromRegistry('test'),
+  command: ["-c", "4", "amazon.com"],
+  enableLogging: false,
+  desiredTaskCount: 2,
+  environment: {
+    TEST_ENVIRONMENT_VARIABLE1: "test environment variable 1 value",
+    TEST_ENVIRONMENT_VARIABLE2: "test environment variable 2 value",
+  },
+  maxScalingCapacity: 5,
+  containerName: 'test',
+  disableCpuBasedScaling: true,
+});
+```
+
 ## Scheduled Tasks
 
 To define a task that runs periodically, there are 2 options:

packages/aws-cdk-lib/aws-ecs-patterns/lib/base/queue-processing-service-base.ts

@@ -221,6 +221,20 @@ export interface QueueProcessingServiceBaseProps {
    * @default - false
    */
   readonly enableExecuteCommand?: boolean;
+
+  /**
+   * Flag to disable CPU based auto scaling strategy on the service.
+   *
+   * @default - false
+   */
+  readonly disableCpuBasedScaling?: boolean
+
+  /**
+   * The target CPU utilization percentage for CPU based scaling strategy when enabled.
+   *
+   * @default - 50
+   */
+  readonly targetUtilizationPercent?: number
 }
 
 /**
@@ -279,6 +293,18 @@ export abstract class QueueProcessingServiceBase extends Construct {
    * The AwsLogDriver to use for logging if logging is enabled.
    */
   public readonly logDriver?: LogDriver;
+  /**
+   * Flag to disable CPU based auto scaling strategy on the service.
+   *
+   * @default - false
+   */
+  public readonly disableCpuBasedScaling: boolean = false
+  /**
+   * The target CPU utilization percentage for CPU based scaling strategy when enabled.
+   *
+   * @default - 50
+   */
+  public readonly targetUtilizationPercent: number = 50
 
   /**
    * Constructs a new instance of the QueueProcessingServiceBase class.
@@ -325,6 +351,8 @@ export abstract class QueueProcessingServiceBase extends Construct {
     // Add the queue name to environment variables
     this.environment = { ...(props.environment || {}), QUEUE_NAME: this.sqsQueue.queueName };
     this.secrets = props.secrets;
+    this.disableCpuBasedScaling = props.disableCpuBasedScaling ?? false;
+    this.targetUtilizationPercent = props.targetUtilizationPercent ?? 50;
 
     this.desiredCount = props.desiredTaskCount ?? 1;
 
@@ -357,9 +385,12 @@ export abstract class QueueProcessingServiceBase extends Construct {
    */
   protected configureAutoscalingForService(service: BaseService) {
     const scalingTarget = service.autoScaleTaskCount({ maxCapacity: this.maxCapacity, minCapacity: this.minCapacity });
-    scalingTarget.scaleOnCpuUtilization('CpuScaling', {
-      targetUtilizationPercent: 50,
-    });
+
+    if (!this.disableCpuBasedScaling) {
+      scalingTarget.scaleOnCpuUtilization('CpuScaling', {
+        targetUtilizationPercent: this.targetUtilizationPercent,
+      });
+    }
     scalingTarget.scaleOnMetric('QueueMessagesVisibleScaling', {
       metric: this.sqsQueue.metricApproximateNumberOfMessagesVisible(),
       scalingSteps: this.scalingSteps,

packages/aws-cdk-lib/aws-ecs-patterns/test/fargate/queue-processing-fargate-service.test.ts

@@ -487,6 +487,98 @@ testDeprecated('test Fargate queue worker service construct - with optional prop
   });
 });
 
+testDeprecated('test Fargate queue worker service construct - with cpu scaling strategy disabled', () => {
+  // GIVEN
+  const stack = new cdk.Stack();
+  const vpc = new ec2.Vpc(stack, 'VPC');
+  const cluster = new ecs.Cluster(stack, 'Cluster', { vpc });
+  cluster.addAsgCapacityProvider(new AsgCapacityProvider(stack, 'DefaultAutoScalingGroupProvider', {
+    autoScalingGroup: new AutoScalingGroup(stack, 'DefaultAutoScalingGroup', {
+      vpc,
+      instanceType: new ec2.InstanceType('t2.micro'),
+      machineImage: MachineImage.latestAmazonLinux(),
+    }),
+  }));
+  const queue = new sqs.Queue(stack, 'fargate-test-queue', {
+    queueName: 'fargate-test-sqs-queue',
+  });
+
+  // WHEN
+  new ecsPatterns.QueueProcessingFargateService(stack, 'Service', {
+    cluster,
+    memoryLimitMiB: 512,
+    image: ecs.ContainerImage.fromRegistry('test'),
+    command: ['-c', '4', 'amazon.com'],
+    enableLogging: false,
+    environment: {
+      TEST_ENVIRONMENT_VARIABLE1: 'test environment variable 1 value',
+      TEST_ENVIRONMENT_VARIABLE2: 'test environment variable 2 value',
+    },
+    queue,
+    maxScalingCapacity: 5,
+    minHealthyPercent: 60,
+    maxHealthyPercent: 150,
+    serviceName: 'fargate-test-service',
+    family: 'fargate-task-family',
+    platformVersion: ecs.FargatePlatformVersion.VERSION1_4,
+    circuitBreaker: { rollback: true },
+    disableCpuBasedScaling: true,
+  });
+
+  // THEN - QueueWorker is of FARGATE launch type, an SQS queue is created and all optional properties are set.
+  Template.fromStack(stack).hasResourceProperties('AWS::ECS::Service', {
+    DeploymentConfiguration: {
+      MinimumHealthyPercent: 60,
+      MaximumPercent: 150,
+      DeploymentCircuitBreaker: {
+        Enable: true,
+        Rollback: true,
+      },
+    },
+    LaunchType: 'FARGATE',
+    ServiceName: 'fargate-test-service',
+    PlatformVersion: ecs.FargatePlatformVersion.VERSION1_4,
+    DeploymentController: {
+      Type: 'ECS',
+    },
+  });
+
+  Template.fromStack(stack).hasResourceProperties('AWS::SQS::Queue', { QueueName: 'fargate-test-sqs-queue' });
+
+  Template.fromStack(stack).hasResourceProperties('AWS::ECS::TaskDefinition', {
+    ContainerDefinitions: [
+      Match.objectLike({
+        Command: [
+          '-c',
+          '4',
+          'amazon.com',
+        ],
+        Environment: [
+          {
+            Name: 'TEST_ENVIRONMENT_VARIABLE1',
+            Value: 'test environment variable 1 value',
+          },
+          {
+            Name: 'TEST_ENVIRONMENT_VARIABLE2',
+            Value: 'test environment variable 2 value',
+          },
+          {
+            Name: 'QUEUE_NAME',
+            Value: {
+              'Fn::GetAtt': [
+                'fargatetestqueue28B43841',
+                'QueueName',
+              ],
+            },
+          },
+        ],
+        Image: 'test',
+      }),
+    ],
+    Family: 'fargate-task-family',
+  });
+});
+
 test('can set custom containerName', () => {
   // GIVEN
   const stack = new cdk.Stack();