什麼是 AWS CDK？

RSS

焦點模式

什麼是 AWS CDK？ - AWS Cloud Development Kit (AWS CDK) v2

的優點 AWS CDK 的範例 AWS CDK AWS CDK features 後續步驟進一步了解

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

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

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

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

AWS Cloud Development Kit (AWS CDK) 是開放原始碼軟體開發架構，可用於在程式碼中定義雲端基礎設施，並透過其佈建 AWS CloudFormation。

AWS CDK 包含兩個主要部分：

AWS CDK 建構程式庫 – 預先編寫的模組化和可重複使用的程式碼，稱為建構，您可以使用、修改和整合來快速開發基礎設施。 AWS CDK Construct Library 的目標是降低在建置應用程式時定義和整合 AWS 服務所需的複雜性 AWS。
AWS CDK Command Line Interface (AWS CDKCLI) – 與 CDK 應用程式互動的命令列工具。使用 CDK CLI建立、管理和部署您的 AWS CDK 專案。CDK CLI也稱為 CDK Toolkit。

AWS CDK 支援 TypeScript、JavaScript、Python、C#/.Net、 Java和 Go。您可以使用任何這些支援的程式設計語言來定義可重複使用的雲端元件，稱為建構。您可以將它們組合成堆疊和應用程式。然後，您將 CDK 應用程式部署到 AWS CloudFormation 以佈建或更新資源。

AWS CDK app structure with stacks, constructs, and deployment to CloudFormation.

的優點 AWS CDK

使用 AWS CDK 開發可靠、可擴展、符合成本效益的雲端應用程式，具有程式設計語言的可觀表達能力。這種方法產生許多好處，包括：

以程式碼 (IaC) 的形式開發和管理基礎設施

將基礎設施練習為程式碼，以程式設計、描述和宣告的方式建立、部署和維護基礎設施。使用 IaC，您會以開發人員處理程式碼的方式對待基礎設施。這會導致管理基礎設施的可擴展性和結構化方法。若要進一步了解 IaC，請參閱 AWS 白皮書上的 DevOps 簡介中的基礎設施程式碼。

使用 AWS CDK，您可以將基礎設施、應用程式程式碼和組態全部放在一個位置，確保您在每個里程碑都擁有完整的雲端可部署系統。採用軟體工程最佳實務，例如程式碼檢閱、單元測試和來源控制，讓您的基礎設施更強大。

使用一般用途程式設計語言定義您的雲端基礎設施

透過 AWS CDK，您可以使用下列任何程式設計語言來定義雲端基礎設施：TypeScript、JavaScript、Python、Java、 C#/.Net和 Go。選擇您偏好的語言，並使用程式設計元素，例如參數、條件、迴圈、合成和繼承，來定義基礎設施的所需結果。

使用相同的程式設計語言來定義您的基礎設施和應用程式邏輯。

在偏好的 IDE （整合式開發環境）中取得開發基礎設施的優勢，例如語法反白和智慧型程式碼完成。

Code snippet showing AWS CDK setup for ECS 叢集 with VPC and Fargate service configuration.

透過部署基礎設施 AWS CloudFormation

AWS CDK 與整合 AWS CloudFormation ，以在上部署和佈建您的基礎設施 AWS。 AWS CloudFormation 是受管 AWS 服務，可廣泛支援在上佈建服務的資源和屬性組態 AWS。透過 AWS CloudFormation，您可以可預測且重複地執行基礎設施部署，並復原錯誤。如果您已經熟悉 AWS CloudFormation，則開始使用時，不需要學習新的 IaC 管理服務 AWS CDK。

使用 constructs 快速開發您的應用程式

透過使用和共用稱為 constructs 的可重複使用元件，更快速地開發。使用低階建構來定義個別 AWS CloudFormation 資源及其屬性。使用高階建構來快速定義應用程式的大型元件，為您的 AWS 資源設定明智且安全的預設值，以較少的程式碼定義更多基礎設施。

建立針對您唯一使用案例自訂的專屬建構，並與您的組織或甚至公眾共用。

的範例 AWS CDK

以下是使用 AWS CDK Constructs Library 建立具有 AWS Fargate 啟動類型的 Amazon Elastic Container Service (Amazon ECS) 服務的範例。如需此範例的詳細資訊，請參閱範例：使用建立 AWS Fargate 服務 AWS CDK。

TypeScript


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

    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 false
    });
  }
}

JavaScript


class MyEcsConstructStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    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 false
    });
  }
}

module.exports = { MyEcsConstructStack }

Python


class MyEcsConstructStack(Stack):

    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
        super().__init__(scope, id, **kwargs)

        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 False

Java


public class MyEcsConstructStack extends Stack {

    public MyEcsConstructStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public MyEcsConstructStack(final Construct scope, final String id,
            StackProps props) {
        super(scope, id, props);

        Vpc vpc = Vpc.Builder.create(this, "MyVpc").maxAzs(3).build();

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

        ApplicationLoadBalancedFargateService.Builder.create(this, "MyFargateService")
                .cluster(cluster)
                .cpu(512)
                .desiredCount(6)
                .taskImageOptions(
                       ApplicationLoadBalancedTaskImageOptions.builder()
                               .image(ContainerImage
                                       .fromRegistry("amazon/amazon-ecs-sample"))
                               .build()).memoryLimitMiB(2048)
                .publicLoadBalancer(true).build();
    }
}

C#


public class MyEcsConstructStack : Stack
{
    public MyEcsConstructStack(Construct scope, string id, IStackProps props=null) : base(scope, id, props)
    {
        var vpc = new Vpc(this, "MyVpc", new VpcProps
        {
            MaxAzs = 3
        });

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

        new ApplicationLoadBalancedFargateService(this, "MyFargateService", 
            new ApplicationLoadBalancedFargateServiceProps
        {
            Cluster = cluster,
            Cpu = 512,
            DesiredCount = 6,
            TaskImageOptions = new ApplicationLoadBalancedTaskImageOptions
            {
                Image = ContainerImage.FromRegistry("amazon/amazon-ecs-sample")
            },
            MemoryLimitMiB = 2048,
            PublicLoadBalancer = true,
        });
    }
}

Go


func NewMyEcsConstructStack(scope constructs.Construct, id string, props *MyEcsConstructStackProps) awscdk.Stack {

	var sprops awscdk.StackProps

	if props != nil {
		sprops = props.StackProps
	}

	stack := awscdk.NewStack(scope, &id, &sprops)

	vpc := awsec2.NewVpc(stack, jsii.String("MyVpc"), &awsec2.VpcProps{
		MaxAzs: jsii.Number(3), // Default is all AZs in region
	})

	cluster := awsecs.NewCluster(stack, jsii.String("MyCluster"), &awsecs.ClusterProps{
		Vpc: vpc,
	})

	awsecspatterns.NewApplicationLoadBalancedFargateService(stack, jsii.String("MyFargateService"),
		&awsecspatterns.ApplicationLoadBalancedFargateServiceProps{
			Cluster:        cluster,           // required
			Cpu:            jsii.Number(512),  // default is 256
			DesiredCount:   jsii.Number(5),    // default is 1
			MemoryLimitMiB: jsii.Number(2048), // Default is 512
			TaskImageOptions: &awsecspatterns.ApplicationLoadBalancedTaskImageOptions{
				Image: awsecs.ContainerImage_FromRegistry(jsii.String("amazon/amazon-ecs-sample"), nil),
			},
			PublicLoadBalancer: jsii.Bool(true), // Default is false
		})

	return stack

}

anchor anchor anchor anchor anchor anchor


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

    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 false
    });
  }
}

此類別會產生 AWS CloudFormation 超過 500 行的範本。部署 AWS CDK 應用程式會產生超過 50 種下列類型的資源。

AWS CDK features

AWS CDKGitHub 儲存庫

如需官方 AWS CDK GitHub儲存庫，請參閱 aws-cdk。您可以在此提交問題、檢視我們的授權、追蹤版本等。

由於 AWS CDK 是開放原始碼，因此團隊鼓勵您做出貢獻，使其成為更好的工具。如需詳細資訊，請參閱貢獻至 AWS Cloud Development Kit (AWS CDK)。

AWS CDK API 參考

AWS CDK 建構程式庫提供 APIs來定義您的 CDK 應用程式，並將 CDK 建構新增至應用程式。如需詳細資訊，請參閱 AWS CDK API 參考。

建構程式設計模型

建構程式設計模型 (CPM) 將背後的概念延伸 AWS CDK 到其他網域。其他使用 CPM 的工具包括：

適用於 Terraform 的 CDK (CDKtf)
CDK for Kubernetes (CDK8s)
Projen，用於建置專案組態

建構中樞

Construct Hub 是線上登錄檔，您可以在其中尋找、發佈和共用開放原始碼 AWS CDK 程式庫。

後續步驟

若要開始使用 AWS CDK，請參閱開始使用 AWS CDK。

進一步了解

若要繼續了解 AWS CDK，請參閱以下內容：

了解 AWS CDK 核心概念 – 的重要概念和術語 AWS CDK。
AWS CDK 研討會 – 實作研討會，以學習和使用 AWS CDK。
AWS CDK 模式 – 無 AWS 伺服器架構模式的開放原始碼集合， AWS CDK 由 AWS 專家為建置。
AWS CDK 程式碼範例 – 範例 AWS CDK 專案的GitHub儲存庫。
cdk.dev – 社群驅動的中樞 AWS CDK，包括社群Slack工作區。
絕佳的 CDK – 儲存GitHub庫，其中包含精選的 AWS CDK 開放原始碼專案清單、指南、部落格和其他資源。
AWS 解決方案建構 – Vetted，組態基礎設施作為程式碼 (IaC) 模式，可輕鬆組裝到可立即生產的應用程式。
AWS 開發人員工具部落格：針對篩選的部落格文章 AWS CDK。
AWS CDK on Stack Overflow – 在上以 aws-cdk 標記的問題Stack Overflow。
AWS CDK 的教學課程 AWS Cloud9 – AWS CDK 搭配 AWS Cloud9 開發環境使用的教學課程。

若要進一步了解的相關主題 AWS CDK，請參閱以下內容：

AWS CloudFormation 概念 – 由於 AWS CDK 是為使用而建置 AWS CloudFormation，我們建議您學習並了解關鍵 AWS CloudFormation 概念。
AWS 詞彙表 – 跨使用的關鍵術語定義 AWS。

若要進一步了解 AWS CDK 可用於簡化無伺服器應用程式開發和部署的相關工具，請參閱以下內容：

AWS Serverless Application Model – 開放原始碼開發人員工具，可簡化並改善在上建置和執行無伺服器應用程式的體驗 AWS。
AWSChalice – 在中寫入無伺服器應用程式的架構Python。

您的瀏覽器已停用或無法使用 Javascript。

您必須啟用 Javascript，才能使用 AWS 文件。請參閱您的瀏覽器說明頁以取得說明。

文件慣用形式

CDK 核心概念

下一個主題：

CDK 核心概念

需要協助？

在本頁面

此頁面是否有幫助？

提供意見回饋

隱私權網站條款 Cookie 偏好設定

選取您的 Cookie 偏好設定

自訂 Cookie 偏好設定

必要

效能

功能

廣告

無法儲存 Cookie 偏好設定