Arbeite mit der AWS CDK Bibliothek

TypeScript unterstützt den Import eines ganzen Namespaces oder einzelner Objekte aus einem Namespace. Jeder Namespace enthält Konstrukte und andere Klassen zur Verwendung mit einem bestimmten Dienst. 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(...);

TypeScriptEbenso unterstützt Python Modulimporte mit Namespaces und selektive Importe. Namespaces in Python sehen aus wie aws_cdk. xxx, wobei xxx für einen AWS Servicenamen steht, z. B. s3 für Amazon S3. (In diesen Beispielen wird Amazon S3 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(...)

Die Importe von Java funktionieren anders als TypeScript die von. Jede Import-Anweisung importiert entweder einen einzelnen Klassennamen aus einem bestimmten Paket oder alle in diesem Paket definierten Klassen (using*). Auf Klassen kann entweder über den Klassennamen selbst zugegriffen werden, falls er importiert wurde, oder über den qualifizierten Klassennamen einschließlich des zugehörigen Pakets.

Bibliotheken werden wie software.amazon.awscdk.services.xxx die AWS Construct-Bibliothek benannt (die Hauptbibliothek istsoftware.amazon.awscdk). Die Maven-Gruppen-ID für AWS CDK Pakete istsoftware.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 using Direktive. Es gibt zwei Stile. Mit einem erhalten Sie Zugriff auf alle Typen im angegebenen Namespace, indem Sie deren Klarnamen verwenden. Mit dem anderen können Sie mithilfe eines Alias auf den Namespace selbst verweisen.

Pakete werden wie AWS Construct Amazon.CDK.AWS.xxx Library-Pakete benannt. (Das Kernmodul istAmazon.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 AWS Construct Library-Modul 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, 'amzn-s3-demo-bucket');

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

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

Python verwendet beim Instanziieren einer Klasse kein new Schlüsselwort. Das Eigenschaftenargument wird mit Schlüsselwortargumenten dargestellt, und die Argumente werden mit benannt. snake_case

Wenn ein Props-Wert selbst ein Bündel von Attributen ist, wird er durch eine nach der Eigenschaft benannte Klasse repräsentiert, die Schlüsselwortargumente für die Untereigenschaften akzeptiert.

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

# Instantiate default Bucket
bucket = s3.Bucket(self, "amzn-s3-demo-bucket")

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

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

In Java wird das Argument props durch eine Klasse mit dem Namen repräsentiert XxxxProps (z. B. für die Requisiten des Bucket Konstrukts). BucketProps Sie erstellen das Argument props mithilfe eines Builder-Musters.

Jede XxxxProps Klasse hat einen Builder. Außerdem gibt es für jedes Konstrukt einen praktischen Builder, der die Requisiten und das Konstrukt in einem Schritt erstellt, wie im folgenden Beispiel gezeigt.

Requisiten haben den gleichen Namen wie in TypeScript, using. camelCase

// Instantiate default Bucket
Bucket bucket = Bucket(self, "amzn-s3-demo-bucket");

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

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

In C# werden Requisiten mithilfe eines Objektinitialisierers für eine Klasse mit dem Namen XxxxProps (z. B. für die Requisiten des Bucket Konstrukts) angegeben. BucketProps

Requisiten werden ähnlich benannt wie, außer mit TypeScript PascalCase

Es ist praktisch, das var Schlüsselwort bei der Instanziierung eines Konstrukts zu verwenden, sodass Sie den Klassennamen nicht zweimal eingeben müssen. Ihr lokaler Code-Styleguide kann jedoch variieren.

// Instantiate default Bucket
var bucket = Bucket(self, "amzn-s3-demo-bucket");

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

// Instantiate Bucket with WebsiteRedirect, which has its own sub-properties
var bucket = Bucket(self, "amzn-s3-demo-bucket", 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 steht. Die Eigenschaften der Konstrukte sind als Struktur definiert.

In Go sind alle Konstruktparameter Zeiger, einschließlich Werte wie Zahlen, Boolesche Werte und Zeichenketten. Verwenden Sie die Komfortfunktionen wie, jsii.String um diese Zeiger zu erstellen.

	// Instantiate default Bucket
	bucket := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), nil)

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

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

Namen sindcamelCase.

bucket.bucketArn

Namen sindsnake_case.

bucket.bucket_arn

Für jede Eigenschaft steht eine Getter-Methode zur Verfügung. Diese Namen sindcamelCase.

bucket.getBucketArn()

Namen sindPascalCase.

bucket.BucketArn

Namen sindPascalCase.

bucket.BucketArn

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

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

Python hat keine Schnittstellenfunktion. Für das können AWS CDK Sie jedoch die Implementierung der Schnittstelle 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 auf der Grundlage der in der Struktur verfügbaren Methoden und Eigenschaften. MyAspectImplementiert beispielsweise im folgenden Code die IAspect Schnittstelle, weil sie eine Visit Methode bereitstellt, die ein Konstrukt benötigt.

type MyAspect struct {
}

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