Dies ist der AWS CDK v2-Entwicklerhandbuch. Das ältere CDK v1 wurde am 1. Juni 2022 gewartet und der Support wurde am 1. Juni 2023 eingestellt.
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Arbeiten Sie mit der AWS CDK-Bibliothek
Importieren und verwenden Sie die AWS Cloud Development Kit (AWS CDK) -Bibliothek, um Ihre AWS Cloud-Infrastruktur mit einer [unterstützten Programmiersprache](languages.md) zu definieren.
## Importieren Sie die AWS CDK-Bibliothek
Die [AWS CDK-Bibliothek](libraries.md) wird oft mit dem TypeScript Paketnamen bezeichnet. `aws-cdk-lib` Der tatsächliche Paketname variiert je nach Sprache. Im Folgenden finden Sie ein Beispiel für die Installation und den Import der CDK-Bibliothek:
**Example**
| | |
| --- |--- |
| **Install** | `npm install aws-cdk-lib` |
| **Import** | `import * as cdk from 'aws-cdk-lib';` |
| | |
| --- |--- |
| **Install** | `npm install aws-cdk-lib` |
| **Import** | `const cdk = require('aws-cdk-lib');` |
| | |
| --- |--- |
| **Install** | `python -m pip install aws-cdk-lib` |
| **Import** | `import aws_cdk as cdk` |
| | |
| --- |--- |
| **Hinein`pom.xml`, füge hinzu** | `Group software.amazon.awscdk; artifact aws-cdk-lib` |
| **Import** | `import software.amazon.awscdk.App;` |
| | |
| --- |--- |
| **Install** | `dotnet add package Amazon.CDK.Lib` |
| **Import** | `using Amazon.CDK;` |
| | |
| --- |--- |
| **Install** | `go get github.com/aws/aws-cdk-go/awscdk/v2` |
| **Import** |
import ( "github.com/aws/aws-cdk-go/awscdk/v2" )
|
Die `construct` Basisklasse und der unterstützende Code befinden sich in der `constructs` Bibliothek. Experimentelle Konstrukte, bei denen die API noch verfeinert wird, werden als separate Module verteilt.
## Verwenden der AWS CDK-API-Referenz
Verwenden Sie bei der Entwicklung mit dem [AWS CDK die AWS CDK-API-Referenz](libraries.md#libraries-reference).
Das Referenzmaterial der einzelnen Module ist in die folgenden Abschnitte unterteilt.
+ *Überblick*: Einführendes Material, das Sie benötigen, um mit dem Service im AWS CDK arbeiten zu können, einschließlich Konzepten und Beispielen.
+ *Konstrukte*: Bibliotheksklassen, die eine oder mehrere konkrete AWS Ressourcen repräsentieren. Dies sind die „kuratierten“ (L2) Ressourcen oder Muster (L3-Ressourcen), die eine übergeordnete Schnittstelle mit vernünftigen Standardeinstellungen bieten.
+ *Klassen: Klassen*, die keine Konstrukte sind und Funktionen bereitstellen, die von Konstrukten im Modul verwendet werden.
+ *Strukturen*: Datenstrukturen (Attributpakete), die die Struktur zusammengesetzter Werte wie Eigenschaften (das `props` Argument von Konstrukten) und Optionen definieren.
+ *Schnittstellen*: Schnittstellen, deren Namen alle mit „I“ beginnen, definieren die absolute Mindestfunktionalität für das entsprechende Konstrukt oder eine andere Klasse. Das CDK verwendet Konstruktschnittstellen, um AWS Ressourcen darzustellen, die außerhalb Ihrer AWS CDK-App definiert sind und auf die durch Methoden wie verwiesen wird. `Bucket.fromBucketArn()`
+ *Enums*: Sammlungen benannter Werte zur Angabe bestimmter Konstruktparameter. Die Verwendung eines Aufzählungswerts ermöglicht es dem CDK, diese Werte während der Synthese auf Gültigkeit zu überprüfen.
+ *CloudFormation Ressourcen*: Diese L1-Konstrukte, deren Namen mit „Cfn“ beginnen, stellen genau die in der Spezifikation definierten Ressourcen dar. CloudFormation Sie werden bei jeder CDK-Version automatisch anhand dieser Spezifikation generiert. Jedes L2- oder L3-Konstrukt kapselt eine oder mehrere Ressourcen. CloudFormation
+ *CloudFormation Eigenschaftstypen*: Die Sammlung benannter Werte, die die Eigenschaften für jede Ressource definieren. CloudFormation
## Schnittstellen im Vergleich zu Konstruktklassen
Das AWS CDK verwendet Schnittstellen auf eine bestimmte Art und Weise, die möglicherweise nicht offensichtlich ist, selbst wenn Sie mit Schnittstellen als Programmierkonzept vertraut sind.
Das AWS CDK unterstützt die Verwendung von Ressourcen, die außerhalb von CDK-Anwendungen definiert wurden, mit Methoden wie. `Bucket.fromBucketArn()` Externe Ressourcen können nicht geändert werden und verfügen möglicherweise nicht über alle Funktionen, die für Ressourcen verfügbar sind, die in Ihrer CDK-App definiert sind, z. B. mithilfe der Klasse. `Bucket` Schnittstellen stellen also die Mindestfunktionalität dar, die im CDK für einen bestimmten AWS Ressourcentyp verfügbar ist, *einschließlich externer* Ressourcen.
Wenn Sie Ressourcen in Ihrer CDK-App instanziieren, sollten Sie also immer konkrete Klassen wie verwenden. `Bucket` Wenn Sie den Typ eines Arguments angeben, das Sie in einem Ihrer eigenen Konstrukte akzeptieren, verwenden Sie den Schnittstellentyp, z. B. `IBucket` wenn Sie bereit sind, mit externen Ressourcen umzugehen (das heißt, Sie müssen sie nicht ändern). Wenn Sie ein CDK-definiertes Konstrukt benötigen, geben Sie den allgemeinsten Typ an, den Sie verwenden können.
Bei einigen Schnittstellen handelt es sich nicht um Konstrukte, sondern um Mindestversionen von Eigenschaften oder Optionspaketen, die bestimmten Klassen zugeordnet sind. Solche Schnittstellen können nützlich sein, wenn es darum geht, Unterklassen zu bilden, um Argumente zu akzeptieren, die Sie an Ihre übergeordnete Klasse weitergeben. Wenn Sie eine oder mehrere zusätzliche Eigenschaften benötigen, sollten Sie diese Schnittstelle oder einen spezifischeren Typ implementieren oder von ihr ableiten.
**Anmerkung**
Einige vom AWS CDK unterstützte Programmiersprachen verfügen nicht über eine Schnittstellenfunktion. In diesen Sprachen sind Schnittstellen ganz normale Klassen. Sie können sie anhand ihrer Namen identifizieren, die dem Muster eines anfänglichen „Ich“ folgen, gefolgt vom Namen eines anderen Konstrukts (z. B.`IBucket`). Es gelten die gleichen Regeln.
## Verwaltung von Abhängigkeiten
Abhängigkeiten für Ihre AWS CDK-App oder -Bibliothek werden mithilfe von Paketverwaltungstools verwaltet. Diese Tools werden häufig mit den Programmiersprachen verwendet.
In der Regel unterstützt das AWS CDK das standardmäßige oder offizielle Paketverwaltungstool der Sprache, falls es eines gibt. Andernfalls unterstützt das AWS CDK die beliebteste oder am häufigsten unterstützte Sprache. Möglicherweise können Sie auch andere Tools verwenden, insbesondere wenn diese mit den unterstützten Tools funktionieren. Die offizielle Unterstützung für andere Tools ist jedoch begrenzt.
Das AWS CDK unterstützt die folgenden Paketmanager:
| Sprache | Unterstütztes Paketverwaltungstool |
| --- | --- |
| TypeScript/JavaScript | NPM (Node Package Manager) oder Yarn |
| Python | PIP (Paketinstallationsprogramm für Python) |
| Java | Maven |
| C\$1 | NuGet |
| Go | Go-Module |
Wenn Sie mit dem AWS `cdk init` CDK-CLI-Befehl ein neues Projekt erstellen, werden Abhängigkeiten für die CDK-Kernbibliotheken und stabilen Konstrukte automatisch angegeben.
Weitere Informationen zur Verwaltung von Abhängigkeiten für unterstützte Programmiersprachen finden Sie im Folgenden:
+ [Verwaltung von Abhängigkeiten in TypeScript](work-with-cdk-typescript.md#work-with-cdk-typescript-dependencies).
+ [Verwaltung von Abhängigkeiten in JavaScript](work-with-cdk-javascript.md#work-with-cdk-javascript-dependencies).
+ [Verwaltung von Abhängigkeiten in Python](work-with-cdk-python.md#work-with-cdk-python-dependencies).
+ [Verwaltung von Abhängigkeiten in Java](work-with-cdk-java.md#work-with-cdk-java-dependencies).
+ [Abhängigkeiten in C\$1 verwalten](work-with-cdk-csharp.md#work-with-cdk-csharp-dependencies).
+ [Abhängigkeiten in Go verwalten](work-with-cdk-go.md#work-with-cdk-go-dependencies).
## Vergleich von AWS CDK in TypeScript mit anderen Sprachen
TypeScript war die erste Sprache, die für die Entwicklung von AWS CDK-Anwendungen unterstützt wurde. Daher ist eine beträchtliche Menge an CDK-Beispielcode geschrieben. TypeScript Wenn Sie in einer anderen Sprache entwickeln, kann es nützlich sein, die Implementierung von AWS CDK-Code mit der Sprache Ihrer Wahl zu TypeScript vergleichen. Dies kann Ihnen helfen, die Beispiele in der gesamten Dokumentation zu verwenden.
## Ein Modul importieren
**Example**
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\$1cdk.** *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 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\$1 importieren Sie Typen mit der Direktive. `using` 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 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 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(...)
```
## Ein Konstrukt instanziieren
AWS CDK-Konstruktklassen haben in allen unterstützten Sprachen denselben Namen. Die meisten Sprachen verwenden das `new` Schlüsselwort, um eine Klasse zu instanziieren (Python und Go nicht). Außerdem `this` bezieht sich das Schlüsselwort in den meisten Sprachen auf die aktuelle Instanz. (Python verwendet `self` konventionell.) Sie sollten jedem Konstrukt, das Sie erstellen, einen Verweis auf die aktuelle Instanz als `scope` Parameter übergeben.
Das dritte Argument für ein AWS CDK-Konstrukt ist ein Objekt`props`, das Attribute enthält, die zum Erstellen des Konstrukts benötigt werden. Dieses Argument kann optional sein, aber wenn es erforderlich ist, behandeln die unterstützten Sprachen es auf idiomatische Weise. Die Namen der Attribute sind ebenfalls an die Standardbenennungsmuster der Sprache angepasst.
**Example**
```
// 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\$1 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` bei der 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"),
}})
```
## Auf Mitglieder zugreifen
Es ist üblich, auf Attribute oder Eigenschaften von Konstrukten und anderen AWS CDK-Klassen zu verweisen und diese Werte beispielsweise als Eingaben zum Erstellen anderer Konstrukte zu verwenden. Die zuvor für Methoden beschriebenen Namensunterschiede gelten auch hier. Außerdem ist es in Java nicht möglich, direkt auf Mitglieder zuzugreifen. Stattdessen wird eine Getter-Methode bereitgestellt.
**Example**
Namen sind`camelCase`.
```
bucket.bucketArn
```
Namen sind`snake_case`.
```
bucket.bucket_arn
```
Für jede Eigenschaft steht eine Getter-Methode zur Verfügung; diese Namen sind`camelCase`.
```
bucket.getBucketArn()
```
Namen sind`PascalCase`.
```
bucket.BucketArn
```
Namen sind`PascalCase`.
```
bucket.BucketArn
```
## Enum-Konstanten
Enum-Konstanten sind auf eine Klasse beschränkt und haben in allen Sprachen Großbuchstaben mit Unterstrichen (manchmal auch als bezeichnet). `SCREAMING_SNAKE_CASE` Da Klassennamen auch in allen unterstützten Sprachen außer Go dieselbe Groß- und Kleinschreibung verwenden, sind qualifizierte Aufzählungsnamen auch in diesen Sprachen identisch.
```
s3.BucketEncryption.KMS_MANAGED
```
In Go sind Enum-Konstanten Attribute des Modul-Namespaces und werden wie folgt geschrieben.
```
awss3.BucketEncryption_KMS_MANAGED
```
## Objektschnittstellen
Das AWS CDK verwendet TypeScript Objektschnittstellen, um anzuzeigen, dass eine Klasse einen erwarteten Satz von Methoden und Eigenschaften implementiert. Sie erkennen eine Objektschnittstelle daran, dass ihr Name mit `I` beginnt. Eine konkrete Klasse gibt die Schnittstellen an, die sie mithilfe des `implements` Schlüsselworts implementiert.
**Example**
JavaScript hat keine Schnittstellenfunktion. Sie können das `implements` Schlüsselwort und die darauf folgenden Klassennamen ignorieren.
```
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 AWS CDK können Sie jedoch die Implementierung der Schnittstelle angeben, indem Sie Ihre Klasse mit `@jsii.implements(interface)` dekorieren.
```
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. `MyAspect`Implementiert 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())
}
```
# Arbeiten mit dem AWS CDK in TypeScript
TypeScript ist eine vollständig unterstützte Client-Sprache für das AWS Cloud Development Kit (AWS CDK) und gilt als stabil. Bei der Arbeit mit dem AWS CDK werden vertraute Tools TypeScript verwendet, darunter der TypeScript Compiler (`tsc`) von Microsoft, [Node.js](https://nodejs.org/) und der Node Package Manager (`npm`). Sie können auch [Yarn](https://yarnpkg.com/) verwenden, wenn Sie möchten, obwohl die Beispiele in diesem Handbuch NPM verwenden. [Die Module, aus denen die AWS Construct-Bibliothek besteht, werden über das NPM-Repository npmjs.org vertrieben.](https://www.npmjs.com/)
Sie können jeden Editor oder jede IDE verwenden. Viele AWS CDK-Entwickler verwenden [Visual Studio Code](https://code.visualstudio.com/) (oder sein Open-Source-Äquivalent [VSCodium](https://vscodium.com/)), das hervorragende Unterstützung für bietet. TypeScript
## Fangen Sie an mit TypeScript
Um mit dem AWS CDK arbeiten zu können, benötigen Sie ein AWS Konto und Anmeldeinformationen und müssen Node.js und das AWS CDK Toolkit installiert haben. Siehe [Erste Schritte mit dem CDK](getting-started.md). AWS
Sie benötigen auch es TypeScript selbst (Version 3.8 oder höher). Wenn Sie es noch nicht haben, können Sie es mit installieren`npm`.
```
$ npm install -g typescript
```
**Anmerkung**
Wenn Sie einen Berechtigungsfehler erhalten und Administratorzugriff auf Ihr System haben, versuchen Sie es`sudo npm install -g typescript`.
TypeScript Bleiben Sie regelmäßig auf dem Laufenden`npm update -g typescript`.
**Anmerkung**
Veraltete Sprachversion von Drittanbietern: Die Sprachversion wird nur bis zu ihrem vom Anbieter oder der Community mitgeteilten EOL (End Of Life) unterstützt und kann sich nach vorheriger Ankündigung ändern.
## Erstellen eines Projekts
Sie erstellen ein neues AWS CDK-Projekt, indem Sie es in einem leeren Verzeichnis aufrufen`cdk init`. Verwenden Sie die `--language` Option und geben Sie an: `typescript`
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language typescript
```
Beim Erstellen eines Projekts werden auch das [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html)Modul und seine Abhängigkeiten installiert.
`cdk init`verwendet den Namen des Projektordners, um verschiedene Elemente des Projekts zu benennen, einschließlich Klassen, Unterordnern und Dateien. Bindestriche im Ordnernamen werden in Unterstriche umgewandelt. Ansonsten sollte der Name jedoch die Form eines TypeScript Bezeichners haben; er sollte beispielsweise nicht mit einer Zahl beginnen oder Leerzeichen enthalten.
## Lokal `tsc` und verwenden `cdk`
In den meisten Fällen wird in diesem Handbuch davon ausgegangen, dass Sie das CDK Toolkit global (`npm install -g typescript aws-cdk`) installieren TypeScript , und die bereitgestellten Befehlsbeispiele (wie`cdk synth`) folgen dieser Annahme. Dieser Ansatz macht es einfach, beide Komponenten auf dem neuesten Stand zu halten, und da beide einen strikten Ansatz zur Abwärtskompatibilität verfolgen, besteht im Allgemeinen nur ein geringes Risiko, immer die neuesten Versionen zu verwenden.
Einige Teams ziehen es vor, alle Abhängigkeiten innerhalb jedes Projekts anzugeben, einschließlich Tools wie dem TypeScript Compiler und dem CDK-Toolkit. Auf diese Weise können Sie diese Komponenten bestimmten Versionen zuordnen und sicherstellen, dass alle Entwickler in Ihrem Team (und Ihrer CI/CD-Umgebung) genau diese Versionen verwenden. Dadurch wird eine mögliche Änderungsquelle vermieden, was dazu beiträgt, Builds und Bereitstellungen konsistenter und wiederholbarer zu gestalten.
Das CDK enthält Abhängigkeiten TypeScript sowohl für beide als auch für das CDK-Toolkit in den TypeScript Projektvorlagen. Wenn Sie also diesen Ansatz verwenden möchten, müssen Sie keine Änderungen an Ihrem Projekt vornehmen. `package.json` Sie müssen lediglich leicht unterschiedliche Befehle zum Erstellen Ihrer App und zum Ausgeben von Befehlen verwenden. `cdk`
| Operation | Verwenden Sie globale Tools | Verwenden Sie lokale Tools |
| --- | --- | --- |
| **Projekt initialisieren** | `cdk init --language typescript` | `npx aws-cdk init --language typescript` |
| **Entwicklung** | `tsc` | `npm run build` |
| **Führen Sie den Befehl CDK Toolkit aus** | `cdk …` | `npm run cdk …` oder `npx aws-cdk …` |
`npx aws-cdk`führt die lokal im aktuellen Projekt installierte Version des CDK Toolkits aus, falls vorhanden, und greift dabei auf die globale Installation zurück, falls vorhanden. Falls keine globale Installation vorhanden ist, wird eine temporäre Kopie des CDK Toolkits `npx` heruntergeladen und ausgeführt. Sie können eine beliebige Version des CDK Toolkits mit der folgenden Syntax angeben: prints. `@` `npx aws-cdk@2.0 --version` `2.0.0`
**Tipp**
Richten Sie einen Alias ein, damit Sie den `cdk` Befehl mit einer lokalen CDK Toolkit-Installation verwenden können.
```
$ alias cdk="npx aws-cdk"
```
```
doskey cdk=npx aws-cdk $*
```
## AWS Construct Library-Module verwalten
Verwenden Sie den Node Package Manager (`npm`), um AWS Construct Library-Module für Ihre Apps sowie andere Pakete, die Sie benötigen, zu installieren und zu aktualisieren. (Sie können `yarn` stattdessen verwenden, `npm` wenn Sie es vorziehen.) `npm`installiert auch die Abhängigkeiten für diese Module automatisch.
Die meisten AWS CDK-Konstrukte befinden sich im CDK-Hauptpaket mit dem Namen. Dies ist eine Standardabhängigkeit in neuen Projekten`aws-cdk-lib`, die von erstellt wurden. `cdk init` Module der „experimentellen“ AWS Construct Library, bei denen sich übergeordnete Konstrukte noch in der Entwicklung befinden, werden wie benannt. `@aws-cdk/-alpha` Der Dienstname hat ein aws-Präfix*.* Wenn Sie sich des Namens eines Moduls nicht sicher sind, [suchen Sie auf NPM danach](https://www.npmjs.com/search?q=%40aws-cdk).
**Anmerkung**
Die [CDK-API-Referenz](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) zeigt auch die Paketnamen.
Mit dem folgenden Befehl wird beispielsweise das experimentelle Modul für AWS CodeStar installiert.
```
$ npm install @aws-cdk/aws-codestar-alpha
```
Die Construct Library-Unterstützung einiger Dienste erfolgt in mehr als einem Namespace. Außerdem gibt es `aws-route53` beispielsweise drei zusätzliche Amazon Route 53-Namespaces,`aws-route53-targets`, `aws-route53-patterns` und. `aws-route53resolver`
Die Abhängigkeiten Ihres Projekts werden in verwaltet. `package.json` Sie können diese Datei bearbeiten, um einige oder alle Ihrer Abhängigkeiten für eine bestimmte Version zu sperren oder um zu ermöglichen, dass sie unter bestimmten Kriterien auf neuere Versionen aktualisiert werden. Um die NPM-Abhängigkeiten Ihres Projekts gemäß den Regeln, die Sie angegeben haben, auf die neueste zulässige Version zu aktualisieren: `package.json`
```
$ npm update
```
In TypeScript importieren Sie Module in Ihren Code unter demselben Namen, den Sie für die Installation mit NPM verwenden. Wir empfehlen die folgenden Methoden, wenn Sie AWS CDK-Klassen und AWS Construct Library-Module in Ihre Anwendungen importieren. Das Befolgen dieser Richtlinien trägt dazu bei, dass Ihr Code mit anderen AWS CDK-Anwendungen konsistent und verständlicher ist.
+ Verwenden Sie `import` Direktiven ES6 im Stil von -style, nicht. `require()`
+ Importiere generell einzelne Klassen von`aws-cdk-lib`.
```
import { App, Stack } from 'aws-cdk-lib';
```
+ Wenn Sie viele Klassen von benötigen`aws-cdk-lib`, können Sie einen Namespace-Alias von verwenden, `cdk` anstatt die einzelnen Klassen zu importieren. Vermeiden Sie es, beides zu tun.
```
import * as cdk from 'aws-cdk-lib';
```
+ Im Allgemeinen importieren Sie AWS Dienstkonstrukte mit kurzen Namespace-Aliasnamen.
```
import { aws_s3 as s3 } from 'aws-cdk-lib';
```
## Verwaltung von Abhängigkeiten in TypeScript
In TypeScript CDK-Projekten werden Abhängigkeiten in der `package.json` Datei im Hauptverzeichnis des Projekts angegeben. Die AWS CDK-Kernmodule befinden sich in einem einzigen `NPM` Paket namens. `aws-cdk-lib`
Wenn Sie ein Paket mit installieren`npm install`, zeichnet NPM das Paket `package.json` für Sie auf.
Wenn Sie möchten, können Sie Yarn anstelle von NPM verwenden. Das CDK unterstützt jedoch nicht den plug-and-play Modus von Yarn, der in Yarn 2 der Standardmodus ist. Fügen Sie der `.yarnrc.yml` Datei Ihres Projekts Folgendes hinzu, um diese Funktion zu deaktivieren.
```
nodeLinker: node-modules
```
### CDK-Anwendungen
Im Folgenden finden Sie eine `package.json` Beispieldatei, die mit dem `cdk init --language typescript` Befehl generiert wurde:
```
{
"name": "my-package",
"version": "0.1.0",
"bin": {
"my-package": "bin/my-package.js"
},
"scripts": {
"build": "tsc",
"watch": "tsc -w",
"test": "jest",
"cdk": "cdk"
},
"devDependencies": {
"@types/jest": "^26.0.10",
"@types/node": "10.17.27",
"jest": "^26.4.2",
"ts-jest": "^26.2.0",
"aws-cdk": "2.16.0",
"ts-node": "^9.0.0",
"typescript": "~3.9.7"
},
"dependencies": {
"aws-cdk-lib": "2.16.0",
"constructs": "^10.0.0",
"source-map-support": "^0.5.16"
}
}
```
Für bereitstellbare CDK-Apps `aws-cdk-lib` muss dies im `dependencies` Abschnitt von angegeben werden. `package.json` Sie können die Versionsnummer mit einem Caret-Zeichen (^) angeben, dass Sie neuere Versionen als die angegebene akzeptieren, sofern sie sich in derselben Hauptversion befinden.
Geben Sie für experimentelle Konstrukte die exakten Versionen der Alpha-Konstruktbibliotheksmodule an, bei denen sich APIs das ändern kann. Verwenden Sie nicht ^ oder \$1, da spätere Versionen dieser Module API-Änderungen mit sich bringen können, die Ihre App beschädigen können.
Geben Sie im `devDependencies` Abschnitt von die Versionen der Bibliotheken und Tools an, die Sie zum `jest` Testen Ihrer App benötigen (z. B. das Test-Framework)`package.json`. Verwenden Sie optional ^, um anzugeben, dass spätere kompatible Versionen zulässig sind.
### Konstruktbibliotheken von Drittanbietern
Wenn Sie eine Konstruktbibliothek entwickeln, geben Sie deren Abhängigkeiten mithilfe einer Kombination aus den `devDependencies` Abschnitten `peerDependencies` und an, wie in der folgenden `package.json` Beispieldatei gezeigt.
```
{
"name": "my-package",
"version": "0.0.1",
"peerDependencies": {
"aws-cdk-lib": "^2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "^10.0.0"
},
"devDependencies": {
"aws-cdk-lib": "2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "10.0.0",
"jsii": "^1.50.0",
"aws-cdk": "^2.14.0"
}
}
```
Verwenden Sie in `peerDependencies` ein Caret-Zeichen (^), um die niedrigste Version anzugeben`aws-cdk-lib`, mit der Ihre Bibliothek arbeitet. Dadurch wird die Kompatibilität Ihrer Bibliothek mit einer Reihe von CDK-Versionen maximiert. Geben Sie genaue Versionen für Alpha-Construct-Bibliotheksmodule an, bei denen sich APIs das ändern kann. `peerDependencies`Durch die Verwendung wird sichergestellt, dass nur eine Kopie aller CDK-Bibliotheken im `node_modules` Baum vorhanden ist.
Geben Sie `devDependencies` unter die Tools und Bibliotheken an, die Sie zum Testen benötigen, optional mit ^, um anzugeben, dass spätere kompatible Versionen zulässig sind. Geben Sie genau (ohne ^ oder \$1) die niedrigsten Versionen `aws-cdk-lib` und andere CDK-Pakete an, mit denen Sie angeben, dass Ihre Bibliothek kompatibel ist. Diese Vorgehensweise stellt sicher, dass Ihre Tests mit diesen Versionen ausgeführt werden. Wenn Sie also versehentlich eine Funktion verwenden, die nur in neueren Versionen zu finden ist, können Ihre Tests sie catch.
**Warnung**
`peerDependencies`werden nur von NPM 7 und höher automatisch installiert. Wenn Sie NPM 6 oder früher verwenden oder wenn Sie Yarn verwenden, müssen Sie die Abhängigkeiten Ihrer Abhängigkeiten in einbeziehen. `devDependencies` Andernfalls werden sie nicht installiert und Sie erhalten eine Warnung vor ungelösten Peer-Abhängigkeiten.
### Abhängigkeiten installieren und aktualisieren
Führen Sie den folgenden Befehl aus, um die Abhängigkeiten Ihres Projekts zu installieren.
**Example**
```
# Install the latest version of everything that matches the ranges in 'package.json'
npm install
# Install the same exact dependency versions as recorded in 'package-lock.json'
npm ci
```
```
# Install the latest version of everything that matches the ranges in 'package.json'
$ yarn upgrade
# Install the same exact dependency versions as recorded in 'yarn.lock'
$ yarn install --frozen-lockfile
```
Um die installierten Module zu aktualisieren, können die vorherigen `yarn upgrade` Befehle `npm install` und verwendet werden. Mit beiden Befehlen werden die Pakete `node_modules` auf die neuesten Versionen aktualisiert, die den Regeln von entsprechen`package.json`. Sie aktualisieren `package.json` sich jedoch nicht von selbst, was Sie möglicherweise tun sollten, um eine neue Mindestversion festzulegen. Wenn Sie Ihr Paket auf hosten GitHub, können Sie [Dependabot-Versionsupdates](https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuring-dependabot-version-updates) so konfigurieren, dass sie automatisch aktualisiert werden. `package.json` Als alternative Vorgehensweise verwenden Sie [npm-check-updates](https://www.npmjs.com/package/npm-check-updates).
**Wichtig**
Standardmäßig wählen NPM und Yarn bei der Installation oder Aktualisierung von Abhängigkeiten die neueste Version jedes Pakets aus, das die in angegebenen Anforderungen erfüllt. `package.json` Es besteht immer das Risiko, dass diese Versionen beschädigt werden (entweder versehentlich oder absichtlich). Testen Sie gründlich, nachdem Sie die Abhängigkeiten Ihres Projekts aktualisiert haben.
## AWS CDK-Idiome in TypeScript
### Requisiten
*Alle AWS Construct-Library-Klassen werden mit drei Argumenten instanziiert: dem *Bereich*, in dem das Konstrukt definiert wird (sein übergeordnetes Objekt im Konstruktbaum), einer *ID* und Requisiten.* Argument *props* ist ein Bündel von Schlüssel/Wert-Paaren, das das Konstrukt verwendet, um die von ihm erstellten Ressourcen zu konfigurieren. AWS Andere Klassen und Methoden verwenden ebenfalls das Muster „Bündel von Attributen“ für Argumente.
TypeScriptIn `props` wird die Form von mithilfe einer Schnittstelle definiert, die Ihnen die erforderlichen und optionalen Argumente und deren Typen mitteilt. Eine solche Schnittstelle wird für jede Art von `props` Argument definiert, normalerweise spezifisch für ein einzelnes Konstrukt oder eine einzelne Methode. Zum Beispiel spezifiziert das [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)Konstrukt (im `aws-cdk-lib/aws-s3` Modul) ein `props` Argument, das der [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)Schnittstelle entspricht.
Wenn eine Eigenschaft selbst ein Objekt ist, zum Beispiel die [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html#websiteredirect](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html#websiteredirect)Eigenschaft von`BucketProps`, hat dieses Objekt in diesem Fall seine eigene Schnittstelle, der seine Form entsprechen muss. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.RedirectTarget.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.RedirectTarget.html)
Wenn Sie einer AWS Construct-Library-Klasse eine Unterklasse zuordnen (oder eine Methode überschreiben, die ein Argument wie Requisiten verwendet), können Sie von der vorhandenen Schnittstelle erben, um eine neue zu erstellen, die alle neuen Requisiten angibt, die Ihr Code benötigt. Wenn Sie die übergeordnete Klasse oder Basismethode aufrufen, können Sie im Allgemeinen das gesamte Argument props übergeben, das Sie erhalten haben, da alle im Objekt angegebenen, aber nicht in der Schnittstelle angegebenen Attribute ignoriert werden.
Eine future Version des AWS CDK könnte zufällig eine neue Immobilie mit einem Namen hinzufügen, den Sie für Ihre eigene Immobilie verwendet haben. Wenn Sie den Wert, den Sie erhalten, in der Vererbungskette weiterreichen, kann dies zu unerwartetem Verhalten führen. Es ist sicherer, eine oberflächliche Kopie der Requisiten weiterzugeben, die Sie erhalten haben, wenn Ihr Eigentum entfernt oder auf `undefined` Null gesetzt wurde. Zum Beispiel:
```
super(scope, name, {...props, encryptionKeys: undefined});
```
Sie können Ihre Eigenschaften auch so benennen, dass klar ist, dass sie zu Ihrem Konstrukt gehören. Auf diese Weise ist es unwahrscheinlich, dass sie in future AWS CDK-Versionen mit Eigenschaften kollidieren. Wenn es viele von ihnen gibt, verwenden Sie ein einzelnes Objekt mit dem entsprechenden Namen, um sie zu speichern.
### Fehlende Werte
Fehlende Werte in einem Objekt (z. B. Requisiten) haben den Wert in. `undefined` TypeScript In Version 3.7 der Sprache wurden Operatoren eingeführt, die die Arbeit mit diesen Werten vereinfachen. Sie erleichtern die Angabe von Standardwerten und die Verkettung von Kurzschlüssen, wenn ein undefinierter Wert erreicht wird. Weitere Informationen zu diesen Funktionen finden Sie in den [Versionshinweisen zu TypeScript 3.7](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html), insbesondere in den ersten beiden Funktionen, Optionales Verketten und Nullish Coalescing.
## CDK-Apps erstellen und ausführen
Im Allgemeinen sollten Sie sich beim Erstellen und Ausführen Ihrer Anwendung im Stammverzeichnis des Projekts befinden.
Node.js kann nicht TypeScript direkt ausgeführt werden. Stattdessen wird Ihre Anwendung so konvertiert, `tsc` dass sie den TypeScript Compiler JavaScript verwendet. Der resultierende JavaScript Code wird dann ausgeführt.
Das AWS CDK tut dies automatisch, wann immer es Ihre App ausführen muss. Es kann jedoch nützlich sein, manuell zu kompilieren, um nach Fehlern zu suchen und Tests durchzuführen. Um Ihre TypeScript App manuell zu kompilieren, geben Sie das Problem ein`npm run build`. Sie können auch `npm run watch` den Überwachungsmodus aufrufen, in dem der TypeScript Compiler Ihre App automatisch neu erstellt, wenn Sie Änderungen an einer Quelldatei speichern.
# Arbeiten mit dem AWS CDK in JavaScript
JavaScript ist eine vollständig unterstützte Client-Sprache für das AWS CDK und gilt als stabil. Bei der Arbeit mit dem AWS Cloud Development Kit (AWS CDK) werden vertraute Tools wie [Node.js](https://nodejs.org/) und der Node Package Manager (`npm`) JavaScript verwendet. Sie können auch [Yarn](https://yarnpkg.com/) verwenden, wenn Sie möchten, obwohl die Beispiele in diesem Handbuch NPM verwenden. [Die Module, aus denen die AWS Construct-Bibliothek besteht, werden über das NPM-Repository npmjs.org vertrieben.](https://www.npmjs.com/)
Sie können jeden Editor oder jede IDE verwenden. Viele AWS CDK-Entwickler verwenden [Visual Studio Code](https://code.visualstudio.com/) (oder sein Open-Source-Äquivalent [VSCodium](https://vscodium.com/)), das eine gute Unterstützung für bietet. JavaScript
## Fangen Sie an mit JavaScript
Um mit dem AWS CDK arbeiten zu können, benötigen Sie ein AWS Konto und Anmeldeinformationen und müssen Node.js und das AWS CDK Toolkit installiert haben. Weitere Informationen finden Sie unter [Erste Schritte mit dem CDK](getting-started.md). AWS
JavaScript AWS Für CDK-Anwendungen sind darüber hinaus keine weiteren Voraussetzungen erforderlich.
**Anmerkung**
Veraltete Sprachversionen von Drittanbietern: Die Sprachversion wird nur bis zu dem Zeitpunkt unterstützt, an dem der Anbieter oder die Community das EOL (End Of Life) festgelegt hat, und kann sich nach vorheriger Ankündigung ändern.
## Erstellen eines Projekts
Sie erstellen ein neues AWS CDK-Projekt, indem Sie es in einem leeren Verzeichnis aufrufen`cdk init`. Verwenden Sie die `--language` Option und geben Sie an: `javascript`
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language javascript
```
Beim Erstellen eines Projekts werden auch das [aws-cdk-lib](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html)Modul und seine Abhängigkeiten installiert.
`cdk init`verwendet den Namen des Projektordners, um verschiedene Elemente des Projekts zu benennen, einschließlich Klassen, Unterordnern und Dateien. Bindestriche im Ordnernamen werden in Unterstriche umgewandelt. Ansonsten sollte der Name jedoch die Form eines JavaScript Bezeichners haben; er sollte beispielsweise nicht mit einer Zahl beginnen oder Leerzeichen enthalten.
## Lokal verwenden `cdk`
In diesem Handbuch wird größtenteils davon ausgegangen, dass Sie das CDK Toolkit global (`npm install -g aws-cdk`) installieren, und die bereitgestellten Befehlsbeispiele (wie`cdk synth`) folgen dieser Annahme. Dieser Ansatz macht es einfach, das CDK Toolkit auf dem neuesten Stand zu halten, und da das CDK einen strikten Ansatz zur Abwärtskompatibilität verfolgt, besteht im Allgemeinen nur ein geringes Risiko, immer die neueste Version zu verwenden.
Einige Teams ziehen es vor, alle Abhängigkeiten innerhalb jedes Projekts anzugeben, einschließlich Tools wie dem CDK Toolkit. Auf diese Weise können Sie solche Komponenten bestimmten Versionen zuordnen und sicherstellen, dass alle Entwickler in Ihrem Team (und Ihrer CI/CD Umgebung) genau diese Versionen verwenden. Dadurch wird eine mögliche Änderungsquelle vermieden, was dazu beiträgt, Builds und Bereitstellungen konsistenter und wiederholbarer zu gestalten.
Das CDK enthält eine Abhängigkeit für das CDK-Toolkit in den JavaScript Projektvorlagen. Wenn Sie also diesen Ansatz verwenden möchten, müssen Sie keine Änderungen an Ihrem Projekt vornehmen. `package.json` Sie müssen lediglich leicht unterschiedliche Befehle zum Erstellen Ihrer App und zum Ausgeben von Befehlen verwenden. `cdk`
| Operation | Verwenden Sie globale Tools | Verwenden Sie lokale Tools |
| --- | --- | --- |
| **Projekt initialisieren** | `cdk init --language javascript` | `npx aws-cdk init --language javascript` |
| **Führen Sie den Befehl CDK Toolkit aus** | `cdk …` | `npm run cdk …` oder `npx aws-cdk …` |
`npx aws-cdk`führt die lokal im aktuellen Projekt installierte Version des CDK Toolkits aus, falls vorhanden, und greift dabei auf die globale Installation zurück, falls vorhanden. Falls keine globale Installation vorhanden ist, wird eine temporäre Kopie des CDK Toolkits `npx` heruntergeladen und ausgeführt. Sie können eine beliebige Version des CDK Toolkits mit der folgenden Syntax angeben: prints. `@` `npx aws-cdk@1.120 --version` `1.120.0`
**Tipp**
Richten Sie einen Alias ein, damit Sie den `cdk` Befehl mit einer lokalen CDK Toolkit-Installation verwenden können.
```
$ alias cdk="npx aws-cdk"
```
```
doskey cdk=npx aws-cdk $*
```
## AWS Construct Library-Module verwalten
Verwenden Sie den Node Package Manager (`npm`), um AWS Construct Library-Module für Ihre Apps sowie andere Pakete, die Sie benötigen, zu installieren und zu aktualisieren. (Sie können `yarn` stattdessen verwenden, `npm` wenn Sie es vorziehen.) `npm`installiert auch die Abhängigkeiten für diese Module automatisch.
Die meisten AWS CDK-Konstrukte befinden sich im CDK-Hauptpaket mit dem Namen. Dies ist eine Standardabhängigkeit in neuen Projekten`aws-cdk-lib`, die von erstellt wurden. `cdk init` Module der „experimentellen“ AWS Construct Library, bei denen sich übergeordnete Konstrukte noch in der Entwicklung befinden, werden wie benannt. `aws-cdk-lib/-alpha` Der Dienstname hat ein aws-Präfix*.* Wenn Sie sich des Namens eines Moduls nicht sicher sind, [suchen Sie auf NPM danach](https://www.npmjs.com/search?q=%40aws-cdk).
**Anmerkung**
Die [CDK-API-Referenz](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) zeigt auch die Paketnamen.
Mit dem folgenden Befehl wird beispielsweise das experimentelle Modul für AWS CodeStar installiert.
```
npm install @aws-cdk/aws-codestar-alpha
```
Die Construct Library-Unterstützung einiger Dienste erfolgt in mehr als einem Namespace. Außerdem gibt es `aws-route53` beispielsweise drei zusätzliche Amazon Route 53-Namespaces,`aws-route53-targets`, `aws-route53-patterns` und. `aws-route53resolver`
Die Abhängigkeiten Ihres Projekts werden in verwaltet. `package.json` Sie können diese Datei bearbeiten, um einige oder alle Ihrer Abhängigkeiten für eine bestimmte Version zu sperren oder um zu ermöglichen, dass sie unter bestimmten Kriterien auf neuere Versionen aktualisiert werden. Um die NPM-Abhängigkeiten Ihres Projekts gemäß den Regeln, die Sie angegeben haben, auf die neueste zulässige Version zu aktualisieren: `package.json`
```
npm update
```
In JavaScript importieren Sie Module in Ihren Code unter demselben Namen, den Sie für die Installation mit NPM verwenden. Wir empfehlen die folgenden Methoden, wenn Sie AWS CDK-Klassen und AWS Construct Library-Module in Ihre Anwendungen importieren. Das Befolgen dieser Richtlinien trägt dazu bei, dass Ihr Code mit anderen AWS CDK-Anwendungen konsistent und verständlicher ist.
+ Verwenden Sie Direktiven`require()`, keine Direktiven im Stil von ES6 -style`import`. Ältere Versionen von Node.js unterstützen keine ES6 Importe, sodass die Verwendung der älteren Syntax weitgehend kompatibel ist. (Wenn Sie wirklich ES6 Importe verwenden möchten, verwenden Sie [esm](https://www.npmjs.com/package/esm), um sicherzustellen, dass Ihr Projekt mit allen unterstützten Versionen von Node.js kompatibel ist.)
+ Im Allgemeinen importieren Sie einzelne Klassen von`aws-cdk-lib`.
```
const { App, Stack } = require('aws-cdk-lib');
```
+ Wenn Sie viele Klassen von benötigen`aws-cdk-lib`, können Sie einen Namespace-Alias von verwenden, `cdk` anstatt die einzelnen Klassen zu importieren. Vermeiden Sie es, beides zu tun.
```
const cdk = require('aws-cdk-lib');
```
+ Im Allgemeinen sollten Sie AWS Construct-Bibliotheken mit kurzen Namespace-Aliasen importieren.
```
const { s3 } = require('aws-cdk-lib/aws-s3');
```
## Verwaltung von Abhängigkeiten in JavaScript
In JavaScript CDK-Projekten werden Abhängigkeiten in der `package.json` Datei im Hauptverzeichnis des Projekts angegeben. Die AWS CDK-Kernmodule befinden sich in einem einzigen `NPM` Paket namens. `aws-cdk-lib`
Wenn Sie ein Paket mit installieren`npm install`, zeichnet NPM das Paket `package.json` für Sie auf.
Wenn Sie möchten, können Sie Yarn anstelle von NPM verwenden. Das CDK unterstützt jedoch nicht den plug-and-play Modus von Yarn, der in Yarn 2 der Standardmodus ist. Fügen Sie der `.yarnrc.yml` Datei Ihres Projekts Folgendes hinzu, um diese Funktion zu deaktivieren.
```
nodeLinker: node-modules
```
### CDK-Anwendungen
Im Folgenden finden Sie eine `package.json` Beispieldatei, die mit dem `cdk init --language typescript` Befehl generiert wurde. Die generierte Datei für JavaScript ist ähnlich, nur ohne die TypeScript zugehörigen Einträge.
```
{
"name": "my-package",
"version": "0.1.0",
"bin": {
"my-package": "bin/my-package.js"
},
"scripts": {
"build": "tsc",
"watch": "tsc -w",
"test": "jest",
"cdk": "cdk"
},
"devDependencies": {
"@types/jest": "^26.0.10",
"@types/node": "10.17.27",
"jest": "^26.4.2",
"ts-jest": "^26.2.0",
"aws-cdk": "2.16.0",
"ts-node": "^9.0.0",
"typescript": "~3.9.7"
},
"dependencies": {
"aws-cdk-lib": "2.16.0",
"constructs": "^10.0.0",
"source-map-support": "^0.5.16"
}
}
```
Für bereitstellbare CDK-Apps `aws-cdk-lib` muss dies im `dependencies` Abschnitt von angegeben werden. `package.json` Sie können die Versionsnummer mit einem Caret-Zeichen (^) angeben, dass Sie neuere Versionen als die angegebene akzeptieren, sofern sie sich in derselben Hauptversion befinden.
Geben Sie für experimentelle Konstrukte die exakten Versionen der Alpha-Konstruktbibliotheksmodule an, bei denen sich APIs das ändern kann. Verwenden Sie nicht ^ oder \$1, da spätere Versionen dieser Module API-Änderungen mit sich bringen können, die Ihre App beschädigen können.
Geben Sie im `devDependencies` Abschnitt von die Versionen der Bibliotheken und Tools an, die Sie zum `jest` Testen Ihrer App benötigen (z. B. das Test-Framework)`package.json`. Verwenden Sie optional ^, um anzugeben, dass spätere kompatible Versionen zulässig sind.
### Konstruktbibliotheken von Drittanbietern
Wenn Sie eine Konstruktbibliothek entwickeln, geben Sie deren Abhängigkeiten mithilfe einer Kombination aus den `devDependencies` Abschnitten `peerDependencies` und an, wie in der folgenden `package.json` Beispieldatei gezeigt.
```
{
"name": "my-package",
"version": "0.0.1",
"peerDependencies": {
"aws-cdk-lib": "^2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "^10.0.0"
},
"devDependencies": {
"aws-cdk-lib": "2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "10.0.0",
"jsii": "^1.50.0",
"aws-cdk": "^2.14.0"
}
}
```
Verwenden Sie in `peerDependencies` ein Caret-Zeichen (^), um die niedrigste Version anzugeben`aws-cdk-lib`, mit der Ihre Bibliothek arbeitet. Dadurch wird die Kompatibilität Ihrer Bibliothek mit einer Reihe von CDK-Versionen maximiert. Geben Sie genaue Versionen für Alpha-Construct-Bibliotheksmodule an, bei denen sich APIs das ändern kann. `peerDependencies`Durch die Verwendung wird sichergestellt, dass nur eine Kopie aller CDK-Bibliotheken im `node_modules` Baum vorhanden ist.
Geben Sie `devDependencies` unter die Tools und Bibliotheken an, die Sie zum Testen benötigen, optional mit ^, um anzugeben, dass spätere kompatible Versionen zulässig sind. Geben Sie genau (ohne ^ oder \$1) die niedrigsten Versionen `aws-cdk-lib` und andere CDK-Pakete an, mit denen Sie angeben, dass Ihre Bibliothek kompatibel ist. Diese Vorgehensweise stellt sicher, dass Ihre Tests mit diesen Versionen ausgeführt werden. Wenn Sie also versehentlich eine Funktion verwenden, die nur in neueren Versionen zu finden ist, können Ihre Tests sie catch.
**Warnung**
`peerDependencies`werden nur von NPM 7 und höher automatisch installiert. Wenn Sie NPM 6 oder früher verwenden oder wenn Sie Yarn verwenden, müssen Sie die Abhängigkeiten Ihrer Abhängigkeiten in einbeziehen. `devDependencies` Andernfalls werden sie nicht installiert und Sie erhalten eine Warnung vor ungelösten Peer-Abhängigkeiten.
### Abhängigkeiten installieren und aktualisieren
Führen Sie den folgenden Befehl aus, um die Abhängigkeiten Ihres Projekts zu installieren.
**Example**
```
# Install the latest version of everything that matches the ranges in 'package.json'
npm install
# Install the same exact dependency versions as recorded in 'package-lock.json'
npm ci
```
```
# Install the latest version of everything that matches the ranges in 'package.json'
yarn upgrade
# Install the same exact dependency versions as recorded in 'yarn.lock'
yarn install --frozen-lockfile
```
Um die installierten Module zu aktualisieren, können die vorherigen `yarn upgrade` Befehle `npm install` und verwendet werden. Mit beiden Befehlen werden die Pakete `node_modules` auf die neuesten Versionen aktualisiert, die den Regeln von entsprechen`package.json`. Sie aktualisieren `package.json` sich jedoch nicht von selbst, was Sie möglicherweise tun sollten, um eine neue Mindestversion festzulegen. Wenn Sie Ihr Paket auf hosten GitHub, können Sie [Dependabot-Versionsupdates](https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuring-dependabot-version-updates) so konfigurieren, dass sie automatisch aktualisiert werden. `package.json` Als alternative Vorgehensweise verwenden Sie [npm-check-updates](https://www.npmjs.com/package/npm-check-updates).
**Wichtig**
Standardmäßig wählen NPM und Yarn bei der Installation oder Aktualisierung von Abhängigkeiten die neueste Version jedes Pakets aus, das die in angegebenen Anforderungen erfüllt. `package.json` Es besteht immer das Risiko, dass diese Versionen beschädigt werden (entweder versehentlich oder absichtlich). Testen Sie gründlich, nachdem Sie die Abhängigkeiten Ihres Projekts aktualisiert haben.
## AWS CDK-Idiome in JavaScript
### Props
Alle AWS Construct-Library-Klassen werden mit drei Argumenten instanziiert: dem *Bereich*, in dem das Konstrukt definiert wird (sein übergeordnetes Objekt im Konstruktbaum), einer *ID* und *props*, einem Bündel von key/value Paaren, das das Konstrukt verwendet, um die von ihm erstellten Ressourcen zu konfigurieren. AWS Andere Klassen und Methoden verwenden ebenfalls das Muster „Bündel von Attributen“ für Argumente.
Wenn Sie eine IDE oder einen Editor verwenden, der über eine gute JavaScript Autovervollständigung verfügt, können Sie vermeiden, dass Eigenschaftsnamen falsch geschrieben werden. Wenn ein Konstrukt eine `encryptionKeys` Eigenschaft erwartet und Sie sie buchstabieren`encryptionkeys`, haben Sie bei der Instanziierung des Konstrukts nicht den gewünschten Wert übergeben. Dies kann bei der Synthese zu einem Fehler führen, wenn die Eigenschaft erforderlich ist, oder dazu führen, dass die Eigenschaft stillschweigend ignoriert wird, wenn sie optional ist. In letzterem Fall erhalten Sie möglicherweise ein Standardverhalten, das Sie überschreiben wollten. Seien Sie hier besonders vorsichtig.
Wenn Sie einer AWS Construct Library-Klasse eine Unterklasse zuordnen (oder eine Methode überschreiben, die ein Argument wie Requisiten verwendet), möchten Sie möglicherweise zusätzliche Eigenschaften für Ihren eigenen Gebrauch akzeptieren. Diese Werte werden von der übergeordneten Klasse oder überschriebenen Methode ignoriert, da in diesem Code nie auf sie zugegriffen wird. Sie können also generell alle Requisiten weitergeben, die Sie erhalten haben.
Eine future Version des AWS CDK könnte zufällig eine neue Immobilie mit einem Namen hinzufügen, den Sie für Ihre eigene Immobilie verwendet haben. Wenn Sie den Wert, den Sie erhalten, in der Vererbungskette weiterreichen, kann dies zu unerwartetem Verhalten führen. Es ist sicherer, eine oberflächliche Kopie der Requisiten weiterzugeben, die Sie erhalten haben, wenn Ihr Eigentum entfernt oder auf `undefined` Null gesetzt wurde. Beispiel:
```
super(scope, name, {...props, encryptionKeys: undefined});
```
Sie können Ihre Eigenschaften auch so benennen, dass klar ist, dass sie zu Ihrem Konstrukt gehören. Auf diese Weise ist es unwahrscheinlich, dass sie in future AWS CDK-Versionen mit Eigenschaften kollidieren werden. Wenn es viele von ihnen gibt, verwenden Sie ein einzelnes Objekt mit dem entsprechenden Namen, um sie zu speichern.
### Fehlende Werte
Fehlende Werte in einem Objekt (z. B.`props`) haben den Wert in. `undefined` JavaScript Für den Umgang mit diesen gelten die üblichen Techniken. Ein gängiges Idiom für den Zugriff auf eine Eigenschaft mit einem möglicherweise undefinierten Wert lautet beispielsweise wie folgt:
```
// a may be undefined, but if it is not, it may have an attribute b
// c is undefined if a is undefined, OR if a doesn't have an attribute b
let c = a && a.b;
```
Wenn es aber `a` auch noch einen anderen „falschen“ Wert geben könnte, ist es besser`undefined`, den Test expliziter zu machen. Hier machen wir uns die Tatsache zunutze, dass `null` und gleich `undefined` sind, um beide gleichzeitig zu testen:
```
let c = a == null ? a : a.b;
```
**Tipp**
Node.js 14.0 und höher unterstützen neue Operatoren, die den Umgang mit undefinierten Werten vereinfachen können. Weitere Informationen finden Sie in den [optionalen Vorschlägen zum Verketten](https://github.com/tc39/proposal-optional-chaining/blob/master/README.md) und Zusammenführen von [Nullwerten](https://github.com/tc39/proposal-nullish-coalescing/blob/master/README.md).
## Verwenden von Beispielen mit TypeScript JavaScript
[TypeScript](https://www.typescriptlang.org/)ist die Sprache, die wir zur Entwicklung des AWS CDK verwenden, und es war die erste Sprache, die für die Entwicklung von Anwendungen unterstützt wurde. Daher sind viele verfügbare AWS CDK-Codebeispiele in dieser Sprache geschrieben. TypeScript Diese Codebeispiele können eine gute Ressource für JavaScript Entwickler sein. Sie müssen nur die TypeScript -spezifischen Teile des Codes entfernen.
TypeScript In Codefragmenten werden häufig die `export` Schlüsselwörter new ECMAScript `import` und verwendet, um Objekte aus anderen Modulen zu importieren und die Objekte so zu deklarieren, dass sie außerhalb des aktuellen Moduls verfügbar gemacht werden. Node.js hat gerade damit begonnen, diese Schlüsselwörter in seinen neuesten Versionen zu unterstützen. Abhängig von der Version von Node.js, die Sie verwenden (oder unterstützen möchten), können Sie Importe und Exporte so umschreiben, dass sie die ältere Syntax verwenden.
Importe können durch Aufrufe der `require()` Funktion ersetzt werden.
**Example**
```
import * as cdk from 'aws-cdk-lib';
import { Bucket, BucketPolicy } from 'aws-cdk-lib/aws-s3';
```
```
const cdk = require('aws-cdk-lib');
const { Bucket, BucketPolicy } = require('aws-cdk-lib/aws-s3');
```
Exporte können dem `module.exports` Objekt zugewiesen werden.
**Example**
```
export class Stack1 extends cdk.Stack {
// ...
}
export class Stack2 extends cdk.Stack {
// ...
}
```
```
class Stack1 extends cdk.Stack {
// ...
}
class Stack2 extends cdk.Stack {
// ...
}
module.exports = { Stack1, Stack2 }
```
**Anmerkung**
Eine Alternative zur Verwendung der Importe und Exporte im alten Stil ist die Verwendung des [ESM-Moduls.](https://www.npmjs.com/package/esm)
Sobald Sie die Importe und Exporte sortiert haben, können Sie sich mit dem eigentlichen Code befassen. Möglicherweise stoßen Sie auf diese häufig verwendeten Funktionen TypeScript :
+ Geben Sie Anmerkungen ein
+ Schnittstellendefinitionen
+ Typkonvertierungen/Umwandlungen
+ Zugriffsmodifikatoren
Typanmerkungen können für Variablen, Klassenmitglieder, Funktionsparameter und Funktionsrückgabetypen bereitgestellt werden. Bei Variablen, Parametern und Elementen werden Typen angegeben, indem hinter dem Bezeichner ein Doppelpunkt und der Typ stehen. Funktionsrückgabewerte folgen der Funktionssignatur und bestehen aus einem Doppelpunkt und dem Typ.
Um Code mit Typanmerkungen in umzuwandeln JavaScript, entfernen Sie den Doppelpunkt und den Typ. Klassenmitglieder müssen einen bestimmten Wert in JavaScript haben. Setzen Sie sie auf, `undefined` wenn sie nur eine Typanmerkung enthalten. TypeScript
**Example**
```
var encrypted: boolean = true;
class myStack extends cdk.Stack {
bucket: s3.Bucket;
// ...
}
function makeEnv(account: string, region: string) : object {
// ...
}
```
```
var encrypted = true;
class myStack extends cdk.Stack {
bucket = undefined;
// ...
}
function makeEnv(account, region) {
// ...
}
```
In werden Schnittstellen verwendet TypeScript, um Bündeln von erforderlichen und optionalen Eigenschaften und ihren Typen einen Namen zu geben. Anschließend können Sie den Schnittstellennamen als Typanmerkung verwenden. TypeScript stellt sicher, dass das Objekt, das Sie beispielsweise als Argument für eine Funktion verwenden, die erforderlichen Eigenschaften der richtigen Typen hat.
```
interface myFuncProps {
code: lambda.Code,
handler?: string
}
```
JavaScript hat keine Schnittstellenfunktion. Wenn Sie also die Typanmerkungen entfernt haben, löschen Sie die Schnittstellendeklarationen vollständig.
*Wenn eine Funktion oder Methode einen Allzwecktyp (z. B.`object`) zurückgibt, Sie diesen Wert aber als spezifischeren untergeordneten Typ behandeln möchten, um auf Eigenschaften oder Methoden zuzugreifen, die nicht Teil der Schnittstelle des allgemeineren Typs sind, TypeScript können Sie den Wert mit einem Typ- oder `as` Schnittstellennamen umwandeln.* JavaScript unterstützt (oder benötigt) dies nicht, also entfernen Sie einfach den folgenden `as` Bezeichner. Eine weniger gebräuchliche Umwandlungssyntax besteht darin``, einen Typnamen in Klammern zu verwenden. Auch diese Umwandlungen müssen entfernt werden.
Schließlich werden die Zugriffsmodifizierer `public``protected`, und `private` für Mitglieder von Klassen TypeScript unterstützt. Alle Klassenmitglieder JavaScript sind öffentlich. Entfernen Sie diese Modifikatoren einfach, wo immer Sie sie sehen.
Zu wissen, wie man diese TypeScript Funktionen identifiziert und entfernt, trägt wesentlich dazu bei, kurze TypeScript Ausschnitte an sie anzupassen. JavaScript Es kann jedoch unpraktisch sein, längere TypeScript Beispiele auf diese Weise zu konvertieren, da sie mit größerer Wahrscheinlichkeit andere Funktionen verwenden. TypeScript Für diese Situationen empfehlen wir [Sucrase](https://github.com/alangpierce/sucrase). Sucrase wird sich nicht beschweren, wenn Code beispielsweise eine undefinierte Variable verwendet, wie es der Fall wäre. `tsc` Wenn es syntaktisch gültig ist, kann Sucrase es mit wenigen Ausnahmen in übersetzen. JavaScript Dies macht es besonders nützlich für die Konvertierung von Snippets, die möglicherweise nicht eigenständig ausgeführt werden können.
## Migration zu TypeScript
Viele JavaScript Entwickler wechseln dazu [TypeScript](https://www.typescriptlang.org/), wenn ihre Projekte größer und komplexer werden. TypeScript ist eine Obermenge von JavaScript — der gesamte JavaScript Code ist gültiger TypeScript Code, sodass keine Änderungen an Ihrem Code erforderlich sind — und es ist auch eine unterstützte CDK-Sprache. AWS Typanmerkungen und andere TypeScript Funktionen sind optional und können zu Ihrer AWS CDK-App hinzugefügt werden, sobald Sie Wert darin finden. TypeScript bietet dir außerdem frühzeitigen Zugriff auf neue JavaScript Funktionen wie optionales Chaining und Nullish-Coalescing, bevor sie fertiggestellt sind — und das, ohne dass du Node.js aktualisieren musst.
TypeScriptDie „formbasierten“ Schnittstellen, die Bündel erforderlicher und optionaler Eigenschaften (und ihrer Typen) innerhalb eines Objekts definieren, ermöglichen das Auffinden häufiger Fehler beim Schreiben des Codes und erleichtern es Ihrer IDE, zuverlässige Autocomplete-Funktionen und andere Codierungshinweise in Echtzeit bereitzustellen.
Das Eincodieren TypeScript erfordert einen zusätzlichen Schritt: das Kompilieren Ihrer App mit dem Compiler,. TypeScript `tsc` Bei typischen AWS CDK-Apps dauert die Kompilierung höchstens einige Sekunden.
Der einfachste Weg, eine bestehende JavaScript AWS CDK-App zu migrieren, TypeScript besteht darin`cdk init app --language typescript`, ein neues TypeScript Projekt mit Ihren Quelldateien (und allen anderen erforderlichen Dateien, wie Assets wie dem Quellcode der AWS Lambda-Funktion) zu erstellen und dann in das neue Projekt zu kopieren. Benennen Sie Ihre JavaScript Dateien so um, dass sie enden `.ts` und mit der Entwicklung beginnen. TypeScript
# Arbeiten mit dem AWS CDK in Python
Python ist eine vollständig unterstützte Client-Sprache für das AWS Cloud Development Kit (AWS CDK) und gilt als stabil. Bei der Arbeit mit dem AWS CDK in Python werden vertraute Tools verwendet, darunter die Standard-Python-Implementierung (CPython), virtuelle Umgebungen mit `virtualenv` und das Python-Paketinstallationsprogramm`pip`. Die Module, aus denen die AWS Construct-Bibliothek besteht, werden über [pypi.org](https://pypi.org/search/?q=aws-cdk) vertrieben. Die Python-Version des AWS CDK verwendet sogar Bezeichner im Python-Stil (z. B. Methodennamen). `snake_case`
Sie können jeden Editor oder jede IDE verwenden. Viele AWS CDK-Entwickler verwenden [Visual Studio Code](https://code.visualstudio.com/) (oder sein Open-Source-Äquivalent [VSCodium](https://vscodium.com/)), das Python über eine [offizielle](https://marketplace.visualstudio.com/items?itemName=ms-python.python) Erweiterung gut unterstützt. Der in Python enthaltene IDLE-Editor reicht aus, um loszulegen. Die Python-Module für das AWS CDK haben Typhinweise, die für ein Linting-Tool oder eine IDE, die Typvalidierung unterstützt, nützlich sind.
## Erste Schritte mit Python
Um mit dem AWS CDK arbeiten zu können, müssen Sie über ein AWS Konto und Anmeldeinformationen verfügen und Node.js und das AWS CDK Toolkit installiert haben. Weitere Informationen finden Sie unter [Erste Schritte mit dem CDK](getting-started.md). AWS
AWS Python-CDK-Anwendungen benötigen Python 3.9 oder höher. Falls Sie es noch nicht installiert haben, [laden Sie eine kompatible Version](https://www.python.org/downloads/) für Ihr Betriebssystem von [python.org](https://www.python.org/) herunter. Wenn Sie Linux verwenden, wurde Ihr System möglicherweise mit einer kompatiblen Version geliefert, oder Sie können es mit dem Paketmanager Ihrer Distribution installieren (`yum``apt`, usw.). Mac-Benutzer könnten an [Homebrew](https://brew.sh/) interessiert sein, einem Paketmanager im Linux-Stil für macOS.
**Anmerkung**
Veraltete Sprachversion von Drittanbietern: Die Sprachversion wird nur bis zu ihrem vom Anbieter oder der Community mitgeteilten EOL (End Of Life) unterstützt und kann sich mit vorheriger Ankündigung ändern.
Das Python-Paketinstallationsprogramm und der Virtual Environment Manager sind ebenfalls erforderlich. `pip` `virtualenv` Windows-Installationen kompatibler Python-Versionen enthalten diese Tools. Unter Linux `pip` und `virtualenv` kann als separate Pakete in Ihrem Paketmanager bereitgestellt werden. Alternativ können Sie sie mit den folgenden Befehlen installieren:
```
python -m ensurepip --upgrade
python -m pip install --upgrade pip
python -m pip install --upgrade virtualenv
```
Wenn Sie auf einen Berechtigungsfehler stoßen, führen Sie die obigen Befehle mit der `--user` Markierung aus, sodass die Module in Ihrem Benutzerverzeichnis installiert werden, oder verwenden Sie `sudo` sie, um die Berechtigungen für die systemweite Installation der Module zu erhalten.
**Anmerkung**
Es ist üblich, dass Linux-Distributionen den Namen der ausführbaren Datei `python3` für Python 3.x verwenden und auf eine Python 2.x-Installation `python` verweisen. Einige Distributionen haben ein optionales Paket, das Sie installieren können, damit sich der `python` Befehl auf Python 3 bezieht. Andernfalls können Sie den Befehl, mit dem Ihre Anwendung ausgeführt wird, anpassen, indem Sie ihn `cdk.json` im Hauptverzeichnis des Projekts bearbeiten.
**Anmerkung**
Unter Windows möchten Sie vielleicht Python (und`pip`) mit der `py` ausführbaren Datei, dem [Python-Launcher für Windows](https://docs.python.org/3/using/windows.html#launcher), aufrufen. Mit dem Launcher können Sie unter anderem einfach angeben, welche installierte Version von Python Sie verwenden möchten.
Wenn die Eingabe `python` in der Befehlszeile zu einer Meldung über die Installation von Python aus dem Windows Store führt, auch nach der Installation einer Windows-Version von Python, öffnen Sie den Windows-Einstellungsbereich „App-Ausführungs-Aliase verwalten“ und deaktivieren Sie die beiden App Installer-Einträge für Python.
## Erstellen eines Projekts
Sie erstellen ein neues AWS CDK-Projekt, indem Sie es `cdk init` in einem leeren Verzeichnis aufrufen. Verwenden Sie die `--language` Option und geben Sie an: `python`
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language python
```
`cdk init`verwendet den Namen des Projektordners, um verschiedene Elemente des Projekts zu benennen, einschließlich Klassen, Unterordnern und Dateien. Bindestriche im Ordnernamen werden in Unterstriche umgewandelt. Ansonsten sollte der Name jedoch der Form eines Python-Bezeichners folgen; er sollte beispielsweise nicht mit einer Zahl beginnen oder Leerzeichen enthalten.
Um mit dem neuen Projekt zu arbeiten, aktivieren Sie seine virtuelle Umgebung. Dadurch können die Abhängigkeiten des Projekts lokal und nicht global im Projektordner installiert werden.
```
$ source .venv/bin/activate
```
**Anmerkung**
Möglicherweise erkennen Sie dies als den Mac/Linux Befehl zur Aktivierung einer virtuellen Umgebung. Die Python-Vorlagen enthalten eine Batch-Datei, `source.bat`, die die Verwendung desselben Befehls unter Windows ermöglicht. Der traditionelle Windows-Befehl`.\venv\Scripts\activate`,, funktioniert auch.
Wenn Sie Ihr AWS CDK-Projekt mit CDK Toolkit v1.70.0 oder früher initialisiert haben, befindet sich Ihre virtuelle Umgebung im Verzeichnis statt. `.env` `.venv`
**Wichtig**
Aktivieren Sie die virtuelle Umgebung des Projekts, wann immer Sie damit beginnen, daran zu arbeiten. Andernfalls haben Sie keinen Zugriff auf die dort installierten Module, und die von Ihnen installierten Module werden in das globale Python-Modulverzeichnis verschoben (oder führen zu einem Berechtigungsfehler).
Nachdem Sie Ihre virtuelle Umgebung zum ersten Mal aktiviert haben, installieren Sie die Standardabhängigkeiten der App:
```
$ python -m pip install -r requirements.txt
```
## Verwaltung von AWS Construct Library-Modulen
Verwenden Sie das Python-Paketinstallationsprogramm`pip`,, um AWS Construct Library-Module für Ihre Apps sowie andere Pakete, die Sie benötigen, zu installieren und zu aktualisieren. `pip`installiert auch die Abhängigkeiten für diese Module automatisch. Wenn Ihr System den Befehl nicht `pip` als eigenständigen Befehl erkennt, rufen Sie ihn wie folgt `pip` als Python-Modul auf:
```
$ python -m pip
```
Die meisten AWS CDK-Konstrukte sind enthalten. `aws-cdk-lib` Experimentelle Module befinden sich in separaten Modulen mit dem Namen wie. `aws-cdk..alpha` Der Dienstname enthält ein *AWS-Präfix*. Wenn Sie sich des Namens eines Moduls nicht sicher sind, [suchen Sie bei PyPI danach](https://pypi.org/search/?q=aws-cdk). Mit dem folgenden Befehl wird beispielsweise die Bibliothek installiert. AWS CodeStar
```
$ python -m pip install aws-cdk.aws-codestar-alpha
```
Die Konstrukte einiger Dienste befinden sich in mehr als einem Namespace. Außerdem gibt es `aws-cdk.aws-route53` beispielsweise drei zusätzliche Amazon Route 53-Namespaces mit den Namen`aws-route53-targets`, und`aws-route53-patterns`. `aws-route53resolver`
**Anmerkung**
Die [Python-Ausgabe der CDK API Reference](https://docs.aws.amazon.com/cdk/api/v2/python/index.html) zeigt auch die Paketnamen.
Die Namen, die für den Import von AWS Construct Library-Modulen in Ihren Python-Code verwendet werden, sehen wie folgt aus.
```
import aws_cdk.aws_s3 as s3
import aws_cdk.aws_lambda as lambda_
```
Wir empfehlen die folgenden Methoden, wenn Sie AWS CDK-Klassen und AWS Construct Library-Module in Ihre Anwendungen importieren. Das Befolgen dieser Richtlinien trägt dazu bei, dass Ihr Code mit anderen AWS CDK-Anwendungen konsistent und verständlicher ist.
+ Im Allgemeinen sollten Sie einzelne Klassen aus der obersten `aws_cdk` Ebene importieren.
```
from aws_cdk import App, Construct
```
+ Wenn Sie viele Klassen aus dem benötigen`aws_cdk`, können Sie einen Namespace-Alias von verwenden, `cdk` anstatt einzelne Klassen zu importieren. Vermeiden Sie es, beides zu tun.
```
import aws_cdk as cdk
```
+ Im Allgemeinen sollten Sie AWS Construct-Bibliotheken mit kurzen Namespace-Aliasen importieren.
```
import aws_cdk.aws_s3 as s3
```
Aktualisieren Sie nach der Installation eines Moduls die `requirements.txt` Datei Ihres Projekts, in der die Abhängigkeiten Ihres Projekts aufgeführt sind. Es ist am besten, dies manuell zu tun, anstatt es zu verwenden`pip freeze`. `pip freeze`erfasst die aktuellen Versionen aller Module, die in Ihrer virtuellen Python-Umgebung installiert sind. Dies kann nützlich sein, wenn Sie ein Projekt bündeln, das an anderer Stelle ausgeführt werden soll.
Normalerweise `requirements.txt` sollten Sie jedoch nur Abhängigkeiten der obersten Ebene auflisten (Module, von denen Ihre App direkt abhängt) und nicht die Abhängigkeiten dieser Bibliotheken. Diese Strategie erleichtert die Aktualisierung Ihrer Abhängigkeiten.
Sie können Änderungen vornehmen`requirements.txt`, um Upgrades zuzulassen. Ersetzen Sie einfach die `==` vorherige Versionsnummer durch, `~=` um Upgrades auf eine höhere kompatible Version zu ermöglichen, oder entfernen Sie die Versionsanforderung vollständig, um die neueste verfügbare Version des Moduls anzugeben.
Wenn die `requirements.txt` Datei entsprechend bearbeitet wurde, um Upgrades zu ermöglichen, geben Sie diesen Befehl ein, um die in Ihrem Projekt installierten Module jederzeit zu aktualisieren:
```
$ pip install --upgrade -r requirements.txt
```
## Abhängigkeiten in Python verwalten
In Python spezifizieren Sie Abhängigkeiten, indem Sie sie `requirements.txt` für Anwendungen oder `setup.py` für Konstruktbibliotheken eingeben. Abhängigkeiten werden dann mit dem PIP-Tool verwaltet. PIP wird auf eine der folgenden Arten aufgerufen:
```
pip
python -m pip
```
Der `python -m pip` Aufruf funktioniert auf den meisten Systemen; `pip` erfordert, dass sich die ausführbare Datei von PIP im Systempfad befindet. Wenn `pip` das nicht funktioniert, versuchen Sie, es durch zu ersetzen. `python -m pip`
Der `cdk init --language python` Befehl erstellt eine virtuelle Umgebung für Ihr neues Projekt. Dadurch kann jedes Projekt seine eigenen Versionen von Abhängigkeiten und auch eine `requirements.txt` Basisdatei haben. Sie müssen diese virtuelle Umgebung `source .venv/bin/activate` jedes Mal aktivieren, indem Sie sie ausführen, wenn Sie mit der Arbeit an dem Projekt beginnen. Führen Sie unter Windows `.\venv\Scripts\activate` stattdessen den Befehl aus
### CDK-Anwendungen
Im Folgenden sehen Sie ein Beispiel für eine `requirements.txt`-Datei. Da PIP nicht über eine Funktion zum Sperren von Abhängigkeiten verfügt, empfehlen wir, den Operator == zu verwenden, um exakte Versionen für alle Abhängigkeiten anzugeben, wie hier gezeigt.
```
aws-cdk-lib==2.14.0
aws-cdk.aws-appsync-alpha==2.10.0a0
```
Durch die Installation eines Moduls mit `pip install` wird es nicht automatisch hinzugefügt. `requirements.txt` Das müssen Sie selbst tun. Wenn Sie auf eine neuere Version einer Abhängigkeit aktualisieren möchten, bearbeiten Sie deren Versionsnummer unter`requirements.txt`.
Um die Abhängigkeiten Ihres Projekts nach der Erstellung oder Bearbeitung zu installieren oder zu aktualisieren`requirements.txt`, führen Sie den folgenden Befehl aus:
```
python -m pip install -r requirements.txt
```
**Tipp**
Der `pip freeze` Befehl gibt die Versionen aller installierten Abhängigkeiten in einem Format aus, das in eine Textdatei geschrieben werden kann. Dies kann als Anforderungsdatei mit verwendet werden`pip install -r`. Diese Datei ist praktisch, um alle Abhängigkeiten (einschließlich transitiver Abhängigkeiten) genau den Versionen zuzuordnen, mit denen Sie getestet haben. Um Probleme bei der späteren Aktualisierung von Paketen zu vermeiden, verwenden Sie hierfür eine separate Datei, z. B. `freeze.txt` (not`requirements.txt`). Generieren Sie sie dann neu, wenn Sie die Abhängigkeiten Ihres Projekts aktualisieren.
### Konstruktbibliotheken von Drittanbietern
In Bibliotheken werden Abhängigkeiten in angegeben`setup.py`, sodass transitive Abhängigkeiten automatisch heruntergeladen werden, wenn das Paket von einer Anwendung verwendet wird. Andernfalls muss jede Anwendung, die Ihr Paket verwenden möchte, Ihre Abhängigkeiten in ihre `requirements.txt` Dateien kopieren. Ein Beispiel `setup.py` wird hier gezeigt.
```
from setuptools import setup
setup(
name='my-package',
version='0.0.1',
install_requires=[
'aws-cdk-lib==2.14.0',
],
...
)
```
Um an dem Paket für die Entwicklung zu arbeiten, erstellen oder aktivieren Sie eine virtuelle Umgebung und führen Sie dann den folgenden Befehl aus.
```
python -m pip install -e .
```
Obwohl PIP automatisch transitive Abhängigkeiten installiert, kann von jedem Paket nur eine Kopie installiert werden. Die Version, die im Abhängigkeitsbaum am höchsten angegeben ist, wird ausgewählt; Anwendungen haben immer das letzte Wort darüber, welche Version von Paketen installiert wird.
## AWS CDK-Idiome in Python
### Sprachkonflikte
In Python `lambda` ist dies ein Sprachschlüsselwort, sodass Sie es nicht als Namen für das AWS Lambda-Konstruktbibliotheksmodul oder für Lambda-Funktionen verwenden können. Die Python-Konvention für solche Konflikte besteht darin, im Variablennamen einen abschließenden Unterstrich wie in `lambda_` zu verwenden.
Konventionell wird das zweite Argument für AWS CDK-Konstrukte benannt. `id` Wenn Sie Ihre eigenen Stapel und Konstrukte schreiben, `id` „überschattet“ der Aufruf eines Parameters die eingebaute Python-Funktion`id()`, die den eindeutigen Bezeichner eines Objekts zurückgibt. Diese Funktion wird nicht sehr oft verwendet, aber wenn Sie sie zufällig in Ihrem Konstrukt benötigen sollten, benennen Sie das Argument beispielsweise um. `construct_id`
### Argumente und Eigenschaften
Alle AWS Construct-Library-Klassen werden mit drei Argumenten instanziiert: dem *Bereich*, in dem das Konstrukt definiert wird (sein übergeordnetes Objekt im Konstruktbaum), einer *ID* und *Requisiten*, einem Bündel von key/value Paaren, das das Konstrukt verwendet, um die von ihm erstellten Ressourcen zu konfigurieren. Andere Klassen und Methoden verwenden ebenfalls das Muster „Bündel von Attributen“ für Argumente.
*scope* und *id* sollten immer als Positionsargumente und nicht als Schlüsselwortargumente übergeben werden, da sich ihre Namen ändern, wenn das Konstrukt eine Eigenschaft namens *scope* oder *id* akzeptiert.
In Python werden Requisiten als Schlüsselwortargumente ausgedrückt. Wenn ein Argument verschachtelte Datenstrukturen enthält, werden diese mithilfe einer Klasse ausgedrückt, die bei der Instanziierung ihre eigenen Schlüsselwortargumente verwendet. Das gleiche Muster wird auf andere Methodenaufrufen angewendet, die ein strukturiertes Argument verwenden.
In der `add_lifecycle_rule` Methode eines Amazon S3 S3-Buckets ist die `transitions` Eigenschaft beispielsweise eine Liste von `Transition` Instances.
```
bucket.add_lifecycle_rule(
transitions=[
Transition(
storage_class=StorageClass.GLACIER,
transition_after=Duration.days(10)
)
]
)
```
Wenn Sie eine Klasse erweitern oder eine Methode überschreiben, möchten Sie möglicherweise zusätzliche Argumente für Ihre eigenen Zwecke akzeptieren, die von der übergeordneten Klasse nicht verstanden werden. In diesem Fall sollten Sie die Argumente, die Ihnen egal sind, mit dem \$1\$1kwargs-Idiom akzeptieren und Argumente verwenden, die nur Stichwörter enthalten, um die Argumente zu akzeptieren, an denen Sie interessiert sind. Wenn Sie den Konstruktor des übergeordneten Elements oder die überschriebene Methode aufrufen, übergeben Sie nur die Argumente, die das Objekt erwartet (oft nur\$1\$1kwargs). Die Übergabe von Argumenten, die die übergeordnete Klasse oder Methode nicht erwartet, führt zu einem Fehler.
```
class MyConstruct(Construct):
def __init__(self, id, *, MyProperty=42, **kwargs):
super().__init__(self, id, **kwargs)
# ...
```
Eine future Version des AWS CDK könnte zufällig eine neue Immobilie mit einem Namen hinzufügen, den Sie für Ihre eigene Immobilie verwendet haben. Dies wird zwar keine technischen Probleme für Benutzer Ihres Konstrukts oder Ihrer Methode verursachen (da Ihre Eigenschaft nicht „in der Kette“ weitergereicht wird, verwendet die übergeordnete Klasse oder überschriebene Methode einfach einen Standardwert), aber es kann zu Verwirrung führen. Sie können dieses potenzielle Problem vermeiden, indem Sie Ihre Eigenschaften so benennen, dass sie eindeutig zu Ihrem Konstrukt gehören. Wenn es viele neue Eigenschaften gibt, bündeln Sie sie in einer Klasse mit dem entsprechenden Namen und übergeben Sie sie als einzelnes Schlüsselwortargument.
### Fehlende Werte
Das AWS CDK wird verwendet, `None` um fehlende oder undefinierte Werte darzustellen. Wenn Sie mit\$1\$1kwargs arbeiten, verwenden Sie die `get()` Methode des Wörterbuchs, um einen Standardwert anzugeben, falls eine Eigenschaft nicht angegeben wird. Vermeiden Sie die Verwendung`kwargs[…]`, da dies auf fehlende Werte zurückzuführen `KeyError` ist.
```
encrypted = kwargs.get("encrypted") # None if no property "encrypted" exists
encrypted = kwargs.get("encrypted", False) # specify default of False if property is missing
```
Einige AWS CDK-Methoden (z. B. `tryGetContext()` zum Abrufen eines Laufzeitkontextwerts) geben möglicherweise einen Wert zurück`None`, den Sie explizit überprüfen müssen.
### Verwenden von Schnittstellen
Python hat keine Schnittstellenfunktion wie einige andere Sprachen, obwohl es [abstrakte Basisklassen](https://docs.python.org/3/library/abc.html) hat, die ähnlich sind. (Wenn Sie mit Schnittstellen nicht vertraut sind, hat Wikipedia [eine gute Einführung](https://en.wikipedia.org/wiki/Interface_(computing)#In_object-oriented_languages).) TypeScript, die Sprache, in der das AWS CDK implementiert ist, stellt Schnittstellen bereit, und Konstrukte und andere AWS CDK-Objekte erfordern oft ein Objekt, das sich an eine bestimmte Schnittstelle hält, anstatt es von einer bestimmten Klasse zu erben. [Das AWS CDK bietet also eine eigene Schnittstellenfunktion als Teil der JSII-Schicht.](https://github.com/aws/jsii)
Um anzugeben, dass eine Klasse eine bestimmte Schnittstelle implementiert, können Sie den Decorator verwenden: `@jsii.implements`
```
from aws_cdk import IAspect, IConstruct
import jsii
@jsii.implements(IAspect)
class MyAspect():
def visit(self, node: IConstruct) -> None:
print("Visited", node.node.path)
```
### Geben Sie Fallstricke ein
Python verwendet dynamische Typisierung, bei der sich alle Variablen auf einen Wert beliebigen Typs beziehen können. Parameter und Rückgabewerte können mit Typen annotiert werden, aber das sind „Hinweise“ und werden nicht erzwungen. Das bedeutet, dass es in Python einfach ist, den falschen Wertetyp an ein AWS CDK-Konstrukt zu übergeben. Anstatt beim Build einen Typfehler zu erhalten, wie Sie es bei einer statisch typisierten Sprache tun würden, erhalten Sie möglicherweise einen Laufzeitfehler, wenn die JSII-Schicht (die zwischen Python und dem TypeScript Kern des AWS CDK übersetzt) den unerwarteten Typ nicht verarbeiten kann.
Unserer Erfahrung nach fallen die Typfehler, die Python-Programmierer machen, in diese Kategorien.
+ Übergeben eines einzelnen Werts, wenn ein Konstrukt einen Container erwartet (Python-Liste oder Wörterbuch) oder umgekehrt.
+ Übergabe eines Werts eines Typs, der mit einem Layer-1-Konstrukt (`CfnXxxxxx`) verknüpft ist, an ein L2- oder L3-Konstrukt oder umgekehrt.
## Vermeidung von Typfehlern
Die AWS-CDK-Python-Module enthalten Typanmerkungen, sodass Sie Tools verwenden können, die sie unterstützen, um Typfehler vor der Bereitstellung zu erkennen.
### IDE-Integration (empfohlen)
Visual Studio Code with Pylance bietet eine Typüberprüfung in Echtzeit, während Sie Code schreiben:
1. Installieren Sie die [Pylance-Erweiterung](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
1. Konfigurieren Sie das strikte Einchecken von Typen: `.vscode/settings.json`
```
{
"python.languageServer": "Pylance",
"python.analysis.typeCheckingMode": "strict"
}
```
1. Tippfehler werden jetzt sofort mit roten Schnörkeln und detaillierten Fehlermeldungen angezeigt
[PyCharm](https://www.jetbrains.com/pycharm/)bietet auch eine integrierte Typprüfung mit ähnlichen Funktionen.
### Typüberprüfung in der Befehlszeile
Verwenden Sie für CI/CD Pipelines oder die Validierung vor dem Commit einen der folgenden Typprüfer:
**MyPy (Python-basiert):**
```
pip install mypy
mypy app.py
```
**Pyright (schneller, JavaScript basiert, dieselbe Engine wie Pylance):**
```
npm install -g pyright
pyright app.py
```
### Empfohlener Workflow
1. Während der Entwicklung: Verwenden Sie Pyright oder Pylance für sofortiges Feedback
1. Vor dem Commit: Führen Sie aus oder `mypy app.py` `pyright app.py`
1. In CI/CD: Machen Sie die Typprüfung vor der Bereitstellung zu einem erforderlichen Schritt
# Arbeiten mit dem AWS CDK in Java
Java ist eine vollständig unterstützte Client-Sprache für das AWS CDK und gilt als stabil. Sie können AWS CDK-Anwendungen in Java mit vertrauten Tools entwickeln, darunter das JDK (das von Oracle oder eine OpenJDK-Distribution wie Amazon Corretto) und Apache Maven.
Das AWS CDK unterstützt Java 8 und höher. Wir empfehlen jedoch, die neueste Version zu verwenden, da spätere Versionen der Sprache Verbesserungen enthalten, die sich besonders für die Entwicklung von AWS CDK-Anwendungen eignen. Zum Beispiel führt Java 9 die `Map.of()` Methode ein (eine bequeme Möglichkeit, Hashmaps zu deklarieren, die als Objektliterale geschrieben würden). TypeScript Java 10 führt die Inferenz lokaler Typen mithilfe des Schlüsselworts ein. `var`
**Anmerkung**
Die meisten Codebeispiele in diesem Entwicklerhandbuch funktionieren mit Java 8. Einige Beispiele verwenden`Map.of()`; diese Beispiele enthalten Kommentare, in denen darauf hingewiesen wird, dass sie Java 9 benötigen.
Sie können einen beliebigen Texteditor oder eine Java-IDE verwenden, die Maven-Projekte lesen kann, um an Ihren AWS CDK-Apps zu arbeiten. In diesem Handbuch finden Sie Hinweise zu [Eclipse](https://www.eclipse.org/downloads/), aber IntelliJ IDEA und andere IDEs können Maven-Projekte importieren und für die Entwicklung von AWS CDK-Anwendungen in Java verwendet werden. NetBeans
Es ist möglich, AWS CDK-Anwendungen in anderen von JVM gehosteten Sprachen als Java zu schreiben (z. B. Kotlin, Groovy, Clojure oder Scala), aber die Erfahrung ist möglicherweise nicht besonders idiomatisch, und wir können keinen Support für diese Sprachen anbieten.
## Fangen Sie mit Java an
Um mit dem AWS CDK arbeiten zu können, müssen Sie über ein AWS Konto und Anmeldeinformationen verfügen und Node.js und das AWS CDK Toolkit installiert haben. Siehe [Erste Schritte mit dem CDK](getting-started.md). AWS
AWS Java-CDK-Anwendungen benötigen Java 8 (v1.8) oder höher. [Wir empfehlen [Amazon Corretto](https://aws.amazon.com/corretto/), aber Sie können jede OpenJDK-Distribution oder das JDK von Oracle verwenden.](https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html) Sie benötigen außerdem [Apache](https://maven.apache.org/download.cgi) Maven 3.5 oder höher. Sie können auch Tools wie Gradle verwenden, aber die vom AWS CDK Toolkit generierten Anwendungs-Skeletons sind Maven-Projekte.
**Anmerkung**
Veraltete Sprachversion von Drittanbietern: Die Sprachversion wird nur bis zu ihrem vom Anbieter oder der Community mitgeteilten EOL (End Of Life) unterstützt und kann sich mit vorheriger Ankündigung ändern.
## Erstellen eines Projekts
Sie erstellen ein neues AWS CDK-Projekt, indem Sie es in einem leeren Verzeichnis aufrufen`cdk init`. Verwenden Sie die `--language` Option und geben Sie an: `java`
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language java
```
`cdk init`verwendet den Namen des Projektordners, um verschiedene Elemente des Projekts zu benennen, einschließlich Klassen, Unterordnern und Dateien. Bindestriche im Ordnernamen werden in Unterstriche umgewandelt. Ansonsten sollte der Name jedoch die Form eines Java-Bezeichners haben; er sollte beispielsweise nicht mit einer Zahl beginnen oder Leerzeichen enthalten.
Das daraus resultierende Projekt enthält einen Verweis auf das `software.amazon.awscdk` Maven-Paket. Es und seine Abhängigkeiten werden automatisch von Maven installiert.
Wenn Sie eine IDE verwenden, können Sie das Projekt jetzt öffnen oder importieren. Wählen Sie in Eclipse beispielsweise „**Datei**“ > „**Importieren**“ > „**Maven**“ > „**Bestehende Maven-Projekte**“. Stellen Sie sicher, dass die Projekteinstellungen so eingestellt sind, dass sie Java 8 (1.8) verwenden.
## Module der AWS Construct Library verwalten
Verwenden Sie Maven, um AWS Construct Library-Pakete zu installieren, die sich in der Gruppe `software.amazon.awscdk` befinden. Die meisten Konstrukte befinden sich im Artefakt`aws-cdk-lib`, das standardmäßig zu neuen Java-Projekten hinzugefügt wird. Module für Dienste, deren CDK-Unterstützung auf höherer Ebene noch in der Entwicklung ist, befinden sich in separaten „experimentellen“ Paketen, die mit einer Kurzversion (kein AWS oder Amazon-Präfix) des Namens ihres Dienstes benannt sind. [Suchen Sie im Maven Central Repository](https://search.maven.org/search?q=software.amazon.awscdk) nach den Namen aller AWS CDK- und Construct-Modulbibliotheken. AWS
**Anmerkung**
Die [Java-Ausgabe der CDK API Reference](https://docs.aws.amazon.com/cdk/api/v2/java/index.html) zeigt auch die Paketnamen.
Die AWS Construct Library-Unterstützung einiger Dienste erfolgt in mehr als einem Namespace. Die Funktionalität von Amazon Route 53 ist beispielsweise in`software.amazon.awscdk.route53`, `route53-patterns``route53resolver`, und unterteilt`route53-targets`.
Das AWS CDK-Hauptpaket wird im Java-Code als `software.amazon.awscdk` importiert. Module für die verschiedenen Dienste in der AWS Construct-Bibliothek befinden sich unter `software.amazon.awscdk.services` und sind ähnlich ihrem Maven-Paketnamen benannt. Der Namespace des Amazon S3 S3-Moduls lautet `software.amazon.awscdk.services.s3` beispielsweise.
Wir empfehlen, für jede AWS Construct Library-Klasse, die Sie in jeder Ihrer Java-Quelldateien verwenden, eine separate `import` Java-Anweisung zu schreiben und Platzhalter-Importe zu vermeiden. Sie können immer den vollständig qualifizierten Namen eines Typs (einschließlich seines Namespace) ohne Anweisung verwenden. `import`
Wenn Ihre Anwendung von einem experimentellen Paket abhängt, bearbeiten Sie das Ihres Projekts `pom.xml` und fügen Sie dem `` Container ein neues `` Element hinzu. Das folgende `` Element spezifiziert beispielsweise das Bibliotheksmodul für CodeStar experimentelle Konstrukte:
```
software.amazon.awscdkcodestar-alpha2.0.0-alpha.10
```
**Tipp**
Wenn Sie eine Java-IDE verwenden, verfügt sie wahrscheinlich über Funktionen zur Verwaltung von Maven-Abhängigkeiten. Wir empfehlen jedoch, `pom.xml` direkt zu bearbeiten, es sei denn, Sie sind sich absolut sicher, dass die Funktionalität der IDE mit dem übereinstimmt, was Sie von Hand tun würden.
## Verwaltung von Abhängigkeiten in Java
In Java werden Abhängigkeiten in Maven spezifiziert `pom.xml` und installiert. Der `` Container enthält ein `` Element für jedes Paket. Im Folgenden finden Sie einen Abschnitt `pom.xml` für eine typische CDK-Java-App.
```
software.amazon.awscdkaws-cdk-lib2.14.0software.amazon.awscdkappsync-alpha2.10.0-alpha.0
```
**Tipp**
In vielen IDEs Java-Versionen sind Maven-Unterstützung und visuelle `pom.xml` Editoren integriert, die Sie möglicherweise für die Verwaltung von Abhängigkeiten als praktisch erachten.
Maven unterstützt das Sperren von Abhängigkeiten nicht. Es ist zwar möglich, Versionsbereiche anzugeben`pom.xml`, wir empfehlen jedoch, immer exakte Versionen zu verwenden, damit Ihre Builds wiederholbar bleiben.
Maven installiert automatisch transitive Abhängigkeiten, aber von jedem Paket kann nur eine Kopie installiert sein. Die Version, die im POM-Baum am höchsten angegeben ist, wird ausgewählt. Anwendungen haben immer das letzte Wort darüber, welche Version von Paketen installiert wird.
Maven installiert oder aktualisiert Ihre Abhängigkeiten automatisch, wann immer Sie Ihr Projekt erstellen (`mvn compile`) oder verpacken (`mvn package`). Das CDK Toolkit macht dies automatisch bei jeder Ausführung, sodass es im Allgemeinen nicht notwendig ist, Maven manuell aufzurufen.
## AWS CDK-Idiome in Java
### Props
Alle AWS Construct-Library-Klassen werden mit drei Argumenten instanziiert: dem *Bereich*, in dem das Konstrukt definiert wird (sein übergeordnetes Objekt im Konstruktbaum), einer *ID* und *props*, einem Bündel von key/value Paaren, das das Konstrukt verwendet, um die von ihm erstellten Ressourcen zu konfigurieren. Andere Klassen und Methoden verwenden ebenfalls das Muster „Bündel von Attributen“ für Argumente.
In Java werden Requisiten mit dem [Builder-Muster](https://en.wikipedia.org/wiki/Builder_pattern) ausgedrückt. Jeder Konstrukttyp hat einen entsprechenden Requisitentyp. Beispielsweise verwendet das `Bucket` Konstrukt (das einen Amazon S3 S3-Bucket darstellt) als Requisiten eine Instanz von. `BucketProps`
Die `BucketProps` Klasse hat (wie jede Requisitenklasse der AWS Construct Library) eine innere Klasse namens. `Builder` Der `BucketProps.Builder` Typ bietet Methoden, um die verschiedenen Eigenschaften einer `BucketProps` Instanz festzulegen. Jede Methode gibt die `Builder` Instanz zurück, sodass die Methodenaufrufen verkettet werden können, um mehrere Eigenschaften festzulegen. Am Ende der Kette rufen Sie auf, `build()` um das `BucketProps` Objekt tatsächlich zu erzeugen.
```
Bucket bucket = new Bucket(this, "amzn-s3-demo-bucket", new BucketProps.Builder()
.versioned(true)
.encryption(BucketEncryption.KMS_MANAGED)
.build());
```
Konstrukte und andere Klassen, deren letztes Argument ein Objekt ist, das an Requisiten erinnert, bieten eine Abkürzung. Die Klasse hat eine eigene, `Builder` die sie und ihr Props-Objekt in einem Schritt instanziiert. Auf diese Weise müssen Sie nicht explizit (zum Beispiel) sowohl als auch ein `Bucket` --instanziieren `BucketProps` und Sie benötigen auch keinen Import für den Typ Requisiten.
```
Bucket bucket = Bucket.Builder.create(this, "amzn-s3-demo-bucket")
.versioned(true)
.encryption(BucketEncryption.KMS_MANAGED)
.build();
```
Wenn Sie Ihr eigenes Konstrukt aus einem vorhandenen Konstrukt ableiten, möchten Sie möglicherweise zusätzliche Eigenschaften akzeptieren. Wir empfehlen Ihnen, diese Builder-Muster zu befolgen. Dies ist jedoch nicht so einfach wie die Unterteilung einer Konstruktklasse. Sie müssen die beweglichen Teile der beiden neuen `Builder` Klassen selbst bereitstellen. Möglicherweise ziehen Sie es vor, dass Ihr Konstrukt einfach ein oder mehrere zusätzliche Argumente akzeptiert. Sie sollten zusätzliche Konstruktoren angeben, wenn ein Argument optional ist.
### Generische Strukturen
In einigen APIs Fällen verwendet das AWS CDK JavaScript Arrays oder untypisierte Objekte als Eingabe für eine Methode. (Siehe zum Beispiel die Methode.) AWS CodeBuild [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild.BuildSpec.html#static-fromwbrobjectvalue](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild.BuildSpec.html#static-fromwbrobjectvalue) In Java werden diese Objekte dargestellt als`java.util.Map`. In Fällen, in denen es sich bei den Werten ausschließlich um Zeichenketten handelt, können Sie Folgendes verwenden`Map`.
Java bietet keine Möglichkeit, Literale für solche Container zu schreiben, wie dies in einigen anderen Sprachen der Fall ist. In Java 9 und höher können Sie [https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-](https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-)damit bequem Zuordnungen mit bis zu zehn Einträgen innerhalb eines dieser Aufrufe definieren.
```
java.util.Map.of(
"base-directory", "dist",
"files", "LambdaStack.template.json"
)
```
Um Karten mit mehr als zehn Einträgen zu erstellen, verwenden Sie [https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-](https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-).
Wenn Sie Java 8 verwenden, könnten Sie Ihre eigenen Methoden bereitstellen, die diesen ähneln.
JavaScript Arrays werden `List` in Java als `List