AWS CDK 在支持的编程语言中使用

TypeScript 支持导入整个命名空间或从命名空间导入单个对象。每个命名空间都包含用于给定 AWS 服务的构造和其他类。

// Import main CDK library as cdk
import * as cdk from 'aws-cdk-lib';   // ES6 import preferred in TS
const cdk = require('aws-cdk-lib');   // Node.js require() preferred in JS

// Import specific core CDK classes
import { Stack, App } from 'aws-cdk-lib';
const { Stack, App } = require('aws-cdk-lib');

// Import AWS S3 namespace as s3 into current namespace
import { aws_s3 as s3 } from 'aws-cdk-lib';   // TypeScript
const s3 = require('aws-cdk-lib/aws-s3');     // JavaScript

// Having imported cdk already as above, this is also valid
const s3 = cdk.aws_s3;

// Now use s3 to access the S3 types
const bucket = s3.Bucket(...);

// Selective import of s3.Bucket
import { Bucket } from 'aws-cdk-lib/aws-s3';        // TypeScript
const { Bucket } = require('aws-cdk-lib/aws-s3');   // JavaScript

// Now use Bucket to instantiate an S3 bucket
const bucket = Bucket(...);

比如 TypeScript，Python 支持命名空间模块导入和选择性导入。Python 中的命名空间看起来像 aws_cdk。 xxx，其中 xxx 表示 AWS 服务名称，例如亚马逊 S3 的 s3。（这些示例中使用了 Amazon S3）。

# Import main CDK library as cdk
import aws_cdk as cdk

# Selective import of specific core classes
from aws_cdk import Stack, App
            
# Import entire module as s3 into current namespace
import aws_cdk.aws_s3 as s3

# s3 can now be used to access classes it contains
bucket = s3.Bucket(...)

# Selective import of s3.Bucket into current namespace
from aws_cdk.s3 import Bucket

# Bucket can now be used to instantiate a bucket
bucket = Bucket(...)

Java 的导入工作方式与 TypeScript's 不同。每个 import 语句要么从给定包中导入单个类名，要么导入该包中定义的所有类（使用*）。可以单独使用类名（如果已导入）或包括其包在内的限定类名来访问类。

库的命名与 AWS 构造库类似software.amazon.awscdk.services.xxx（主库是software.amazon.awscdk）。 AWS CDK 软件包的 Maven 群组 ID 是software.amazon.awscdk。

// Make certain core classes available
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.App;

// Make all Amazon S3 construct library classes available
import software.amazon.awscdk.services.s3.*;

// Make only Bucket and EventType classes available
import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.s3.EventType;

// An imported class may now be accessed using the simple class name (assuming that name
// does not conflict with another class)
Bucket bucket = Bucket.Builder.create(...).build();

// We can always use the qualified name of a class (including its package) even without an
// import directive
software.amazon.awscdk.services.s3.Bucket bucket = 
    software.amazon.awscdk.services.s3.Bucket.Builder.create(...)
        .build();
          
// Java 10 or later can use var keyword to avoid typing the type twice
var bucket = 
    software.amazon.awscdk.services.s3.Bucket.Builder.create(...)
        .build();

在 C# 中，您可以使用using指令导入类型。有两种风格。一个允许你使用普通名称访问指定命名空间中的所有类型。对于另一个，你可以使用别名来引用命名空间本身。

包的命名与 AWS 构Amazon.CDK.AWS.xxx造库包类似。（核心模块是Amazon.CDK。）

// Make CDK base classes available under cdk
using cdk = Amazon.CDK;

// Make all Amazon S3 construct library classes available
using Amazon.CDK.AWS.S3;

// Now we can access any S3 type using its name
var bucket = new Bucket(...);

// Import the S3 namespace under an alias
using s3 = Amazon.CDK.AWS.S3;

// Now we can access an S3 type through the namespace alias
var bucket = new s3.Bucket(...);

// We can always use the qualified name of a type (including its namespace) even without a
// using directive
var bucket = new Amazon.CDK.AWS.S3.Bucket(...)

每个 AWS 构造库模块都以 Go 包的形式提供。

import (
    "github.com/aws/aws-cdk-go/awscdk/v2"           // CDK core package
    "github.com/aws/aws-cdk-go/awscdk/v2/awss3"     // AWS S3 construct library module
)

// now instantiate a bucket
bucket := awss3.NewBucket(...)

// use aliases for brevity/clarity
import (
    cdk "github.com/aws/aws-cdk-go/awscdk/v2"           // CDK core package
    s3  "github.com/aws/aws-cdk-go/awscdk/v2/awss3"     // AWS S3 construct library module
)

bucket := s3.NewBucket(...)

// Instantiate default Bucket
const bucket = new s3.Bucket(this, 'MyBucket');

// Instantiate Bucket with bucketName and versioned properties
const bucket = new s3.Bucket(this, 'MyBucket', {
  bucketName: 'my-bucket',
   versioned: true,
});

// Instantiate Bucket with websiteRedirect, which has its own sub-properties
const bucket = new s3.Bucket(this, 'MyBucket', {
  websiteRedirect: {host: 'aws.amazon.com'}});

Python 在实例化类时不使用new关键字。属性参数使用关键字参数表示，参数使用命名snake_case。

如果 props 值本身就是一组属性，则它由一个以该属性命名的类表示，该类接受子属性的关键字参数。

在 Python 中，当前实例作为第一个参数传递给方法，self按照惯例命名。

# Instantiate default Bucket
bucket = s3.Bucket(self, "MyBucket")

# Instantiate Bucket with bucket_name and versioned properties
bucket = s3.Bucket(self, "MyBucket", bucket_name="my-bucket", versioned=true)

# Instantiate Bucket with website_redirect, which has its own sub-properties
bucket = s3.Bucket(self, "MyBucket", website_redirect=s3.WebsiteRedirect(
            host_name="aws.amazon.com"))

在 Java 中，props 参数由一个名为的类表示XxxxProps（例如，BucketProps用于Bucket构造的 props）。你可以使用生成器模式构建 props 参数。

每个XxxxProps类都有一个生成器。每个构造都有一个方便的构建器，可以一步构建 props 和构造，如以下示例所示。

道具的命名与中的相同 TypeScript，使用camelCase。

// Instantiate default Bucket
Bucket bucket = Bucket(self, "MyBucket");

// Instantiate Bucket with bucketName and versioned properties
Bucket bucket = Bucket.Builder.create(self, "MyBucket")
                      .bucketName("my-bucket").versioned(true)
                      .build();

# Instantiate Bucket with websiteRedirect, which has its own sub-properties
Bucket bucket = Bucket.Builder.create(self, "MyBucket")
                      .websiteRedirect(new websiteRedirect.Builder()
                          .hostName("aws.amazon.com").build())
                      .build();

在 C# 中，prop 是使用名为的类的对象初始化器指定的XxxxProps（例如，BucketProps用于Bucket构造的 props）。

道具的命名方式与类似 TypeScript，唯一的不同是使用PascalCase。

在实例化构造时使用var关键字很方便，因此无需键入类名两次。但是，您的本地代码风格指南可能会有所不同。

// Instantiate default Bucket
var bucket = Bucket(self, "MyBucket");

// Instantiate Bucket with BucketName and Versioned properties
var bucket =  Bucket(self, "MyBucket", new BucketProps {
                      BucketName = "my-bucket",
                      Versioned  = true});

// Instantiate Bucket with WebsiteRedirect, which has its own sub-properties
var bucket = Bucket(self, "MyBucket", new BucketProps {
                      WebsiteRedirect = new WebsiteRedirect {
                              HostName = "aws.amazon.com"
                      }});

要在 Go 中创建构造，请调用函数，NewXxxxxx其中Xxxxxxx是构造的名称。构造的属性被定义为一个结构。

在 Go 中，所有构造参数都是指针，包括数字、布尔值和字符串等值。使用诸如创建这些指针之类jsii.String的便捷函数。

	// Instantiate default Bucket
	bucket := awss3.NewBucket(stack, jsii.String("MyBucket"), nil)

	// Instantiate Bucket with BucketName and Versioned properties
	bucket1 := awss3.NewBucket(stack, jsii.String("MyBucket"), &awss3.BucketProps{
		BucketName: jsii.String("my-bucket"),
		Versioned:  jsii.Bool(true),
	})

	// Instantiate Bucket with WebsiteRedirect, which has its own sub-properties
	bucket2 := awss3.NewBucket(stack, jsii.String("MyBucket"), &awss3.BucketProps{
		WebsiteRedirect: &awss3.RedirectTarget{
			HostName: jsii.String("aws.amazon.com"),
		}})

名字是camelCase。

bucket.bucketArn

名字是snake_case。

bucket.bucket_arn

为每个属性提供了一个 getter 方法；这些名称是camelCase。

bucket.getBucketArn()

名字是PascalCase。

bucket.BucketArn

名字是PascalCase。

bucket.BucketArn

import { IAspect, IConstruct } from 'aws-cdk-lib';

class MyAspect implements IAspect {
  public visit(node: IConstruct) {
    console.log('Visited', node.node.path);
  }
}

Python 没有接口功能。但是，对于这些来说， AWS CDK 你可以通过装饰你的类来表示接口的@jsii.implements(interface)实现。

from aws_cdk import IAspect, IConstruct
import jsii

@jsii.implements(IAspect)
class MyAspect():
  def visit(self, node: IConstruct) -> None:
    print("Visited", node.node.path)

import software.amazon.awscdk.IAspect;
import software.amazon.awscdk.IConstruct;

public class MyAspect implements IAspect {
    public void visit(IConstruct node) {
        System.out.format("Visited %s", node.getNode().getPath());
    }
}

using Amazon.CDK;

public class MyAspect : IAspect
{
    public void Visit(IConstruct node)
    {
        System.Console.WriteLine($"Visited ${node.Node.Path}");
    }
}

Go 结构不需要显式声明它们实现了哪些接口。Go 编译器根据结构上可用的方法和属性来确定实现。例如，在以下代码中，MyAspect实现该IAspect接口，因为它提供了一种采用构造Visit的方法。

type MyAspect struct {
}

func (a MyAspect) Visit(node constructs.IConstruct) {
	fmt.Println("Visited", *node.Node().Path())
}