(aws-events-targets): The EcsTask target for the L2 EventBridge Rule construct needs to have a "launch type" parameter

[sabiiiq]

Describe the feature

When setting an ECS task as a target for an EventBridge rule via the AWS console or AWS SDKs, you are given the option to select the launch type for the compute that the task will run on.

However, the EcsTask target for the L2 EventBridge Rule construct does not provide a means to select the launch type.

As a result, I've had to use the more verbose L1 CfnRule construct and EcsParameters interface, which does provide a launchType parameter.

Use Case

I was trying to create an EventBridge rule that runs an ECS task when triggered. While I intend for this task to run on Fargate, I'd added both EC2 and Fargate compatibilities for the task definition so that I could run it on EC2 in case I ever needed visibility into the compute environment for troubleshooting.

I used the L2 EventBridge Rule construct and its associated EcsTask target which provided a relatively simple interface:

import * as cdk from 'aws-cdk-lib';
import * as ecs from 'aws-cdk-lib/aws-ecs';
import * as ec2 from 'aws-cdk-lib/aws-ec2';
import * as events from 'aws-cdk-lib/aws-events';
import * as targets from 'aws-cdk-lib/aws-events-targets';
import { Construct } from 'constructs';

export class exampleStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
    
    const ecsCluster = new ecs.Cluster(this, 'ECSCluster', {
	...
	enableFargateCapacityProviders: true,
	...
    });
    const ecsTaskDefinition = new ecs.TaskDefinition(this, 'ECSTaskDefinition', {
	...
	compatibility: ecs.Compatibility.EC2_AND_FARGATE,
	...
    });
    const securityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', {...});

    const eventBridgeRule = new events.Rule(this, 'EventBridgeRule', {
      eventPattern: {...}
      }
    });
    eventBridgeRule.addTarget(
      new targets.EcsTask({
        cluster: ecsCluster,
        taskDefinition: ecsTaskDefinition,
        taskCount: 1,
        subnetSelection: {subnetType: ec2.SubnetType.PRIVATE_ISOLATED},
        securityGroups: [securityGroup]
      })
    );
  }
}

However, after running cdk deploy and triggering the EventBridge rule, the ECS task failed to run because the launch type had implicitly been set to EC2 and only Fargate compute was available for the cluster. Looking at the configuration of the EventBridge rule and target in the AWS console, and running cdk synth, I confirmed that the launch type had somehow been set to EC2.

...
EcsParameters: 
	LaunchType: EC2
...

Looking through the code for the EcsTask target class, the launchType property is set implicitly by invoking the ecs.taskDefinition.isEc2Compatible() method:

• https://github.com/aws/aws-cdk/blob/main/packages/aws-cdk-lib/aws-events-targets/lib/ecs-task.ts#L232
• https://github.com/aws/aws-cdk/blob/main/packages/aws-cdk-lib/aws-ecs/lib/base/task-definition.ts#L1258-L1260

In other words, if the task definition has any EC2 compatibility at all, the launch type of the EcsTask EventBridge target is automatically set to EC2, even you are trying to run the task in a cluster that has only Fargate compute available.

As a result, I had to rewrite my CDK code to use the much more verbose L1 CfnRule construct and EcsParameters interface, just because this one parameter was missing. This involved writing out a lot more code than I would have preferred to.

Proposed Solution

Adding a launchType parameter for the EcsTask target would make the L2 EventBridge Rule construct and EcsTask target more usable. I could then use the same code I showed above, just with the addition of the launchType parameter:

import * as cdk from 'aws-cdk-lib';
import * as ecs from 'aws-cdk-lib/aws-ecs';
import * as ec2 from 'aws-cdk-lib/aws-ec2';
import * as events from 'aws-cdk-lib/aws-events';
import * as targets from 'aws-cdk-lib/aws-events-targets';
import { Construct } from 'constructs';

export class exampleStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
    
    const ecsCluster = new ecs.Cluster(this, 'ECSCluster', {
	...
	enableFargateCapacityProviders: true,
	...
    });
    const ecsTaskDefinition = new ecs.TaskDefinition(this, 'ECSTaskDefinition', {
	...
	compatibility: ecs.Compatibility.EC2_AND_FARGATE,
	...
    });
    const securityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', {...});

    const eventBridgeRule = new events.Rule(this, 'EventBridgeRule', {
      eventPattern: {...}
      }
    });
    eventBridgeRule.addTarget(
      new targets.EcsTask({
        cluster: ecsCluster,
        taskDefinition: ecsTaskDefinition,
        taskCount: 1,
        subnetSelection: {subnetType: ec2.SubnetType.PRIVATE_ISOLATED},
        securityGroups: [securityGroup],
        launchType: 'FARGATE'
      })
    );
  }
}

Other Information

No response

Acknowledgements

• I may be able to implement this feature request
• This feature might incur a breaking change

CDK version used

2.121.1

Environment details (OS name and version, etc.)

Amazon Linux 2

[pahud]

Did you mean your compatibility could be Compatibility.EC2_AND_FARGATE but your cluster is a FARGATE only cluster and you need to set the LaunchType as Fargate?

Yes looks like EcsTask should have an optional prop for launchType which is implicitly determined if undefined.

I guess you still can use L2 and addPropertyOverride() to override the auto-generated launch type prop.

[sabiiiq]

Yes, exactly. That's what I want to be able to do with the L2 Rule construct and EcsTask target.

[pahud]

Before we have a PR for that, you can work it around like this:

    const eventBridgeRule = new events.Rule(this, 'EventBridgeRule', {
      schedule,
    });

    eventBridgeRule.addTarget(
      new targets.EcsTask({
        cluster: ecsCluster,
        taskDefinition: ecsTaskDefinition,
        taskCount: 1,
        subnetSelection: {subnetType: ec2.SubnetType.PRIVATE_ISOLATED},
        // launchType: 'FARGATE'
      })
    );

    const cfnRule = eventBridgeRule.node.tryFindChild('Resource') as events.CfnRule;
    cfnRule.addPropertyOverride('Targets.0.EcsParameters.LaunchType', 'FARGATE');

Let me know if it works for you.

[github-actions]

⚠️COMMENT VISIBILITY WARNING⚠️

Comments on closed issues are hard for our team to see.
If you need more assistance, please either tag a team member or open a new issue that references this one.
If you wish to keep having a conversation with other community members under this issue feel free to do so.

[github-actions]

⚠️COMMENT VISIBILITY WARNING⚠️

Comments on closed issues are hard for our team to see.
If you need more assistance, please either tag a team member or open a new issue that references this one.
If you wish to keep having a conversation with other community members under this issue feel free to do so.