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.
# Erste Schritte mit dem CDK AWS
Beginnen Sie mit dem AWS Cloud Development Kit (AWS CDK), indem Sie das CDK Command Line Interface ( AWS AWS CDK CLI) installieren und konfigurieren. Verwenden Sie dann die CDK-CLI, um Ihre erste CDK-App zu erstellen, Ihre AWS Umgebung zu booten und Ihre Anwendung bereitzustellen.
## Voraussetzungen
Bevor Sie mit dem AWS CDK beginnen, müssen Sie alle Voraussetzungen erfüllen. Diese Voraussetzungen sind für diejenigen erforderlich, die neu AWS oder neu in der Programmierung sind. Anweisungen finden Sie unter [AWS CDK-Voraussetzungen](prerequisites.md).
Wir empfehlen, dass Sie ein grundlegendes Verständnis davon haben, was das AWS CDK ist. Weitere Informationen finden Sie unter [Was ist das AWS CDK](home.md)? und [lernen Sie die Kernkonzepte von AWS CDK](core-concepts.md) kennen.
## Installieren Sie die AWS CDK-CLI
Verwenden Sie den Node Package Manager, um die CDK-CLI zu installieren. Wir empfehlen, es global mit dem folgenden Befehl zu installieren:
```
$ npm install -g aws-cdk
```
Verwenden Sie die folgende Befehlsstruktur, um eine bestimmte Version der CDK-CLI zu installieren:
```
$ npm install -g aws-cdk@X.YY.Z
```
Wenn Sie mehrere Versionen des AWS CDK verwenden möchten, sollten Sie erwägen, eine passende Version der CDK-CLI in einzelnen CDK-Projekten zu installieren. Entfernen Sie dazu die `-g` Option aus dem Befehl. `npm install` Verwenden Sie dann, `npx aws-cdk` um die CDK-CLI aufzurufen. Dadurch wird eine lokale Version ausgeführt, falls sie existiert. Andernfalls wird die global installierte Version verwendet.
**Problembehandlung bei einer CDK-CLI-Installation**
Wenn Sie einen Berechtigungsfehler erhalten und Administratorzugriff auf Ihr System haben, führen Sie Folgendes aus:
```
$ sudo npm install -g aws-cdk
```
Wenn Sie eine Fehlermeldung erhalten, versuchen Sie, die CDK-CLI zu deinstallieren, indem Sie Folgendes ausführen:
```
$ npm uninstall -g aws-cdk
```
Wiederholen Sie dann die Schritte, um die CDK-CLI neu zu installieren.
## Überprüfen Sie eine erfolgreiche CDK-CLI-Installation
Führen Sie den folgenden Befehl aus, um eine erfolgreiche Installation zu überprüfen. Die AWS CDK-CLI sollte die Versionsnummer ausgeben:
```
$ cdk --version
```
## AWS CDK-CLI konfigurieren
Nach der Installation der CDK-CLI können Sie damit beginnen, Anwendungen auf Ihrem lokalen Computer zu entwickeln. Für die Interaktion AWS, z. B. die Bereitstellung von Anwendungen, müssen auf Ihrem lokalen Computer Sicherheitsanmeldedaten konfiguriert sein, mit denen Sie alle von Ihnen initiierten Aktionen ausführen können.
Um Sicherheitsanmeldeinformationen auf Ihrem lokalen Computer zu konfigurieren, verwenden Sie die AWS CLI. Wie Sie Sicherheitsanmeldedaten konfigurieren, hängt davon ab, wie Sie Benutzer verwalten. Anweisungen finden Sie unter [Authentifizierungs- und Zugangsdaten](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html) im *Benutzerhandbuch für die AWS Befehlszeilenschnittstelle*.
Die CDK-CLI verwendet automatisch die Sicherheitsanmeldedaten, die Sie mit der AWS CLI konfigurieren. Wenn Sie beispielsweise ein IAM Identity Center-Benutzer sind, können Sie den `aws configure sso` Befehl verwenden, um Sicherheitsanmeldeinformationen zu konfigurieren. Wenn Sie ein IAM-Benutzer sind, können Sie den `aws configure` Befehl verwenden. Die AWS CLI führt Sie durch die Konfiguration der Sicherheitsanmeldedaten auf Ihrem lokalen Computer und speichert die erforderlichen Informationen in Ihren `credentials` Dateien `config` und Dateien. Wenn Sie dann die CDK-CLI verwenden, z. B. eine Anwendung mit bereitstellen`cdk deploy`, verwendet die CDK-CLI Ihre konfigurierten Sicherheitsanmeldeinformationen.
Genau wie die AWS CLI verwendet die CDK-CLI standardmäßig Ihr `default` Profil. Sie können ein Profil mit der [`--profile`](ref-cli-cmd.md#ref-cli-cmd-options-profile)CDK-CLI-Option angeben. Weitere Informationen zur Verwendung von Sicherheitsanmeldedaten mit der CDK-CLI finden [Sie unter Sicherheitsanmeldedaten für die AWS CDK-CLI konfigurieren](configure-access.md).
## (Optional) Installieren Sie zusätzliche CDK-Tools AWS
Das [AWS Toolkit for Visual Studio Code](https://aws.amazon.com/visualstudiocode/) ist ein Open-Source-Plug-InVisual Studio Code, mit dem Sie Anwendungen erstellen, debuggen und bereitstellen können. AWS Das Toolkit bietet ein integriertes Erlebnis für die Entwicklung AWS von CDK-Anwendungen. Es enthält die AWS CDK Explorer-Funktion, mit der Sie Ihre AWS CDK-Projekte auflisten und die verschiedenen Komponenten der CDK-Anwendung durchsuchen können. Detaillierte Informationen finden Sie hier:
+ [Installation des AWS Toolkit for Visual Studio Code.](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/setup-toolkit.html)
+ [AWS CDK für VS Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/cdk-explorer.html).
## Erstelle deine erste CDK-App
Sie sind jetzt bereit, mit der Verwendung des AWS CDK zu beginnen, indem Sie Ihre erste CDK-App erstellen. Eine Anleitung findest du unter [Tutorial: Erstelle deine erste AWS CDK-App](hello-world.md).
# Tutorial: Erstelle deine erste AWS CDK-App
Beginnen Sie mit der Verwendung des AWS Cloud Development Kit (AWS CDK), indem Sie die AWS CDK-Befehlszeilenschnittstelle (AWS CDK CLI) verwenden, um Ihre erste CDK-App zu entwickeln, Ihre AWS Umgebung zu booten und Ihre Anwendung darauf bereitzustellen. AWS
## Voraussetzungen
Bevor Sie mit diesem Tutorial beginnen, führen Sie alle Einrichtungsschritte unter [Erste](getting-started.md) Schritte mit dem CDK durch. AWS
## Über dieses Tutorial
In diesem Tutorial werden Sie AWS mithilfe des AWS CDK eine einfache Anwendung erstellen und bereitstellen. Die Anwendung besteht aus einer [AWS Lambda-Funktion](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html), die beim Aufruf eine `Hello World!` Nachricht zurückgibt. Die Funktion wird über eine [Lambda-Funktions-URL](https://docs.aws.amazon.com/lambda/latest/dg/lambda-urls.html) aufgerufen, die als dedizierter HTTP (S) -Endpunkt für Ihre Lambda-Funktion dient.
In diesem Tutorial werden Sie Folgendes ausführen:
+ **Erstellen Sie Ihr Projekt** — Erstellen Sie ein CDK-Projekt mit dem `cdk init` CDK-CLI-Befehl.
+ **Konfiguration Ihrer AWS Umgebung** — Konfigurieren Sie die AWS Umgebung, in der Sie Ihre Anwendung bereitstellen werden.
+ **Bootstrap für Ihre AWS Umgebung** — Bereiten Sie Ihre AWS Umgebung für die Bereitstellung vor, indem Sie sie mit dem CDK-CLI-Befehl bootstrappen. `cdk bootstrap`
+ **Entwickeln Sie Ihre App** — Verwenden Sie Konstrukte aus der AWS Construct-Bibliothek, um Ihre Lambda-Funktions- und Lambda-Funktions-URL-Ressourcen zu definieren.
+ **Bereiten Sie Ihre App für die Bereitstellung** vor — Verwenden Sie die CDK-CLI, um Ihre App zu erstellen und eine AWS CloudFormation Vorlage zu synthetisieren.
+ **Stellen Sie Ihre App** bereit — Verwenden Sie den `cdk deploy` CDK-CLI-Befehl, um Ihre Anwendung bereitzustellen und Ihre AWS Ressourcen bereitzustellen.
+ **Interagieren Sie mit Ihrer Anwendung** — Interagieren Sie mit Ihrer bereitgestellten Lambda-Funktion, AWS indem Sie sie aufrufen und eine Antwort erhalten.
+ **Ändern Sie Ihre App** — Ändern Sie Ihre Lambda-Funktion und stellen Sie sie bereit, um Ihre Änderungen zu implementieren.
+ **App löschen** — Löscht alle Ressourcen, die Sie mit dem `cdk destroy` CDK-CLI-Befehl erstellt haben.
## Schritt 1: Erstellen Sie Ihr CDK-Projekt
In diesem Schritt erstellen Sie ein neues CDK-Projekt. Ein CDK-Projekt sollte sich in einem eigenen Verzeichnis mit eigenen lokalen Modulabhängigkeiten befinden.
**Um ein CDK-Projekt zu erstellen**
1. Erstellen Sie von einem Startverzeichnis Ihrer Wahl aus ein Verzeichnis mit dem Namen`hello-cdk`:
```
$ mkdir hello-cdk && cd hello-cdk
```
**Wichtig**
Achten Sie darauf, dass Sie Ihr Projektverzeichnis *genau so benennen`hello-cdk`, wie hier gezeigt*. Die CDK-CLI verwendet diesen Verzeichnisnamen, um Dinge in Ihrem CDK-Code zu benennen. Wenn Sie einen anderen Verzeichnisnamen verwenden, werden Sie in diesem Tutorial auf Probleme stoßen.
1. Initialisieren Sie im `hello-cdk` Verzeichnis ein neues CDK-Projekt mit dem CDK-CLI-Befehl. `cdk init` Geben Sie die `app` Vorlage und Ihre bevorzugte Programmiersprache mit der Option an: `--language`
**Example**
------
#### [ TypeScript ]
```
$ cdk init app --language typescript
```
------
#### [ JavaScript ]
```
$ cdk init app --language javascript
```
------
#### [ Python ]
```
$ cdk init app --language python
```
Nachdem die App erstellt wurde, geben Sie auch die folgenden beiden Befehle ein. Diese aktivieren die virtuelle Python-Umgebung der App und installieren die AWS CDK-Kernabhängigkeiten.
```
$ source .venv/bin/activate # On Windows, run `.\venv\Scripts\activate` instead
$ python -m pip install -r requirements.txt
```
------
#### [ Java ]
```
$ cdk init app --language java
```
Wenn Sie eine IDE verwenden, können Sie das Projekt jetzt öffnen oder importieren. Wählen Sie Eclipse beispielsweise „**Datei**“ > „**Importieren“ > „**Maven**“** > „**Bestehende Maven-Projekte**“. Stellen Sie sicher, dass die Projekteinstellungen so eingestellt sind, dass sie Java 8 (1.8) verwenden.
------
#### [ C\$1 ]
```
$ cdk init app --language csharp
```
Wenn Sie Visual Studio verwenden, öffnen Sie die Lösungsdatei im `src` Verzeichnis.
------
#### [ Go ]
```
$ cdk init app --language go
```
Geben Sie nach der Erstellung der App auch den folgenden Befehl ein, um die AWS Construct Library-Module zu installieren, die die App benötigt.
```
$ go get
```
------
Der `cdk init` Befehl erstellt eine Struktur von Dateien und Ordnern innerhalb des `hello-cdk` Verzeichnisses, um den Quellcode für Ihre CDK-App zu organisieren. *Diese Struktur von Dateien und Ordnern wird Ihr CDK-Projekt genannt.* Nehmen Sie sich einen Moment Zeit, um Ihr CDK-Projekt zu erkunden.
Wenn Sie es Git installiert haben, `cdk init` wird jedes Projekt, mit dem Sie erstellen, auch als Git Repository initialisiert.
Während der Projektinitialisierung erstellt die CDK-CLI eine CDK-App, die einen einzelnen CDK-Stack enthält. Die CDK-App-Instanz wird mit dem Konstrukt erstellt. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html) Im Folgenden finden Sie einen Teil dieses Codes aus Ihrer CDK-Anwendungsdatei:
**Example**
Befindet sich in`bin/hello-cdk.ts`:
```
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
});
```
Befindet sich in`bin/hello-cdk.js`:
```
#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { HelloCdkStack } = require('../lib/hello-cdk-stack');
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
});
```
Befindet sich in`app.py`:
```
#!/usr/bin/env python3
import os
import aws_cdk as cdk
from hello_cdk.hello_cdk_stack import HelloCdkStack
app = cdk.App()
HelloCdkStack(app, "HelloCdkStack",)
app.synth()
```
Befindet sich in`src/main/java/…/HelloCdkApp.java`:
```
package com.myorg;
import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;
import java.util.Arrays;
public class HelloCdkApp {
public static void main(final String[] args) {
App app = new App();
new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
.build());
app.synth();
}
}
```
Befindet sich in`src/HelloCdk/Program.cs`:
```
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;
namespace HelloCdk
{
sealed class Program
{
public static void Main(string[] args)
{
var app = new App();
new HelloCdkStack(app, "HelloCdkStack", new StackProps
{});
app.Synth();
}
}
}
```
Befindet sich in`hello-cdk.go`:
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
)
// ...
func main() {
defer jsii.Close()
app := awscdk.NewApp(nil)
NewHelloCdkStack(app, "HelloCdkStack", &HelloCdkStackProps{
awscdk.StackProps{
Env: env(),
},
})
app.Synth(nil)
}
// ...
```
Der CDK-Stack wird mit dem [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html)Konstrukt erstellt. Im Folgenden finden Sie einen Teil dieses Codes aus Ihrer CDK-Stack-Datei:
**Example**
Befindet sich in`lib/hello-cdk-stack.ts`:
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define your constructs here
}
}
```
Befindet sich in`lib/hello-cdk-stack.js`:
```
const { Stack } = require('aws-cdk-lib');
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define your constructs here
}
}
module.exports = { HelloCdkStack }
```
Befindet sich in`hello_cdk/hello_cdk_stack.py`:
```
from aws_cdk import (
Stack,
)
from constructs import Construct
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define your constructs here
```
Befindet sich in`src/main/java/…/HelloCdkStack.java`:
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
public class HelloCdkStack extends Stack {
public HelloCdkStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Define your constructs here
}
}
```
Befindet sich in`src/HelloCdk/HelloCdkStack.cs`:
```
using Amazon.CDK;
using Constructs;
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define your constructs here
}
}
}
```
Befindet sich in`hello-cdk.go`:
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
)
type HelloCdkStackProps struct {
awscdk.StackProps
}
func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
return stack
}
// ...
```
## Schritt 2: Konfigurieren Sie Ihre AWS Umgebung
In diesem Schritt konfigurieren Sie die AWS Umgebung für Ihren CDK-Stack. Auf diese Weise geben Sie an, in welcher Umgebung Ihr CDK-Stack bereitgestellt wird.
Bestimmen Sie zunächst die AWS Umgebung, die Sie verwenden möchten. Eine AWS Umgebung besteht aus einem AWS Konto und einer AWS Region.
Wenn Sie die AWS CLI verwenden, um Sicherheitsanmeldeinformationen auf Ihrem lokalen Computer zu konfigurieren, können Sie dann die AWS CLI verwenden, um AWS Umgebungsinformationen für ein bestimmtes Profil abzurufen.
**So verwenden Sie die AWS CLI, um Ihre AWS Konto-ID abzurufen**
1. Führen Sie den folgenden AWS CLI-Befehl aus, um die AWS Konto-ID für Ihr `default` Profil abzurufen:
```
$ aws sts get-caller-identity --query "Account" --output text
```
1. Wenn Sie lieber ein benanntes Profil verwenden möchten, geben Sie den Namen Ihres Profils mit der `--profile` Option an:
```
$ aws sts get-caller-identity --profile your-profile-name --query "Account" --output text
```
**So verwenden Sie die AWS CLI, um Ihre AWS Region abzurufen**
1. Führen Sie den folgenden AWS CLI-Befehl aus, um die Region abzurufen, die Sie für Ihr `default` Profil konfiguriert haben:
```
$ aws configure get region
```
1. Wenn Sie lieber ein benanntes Profil verwenden möchten, geben Sie den Namen Ihres Profils mit der `--profile` Option an:
```
$ aws configure get region --profile your-profile-name
```
Als Nächstes konfigurieren Sie die AWS Umgebung für Ihren CDK-Stack, indem Sie die `HelloCdkStack` Instanz in Ihrer *Anwendungsdatei* ändern. Für dieses Tutorial werden Sie Ihre AWS Umgebungsinformationen fest codieren. Dies wird für Produktionsumgebungen nicht empfohlen. Informationen zu anderen Methoden zur Konfiguration von Umgebungen finden Sie unter [Umgebungen für die Verwendung mit dem AWS CDK konfigurieren](configure-env.md).
**So konfigurieren Sie die Umgebung für Ihren CDK-Stack**
1. Verwenden Sie in Ihrer *Anwendungsdatei* die `env` Eigenschaft des `Stack` Konstrukts, um Ihre Umgebung zu konfigurieren. Im Folgenden wird ein Beispiel gezeigt:
**Example**
------
#### [ TypeScript ]
Befindet sich in`bin/hello-cdk.ts`:
```
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
env: { account: '123456789012', region: 'us-east-1' },
});
```
------
#### [ JavaScript ]
Befindet sich in`bin/hello-cdk.js`:
```
#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { HelloCdkStack } = require('../lib/hello-cdk-stack');
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
env: { account: '123456789012', region: 'us-east-1' },
});
```
------
#### [ Python ]
Befindet sich in`app.py`:
```
#!/usr/bin/env python3
import os
import aws_cdk as cdk
from hello_cdk.hello_cdk_stack import HelloCdkStack
app = cdk.App()
HelloCdkStack(app, "HelloCdkStack",
env=cdk.Environment(account='123456789012', region='us-east-1'),
)
app.synth()
```
------
#### [ Java ]
Befindet sich in`src/main/java/…/HelloCdkApp.java`:
```
package com.myorg;
import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;
import java.util.Arrays;
public class HelloCdkApp {
public static void main(final String[] args) {
App app = new App();
new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
.env(Environment.builder()
.account("123456789012")
.region("us-east-1")
.build())
.build());
app.synth();
}
}
```
------
#### [ C\$1 ]
Befindet sich in`src/HelloCdk/Program.cs`:
```
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;
namespace HelloCdk
{
sealed class Program
{
public static void Main(string[] args)
{
var app = new App();
new HelloCdkStack(app, "HelloCdkStack", new StackProps
{
Env = new Amazon.CDK.Environment
{
Account = "123456789012",
Region = "us-east-1",
}
});
app.Synth();
}
}
}
```
------
#### [ Go ]
Befindet sich in`hello-cdk.go`:
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
)
// ...
func main() {
defer jsii.Close()
app := awscdk.NewApp(nil)
NewHelloCdkStack(app, "HelloCdkStack", &HelloCdkStackProps{
awscdk.StackProps{
Env: env(),
},
})
app.Synth(nil)
}
func env() *awscdk.Environment {
return &awscdk.Environment{
Account: jsii.String("123456789012"),
Region: jsii.String("us-east-1"),
}
}
```
------
## Schritt 3: Bootstrap für Ihre Umgebung AWS
In diesem Schritt booten Sie die AWS Umgebung, die Sie im vorherigen Schritt konfiguriert haben. Dadurch wird Ihre Umgebung auf CDK-Bereitstellungen vorbereitet.
Um Ihre Umgebung zu booten, führen Sie im Stammverzeichnis Ihres CDK-Projekts Folgendes aus:
```
$ cdk bootstrap
```
Wenn Sie das Bootstrapping vom Stammverzeichnis Ihres CDK-Projekts aus durchführen, müssen Sie keine zusätzlichen Informationen angeben. Die CDK-CLI bezieht Umgebungsinformationen aus Ihrem Projekt. Wenn Sie außerhalb eines CDK-Projekts booten, müssen Sie Umgebungsinformationen mit dem Befehl angeben. `cdk bootstrap` Weitere Informationen finden Sie unter [Bootstrap für Ihre Umgebung zur Verwendung mit dem CDK](bootstrapping-env.md). AWS
## Schritt 4: Erstellen Sie Ihre CDK-App
In den meisten Programmierumgebungen erstellen oder kompilieren Sie Code, nachdem Sie Änderungen vorgenommen haben. Dies ist beim AWS CDK nicht erforderlich, da die CDK-CLI diesen Schritt automatisch durchführt. Sie können jedoch immer noch manuell bauen, wenn Sie Syntax- und Typfehler abfangen möchten. Im Folgenden wird ein Beispiel gezeigt:
**Example**
```
$ npm run build
> hello-cdk@0.1.0 build
> tsc
```
Es ist kein Build-Schritt erforderlich.
Es ist kein Build-Schritt erforderlich.
```
$ mvn compile -q
```
Oder drücken Sie `Control-B` Eclipse (anderes Java IDEs kann variieren)
```
$ dotnet build src
```
Oder drücken Sie F6 in Visual Studio
```
$ go build
```
## Schritt 5: Listet die CDK-Stacks in eurer App auf
Zu diesem Zeitpunkt sollten Sie über eine CDK-App verfügen, die einen einzelnen CDK-Stack enthält. Verwenden Sie zur Überprüfung den `cdk list` CDK-CLI-Befehl, um Ihre Stacks anzuzeigen. Die Ausgabe sollte einen einzelnen Stack mit dem Namen anzeigen: `HelloCdkStack`
```
$ cdk list
HelloCdkStack
```
Wenn Sie diese Ausgabe nicht sehen, stellen Sie sicher, dass Sie sich im richtigen Arbeitsverzeichnis Ihres Projekts befinden, und versuchen Sie es erneut. Wenn Sie Ihren Stack immer noch nicht sehen, wiederholen Sie [Schritt 1: Erstellen Sie Ihr CDK-Projekt](#hello-world-create) und versuchen Sie es erneut.
## Schritt 6: Definieren Sie Ihre Lambda-Funktion
In diesem Schritt importieren Sie das [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)Modul aus der Construct-Bibliothek und verwenden das AWS [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)L2-Konstrukt.
Ändern Sie Ihre CDK-Stack-Datei wie folgt:
**Example**
Befindet sich in`lib/hello-cdk-stack.ts`:
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
// Import the Lambda module
import * as lambda from 'aws-cdk-lib/aws-lambda';
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
`),
});
}
}
```
Befindet sich in`lib/hello-cdk-stack.js`:
```
const { Stack } = require('aws-cdk-lib');
// Import the Lambda module
const lambda = require('aws-cdk-lib/aws-lambda');
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
`),
});
}
}
module.exports = { HelloCdkStack }
```
Befindet sich in`hello_cdk/hello_cdk_stack.py`:
```
from aws_cdk import (
Stack,
aws_lambda as _lambda, # Import the Lambda module
)
from constructs import Construct
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define the Lambda function resource
my_function = _lambda.Function(
self, "HelloWorldFunction",
runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
handler = "index.handler",
code = _lambda.Code.from_inline(
"""
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
"""
),
)
```
Befindet sich in`src/main/java/…/HelloCdkStack.java`:
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
// Import Lambda function
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;
public class HelloCdkStack extends Stack {
public HelloCdkStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Define the Lambda function resource
Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
.runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
.handler("index.handler")
.code(Code.fromInline(
"exports.handler = async function(event) {" +
" return {" +
" statusCode: 200," +
" body: JSON.stringify('Hello World!')" +
" };" +
"};"))
.build();
}
}
```
Befindet sich in`src/main/java/…/HelloCdkStack.java`:
```
using Amazon.CDK;
using Constructs;
// Import the Lambda module
using Amazon.CDK.AWS.Lambda;
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define the Lambda function resource
var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
{
Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
Handler = "index.handler",
Code = Code.FromInline(@"
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
"),
});
}
}
}
```
Befindet sich in`hello-cdk.go`:
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
// Import the Lambda module
"github.com/aws/aws-cdk-go/awscdk/v2/awslambda"
)
type HelloCdkStackProps struct {
awscdk.StackProps
}
func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
// Define the Lambda function resource
myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
Handler: jsii.String("index.handler"),
Code: awslambda.Code_FromInline(jsii.String(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
`)),
})
return stack
}
// ...
```
Schauen wir uns das `Function` Konstrukt genauer an. Wie alle Konstrukte benötigt die `Function` Klasse drei Parameter:
+ **scope** — Definiert Ihre `Stack` Instanz als übergeordnetes Objekt des `Function` Konstrukts. Alle Konstrukte, die AWS Ressourcen definieren, werden innerhalb des Gültigkeitsbereichs eines Stacks erstellt. Sie können Konstrukte innerhalb von Konstrukten definieren und so eine Hierarchie (Baum) erstellen. Hier und in den meisten Fällen ist der Geltungsbereich `this` (`self`in Python).
+ **Id** — Die Konstrukt-ID von `Function` in Ihrer AWS CDK-App. Diese ID sowie ein Hash, der auf der Position der Funktion innerhalb des Stacks basiert, identifizieren die Funktion während der Bereitstellung eindeutig. Das AWS CDK verweist auch auf diese ID, wenn Sie das Konstrukt in Ihrer App aktualisieren und erneut bereitstellen, um die bereitgestellte Ressource zu aktualisieren. Hier lautet Ihre Konstrukt-ID. `HelloWorldFunction` Funktionen können auch einen Namen haben, der mit der `functionName` Eigenschaft angegeben wird. Dies unterscheidet sich von der Konstrukt-ID.
+ **props** — Ein Bündel von Werten, die Eigenschaften der Funktion definieren. Hier definieren Sie die `code` Eigenschaften `runtime``handler`, und.
Requisiten werden in den vom AWS CDK unterstützten Sprachen unterschiedlich dargestellt.
+ In TypeScript und `props` steht für ein einzelnes Argument JavaScript, und Sie übergeben ein Objekt, das die gewünschten Eigenschaften enthält.
+ In Python werden Requisiten als Schlüsselwortargumente übergeben.
+ In Java wird ein Builder bereitgestellt, um die Requisiten zu übergeben. Es gibt zwei: einen dafür und einen zweiten`FunctionProps`, `Function` damit Sie das Konstrukt und das zugehörige Requisitenobjekt in einem Schritt erstellen können. Dieser Code verwendet Letzteres.
+ In C\$1 instanziieren Sie ein `FunctionProps` Objekt mithilfe eines Objektinitialisierers und übergeben es als dritten Parameter.
Wenn die Requisiten eines Konstrukts optional sind, können Sie den Parameter komplett weglassen. `props`
Alle Konstrukte verwenden dieselben drei Argumente, sodass Sie beim Kennenlernen neuer Argumente leicht den Überblick behalten können. Und wie Sie vielleicht erwarten, können Sie jedes Konstrukt in Unterklassen unterteilen, um es an Ihre Bedürfnisse anzupassen oder wenn Sie die Standardwerte ändern möchten.
## Schritt 7: Definieren Sie Ihre Lambda-Funktions-URL
In diesem Schritt verwenden Sie die `addFunctionUrl` Hilfsmethode des `Function` Konstrukts, um eine Lambda-Funktions-URL zu definieren. Um den Wert dieser URL bei der Bereitstellung auszugeben, erstellen Sie mithilfe des [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html)Konstrukts eine AWS CloudFormation Ausgabe.
Fügen Sie Ihrer CDK-Stack-Datei Folgendes hinzu:
**Example**
Befindet sich in`lib/hello-cdk-stack.ts`:
```
// ...
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
const myFunctionUrl = myFunction.addFunctionUrl({
authType: lambda.FunctionUrlAuthType.NONE,
});
// Define a CloudFormation output for your URL
new cdk.CfnOutput(this, "myFunctionUrlOutput", {
value: myFunctionUrl.url,
})
}
}
```
Befindet sich in`lib/hello-cdk-stack.js`:
```
const { Stack, CfnOutput } = require('aws-cdk-lib'); // Import CfnOutput
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
const myFunctionUrl = myFunction.addFunctionUrl({
authType: lambda.FunctionUrlAuthType.NONE,
});
// Define a CloudFormation output for your URL
new CfnOutput(this, "myFunctionUrlOutput", {
value: myFunctionUrl.url,
})
}
}
module.exports = { HelloCdkStack }
```
Befindet sich in`hello_cdk/hello_cdk_stack.py`:
```
from aws_cdk import (
# ...
CfnOutput # Import CfnOutput
)
from constructs import Construct
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define the Lambda function resource
# ...
# Define the Lambda function URL resource
my_function_url = my_function.add_function_url(
auth_type = _lambda.FunctionUrlAuthType.NONE,
)
# Define a CloudFormation output for your URL
CfnOutput(self, "myFunctionUrlOutput", value=my_function_url.url)
```
Befindet sich in`src/main/java/…/HelloCdkStack.java`:
```
package com.myorg;
// ...
// Import Lambda function URL
import software.amazon.awscdk.services.lambda.FunctionUrl;
import software.amazon.awscdk.services.lambda.FunctionUrlAuthType;
import software.amazon.awscdk.services.lambda.FunctionUrlOptions;
// Import CfnOutput
import software.amazon.awscdk.CfnOutput;
public class HelloCdkStack extends Stack {
public HelloCdkStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
FunctionUrl myFunctionUrl = myFunction.addFunctionUrl(FunctionUrlOptions.builder()
.authType(FunctionUrlAuthType.NONE)
.build());
// Define a CloudFormation output for your URL
CfnOutput.Builder.create(this, "myFunctionUrlOutput")
.value(myFunctionUrl.getUrl())
.build();
}
}
```
Befindet sich in`src/main/java/…/HelloCdkStack.java`:
```
// ...
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
var myFunctionUrl = myFunction.AddFunctionUrl(new FunctionUrlOptions
{
AuthType = FunctionUrlAuthType.NONE
});
// Define a CloudFormation output for your URL
new CfnOutput(this, "myFunctionUrlOutput", new CfnOutputProps
{
Value = myFunctionUrl.Url
});
}
}
}
```
Befindet sich in`hello-cdk.go`:
```
// ...
func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
myFunctionUrl := myFunction.AddFunctionUrl(&awslambda.FunctionUrlOptions{
AuthType: awslambda.FunctionUrlAuthType_NONE,
})
// Define a CloudFormation output for your URL
awscdk.NewCfnOutput(stack, jsii.String("myFunctionUrlOutput"), &awscdk.CfnOutputProps{
Value: myFunctionUrl.Url(),
})
return stack
}
// ...
```
**Warnung**
Um dieses Tutorial einfach zu halten, ist Ihre Lambda-Funktions-URL ohne Authentifizierung definiert. Bei der Bereitstellung wird dadurch ein öffentlich zugänglicher Endpunkt erstellt, über den Sie Ihre Funktion aufrufen können. Wenn Sie mit diesem Tutorial fertig sind, folgen Sie [Schritt 12: Löschen Sie Ihre Anwendung](#hello-world-delete), um diese Ressourcen zu löschen.
## Schritt 8: Synthetisieren Sie eine Vorlage CloudFormation
In diesem Schritt bereiten Sie sich auf die Bereitstellung vor, indem Sie eine CloudFormation Vorlage mit dem `cdk synth` CDK-CLI-Befehl synthetisieren. Dieser Befehl führt eine grundlegende Validierung Ihres CDK-Codes durch, führt Ihre CDK-App aus und generiert eine CloudFormation Vorlage aus Ihrem CDK-Stack.
Wenn Ihre App mehr als einen Stapel enthält, müssen Sie angeben, welche Stapel synthetisiert werden sollen. Da Ihre App einen einzigen Stack enthält, erkennt die CDK-CLI automatisch den zu synthetisierenden Stack.
Wenn Sie keine Vorlage synthetisieren, führt die CDK-CLI diesen Schritt bei der Bereitstellung automatisch durch. Wir empfehlen jedoch, diesen Schritt vor jeder Bereitstellung auszuführen, um nach Synthesefehlern zu suchen.
Bevor Sie eine Vorlage synthetisieren, können Sie optional Ihre Anwendung so erstellen, dass Syntax- und Typfehler erkannt werden. Anweisungen finden Sie unter [Schritt 4: Erstellen Sie Ihre CDK-App](#hello-world-build).
Um eine CloudFormation Vorlage zu synthetisieren, führen Sie im Stammverzeichnis Ihres Projekts Folgendes aus:
```
$ cdk synth
```
**Anmerkung**
Wenn Sie eine Fehlermeldung wie die folgende erhalten, überprüfen Sie, ob Sie sich im `hello-cdk` Verzeichnis befinden, und versuchen Sie es erneut:
```
--app is required either in command-line, in cdk.json or in ~/.cdk.json
```
Bei Erfolg gibt die CDK-CLI eine `YAML` —formatierte CloudFormation Vorlage aus `stdout` und speichert eine `JSON` —formatierte Vorlage im `cdk.out` Verzeichnis Ihres Projekts.
Im Folgenden finden Sie ein Beispiel für die Ausgabe der Vorlage: CloudFormation
### AWS CloudFormation Vorlage
```
Resources:
HelloWorldFunctionServiceRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Statement:
- Action: sts:AssumeRole
Effect: Allow
Principal:
Service: lambda.amazonaws.com
Version: "2012-10-17"
ManagedPolicyArns:
- Fn::Join:
- ""
- - "arn:"
- Ref: AWS::Partition
- :iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/ServiceRole/Resource
HelloWorldFunction:
Type: AWS::Lambda::Function
Properties:
Code:
ZipFile: "
\ exports.handler = async function(event) {
\ return {
\ statusCode: 200,
\ body: JSON.stringify('Hello World!'),
\ };
\ };
\ "
Handler: index.handler
Role:
Fn::GetAtt:
- HelloWorldFunctionServiceRole
- Arn
Runtime: nodejs20.x
DependsOn:
- HelloWorldFunctionServiceRole
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
HelloWorldFunctionFunctionUrl:
Type: AWS::Lambda::Url
Properties:
AuthType: NONE
TargetFunctionArn:
Fn::GetAtt:
- HelloWorldFunction
- Arn
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
HelloWorldFunctioninvokefunctionurl:
Type: AWS::Lambda::Permission
Properties:
Action: lambda:InvokeFunctionUrl
FunctionName:
Fn::GetAtt:
- HelloWorldFunction
- Arn
FunctionUrlAuthType: NONE
Principal: "*"
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url
CDKMetadata:
Type: AWS::CDK::Metadata
Properties:
Analytics: v2:deflate64:
Metadata:
aws:cdk:path: HelloCdkStack/CDKMetadata/Default
Condition: CDKMetadataAvailable
Outputs:
myFunctionUrlOutput:
Value:
Fn::GetAtt:
- HelloWorldFunctionFunctionUrl
- FunctionUrl
Parameters:
BootstrapVersion:
Type: AWS::SSM::Parameter::Value
Default: /cdk-bootstrap//version
Description: Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]
Rules:
CheckBootstrapVersion:
Assertions:
- Assert:
Fn::Not:
- Fn::Contains:
- - "1"
- "2"
- "3"
- "4"
- "5"
- Ref: BootstrapVersion
AssertDescription: CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI.
```
**Anmerkung**
Jede generierte Vorlage enthält standardmäßig eine ` AWS::CDK::Metadata` Ressource. Das AWS CDK-Team verwendet diese Metadaten, um Einblicke in die AWS CDK-Nutzung zu gewinnen und Möglichkeiten zu finden, diese zu verbessern. Einzelheiten, einschließlich der Möglichkeit, die Versionsberichterstattung zu deaktivieren, finden Sie unter [Versionsberichterstattung](cli.md#version-reporting).
Durch die Definition eines einzigen L2-Konstrukts erstellt das AWS CDK eine umfangreiche CloudFormation Vorlage, die Ihre Lambda-Ressourcen sowie die Berechtigungen und die Glue-Logik enthält, die für die Interaktion Ihrer Ressourcen in Ihrer Anwendung erforderlich sind.
## Schritt 9: Stellen Sie Ihren CDK-Stack bereit
In diesem Schritt verwenden Sie den `cdk deploy` CDK-CLI-Befehl, um Ihren CDK-Stack bereitzustellen. Mit diesem Befehl wird Ihre generierte CloudFormation Vorlage abgerufen und über diese bereitgestellt AWS CloudFormation, wodurch Ihre Ressourcen als Teil eines Stacks bereitgestellt werden. CloudFormation
Führen Sie im Stammverzeichnis Ihres Projekts den folgenden Befehl aus. Bestätige die Änderungen, wenn du dazu aufgefordert wirst:
```
$ cdk deploy
✨ Synthesis time: 2.69s
HelloCdkStack: start: Building :current_account-current_region
HelloCdkStack: success: Built :current_account-current_region
HelloCdkStack: start: Publishing :current_account-current_region
HelloCdkStack: success: Published :current_account-current_region
This deployment will make potentially sensitive changes according to your current security approval level (--require-approval broadening).
Please confirm you intend to make the following modifications:
IAM Statement Changes
┌───┬───────────────────────────────────────┬────────┬──────────────────────────┬──────────────────────────────┬───────────┐
│ │ Resource │ Effect │ Action │ Principal │ Condition │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction.Arn} │ Allow │ lambda:InvokeFunctionUrl │ * │ │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction/ServiceRole.Arn} │ Allow │ sts:AssumeRole │ Service:lambda.amazonaws.com │ │
└───┴───────────────────────────────────────┴────────┴──────────────────────────┴──────────────────────────────┴───────────┘
IAM Policy Changes
┌───┬───────────────────────────────────┬────────────────────────────────────────────────────────────────────────────────┐
│ │ Resource │ Managed Policy ARN │
├───┼───────────────────────────────────┼────────────────────────────────────────────────────────────────────────────────┤
│ + │ ${HelloWorldFunction/ServiceRole} │ arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole │
└───┴───────────────────────────────────┴────────────────────────────────────────────────────────────────────────────────┘
(NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299)
Do you wish to deploy these changes (y/n)? y
```
Ähnlich wie müssen `cdk synth` Sie den AWS CDK-Stack nicht angeben, da die App einen einzigen Stack enthält.
Während der Bereitstellung zeigt die CDK-CLI Fortschrittsinformationen an, während Ihr Stack bereitgestellt wird. Wenn Sie fertig sind, können Sie zur [AWS CloudFormation Konsole](https://console.aws.amazon.com/cloudformation/home) gehen, um Ihren `HelloCdkStack` Stack anzusehen. Sie können auch zur Lambda-Konsole gehen, um Ihre `HelloWorldFunction` Ressource anzuzeigen.
Wenn die Bereitstellung abgeschlossen ist, gibt die CDK-CLI Ihre Endpunkt-URL aus. Kopieren Sie diese URL für den nächsten Schritt. Im Folgenden wird ein Beispiel gezeigt:
```
...
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...
✅ HelloCdkStack
✨ Deployment time: 41.65s
Outputs:
HelloCdkStack.myFunctionUrlOutput = https://.lambda-url..on.aws/
Stack ARN:
arn:aws:cloudformation::stack/HelloCdkStack/
✨ Total time: 44.34s
```
## Schritt 10: Interagieren Sie mit Ihrer Anwendung auf AWS
In diesem Schritt interagieren Sie mit Ihrer Anwendung, AWS indem Sie Ihre Lambda-Funktion über die Funktions-URL aufrufen. Wenn Sie auf die URL zugreifen, gibt Ihre Lambda-Funktion die `Hello World!` Nachricht zurück.
Um Ihre Funktion aufzurufen, greifen Sie über Ihren Browser oder über die Befehlszeile auf die Funktions-URL zu. Im Folgenden wird ein Beispiel gezeigt:
```
$ curl https://.lambda-url..on.aws/
"Hello World!"%
```
## Schritt 11: Ändern Sie Ihre Anwendung
In diesem Schritt ändern Sie die Meldung, die die Lambda-Funktion zurückgibt, wenn sie aufgerufen wird. Sie führen einen Vergleich mit dem `cdk diff` CDK-CLI-Befehl durch, um eine Vorschau Ihrer Änderungen anzuzeigen, und stellen sie bereit, um Ihre Anwendung zu aktualisieren. Anschließend interagieren Sie mit Ihrer Anwendung AWS , um Ihre neue Nachricht zu sehen.
Ändern Sie die `myFunction` Instanz in Ihrer CDK-Stack-Datei wie folgt:
**Example**
Befindet sich in`lib/hello-cdk-stack.ts`:
```
// ...
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Modify the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
`),
});
// ...
}
}
```
Befindet sich in`lib/hello-cdk-stack.js`:
```
// ...
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Modify the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
`),
});
// ...
}
}
module.exports = { HelloCdkStack }
```
Befindet sich in`hello_cdk/hello_cdk_stack.py`:
```
# ...
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Modify the Lambda function resource
my_function = _lambda.Function(
self, "HelloWorldFunction",
runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
handler = "index.handler",
code = _lambda.Code.from_inline(
"""
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
"""
),
)
# ...
```
Befindet sich in`src/main/java/…/HelloCdkStack.java`:
```
// ...
public class HelloCdkStack extends Stack {
public HelloCdkStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Modify the Lambda function resource
Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
.runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
.handler("index.handler")
.code(Code.fromInline(
"exports.handler = async function(event) {" +
" return {" +
" statusCode: 200," +
" body: JSON.stringify('Hello CDK!')" +
" };" +
"};"))
.build();
// ...
}
}
```
```
// ...
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Modify the Lambda function resource
var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
{
Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
Handler = "index.handler",
Code = Code.FromInline(@"
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
"),
});
// ...
}
}
}
```
```
// ...
type HelloCdkStackProps struct {
awscdk.StackProps
}
func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
// Modify the Lambda function resource
myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
Handler: jsii.String("index.handler"),
Code: awslambda.Code_FromInline(jsii.String(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
`)),
})
// ...
}
```
Derzeit wurden durch Ihre Codeänderungen keine direkten Aktualisierungen Ihrer bereitgestellten Lambda-Ressource vorgenommen. Ihr Code definiert den gewünschten Status Ihrer Ressource. Um Ihre bereitgestellte Ressource zu ändern, verwenden Sie die CDK-CLI, um den gewünschten Status in einer neuen AWS CloudFormation Vorlage zu synthetisieren. Anschließend stellen Sie Ihre neue CloudFormation Vorlage als Änderungssatz bereit. Mit Änderungssätzen werden nur die Änderungen vorgenommen, die erforderlich sind, um den gewünschten neuen Status zu erreichen.
Führen Sie den `cdk diff` Befehl aus, um eine Vorschau Ihrer Änderungen anzuzeigen. Im Folgenden wird ein Beispiel gezeigt:
```
$ cdk diff
Stack HelloCdkStack
Hold on while we create a read-only change set to get a diff with accurate replacement information (use --no-change-set to use a less accurate but faster template-only diff)
Resources
[~] AWS::Lambda::Function HelloWorldFunction HelloWorldFunction
└─ [~] Code
└─ [~] .ZipFile:
├─ [-]
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
└─ [+]
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
✨ Number of stacks with differences: 1
```
Um diesen Diff zu erstellen, fragt die CDK-CLI Ihr AWS Kontokonto nach der neuesten AWS CloudFormation Vorlage für den `HelloCdkStack` Stack ab. Anschließend vergleicht sie die neueste Vorlage mit der Vorlage, die sie gerade aus Ihrer App synthetisiert hat.
Führen Sie den `cdk deploy` Befehl aus, um Ihre Änderungen zu implementieren. Im Folgenden wird ein Beispiel gezeigt:
```
$ cdk deploy
✨ Synthesis time: 2.12s
HelloCdkStack: start: Building :current_account-current_region
HelloCdkStack: success: Built :current_account-current_region
HelloCdkStack: start: Publishing :current_account-current_region
HelloCdkStack: success: Published :current_account-current_region
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...
✅ HelloCdkStack
✨ Deployment time: 26.96s
Outputs:
HelloCdkStack.myFunctionUrlOutput = https://.lambda-url..on.aws/
Stack ARN:
arn:aws:cloudformation::stack/HelloCdkStack/
✨ Total time: 29.07s
```
Um mit Ihrer Anwendung zu interagieren, wiederholen Sie [Schritt 10: Interagieren Sie mit Ihrer Anwendung auf AWS](#hello-world-interact). Im Folgenden wird ein Beispiel gezeigt:
```
$ curl https://.lambda-url..on.aws/
"Hello CDK!"%
```
## Schritt 12: Löschen Sie Ihre Bewerbung
In diesem Schritt verwenden Sie den `cdk destroy` CDK-CLI-Befehl, um Ihre Anwendung zu löschen. Dieser Befehl löscht den mit Ihrem CloudFormation CDK-Stack verknüpften Stack, der die von Ihnen erstellten Ressourcen enthält.
Um Ihre Anwendung zu löschen, führen Sie den `cdk destroy` Befehl aus und bestätigen Sie Ihre Anfrage zum Löschen der Anwendung. Im Folgenden wird ein Beispiel gezeigt:
```
$ cdk destroy
Are you sure you want to delete: HelloCdkStack (y/n)? y
HelloCdkStack: destroying... [1/1]
✅ HelloCdkStack: destroyed
```
## Nächste Schritte
Herzlichen Glückwunsch\$1 Sie haben dieses Tutorial abgeschlossen und das AWS CDK verwendet, um erfolgreich Ressourcen in der AWS Cloud zu erstellen, zu ändern und zu löschen. Sie können jetzt mit der Verwendung des AWS CDK beginnen.
Weitere Informationen zur Verwendung des AWS CDK in Ihrer bevorzugten Programmiersprache finden Sie unter [Arbeiten mit der AWS CDK-Bibliothek](work-with.md).
Weitere Ressourcen finden Sie im Folgenden:
+ Probieren Sie den [CDK-Workshop](https://cdkworkshop.com/) aus, um sich eingehender mit einem komplexeren Projekt vertraut zu machen.
+ Sehen Sie sich die [API-Referenz](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) an, um mit der Erkundung der CDK-Konstrukte zu beginnen, die für Ihre bevorzugten Dienste verfügbar sind. AWS
+ Besuchen Sie [Construct Hub](https://constructs.dev/search?q=&cdk=aws-cdk&cdkver=2&sort=downloadsDesc&offset=0), um Konstrukte zu entdecken, die von und anderen erstellt AWS wurden.
+ Entdecken Sie [Beispiele für](https://github.com/aws-samples/aws-cdk-examples) die Verwendung des AWS CDK.
Das AWS CDK ist ein Open-Source-Projekt. Informationen zum Beitrag finden Sie unter [Beitrag zum AWS Cloud Development Kit (AWS CDK)](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md).