Fargate服务：启动类型与容量提供方策略对比及配置疑问

Great question! Let's break this down into two clear parts: the differences between using the Fargate launch type vs. a 100% FARGATE capacity provider strategy, and how to configure the latter via CDK.

1. Differences Between Fargate Launch Type and 100% FARGATE Capacity Provider Strategy #

While both configurations result in your tasks running on Fargate on-demand capacity, there are key distinctions in flexibility and future-proofing:

• Functional Flexibility:
  • The Fargate launch type is the original, restrictive way to deploy Fargate tasks—you’re locked exclusively into FARGATE (on-demand) capacity with no easy path to mix in spot instances later without reconfiguring your service.
  • A 100% FARGATE capacity provider strategy achieves the exact same on-demand behavior but is built on AWS’s modern capacity provider framework. This means you can effortlessly adjust the strategy down the line (e.g., add a FARGATE_SPOT provider with a 50/50 split) without overhauling your service setup.
• AWS Behavior Priority:
  • When you specify a capacity provider strategy, AWS completely ignores the launchType parameter. Conversely, if you only set the launch type to Fargate, AWS defaults to using the FARGATE capacity provider behind the scenes.
  • For auto-scaling, both setups support target tracking or step scaling policies, but the capacity provider strategy gives you more granular control if you ever expand to mixed capacity (e.g., scale spot tasks first before on-demand).
• Best Practice Alignment:
  • AWS recommends using capacity provider strategies over launch types for new deployments, as they’re the future-proofed way to manage task capacity across both EC2 and Fargate environments.

2. Configuring Capacity Provider Strategy via CDK #

Absolutely! You can specify a capacity provider strategy in CDK, whether using the high-level NetworkLoadBalancedFargateService construct or the lower-level FargateService construct. Here’s how:

Option 1: Using the High-Level NetworkLoadBalancedFargateService #

This is the simplest approach if you want to keep using the pre-built load-balanced service pattern:

import * as cdk from 'aws-cdk-lib';
import * as ecs from 'aws-cdk-lib/aws-ecs';
import * as ecsPatterns from 'aws-cdk-lib/aws-ecs-patterns';

export class FargateCapacityProviderStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const cluster = new ecs.Cluster(this, 'MyCluster', {
      vpc: cdk.aws_ec2.Vpc.fromLookup(this, 'MyVpc', { vpcId: 'your-vpc-id' }),
    });

    const taskDefinition = new ecs.FargateTaskDefinition(this, 'MyTaskDef', {
      cpu: 256,
      memoryLimitMiB: 512,
    });

    taskDefinition.addContainer('MyApp', {
      image: ecs.ContainerImage.fromRegistry('nginx'), // Replace with your image
      portMappings: [{ containerPort: 80 }],
    });

    // Configure the load-balanced service with capacity provider strategy
    new ecsPatterns.NetworkLoadBalancedFargateService(this, 'MyLBService', {
      cluster,
      taskDefinition,
      serviceProps: {
        capacityProviderStrategies: [
          {
            capacityProvider: 'FARGATE',
            weight: 100, // 100% of tasks run on FARGATE
            base: 1, // At least 1 task always runs on FARGATE
          },
        ],
        // Note: launchType is ignored when capacityProviderStrategies is set, so you can omit it
      },
    });
  }
}

Option 2: Using the Lower-Level FargateService #

If you need more control over the service or load balancer configuration:

import * as cdk from 'aws-cdk-lib';
import * as ecs from 'aws-cdk-lib/aws-ecs';
import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';

export class FargateCapacityProviderStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const vpc = cdk.aws_ec2.Vpc.fromLookup(this, 'MyVpc', { vpcId: 'your-vpc-id' });
    const cluster = new ecs.Cluster(this, 'MyCluster', { vpc });

    const taskDefinition = new ecs.FargateTaskDefinition(this, 'MyTaskDef', {
      cpu: 256,
      memoryLimitMiB: 512,
    });

    taskDefinition.addContainer('MyApp', {
      image: ecs.ContainerImage.fromRegistry('nginx'),
      portMappings: [{ containerPort: 80 }],
    });

    // Create Network Load Balancer
    const nlb = new elbv2.NetworkLoadBalancer(this, 'MyNLB', {
      vpc,
      internetFacing: true,
    });

    const listener = nlb.addListener('MyListener', { port: 80 });

    // Create Fargate Service with capacity provider strategy
    const service = new ecs.FargateService(this, 'MyFargateService', {
      cluster,
      taskDefinition,
      capacityProviderStrategies: [
        {
          capacityProvider: 'FARGATE',
          weight: 100,
          base: 1,
        },
      ],
    });

    // Attach service to NLB listener
    listener.addTargets('ECSTarget', {
      port: 80,
      targets: [service],
    });
  }
}

Key Notes: #

• Ensure your ECS cluster has the FARGATE capacity provider attached (new clusters include this by default; for older clusters, you may need to add it manually).
• When capacityProviderStrategies is set, AWS ignores any launchType value you specify, so you can safely omit that parameter.

内容的提问来源于stack exchange，提问作者Saining Li