Arbeiten mit AWS CDK in unterstützten Programmiersprachen

TypeScript unterstützt den Import entweder eines gesamten Namespace oder einzelner Objekte aus einem Namespace. Jeder Namespace enthält Konstrukte und andere Klassen zur Verwendung mit einem bestimmten AWS Service.

// 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(...);

Wie unterstützt TypeScriptPython auch Importe von namespace-Modulen und selektive Importe. Namespaces in Python sehen wie aws_cdk.xxx aus, wobei xxx einen - AWS Servicenamen darstellt, z. B. s3 für Amazon S3. (Amazon S3 wird in diesen Beispielen verwendet).

# 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-Importe funktionieren anders als TypeScript. Jede Importanweisung importiert entweder einen einzelnen Klassennamen aus einem bestimmten Paket oder alle in diesem Paket definierten Klassen (mit *). Auf Klassen kann entweder mit dem Klassennamen selbst zugegriffen werden, wenn er importiert wurde, oder mit dem qualifizierten Klassennamen einschließlich seines Pakets.

Bibliotheken werden wie software.amazon.awscdk.services.xxx für die AWS Construct Library benannt (die Hauptbibliothek ist software.amazon.awscdk). Die Maven-Gruppen-ID für AWS CDK Pakete lautet 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();

In C# importieren Sie Typen mit der -usingRichtlinie. Es gibt zwei Stile. Eine ermöglicht Ihnen den Zugriff auf alle Typen im angegebenen Namespace unter Verwendung ihrer einfachen Namen. Mit dem anderen können Sie mithilfe eines Alias auf den Namespace selbst verweisen.

Pakete werden wie Amazon.CDK.AWS.xxx für Pakete der AWS Construct Library benannt. (Das Kernmodul ist 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(...)

Jedes Modul der AWS Construct Library wird als Go-Paket bereitgestellt.

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 verwendet beim Instanziieren einer Klasse kein new Schlüsselwort. Das Eigenschaftenargument wird mithilfe von Schlüsselwortargumenten dargestellt, und die Argumente werden mit benanntsnake_case.

Wenn es sich bei einem Eigenschaftswert selbst um ein Paket von Attributen handelt, wird er durch eine Klasse mit dem Namen nach der Eigenschaft dargestellt, die Schlüsselwortargumente für die Untereigenschaften akzeptiert.

In Python wird die aktuelle Instance als erstes Argument, das self nach Konvention benannt ist, an Methoden übergeben.

# 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"))

In Java wird das Props-Argument durch eine Klasse mit dem Namen dargestellt XxxxProps (z. B. BucketProps für die Props des BucketKonstrukts). Sie erstellen das Props-Argument mit einem Builder-Muster.

Jede XxxxProps Klasse hat einen Builder. Es gibt auch einen praktischen Builder für jedes Konstrukt, das die Eigenschaften und das Konstrukt in einem Schritt erstellt, wie im folgenden Beispiel gezeigt.

Props werden mit gleich benannt wie in TypeScriptcamelCase.

// 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();

In C# werden Eigenschaften mithilfe eines Objektinitialisierers für eine Klasse namens XxxxProps (z. B. BucketProps für die Eigenschaften des BucketKonstrukts) angegeben.

Props werden ähnlich benannt wie TypeScript, mit Ausnahme von PascalCase.

Es ist praktisch, das var Schlüsselwort beim Instanziieren eines Konstrukts zu verwenden, sodass Sie den Klassennamen nicht zweimal eingeben müssen. Ihr lokaler Leitfaden zum Codestil kann jedoch variieren.

// 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"
                      }});

Um ein Konstrukt in Go zu erstellen, rufen Sie die Funktion auf, NewXxxxxx wobei der Name des Konstrukts Xxxxxxx ist. Die Eigenschaften der Konstrukte sind als Struktur definiert.

In Go sind alle Konstruktparameter Zeiger, einschließlich Werte wie Zahlen, boolesche Werte und Zeichenfolgen. Verwenden Sie die Convenience-Funktionen wie jsii.String , um diese Zeiger zu erstellen.

	// 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"),
		}})

Namen sind camelCase.

bucket.bucketArn

Namen sind snake_case.

bucket.bucket_arn

Für jede Eigenschaft wird eine Getter-Methode bereitgestellt. Diese Namen sind camelCase.

bucket.getBucketArn()

Namen sind PascalCase.

bucket.BucketArn

Namen sind 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 verfügt über keine Schnittstellenfunktion. Für können AWS CDK Sie jedoch die Schnittstellenimplementierung angeben, indem Sie Ihre Klasse mit dekorieren@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-Strukturen müssen nicht explizit deklarieren, welche Schnittstellen sie implementieren. Der Go-Compiler bestimmt die Implementierung basierend auf den Methoden und Eigenschaften, die in der -Struktur verfügbar sind. Im folgenden Code MyAspect implementiert beispielsweise die IAspect Schnittstelle, da sie eine Visit Methode bereitstellt, die ein Konstrukt verwendet.

type MyAspect struct {
}

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