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.

# Lokales Testen und Erstellen von AWS CDK-Anwendungen mit der AWS SAM-CLI
<a name="testing-locally"></a>

Sie können die AWS SAM-CLI verwenden, um serverlose Anwendungen, die mit dem AWS Cloud Development Kit (AWS CDK) definiert wurden, lokal zu testen und zu erstellen. Da die AWS SAM-CLI innerhalb der AWS CDK-Projektstruktur funktioniert, können Sie die [AWS CDK-CLI-Referenz weiterhin zum Erstellen, Ändern und Bereitstellen Ihrer AWS CDK-Anwendungen](cli.md) verwenden.

Einzelheiten zur Verwendung von AWS SAM finden Sie unter [Erste Schritte mit AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) im * AWS Serverless Application* Model Developer Guide.

**Topics**
+ [Erste Schritte mit lokalen Tests](testing-locally-getting-started.md)
+ [Lokales Testen von AWS CDK-Anwendungen mit SAM AWS](testing-locally-with-sam-cli.md)
+ [AWS CDK-Anwendungen mit SAM erstellen AWS](testing-locally-build-with-sam-cli.md)

# Erste Schritte mit lokalen Tests
<a name="testing-locally-getting-started"></a>

In diesem Thema wird beschrieben, was Sie für die Verwendung der AWS SAM-CLI mit AWS CDK-Anwendungen benötigen, und es enthält Anweisungen zum Erstellen und lokalen Testen einer einfachen AWS CDK-Anwendung.

## Voraussetzungen
<a name="testing-locally-getting-started-prerequisites"></a>

Um lokal zu testen, müssen Sie die AWS SAM-CLI installieren. Installationsanweisungen finden [Sie unter AWS SAM-CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/getting_started.html) installieren.

## Eine AWS CDK-Anwendung erstellen und lokal testen
<a name="testing-locally-getting-started-tutorial"></a>

Um eine AWS CDK-Anwendung mit der AWS SAM-CLI lokal zu testen, benötigen Sie eine AWS CDK-Anwendung, die eine Lambda-Funktion enthält. Gehen Sie wie folgt vor, um eine grundlegende AWS CDK-Anwendung mit einer Lambda-Funktion zu erstellen. Weitere Informationen finden Sie unter [Creating a serverless application using the AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/serverless_example.html) im * AWS Cloud Development Kit (AWS CDK)* Developer Guide.<a name="testing-locally-getting-started-tutorial-init"></a>

 **Schritt 1: Erstellen Sie eine CDK-Anwendung AWS **   
Initialisieren Sie für dieses Tutorial eine AWS CDK-Anwendung, die verwendet. TypeScript  
Befehl zum Ausführen:  

```
$ mkdir cdk-sam-example
$ cd cdk-sam-example
$ cdk init app --language typescript
```<a name="testing-locally-getting-started-tutorial-lambda"></a>

 **Schritt 2: Fügen Sie Ihrer Anwendung eine Lambda-Funktion hinzu**   
Ersetzen Sie den Code `lib/cdk-sam-example-stack.ts` durch folgenden Code:  

```
import { Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as lambda from 'aws-cdk-lib/aws-lambda';

export class CdkSamExampleStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    new lambda.Function(this, 'MyFunction', {
      runtime: lambda.Runtime.PYTHON_3_12,
      handler: 'app.lambda_handler',
      code: lambda.Code.fromAsset('./my_function'),
    });
  }
}
```<a name="testing-locally-getting-started-tutorial-code"></a>

 **Schritt 3: Fügen Sie Ihren Lambda-Funktionscode hinzu**   
Erstellen Sie ein Verzeichnis mit dem Namen `my_function`. Erstellen Sie in diesem Verzeichnis eine Datei namens `app.py`.  
Befehl zum Ausführen:  

**Example**  

```
$ mkdir my_function
$ cd my_function
$ touch app.py
```

```
$ mkdir my_function
$ cd my_function
$ type nul > app.py
```

```
$ mkdir my_function
$ cd my_function
$ New-Item -Path "app.py”
```
Fügen Sie folgenden Code zu hinz `app.py`:

```
def lambda_handler(event, context):
    return "Hello from SAM and the CDK!"
```<a name="testing-locally-getting-started-tutorial-function"></a>

 **Schritt 4: Testen Sie Ihre Lambda-Funktion**   
Sie können die AWS SAM-CLI verwenden, um lokal eine Lambda-Funktion aufzurufen, die Sie in einer AWS CDK-Anwendung definieren. Dazu benötigen Sie den Konstrukt-Identifier der Funktion und den Pfad zu Ihrer synthetisierten Vorlage. AWS CloudFormation   
Führen Sie den folgenden Befehl aus, um zum `lib` Verzeichnis zurückzukehren:  

```
$  cd ..
```
 **Befehl zum Ausführen:**   

```
$  cdk synth --no-staging
```

```
$  sam local invoke MyFunction --no-event -t ./cdk.out/CdkSamExampleStack.template.json
```
 **Beispielausgabe:**   

```
Invoking app.lambda_handler (python3.9)

START RequestId: 5434c093-7182-4012-9b06-635011cac4f2 Version: $LATEST
"Hello from SAM and the CDK!"
END RequestId: 5434c093-7182-4012-9b06-635011cac4f2
REPORT RequestId: 5434c093-7182-4012-9b06-635011cac4f2	Init Duration: 0.32 ms	Duration: 177.47 ms	Billed Duration: 178 ms	Memory Size: 128 MB	Max Memory Used: 128 MB
```

# Lokales Testen von AWS CDK-Anwendungen mit SAM AWS
<a name="testing-locally-with-sam-cli"></a>

Sie können die AWS SAM-CLI verwenden, um Ihre AWS CDK-Anwendungen lokal zu testen, indem Sie die folgenden Befehle im Projektstammverzeichnis Ihrer AWS CDK-Anwendung ausführen:
+  ` [sam local invoke](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-local-invoke.html) ` 
+  ` [sam local start-api](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-local-start-api.html) ` 
+  ` [sam local start-lambda](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-local-start-lambda.html) ` 

Bevor Sie einen der `sam local` Befehle mit einer AWS CDK-Anwendung ausführen, müssen Sie ihn ausführen. `cdk synth`

Bei der Ausführung benötigen `sam local invoke` Sie den Konstrukt-Identifier der Funktion, den Sie aufrufen möchten, und den Pfad zu Ihrer synthetisierten AWS CloudFormation Vorlage. Wenn Ihre Anwendung verschachtelte Stacks verwendet, benötigen Sie zur Lösung von Namenskonflikten auch den Stacknamen, in dem die Funktion definiert ist.

 **Usage**   

```
# Invoke the function FUNCTION_IDENTIFIER declared in the stack STACK_NAME
$  sam local invoke <OPTIONS> <STACK_NAME/FUNCTION_IDENTIFIER>

# Start all APIs declared in the AWS CDK application
$  sam local start-api -t <./cdk.out/CdkSamExampleStack.template.json> <OPTIONS>

# Start a local endpoint that emulates AWS Lambda
$  sam local start-lambda -t <./cdk.out/CdkSamExampleStack.template.json> <OPTIONS>
```

## Beispiel
<a name="testing-cdk-applications-examples"></a>

Betrachten Sie Stacks und Funktionen, die mit dem folgenden Beispiel deklariert wurden:

```
app = new HelloCdkStack(app, "HelloCdkStack",
   ...
)
class HelloCdkStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    ...
    new lambda.Function(this, 'MyFunction', {
        ...
    });

    new HelloCdkNestedStack(this, 'HelloNestedStack' ,{
        ...
    });
  }
}

class HelloCdkNestedStack extends cdk.NestedStack {
  constructor(scope: Construct, id: string, props?: cdk.NestedStackProps) {
    ...
    new lambda.Function(this, 'MyFunction', {
        ...
    });
    new lambda.Function(this, 'MyNestedFunction', {
        ...
    });
  }
}
```

Die folgenden Befehle rufen lokal die im obigen Beispiel definierten Lambda-Funktionen auf:

```
# Invoke MyFunction from the HelloCdkStack
$ sam local invoke -t <./cdk.out/HelloCdkStack.template.json> <MyFunction>
```

```
# Invoke MyNestedFunction from the HelloCdkNestedStack
$ sam local invoke -t <./cdk.out/HelloCdkStack.template.json> <MyNestedFunction>
```

```
# Invoke MyFunction from the HelloCdkNestedStack
$ sam local invoke -t <./cdk.out/HelloCdkStack.template.json> <HelloNestedStack/MyFunction>
```

# AWS CDK-Anwendungen mit SAM erstellen AWS
<a name="testing-locally-build-with-sam-cli"></a>

Die AWS SAM-CLI bietet Unterstützung für die Erstellung von Lambda-Funktionen und -Layern, die in Ihrer AWS CDK-Anwendung mit definiert sind. ` [sam build](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-build.html) `

Bei Lambda-Funktionen, die Zip-Artefakte verwenden, führen Sie die `sam local` Befehle aus, `cdk synth` bevor Sie sie ausführen. `sam build`ist nicht erforderlich.

Wenn Ihre AWS CDK-Anwendung Funktionen mit dem Image-Typ verwendet, führen Sie sie aus `cdk synth` und führen Sie sie dann aus, `sam build` bevor Sie `sam local` Befehle ausführen. Wenn Sie ausführen`sam build`, erstellt AWS SAM keine Lambda-Funktionen oder -Layer, die laufzeitspezifische Konstrukte verwenden, z. B. ` [NodejsFunction](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda_nodejs.NodejsFunction.html) ` `sam build`[unterstützt keine gebündelten Ressourcen.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.BundlingOptions.html)

## Beispiel
<a name="testing-locally-build-with-sam-cli-examples"></a>

Wenn Sie den folgenden Befehl im Stammverzeichnis des AWS CDK-Projekts ausführen, wird die Anwendung erstellt.

```
$ sam build -t <./cdk.out/CdkSamExampleStack.template.json>
```