選取您的 Cookie 偏好設定

我們使用提供自身網站和服務所需的基本 Cookie 和類似工具。我們使用效能 Cookie 收集匿名統計資料，以便了解客戶如何使用我們的網站並進行改進。基本 Cookie 無法停用，但可以按一下「自訂」或「拒絕」以拒絕效能 Cookie。

如果您同意，AWS 與經核准的第三方也會使用 Cookie 提供實用的網站功能、記住您的偏好設定，並顯示相關內容，包括相關廣告。若要接受或拒絕所有非必要 Cookie，請按一下「接受」或「拒絕」。若要進行更詳細的選擇，請按一下「自訂」。

偏好設定
聯絡我們
意見回饋
AWS Documentation
建立 AWS 帳戶

範例：使用 建立 AWS Fargate 服務 AWS CDK

RSS
焦點模式
範例：使用 建立 AWS Fargate 服務 AWS CDK - AWS Cloud Development Kit (AWS CDK) v2
建立 CDK 專案建立 Fargate 服務清除

這是 AWS CDK v2 開發人員指南。較舊的 CDK v1 已於 2022 年 6 月 1 日進入維護，並於 2023 年 6 月 1 日結束支援。

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

這是 AWS CDK v2 開發人員指南。較舊的 CDK v1 已於 2022 年 6 月 1 日進入維護，並於 2023 年 6 月 1 日結束支援。

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

在此範例中，我們會示範如何建立在 Amazon Elastic Container Service (Amazon ECS) 叢集上執行 AWS Fargate 的服務，該叢集由面向網際網路的 Application Load Balancer 從 Amazon ECR 上的映像前端。

Amazon ECS 是高度可擴展、快速的容器管理服務，可讓您輕鬆地執行、停止和管理叢集上的Docker容器。您可以使用 Fargate 啟動類型啟動服務或任務，將叢集託管在由 Amazon ECS 管理的無伺服器基礎設施上。如需更多控制，您可以在使用 Amazon EC2 啟動類型管理的 Amazon Elastic Compute Cloud (Amazon EC2) 執行個體叢集上託管任務。

在此範例中，我們使用 Fargate 啟動類型來啟動某些服務。如果您已使用 AWS Management Console 來建立 Fargate 服務，則知道要遵循許多步驟來完成該任務。 AWS 有幾個教學課程和文件主題，會逐步引導您建立 Fargate 服務，包括：

此範例使用 建立類似的 Fargate 服務 AWS CDK。

此範例中使用的 Amazon ECS 建構模組可提供下列優點，協助您使用 AWS 服務：

  • 自動設定負載平衡器。

  • 自動開啟負載平衡器的安全群組。這可讓負載平衡器與執行個體通訊，而不必明確建立安全群組。

  • 自動排序服務與連接至目標群組的負載平衡器之間的相依性，其中 會在建立執行個體之前 AWS CDK 強制執行建立接聽程式的正確順序。

  • 在自動擴展群組上自動設定使用者資料。這會建立正確的組態，將叢集與 AMIs建立關聯。

  • 及早驗證參數組合。這會更早地公開 AWS CloudFormation 問題，從而節省部署時間。例如，視任務而定，不適當設定記憶體設定很容易。先前，在部署應用程式之前，我們不會遇到錯誤。但現在 AWS CDK 可以偵測組態錯誤，並在合成應用程式時發出錯誤。

  • 如果我們使用來自 Amazon ECR 的映像，則會自動新增 Amazon Elastic Container Registry (Amazon ECR) 的許可。

  • 自動擴展。 AWS CDK 提供一種方法，讓我們在使用 Amazon EC2 叢集時可以自動擴展執行個體。當我們在 Fargate 叢集中使用執行個體時，會自動發生這種情況。

    此外，當自動調整規模嘗試停止執行個體，但任務正在執行或排程在該執行個體上時， AWS CDK 可防止刪除執行個體。

    先前，我們必須建立 Lambda 函數才能擁有此功能。

  • 提供資產支援，讓我們可以在一個步驟中將來源從機器部署到 Amazon ECS。先前，若要使用應用程式來源，我們必須執行數個手動步驟，例如上傳至 Amazon ECR 和建立Docker映像。

重要

我們將使用的ApplicationLoadBalancedFargateService建構包含許多 AWS 元件，其中有些元件如果保留在 AWS 帳戶中佈建，則會產生非微不足道的成本，即使我們不使用它們。如果您遵循此範例，請務必清除 (cdk destroy)。

建立 CDK 專案

我們從建立 CDK 專案開始。這是存放 AWS CDK 程式碼的目錄，包括 CDK 應用程式。

TypeScript
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language typescript
JavaScript
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language javascript
Python
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language python
source .venv/bin/activate # On Windows, run '.\venv\Scripts\activate' instead
pip install -r requirements.txt
Java
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language java

我們現在可以將 Maven 專案匯入 IDE。

C#
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language csharp

我們現在可以src/MyEcsConstruct.sln在 Visual Studio 中開啟 。

anchoranchoranchoranchoranchor
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language typescript

接下來，我們會執行應用程式並確認它建立空堆疊。

cdk synth

建立 Fargate 服務

有兩種不同的方式可以使用 Amazon ECS 執行容器任務：

  • 使用 Fargate啟動類型，其中 Amazon ECS 會管理我們執行容器的實體機器。

  • 使用 EC2啟動類型，我們在其中執行 管理，例如指定自動擴展。

在此範例中，我們將建立在 Amazon ECS 叢集上執行的 Fargate 服務，前方為面向網際網路的 Application Load Balancer。

我們將下列 AWS 建構程式庫模組匯入至堆疊檔案：

TypeScript

檔案： lib/my_ecs_construct-stack.ts

import * as ec2 from "aws-cdk-lib/aws-ec2";
import * as ecs from "aws-cdk-lib/aws-ecs";
import * as ecs_patterns from "aws-cdk-lib/aws-ecs-patterns";
JavaScript

檔案： lib/my_ecs_construct-stack.js

const ec2 = require("aws-cdk-lib/aws-ec2");
const ecs = require("aws-cdk-lib/aws-ecs");
const ecs_patterns = require("aws-cdk-lib/aws-ecs-patterns");
Python

檔案： my_ecs_construct/my_ecs_construct_stack.py

from aws_cdk import (aws_ec2 as ec2, aws_ecs as ecs,
                     aws_ecs_patterns as ecs_patterns)
Java

檔案： src/main/java/com/myorg/MyEcsConstructStack.java

import software.amazon.awscdk.services.ec2.*;
import software.amazon.awscdk.services.ecs.*;
import software.amazon.awscdk.services.ecs.patterns.*;
C#

檔案： src/MyEcsConstruct/MyEcsConstructStack.cs

using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.ECS;
using Amazon.CDK.AWS.ECS.Patterns;
anchoranchoranchoranchoranchor

檔案： lib/my_ecs_construct-stack.ts

import * as ec2 from "aws-cdk-lib/aws-ec2";
import * as ecs from "aws-cdk-lib/aws-ecs";
import * as ecs_patterns from "aws-cdk-lib/aws-ecs-patterns";

在我們的堆疊中，我們新增下列程式碼：

TypeScript
    const vpc = new ec2.Vpc(this, "MyVpc", {
      maxAzs: 3 // Default is all AZs in region
    });

    const cluster = new ecs.Cluster(this, "MyCluster", {
      vpc: vpc
    });

    // Create a load-balanced Fargate service and make it public
    new ecs_patterns.ApplicationLoadBalancedFargateService(this, "MyFargateService", {
      cluster: cluster, // Required
      cpu: 512, // Default is 256
      desiredCount: 6, // Default is 1
      taskImageOptions: { image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample") },
      memoryLimitMiB: 2048, // Default is 512
      publicLoadBalancer: true // Default is true
    });
JavaScript
    const vpc = new ec2.Vpc(this, "MyVpc", {
      maxAzs: 3 // Default is all AZs in region
    });

    const cluster = new ecs.Cluster(this, "MyCluster", {
      vpc: vpc
    });

    // Create a load-balanced Fargate service and make it public
    new ecs_patterns.ApplicationLoadBalancedFargateService(this, "MyFargateService", {
      cluster: cluster, // Required
      cpu: 512, // Default is 256
      desiredCount: 6, // Default is 1
      taskImageOptions: { image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample") },
      memoryLimitMiB: 2048, // Default is 512
      publicLoadBalancer: true // Default is true
    });
Python
        vpc = ec2.Vpc(self, "MyVpc", max_azs=3)     # default is all AZs in region

        cluster = ecs.Cluster(self, "MyCluster", vpc=vpc)

        ecs_patterns.ApplicationLoadBalancedFargateService(self, "MyFargateService",
            cluster=cluster,            # Required
            cpu=512,                    # Default is 256
            desired_count=6,            # Default is 1
            task_image_options=ecs_patterns.ApplicationLoadBalancedTaskImageOptions(
                image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")),
            memory_limit_mib=2048,      # Default is 512
            public_load_balancer=True)  # Default is True
Java
        Vpc vpc = Vpc.Builder.create(this, "MyVpc")
                            .maxAzs(3)  // Default is all AZs in region
                            .build();

        Cluster cluster = Cluster.Builder.create(this, "MyCluster")
                            .vpc(vpc).build();

        // Create a load-balanced Fargate service and make it public
        ApplicationLoadBalancedFargateService.Builder.create(this, "MyFargateService")
                    .cluster(cluster)           // Required
                    .cpu(512)                   // Default is 256
                     .desiredCount(6)            // Default is 1
                     .taskImageOptions(
                             ApplicationLoadBalancedTaskImageOptions.builder()
                                     .image(ContainerImage.fromRegistry("amazon/amazon-ecs-sample"))
                                     .build())
                     .memoryLimitMiB(2048)       // Default is 512
                     .publicLoadBalancer(true)   // Default is true
                     .build();
C#
            var vpc = new Vpc(this, "MyVpc", new VpcProps
            {
                MaxAzs = 3 // Default is all AZs in region
            });

            var cluster = new Cluster(this, "MyCluster", new ClusterProps
            {
                Vpc = vpc
            });

            // Create a load-balanced Fargate service and make it public
            new ApplicationLoadBalancedFargateService(this, "MyFargateService",
                new ApplicationLoadBalancedFargateServiceProps
                {
                    Cluster = cluster,          // Required
                    DesiredCount = 6,           // Default is 1
                    TaskImageOptions = new ApplicationLoadBalancedTaskImageOptions
                    {
                        Image = ContainerImage.FromRegistry("amazon/amazon-ecs-sample")
                    },
                    MemoryLimitMiB = 2048,      // Default is 256
                    PublicLoadBalancer = true   // Default is true
                }
            );
anchoranchoranchoranchoranchor
    const vpc = new ec2.Vpc(this, "MyVpc", {
      maxAzs: 3 // Default is all AZs in region
    });

    const cluster = new ecs.Cluster(this, "MyCluster", {
      vpc: vpc
    });

    // Create a load-balanced Fargate service and make it public
    new ecs_patterns.ApplicationLoadBalancedFargateService(this, "MyFargateService", {
      cluster: cluster, // Required
      cpu: 512, // Default is 256
      desiredCount: 6, // Default is 1
      taskImageOptions: { image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample") },
      memoryLimitMiB: 2048, // Default is 512
      publicLoadBalancer: true // Default is true
    });

接下來，我們會執行下列命令來驗證程式碼，以合成堆疊：

cdk synth

堆疊有數百行，因此我們不會在此顯示。堆疊應包含一個預設執行個體、一個私有子網路和三個可用區域的公有子網路，以及一個安全群組。

若要部署堆疊，我們會執行下列動作：

cdk deploy

AWS CloudFormation 會顯示部署我們的應用程式時所採取數十個步驟的相關資訊。

部署完成後，我們已成功建立 Fargate 支援的 Amazon ECS 服務來執行Docker映像。

清除

作為一般維護最佳實務，為了將不必要的成本降至最低，我們會在完成時刪除堆疊：

cdk destroy

在本頁面

隱私權網站條款Cookie 偏好設定
© 2025, Amazon Web Services, Inc.或其附屬公司。保留所有權利。