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. # Testen Sie Ihre serverlose Anwendung mit AWS SAM Nachdem Sie Ihre Anwendung geschrieben und erstellt haben, können Sie Ihre Anwendung testen, um sicherzustellen, dass sie ordnungsgemäß funktioniert. Mit der AWS SAM Befehlszeilenschnittstelle (CLI) können Sie Ihre serverlose Anwendung lokal testen, bevor Sie sie in die AWS Cloud hochladen. Durch das Testen Ihrer Anwendung können Sie die Funktionalität, Zuverlässigkeit und Leistung der Anwendung überprüfen und gleichzeitig Probleme (Bugs) identifizieren, die behoben werden müssen. Dieser Abschnitt enthält Anleitungen zu gängigen Methoden, die Sie beim Testen Ihrer Anwendung anwenden können. Die Themen in diesem Abschnitt konzentrieren sich hauptsächlich auf die lokalen Tests, die Sie vor der Bereitstellung in der AWS Cloud durchführen können. Das Testen vor der Bereitstellung hilft Ihnen dabei, Probleme proaktiv zu identifizieren und so unnötige Kosten im Zusammenhang mit Bereitstellungsproblemen zu reduzieren. Jedes Thema in diesem Abschnitt beschreibt einen Test, den Sie durchführen können. Sagt yoxi include href? u Die Vorteile seiner Verwendung und enthält Beispiele, die Ihnen zeigen, wie Sie den Test durchführen können. Nachdem Sie Ihre Anwendung getestet haben, sind Sie bereit, alle gefundenen Probleme zu debuggen. **Topics** + [Einführung in das Testen mit dem sam local Befehl](using-sam-cli-local.md) + [Lokal Lambda-Funktionen aufrufen mit AWS SAM](serverless-sam-cli-using-invoke.md) + [Lokal ausgeführtes API Gateway mit AWS SAM](serverless-sam-cli-using-start-api.md) + [Einführung in Cloud-Tests mit sam remote test-event](using-sam-cli-remote-test-event.md) + [Einführung in das Testen in der Cloud mit sam remote invoke](using-sam-cli-remote-invoke.md) + [Automatisieren Sie lokale Integrationstests mit AWS SAM](serverless-sam-cli-using-automated-tests.md) + [Generieren Sie Beispielereignis-Payloads mit AWS SAM](serverless-sam-cli-using-generate-event.md) + [Testen und Debuggen langlebiger Funktionen](test-and-debug-durable-functions.md) # Einführung in das Testen mit dem sam local Befehl Verwenden Sie den AWS Serverless Application Model Befehl Command Line Interface (AWS SAMCLI)`sam local`, um Ihre serverlosen Anwendungen lokal zu testen. Eine Einführung in das finden Sie AWS SAMCLI unter[Was ist das? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli). ## Voraussetzungen Um das zu verwenden`sam local`, installieren Sie das, AWS SAMCLI indem Sie die folgenden Schritte ausführen: + [AWS SAM Voraussetzungen](prerequisites.md). + [Installieren Sie das AWS SAMCLI](install-sam-cli.md). Vor der Verwendung empfehlen wir`sam local`, sich mit folgenden Grundkenntnissen vertraut zu machen: + [Konfiguration der AWS SAMCLI](using-sam-cli-configure.md). + [Erstellen Sie Ihre Bewerbung in AWS SAM](using-sam-cli-init.md). + [Einführung in das Bauen mit AWS SAM](using-sam-cli-build.md). + [Einführung in die Bereitstellung mit AWS SAM](using-sam-cli-deploy.md). ## Verwenden des sam local Befehls Verwenden Sie den `sam local` Befehl zusammen mit einem seiner Unterbefehle, um verschiedene Arten von lokalen Tests für Ihre Anwendung durchzuführen. ``` $ sam local ``` Weitere Informationen zu den einzelnen Unterbefehlen finden Sie im Folgenden: + **[Einführung in sam local generate-event](using-sam-cli-local-generate-event.md)**— Generiert AWS-Service Ereignisse für lokale Tests. + **[Einführung in sam local invoke](using-sam-cli-local-invoke.md)**— Initiiert einen einmaligen Aufruf einer AWS Lambda Funktion lokal. + **[Einführung in sam local start-api](using-sam-cli-local-start-api.md)**— Führen Sie Ihre Lambda-Funktionen über einen lokalen HTTP-Server aus. + **[Einführung in sam local start-lambda](using-sam-cli-local-start-lambda.md)**— Führen Sie Ihre Lambda-Funktionen über einen lokalen HTTP-Server zur Verwendung mit dem AWS CLI oder SDKs aus. # Einführung in das Testen mit sam local generate-event Verwenden Sie den AWS Serverless Application Model `sam local generate-event` Unterbefehl Command Line Interface (AWS SAMCLI), um Beispiele für Nutzdaten von Ereignissen für unterstützte Ereignisse zu generieren. AWS-Services Sie können diese Ereignisse dann ändern und zum Testen an lokale Ressourcen weitergeben. + Eine Einführung in das finden AWS SAMCLI Sie unter [Was ist das? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli) + Eine Liste der `sam local generate-event` Befehlsoptionen finden Sie unter[sam local generate-event](sam-cli-command-reference-sam-local-generate-event.md). Ein *Ereignis* ist ein JSON-Objekt, das generiert wird, wenn ein eine Aktion oder Aufgabe AWS-Service ausführt. Diese Ereignisse enthalten spezifische Informationen, z. B. die verarbeiteten Daten oder den Zeitstempel des Ereignisses. Die meisten AWS-Services generieren Ereignisse, und die Ereignisse jedes Dienstes sind für den jeweiligen Dienst eindeutig formatiert. Von einem Dienst generierte Ereignisse werden als *Ereignisquelle* an andere Dienste weitergegeben. Beispielsweise kann ein Artikel, der in einem Amazon Simple Storage Service (Amazon S3) -Bucket platziert wird, ein Ereignis auslösen. Dieses Ereignis kann dann als Ereignisquelle für eine AWS Lambda Funktion zur weiteren Verarbeitung der Daten verwendet werden. Ereignisse, die Sie mit generieren, `sam local generate-event` werden in derselben Struktur formatiert wie die tatsächlichen Ereignisse, die vom AWS Service erstellt wurden. Sie können den Inhalt dieser Ereignisse ändern und sie zum Testen von Ressourcen in Ihrer Anwendung verwenden. ## Voraussetzungen Um das zu verwenden`sam local generate-event`, installieren Sie das, AWS SAMCLI indem Sie die folgenden Schritte ausführen: + [AWS SAM Voraussetzungen](prerequisites.md). + [Installieren Sie das AWS SAMCLI](install-sam-cli.md). Vor der Verwendung empfehlen wir`sam local generate-event`, sich mit folgenden Grundkenntnissen vertraut zu machen: + [Konfiguration der AWS SAMCLI](using-sam-cli-configure.md). + [Erstellen Sie Ihre Bewerbung in AWS SAM](using-sam-cli-init.md). + [Einführung in das Bauen mit AWS SAM](using-sam-cli-build.md). + [Einführung in die Bereitstellung mit AWS SAM](using-sam-cli-deploy.md). ## Generieren Sie Beispielereignisse Verwenden Sie den AWS SAMCLI `sam local generate-event` Unterbefehl, um Ereignisse für unterstützte AWS-Services zu generieren. **Um eine Liste der unterstützten zu sehen AWS-Services** 1. Führen Sie Folgendes aus: ``` $ sam local generate-event ``` 1. Die Liste der unterstützten AWS-Services wird angezeigt. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local generate-event ... Commands: alb alexa-skills-kit alexa-smart-home apigateway appsync batch cloudformation ... ``` **Um ein lokales Ereignis zu generieren** 1. Führen Sie den unterstützten Dienstnamen aus `sam local generate-event` und geben Sie ihn an. Daraufhin wird eine Liste der Ereignistypen angezeigt, die Sie generieren können. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local generate-event s3 Usage: sam local generate-event s3 [OPTIONS] COMMAND [ARGS]... Options: -h, --help Show this message and exit. Commands: batch-invocation Generates an Amazon S3 Batch Operations Invocation Event delete Generates an Amazon S3 Delete Event put Generates an Amazon S3 Put Event ``` 1. Um das Beispielereignis zu generieren`sam local generate-event`, führen Sie es aus und geben Sie den Dienst und den Ereignistyp an. ``` $ sam local generate-event ``` Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local generate-event s3 put { "Records": [ { "eventVersion": "2.0", "eventSource": "aws:s3", "awsRegion": "us-east-1", "eventTime": "1970-01-01T00:00:00.000Z", "eventName": "ObjectCreated:Put", "userIdentity": { "principalId": "EXAMPLE" }, "requestParameters": { "sourceIPAddress": "127.0.0.1" }, "responseElements": { "x-amz-request-id": "EXAMPLE123456789", "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH" }, "s3": { "s3SchemaVersion": "1.0", "configurationId": "testConfigRule", "bucket": { "name": "sam-s3-demo-bucket", "ownerIdentity": { "principalId": "EXAMPLE" }, "arn": "arn:aws:s3:::sam-s3-demo-bucket" }, "object": { "key": "test/key", "size": 1024, "eTag": "0123456789abcdef0123456789abcdef", "sequencer": "0A1B2C3D4E5F678901" } } } ] } ``` Diese Beispielereignisse enthalten Platzhalterwerte. Sie können diese Werte ändern, um auf tatsächliche Ressourcen in Ihrer Anwendung oder auf Werte zu verweisen, die beim Testen vor Ort hilfreich sind. **Um ein Beispielereignis zu ändern** 1. Sie können Beispielereignisse in der Befehlszeile ändern. Führen Sie den folgenden Befehl aus, um Ihre Optionen zu sehen: ``` $ sam local generate-event --help ``` Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local generate-event s3 put --help Usage: sam local generate-event s3 put [OPTIONS] Options: --region TEXT Specify the region name you'd like, otherwise the default = us-east-1 --partition TEXT Specify the partition name you'd like, otherwise the default = aws --bucket TEXT Specify the bucket name you'd like, otherwise the default = example-bucket --key TEXT Specify the key name you'd like, otherwise the default = test/key --debug Turn on debug logging to print debug message generated by AWS SAM CLI and display timestamps. --config-file TEXT Configuration file containing default parameter values. [default: samconfig.toml] --config-env TEXT Environment name specifying default parameter values in the configuration file. [default: default] -h, --help Show this message and exit. ``` 1. Verwenden Sie eine dieser Optionen in der Befehlszeile, um Ihre Beispielereignis-Payload zu ändern. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local generate-event s3 put--bucket sam-s3-demo-bucket { "Records": [ { "eventVersion": "2.0", "eventSource": "aws:s3", "awsRegion": "us-east-1", "eventTime": "1970-01-01T00:00:00.000Z", "eventName": "ObjectCreated:Put", "userIdentity": { "principalId": "EXAMPLE" }, "requestParameters": { "sourceIPAddress": "127.0.0.1" }, "responseElements": { "x-amz-request-id": "EXAMPLE123456789", "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH" }, "s3": { "s3SchemaVersion": "1.0", "configurationId": "testConfigRule", "bucket": { "name": "sam-s3-demo-bucket", "ownerIdentity": { "principalId": "EXAMPLE" }, "arn": "arn:aws:s3:::sam-s3-demo-bucket" }, "object": { "key": "test/key", "size": 1024, "eTag": "0123456789abcdef0123456789abcdef", "sequencer": "0A1B2C3D4E5F678901" } } } ] } ``` ## Verwenden Sie generierte Ereignisse für lokale Tests Speichern Sie Ihre generierten Ereignisse lokal und testen Sie sie mit anderen `sam local` Unterbefehlen. **Um Ihre generierten Ereignisse lokal zu speichern** + Führen Sie Folgendes aus: ``` $ sam local generate-event > ``` Im Folgenden finden Sie ein Beispiel für ein Ereignis, das als `s3.json` Datei im `events` Ordner unseres Projekts gespeichert wird. ``` sam-app$ sam local generate-event s3 put --bucket amzn-s3-demo-bucket > events/s3.json ``` **Um ein generiertes Ereignis für lokale Tests zu verwenden** + Übergeben Sie das Ereignis mit anderen `sam local` Unterbefehlen, indem Sie die `--event` Option verwenden. Im Folgenden finden Sie ein Beispiel für die Verwendung des `s3.json` Ereignisses, um unsere Lambda-Funktion lokal aufzurufen: ``` sam-app$ sam local invoke --event events/s3.json S3JsonLoggerFunction Invoking src/handlers/s3-json-logger.s3JsonLoggerHandler (nodejs18.x) Local image is up-to-date Using local image: public.ecr.aws/lambda/nodejs:18-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/S3JsonLoggerFunction as /var/task:ro,delegated, inside runtime container START RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128 Version: $LATEST END RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128 REPORT RequestId: f4f45b6d-2ec6-4235-bc7b-495ec2ae0128 Init Duration: 1.23 ms Duration: 9371.93 ms Billed Duration: 9372 ms Memory Size: 128 MB Max Memory Used: 128 MB ``` ## Weitere Informationen Eine Liste aller `sam local generate-event` Optionen finden Sie unter[sam local generate-event](sam-cli-command-reference-sam-local-generate-event.md). Eine Demo der Verwendung `sam local` finden Sie unter [AWS SAM Lokale Entwicklung. Testen von AWS Cloud Ressourcen aus lokalen Entwicklungsumgebungen](https://www.youtube.com/watch?v=NzPqMrdgD1s&list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd&index=24) in der *Serverless Land Sessions with SAM-Serie*. YouTube # Einführung in das Testen mit sam local invoke Verwenden Sie den AWS Serverless Application Model `sam local invoke` Unterbefehl Command Line Interface (AWS SAMCLI), um einen einmaligen lokalen Aufruf einer AWS Lambda Funktion zu initiieren. + Eine Einführung in das finden Sie unter AWS SAMCLI [Was ist das? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli) + Eine Liste der `sam local invoke` Befehlsoptionen finden Sie unter[sam local invoke](sam-cli-command-reference-sam-local-invoke.md). + Ein Beispiel für die Verwendung `sam local invoke` während eines typischen Entwicklungsworkflows finden Sie unter[Schritt 7: (Optional) Testen Sie Ihre Anwendung lokal](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-test). **Anmerkung** Es wird nicht empfohlen, die lokalen Aufruffunktionen von SAM CLI in nicht vertrauenswürdigem Code zu verwenden. Um eine vollständige Isolierung von Ihrer lokalen Umgebung zu erreichen, führen Sie den Code direkt im Lambda-Service aus. **Anmerkung** `sam local invoke`unterstützt langlebige Funktionen mit automatischen Checkpoint- und Wiedergabefunktionen. Beim lokalen Aufrufen dauerhafter Funktionen wird der Ausführungsstatus automatisch verwaltet. ## Voraussetzungen Um das zu verwenden`sam local invoke`, installieren Sie das, AWS SAMCLI indem Sie die folgenden Schritte ausführen: + [AWS SAM Voraussetzungen](prerequisites.md). + [Installieren Sie das AWS SAMCLI](install-sam-cli.md). Vor der Verwendung empfehlen wir`sam local invoke`, sich mit folgenden Grundkenntnissen vertraut zu machen: + [Konfiguration der AWS SAMCLI](using-sam-cli-configure.md). + [Erstellen Sie Ihre Bewerbung in AWS SAM](using-sam-cli-init.md). + [Einführung in das Bauen mit AWS SAM](using-sam-cli-build.md). + [Einführung in die Bereitstellung mit AWS SAM](using-sam-cli-deploy.md). ## Lokal eine Lambda-Funktion aufrufen Bei der Ausführung AWS SAMCLI wird davon ausgegangen`sam local invoke`, dass Ihr aktuelles Arbeitsverzeichnis das Stammverzeichnis Ihres Projekts ist. Das AWS SAMCLI sucht zuerst nach einer `template.[yaml|yml]` Datei in einem `.aws-sam` Unterordner. Wenn nicht gefunden, sucht der AWS SAMCLI nach einer `template.[yaml|yml]` Datei in Ihrem aktuellen Arbeitsverzeichnis. **Um eine Lambda-Funktion lokal aufzurufen** 1. Führen Sie im Stammverzeichnis Ihres Projekts Folgendes aus: ``` $ sam local invoke ``` 1. Wenn Ihre Anwendung mehr als eine Funktion enthält, geben Sie die logische ID der Funktion an. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local invoke HelloWorldFunction ``` 1. Das AWS SAMCLI erstellt Ihre Funktion in einem lokalen Container mitDocker. Es ruft dann Ihre Funktion auf und gibt die Antwort Ihrer Funktion aus. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local invoke Invoking app.lambda_handler (python3.9) Local image is out of date and will be updated to the latest runtime. To skip this, pass in the parameter --skip-pull-image Building image.................................................................................................................... Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df Version: $LATEST END RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df REPORT RequestId: 64bf7e54-5509-4762-a97c-3d740498d3df Init Duration: 1.09 ms Duration: 608.42 ms Billed Duration: 609 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode": 200, "body": "{\"message\": \"hello world\"}"}% ``` ### Verwalten von -Protokollen Bei der Verwendung `sam local invoke` wird die Laufzeitausgabe der Lambda-Funktion (z. B. Protokolle) und das Ergebnis der Lambda-Funktion an ausgegeben. `stderr` `stdout` Das Folgende ist ein Beispiel für eine grundlegende Lambda-Funktion: ``` def handler(event, context): print("some log") # this goes to stderr return "hello world" # this goes to stdout ``` Sie können diese Standardausgaben speichern. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local invoke 1> stdout.log ... $ cat stdout.log "hello world" $ sam local invoke 2> stderr.log ... $ cat stderr.log Invoking app.lambda_handler (python3.9) Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46 Version: $LATEST some log END RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46 REPORT RequestId: 0b46e646-3bdf-4b58-8beb-242d00912c46 Init Duration: 0.91 ms Duration: 589.19 ms Billed Duration: 590 ms Memory Size: 128 MB Max Memory Used: 128 MB ``` Sie können diese Standardausgaben verwenden, um Ihre lokalen Entwicklungsprozesse weiter zu automatisieren. ## Optionen ### Übergeben Sie benutzerdefinierte Ereignisse, um die Lambda-Funktion aufzurufen Verwenden Sie die `--event` Option, um ein Ereignis an die Lambda-Funktion zu übergeben. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local invoke --event events/s3.json S3JsonLoggerFunction ``` Sie können Ereignisse mit dem `sam local generate-event` Unterbefehl erstellen. Weitere Informationen hierzu finden Sie unter [Einführung in das Testen mit sam local generate-event](using-sam-cli-local-generate-event.md). ### Übergeben Sie Umgebungsvariablen, wenn Sie Ihre Lambda-Funktion aufrufen Wenn Ihre Lambda-Funktion Umgebungsvariablen verwendet, können Sie diese bei lokalen Tests mit der `--env-vars` Option übergeben. Dies ist eine hervorragende Möglichkeit, eine Lambda-Funktion lokal mit Diensten in Ihrer Anwendung zu testen, die bereits in der Cloud bereitgestellt sind. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local invoke --env-vars locals.json ``` ### Geben Sie eine Vorlage oder Funktion an Verwenden Sie die `--template` Option, AWS SAMCLI um eine Vorlage anzugeben, auf die verwiesen werden soll. Es AWS SAMCLI werden nur diese AWS SAM Vorlage und die Ressourcen, auf die sie verweist, geladen. Um eine Funktion einer verschachtelten Anwendung oder eines geschachtelten Stacks aufzurufen, geben Sie die logische ID der Anwendung oder des Stacks zusammen mit der logischen ID der Funktion an. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local invoke StackLogicalId/FunctionLogicalId ``` ### Testen Sie eine Lambda-Funktion aus Ihrem Projekt Terraform Verwenden Sie die `--hook-name` Option, um Lambda-Funktionen aus Ihren Terraform Projekten lokal zu testen. Weitere Informationen hierzu finden Sie unter [Verwenden von AWS SAMCLI with Terraform für lokales Debuggen und Testen](using-samcli-terraform.md). Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local invoke --hook-name terraform --beta-features ``` ## Best Practices Wenn in Ihrer Anwendung ein `.aws-sam` Verzeichnis nicht ausgeführt wird`sam build`, stellen Sie sicher, dass es `sam build` jedes Mal ausgeführt wird, wenn Sie Ihren Funktionscode aktualisieren. Führen Sie dann `sam local invoke` den Befehl aus, um Ihren aktualisierten Funktionscode lokal zu testen. Lokales Testen ist eine hervorragende Lösung für schnelles Entwickeln und Testen vor der Bereitstellung in der Cloud. Bei lokalen Tests wird jedoch nicht alles überprüft, z. B. die Berechtigungen zwischen Ihren Ressourcen in der Cloud. Testen Sie Ihre Anwendungen so oft wie möglich in der Cloud. Wir empfehlen `sam sync` die [Verwendung](using-sam-cli-sync.md), um Ihre Cloud-Test-Workflows zu beschleunigen. ## Beispiele ### Generieren Sie ein Amazon API Gateway Gateway-Beispielereignis und verwenden Sie es, um lokal eine Lambda-Funktion aufzurufen Zunächst generieren wir eine API Gateway Gateway-HTTP-API-Event-Payload und speichern sie in unserem `events` Ordner. ``` $ sam local generate-event apigateway http-api-proxy > events/apigateway_event.json ``` Als Nächstes ändern wir unsere Lambda-Funktion, um einen Parameterwert aus dem Ereignis zurückzugeben. ``` def lambda_handler(event, context): print("HelloWorldFunction invoked") return { "statusCode": 200, "body": json.dumps({ "message": event['queryStringParameters']['parameter2'], }), } ``` Als Nächstes rufen wir lokal unsere Lambda-Funktion auf und stellen unser benutzerdefiniertes Ereignis bereit. ``` $ sam local invoke --event events/apigateway_event.json Invoking app.lambda_handler (python3.9) Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/...sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Version: $LATEST some log END RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 REPORT RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Init Duration: 1.63 ms Duration: 564.07 ms Billed Duration: 565 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode": 200, "body": "{\"message\": \"value\"}"}% ``` ### Übergeben Sie Umgebungsvariablen, wenn Sie eine Lambda-Funktion lokal aufrufen Diese Anwendung hat eine Lambda-Funktion, die eine Umgebungsvariable für einen Amazon DynamoDB-Tabellennamen verwendet. Das Folgende ist ein Beispiel für die in der Vorlage definierte Funktion: AWS SAM ``` AWSTemplateFormatVersion: 2010-09-09 Transform: AWS::Serverless-2016-10-31 ... Resources: getAllItemsFunction: Type: AWS::Serverless::Function Properties: Handler: src/get-all-items.getAllItemsHandler Description: get all items Policies: - DynamoDBReadPolicy: TableName: !Ref SampleTable Environment: Variables: SAMPLE_TABLE: !Ref SampleTable ... ``` Wir möchten unsere Lambda-Funktion lokal testen und gleichzeitig mit unserer DynamoDB-Tabelle in der Cloud interagieren lassen. Dazu erstellen wir unsere Umgebungsvariablendatei und speichern sie im Stammverzeichnis unseres Projekts unter. `locals.json` Der hier angegebene Wert für `SAMPLE_TABLE` verweist auf unsere DynamoDB-Tabelle in der Cloud. ``` { "getAllItemsFunction": { "SAMPLE_TABLE": "dev-demo-SampleTable-1U991234LD5UM98" } } ``` Als Nächstes führen wir unsere Umgebungsvariablen mit der Option aus `sam local invoke` und übergeben sie. `--env-vars` ``` $ sam local invoke getAllItemsFunction --env-vars locals.json Mounting /Users/...sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Version: $LATEST some log END RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 REPORT RequestId: 59535d0d-3d9e-493d-8c98-6264e8e961b8 Init Duration: 1.63 ms Duration: 564.07 ms Billed Duration: 565 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode":200,"body":"{}"} ``` ## Weitere Informationen Eine Liste aller `sam local invoke` Optionen finden Sie unter[sam local invoke](sam-cli-command-reference-sam-local-invoke.md). Eine Demo der Verwendung `sam local` finden Sie unter [AWS SAM Lokale Entwicklung. Testen von AWS Cloud Ressourcen aus lokalen Entwicklungsumgebungen](https://www.youtube.com/watch?v=NzPqMrdgD1s&list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd&index=24) in der *Serverless Land Sessions with SAM-Serie*. YouTube # Einführung in das Testen mit sam local start-api Verwenden Sie den AWS Serverless Application Model `sam local start-api` Unterbefehl Command Line Interface (AWS SAMCLI), um Ihre AWS Lambda Funktionen lokal auszuführen und über einen lokalen HTTP-Serverhost zu testen. Diese Art von Test ist hilfreich für Lambda-Funktionen, die von einem Amazon API Gateway Gateway-Endpunkt aufgerufen werden. + Eine Einführung in das finden Sie unter AWS SAMCLI [Was ist das? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli) + Eine Liste der `sam local start-api` Befehlsoptionen finden Sie unter[sam local start-api](sam-cli-command-reference-sam-local-start-api.md). + Ein Beispiel für die Verwendung `sam local start-api` während eines typischen Entwicklungsworkflows finden Sie unter[Schritt 7: (Optional) Testen Sie Ihre Anwendung lokal](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-test). **Anmerkung** `sam local start-api`unterstützt langlebige Funktionen mit automatischem Checkpoint und Wiedergabefunktionen. Dauerhafte Funktionen arbeiten nahtlos mit dem lokalen API-Gateway-Endpunkt zusammen. ## Voraussetzungen Um das zu verwenden`sam local start-api`, installieren Sie das, AWS SAMCLI indem Sie wie folgt vorgehen: + [AWS SAM Voraussetzungen](prerequisites.md). + [Installieren Sie das AWS SAMCLI](install-sam-cli.md). Vor der Verwendung empfehlen wir`sam local start-api`, sich mit folgenden Grundkenntnissen vertraut zu machen: + [Konfiguration der AWS SAMCLI](using-sam-cli-configure.md). + [Erstellen Sie Ihre Bewerbung in AWS SAM](using-sam-cli-init.md). + [Einführung in das Bauen mit AWS SAM](using-sam-cli-build.md). + [Einführung in die Bereitstellung mit AWS SAM](using-sam-cli-deploy.md). ## Verwenden Sie dieselbe lokale Start-API Beim Ausführen AWS SAMCLI geht das davon aus`sam local start-api`, dass Ihr aktuelles Arbeitsverzeichnis das Stammverzeichnis Ihres Projekts ist. Das AWS SAMCLI sucht zuerst nach einer `template.[yaml|yml]` Datei in einem `.aws-sam` Unterordner. Wenn nicht gefunden, sucht der AWS SAMCLI nach einer `template.[yaml|yml]` Datei in Ihrem aktuellen Arbeitsverzeichnis. **Um einen lokalen HTTP-Server zu starten** 1. Führen Sie im Stammverzeichnis Ihres Projekts Folgendes aus: ``` $ sam local start-api ``` 1. Das AWS SAMCLI erstellt Ihre Lambda-Funktionen in einem lokalen Docker Container. Anschließend wird die lokale Adresse Ihres HTTP-Serverendpunkts ausgegeben. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local start-api Initializing the lambda functions containers. Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container Containers Initialization is done. Mounting HelloWorldFunction at http://127.0.0.1:3000/hello [GET] You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart SAM CLI if you update your AWS SAM template 2023-04-12 14:41:05 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3000 ``` 1. Sie können Ihre Lambda-Funktion über den Browser oder die Befehlszeile aufrufen. Im Folgenden wird ein Beispiel gezeigt: ``` sam-app$ curl http://127.0.0.1:3000/hello {"message": "Hello world!"}% ``` 1. Wenn Sie Änderungen an Ihrem Lambda-Funktionscode vornehmen, sollten Sie Folgendes beachten, um Ihren lokalen HTTP-Server zu aktualisieren: + Wenn Ihre Anwendung kein `.aws-sam` Verzeichnis hat und Ihre Funktion eine interpretierte Sprache verwendet, aktualisiert sie Ihre Funktion AWS SAMCLI automatisch, indem sie einen neuen Container erstellt und diesen hostet. + Wenn Ihre Anwendung über ein `.aws-sam` Verzeichnis verfügt, müssen Sie ausführen, `sam build` um Ihre Funktion zu aktualisieren. Führen Sie dann `sam local start-api` erneut aus, um die Funktion zu hosten. + Wenn Ihre Funktion eine kompilierte Sprache verwendet oder wenn Ihr Projekt komplexe Paketierungsunterstützung erfordert, führen Sie Ihre eigene Build-Lösung aus, um Ihre Funktion zu aktualisieren. Führen Sie dann `sam local start-api` erneut aus, um die Funktion zu hosten. ### Lambda-Funktionen, die Lambda-Autorisierer verwenden **Anmerkung** Diese Funktion ist neu in Version 1.80.0. AWS SAMCLI Informationen zum Upgrade finden Sie unter [Aktualisierung des AWS SAMCLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade). Bei Lambda-Funktionen, die Lambda-Autorisierer verwenden, rufen sie AWS SAMCLI automatisch Ihren Lambda-Autorisierer auf, bevor Sie Ihren Lambda-Funktionsendpunkt aufrufen. Im Folgenden finden Sie ein Beispiel für das Starten eines lokalen HTTP-Servers für eine Funktion, die einen Lambda-Authorizer verwendet: ``` $ sam local start-api 2023-04-17 15:02:13 Attaching import module proxy for analyzing dynamic imports AWS SAM CLI does not guarantee 100% fidelity between authorizers locally and authorizers deployed on AWS. Any application critical behavior should be validated thoroughly before deploying to production. Testing application behaviour against authorizers deployed on AWS can be done using the sam sync command. Mounting HelloWorldFunction at http://127.0.0.1:3000/authorized-request [GET] You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart SAM CLI if you update your AWS SAM template 2023-04-17 15:02:13 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3000 2023-04-17 15:02:13 Press CTRL+C to quit ``` Wenn Sie Ihren Lambda-Funktionsendpunkt über den lokalen HTTP-Server aufrufen, ruft der AWS SAMCLI erste Ihren Lambda-Authorizer auf. Wenn die Autorisierung erfolgreich ist, AWS SAMCLI wird der Endpunkt Ihrer Lambda-Funktion aufgerufen. Im Folgenden wird ein Beispiel gezeigt: ``` $ curl http://127.0.0.1:3000/authorized-request --header "header:my_token" {"message": "from authorizer"}% Invoking app.authorizer_handler (python3.8) Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.8-rapid-x86_64. Mounting /Users/.../sam-app/... as /var/task:ro,delegated, inside runtime container START RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0 Version: $LATEST END RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0 REPORT RequestId: 38d3b472-a2c8-4ea6-9a77-9b386989bef0 Init Duration: 1.08 ms Duration: 628.26 msBilled Duration: 629 ms Memory Size: 128 MB Max Memory Used: 128 MB Invoking app.request_handler (python3.8) Using local image: public.ecr.aws/lambda/python:3.8-rapid-x86_64. Mounting /Users/.../sam-app/... as /var/task:ro,delegated, inside runtime container START RequestId: fdc12255-79a3-4365-97e9-9459d06446ff Version: $LATEST END RequestId: fdc12255-79a3-4365-97e9-9459d06446ff REPORT RequestId: fdc12255-79a3-4365-97e9-9459d06446ff Init Duration: 0.95 ms Duration: 659.13 msBilled Duration: 660 ms Memory Size: 128 MB Max Memory Used: 128 MB No Content-Type given. Defaulting to 'application/json'. 2023-04-17 15:03:03 127.0.0.1 - - [17/Apr/2023 15:03:03] "GET /authorized-request HTTP/1.1" 200 - ``` ## Optionen ### Kontinuierliche Wiederverwendung von Containern zur Beschleunigung lokaler Funktionsaufrufe Standardmäßig AWS SAMCLI erstellt der jedes Mal, wenn Ihre Funktion über den lokalen HTTP-Server aufgerufen wird, einen neuen Container. Verwenden Sie die `--warm-containers` Option, um Ihren Container automatisch für Funktionsaufrufe wiederzuverwenden. Dies beschleunigt die Zeit, die benötigt wird, AWS SAMCLI um Ihre Lambda-Funktion für den lokalen Aufruf vorzubereiten. Sie können diese Option weiter anpassen, indem Sie das Argument `eager` oder `lazy` angeben. + `eager`— Container für alle Funktionen werden beim Start geladen und bleiben zwischen Aufrufen bestehen. + `lazy`— Container werden nur geladen, wenn jede Funktion zum ersten Mal aufgerufen wird. Sie bleiben dann für weitere Aufrufe bestehen. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local start-api --warm-containers eager ``` Wenn Sie Ihren Lambda-Funktionscode verwenden `--warm-containers` und ändern: + Wenn Ihre Anwendung über ein `.aws-sam` Verzeichnis verfügt, führen Sie `sam build` den Befehl aus, um Ihren Funktionscode in den Build-Artefakten Ihrer Anwendung zu aktualisieren. + Wenn eine Codeänderung erkannt wird, wird der Lambda-Funktionscontainer AWS SAMCLI automatisch heruntergefahren. + Wenn Sie die Funktion erneut aufrufen, erstellt der AWS SAMCLI automatisch einen neuen Container. ### Geben Sie ein Container-Image an, das für Ihre Lambda-Funktionen verwendet werden soll Standardmäßig AWS SAMCLI verwendet der Lambda-Basisimages aus Amazon Elastic Container Registry (Amazon ECR), um Ihre Funktionen lokal aufzurufen. Verwenden Sie die `--invoke-image` Option, um auf ein benutzerdefiniertes Container-Image zu verweisen. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local start-api --invoke-image public.ecr.aws/sam/emu-python3.8 ``` Sie können die Funktion angeben, die mit dem benutzerdefinierten Container-Image verwendet werden soll. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local start-api --invoke-image Function1=amazon/aws/sam-cli-emulation-image-python3.8 ``` ### Geben Sie eine Vorlage an, die lokal getestet werden soll Verwenden Sie die `--template` Option, AWS SAMCLI um eine Vorlage anzugeben, auf die verwiesen werden soll. Es AWS SAMCLI werden nur diese AWS SAM Vorlage und die Ressourcen, auf die sie verweist, geladen. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local start-api --template myTemplate.yaml ``` ### Geben Sie die Host-Entwicklungsumgebung Ihrer Lambda-Funktion an Standardmäßig erstellt der `sam local start-api` Unterbefehl einen HTTP-Server `localhost` mit IP-Adresse. `127.0.0.1` Sie können diese Werte anpassen, wenn Ihre lokale Entwicklungsumgebung von Ihrem lokalen Computer isoliert ist. Verwenden Sie die `--container-host` Option, um einen Host anzugeben. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local start-api --container-host host.docker.internal ``` Verwenden Sie die `--container-host-interface` Option, um die IP-Adresse des Host-Netzwerks anzugeben, an das Container-Ports gebunden werden sollen. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local start-api --container-host-interface 0.0.0.0 ``` ## Best Practices Wenn Ihre Anwendung ein `.aws-sam` Verzeichnis hat, das nicht ausgeführt wird`sam build`, stellen Sie sicher, dass es `sam build` jedes Mal ausgeführt wird, wenn Sie Ihren Funktionscode aktualisieren. Führen Sie dann `sam local start-api` die Ausführung aus, um Ihren aktualisierten Funktionscode lokal zu testen. Lokales Testen ist eine hervorragende Lösung für schnelles Entwickeln und Testen vor der Bereitstellung in der Cloud. Bei lokalen Tests wird jedoch nicht alles überprüft, z. B. die Berechtigungen zwischen Ihren Ressourcen in der Cloud. Testen Sie Ihre Anwendungen so oft wie möglich in der Cloud. Wir empfehlen `sam sync` die [Verwendung](using-sam-cli-sync.md), um Ihre Cloud-Test-Workflows zu beschleunigen. ## Weitere Informationen Eine Liste aller `sam local start-api` Optionen finden Sie unter[sam local start-api](sam-cli-command-reference-sam-local-start-api.md). # Einführung in das Testen mit sam local start-lambda Verwenden Sie den AWS SAMCLI Unterbefehl`sam local start-lambda`, um Ihre Lambda-Funktion über und aufzurufen. AWS CLI SDKs Dieser Befehl startet einen lokalen Endpunkt, der Lambda emuliert. + Eine Einführung in das finden Sie unter AWS SAMCLI [Was ist das? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli) + Eine Liste der `sam local start-lambda` Befehlsoptionen finden Sie unter[sam local start-lambda](sam-cli-command-reference-sam-local-start-lambda.md). **Anmerkung** `sam local start-lambda`unterstützt langlebige Funktionen mit automatischem Checkpoint und Wiedergabefunktionen. Dauerhafte Funktionen arbeiten nahtlos mit dem lokalen Lambda-Endpunkt zusammen. ## Voraussetzungen Um das zu verwenden`sam local start-lambda`, installieren Sie das, AWS SAMCLI indem Sie wie folgt vorgehen: + [AWS SAM Voraussetzungen](prerequisites.md). + [Installieren Sie das AWS SAMCLI](install-sam-cli.md). Vor der Verwendung empfehlen wir`sam local start-lambda`, sich mit folgenden Grundkenntnissen vertraut zu machen: + [Konfiguration der AWS SAMCLI](using-sam-cli-configure.md). + [Erstellen Sie Ihre Bewerbung in AWS SAM](using-sam-cli-init.md). + [Einführung in das Bauen mit AWS SAM](using-sam-cli-build.md). + [Einführung in die Bereitstellung mit AWS SAM](using-sam-cli-deploy.md). ## Sam Local Start-Lambda verwenden Beim Ausführen AWS SAMCLI geht das davon aus`sam local start-lambda`, dass Ihr aktuelles Arbeitsverzeichnis das Stammverzeichnis Ihres Projekts ist. Das AWS SAMCLI sucht zuerst nach einer `template.[yaml|yml]` Datei in einem `.aws-sam` Unterordner. Wenn nicht gefunden, sucht der AWS SAMCLI nach einer `template.[yaml|yml]` Datei in Ihrem aktuellen Arbeitsverzeichnis. **Um Sam Local Start-Lambda zu verwenden** 1. Führen Sie im Stammverzeichnis Ihres Projekts Folgendes aus: ``` $ sam local start-lambda ``` 1. Das AWS SAMCLI erstellt Ihre Lambda-Funktionen in einem lokalen Docker Container. Anschließend wird die lokale Adresse an Ihren HTTP-Serverendpunkt ausgegeben. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local start-lambda Initializing the lambda functions containers. Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../sam-app/hello_world as /var/task:ro,delegated, inside runtime container Containers Initialization is done. Starting the Local Lambda Service. You can now invoke your Lambda Functions defined in your template through the endpoint. 2023-04-13 07:25:43 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3001 2023-04-13 07:25:43 Press CTRL+C to quit ``` 1. Verwenden Sie das AWS CLI oder SDKs , um Ihre Lambda-Funktion lokal aufzurufen. Das Folgende ist ein Beispiel für die Verwendung von: AWS CLI ``` $ aws lambda invoke --function-name "HelloWorldFunction" --endpoint-url "http://127.0.0.1:3001" --no-verify-ssl out.txt StatusCode: 200 (END) ``` Das Folgende ist ein Beispiel AWS SDK für die Verwendung vonPython: ``` import boto3 from botocore.config import Config from botocore import UNSIGNED lambda_client = boto3.client('lambda', endpoint_url="http://127.0.0.1:3001", use_ssl=False, verify=False, config=Config(signature_version=UNSIGNED, read_timeout=1, retries={'max_attempts': 0} ) ) lambda_client.invoke(FunctionName="HelloWorldFunction") ``` ## Optionen ### Geben Sie eine Vorlage an Verwenden Sie die `--template` Option, AWS SAMCLI um eine Vorlage anzugeben, auf die verwiesen werden soll. Es AWS SAMCLI werden nur diese AWS SAM Vorlage und die Ressourcen, auf die sie verweist, geladen. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam local start-lambda --template myTemplate.yaml ``` Weitere Informationen zu AWS SAM Vorlagen finden Sie unter[AWS SAM Anatomie der Vorlage](sam-specification-template-anatomy.md). ## Best Practices Wenn Ihre Anwendung ein `.aws-sam` Verzeichnis hat, das ausgeführt wird`sam build`, stellen Sie sicher, dass es `sam build` jedes Mal ausgeführt wird, wenn Sie Ihren Funktionscode aktualisieren. Führen Sie dann `sam local start-lambda` die Ausführung aus, um Ihren aktualisierten Funktionscode lokal zu testen. Lokales Testen ist eine hervorragende Lösung für schnelles Entwickeln und Testen vor der Bereitstellung in der Cloud. Bei lokalen Tests wird jedoch nicht alles überprüft, z. B. die Berechtigungen zwischen Ihren Ressourcen in der Cloud. Testen Sie Ihre Anwendungen so oft wie möglich in der Cloud. Wir empfehlen `sam sync` die [Verwendung](using-sam-cli-sync.md), um Ihre Cloud-Test-Workflows zu beschleunigen. ## Weitere Informationen Eine Liste aller `sam local start-lambda` Optionen finden Sie unter[sam local start-lambda](sam-cli-command-reference-sam-local-start-lambda.md). # Lokal Lambda-Funktionen aufrufen mit AWS SAM Das lokale Aufrufen einer Lambda-Funktion vor dem Testen oder Bereitstellen in der Cloud kann eine Reihe von Vorteilen haben. Es ermöglicht Ihnen, die Logik Ihrer Funktion schneller zu testen. Wenn Sie zuerst lokal testen, verringert sich die Wahrscheinlichkeit, dass Probleme beim Testen in der Cloud oder während der Bereitstellung erkannt werden, wodurch Sie unnötige Kosten vermeiden können. Darüber hinaus erleichtern lokale Tests das Debuggen. Sie können Ihre Lambda-Funktion lokal aufrufen, indem Sie den [sam local invoke](sam-cli-command-reference-sam-local-invoke.md) Befehl verwenden und die logische ID der Funktion und eine Ereignisdatei angeben. **sam local invoke**akzeptiert auch `stdin` als Ereignis. Weitere Informationen zu Veranstaltungen finden Sie unter [Ereignis](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-event) im *AWS Lambda Entwicklerhandbuch*. Informationen zu den Formaten von Ereignisnachrichten verschiedener AWS Dienste finden Sie im *AWS Lambda Entwicklerhandbuch* [unter Verwendung AWS Lambda mit anderen Diensten](https://docs.aws.amazon.com/lambda/latest/dg/lambda-services.html). **Anmerkung** Es wird nicht empfohlen, die lokalen Aufruffunktionen von SAM CLI in nicht vertrauenswürdigem Code zu verwenden. Um vollständig von Ihrer lokalen Umgebung isoliert zu sein, führen Sie den Code direkt im Lambda-Service aus. **Anmerkung** Der **sam local invoke** Befehl entspricht dem Befehl AWS Command Line Interface (AWS CLI). [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/invoke.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/invoke.html) Sie können beide Befehle verwenden, um eine Lambda-Funktion aufzurufen. Sie müssen den **sam local invoke** Befehl in dem Projektverzeichnis ausführen, das die Funktion enthält, die Sie aufrufen möchten. Beispiele: ``` # Invoking function with event file $ sam local invoke "Ratings" -e event.json # Invoking function with event via stdin $ echo '{"message": "Hey, are you there?" }' | sam local invoke --event - "Ratings" # For more options $ sam local invoke --help ``` ## Umgebungsvariablendatei Gehen Sie wie folgt vor, um Umgebungsvariablen lokal zu deklarieren, die die in Ihren Vorlagen definierten Werte überschreiben: 1. Erstellen Sie eine `.env` JSON-Datei oder eine Datei, die die zu überschreibenden Umgebungsvariablen enthält. 1. Verwenden Sie das `--env-vars` Argument, um die in Ihren Vorlagen definierten Werte zu überschreiben. Die `--env-vars` Option unterstützt zwei Dateiformate. Das Dateiformat wird anhand des Dateiinhalts automatisch erkannt. ### Deklarieren von Umgebungsvariablen mit JSON Um Umgebungsvariablen zu deklarieren, die global für alle Ressourcen gelten, geben Sie ein `Parameters` Objekt wie das Folgende an: ``` { "Parameters": { "TABLE_NAME": "localtable", "BUCKET_NAME": "amzn-s3-demo-bucket", "STAGE": "dev" } } ``` Um unterschiedliche Umgebungsvariablen für jede Ressource zu deklarieren, geben Sie Objekte für jede Ressource wie folgt an: ``` { "MyFunction1": { "TABLE_NAME": "localtable", "BUCKET_NAME": "amzn-s3-demo-bucket", }, "MyFunction2": { "TABLE_NAME": "localtable", "STAGE": "dev" } } ``` Bei der Angabe von Objekten für jede Ressource können Sie die folgenden Bezeichner verwenden, die in der Reihenfolge von höchster bis niedrigster Priorität aufgeführt sind: 1. `logical_id` 1. `function_id` 1. `function_name` 1. Vollständige Pfadkennung Sie können beide oben genannten Methoden zum Deklarieren von Umgebungsvariablen zusammen in einer einzigen Datei verwenden. Dabei haben Umgebungsvariablen, die Sie für bestimmte Ressourcen bereitgestellt haben, Vorrang vor globalen Umgebungsvariablen. Speichern Sie Ihre Umgebungsvariablen in einer JSON-Datei, z. B. `env.json` ### Deklarieren von Umgebungsvariablen mit .env-Dateien Sie können auch eine `.env` Datei verwenden, um Umgebungsvariablen zu deklarieren. In einer `.env` Datei deklarierte Variablen gelten global für alle Funktionen und entsprechen dem `Parameters` Objekt im JSON-Format. ``` TABLE_NAME=localtable BUCKET_NAME=amzn-s3-demo-bucket STAGE=dev ``` Das `.env` Format unterstützt Kommentare (Zeilen, die mit beginnen`#`) und Werte in Anführungszeichen. **Anmerkung** Das `.env` Format unterstützt nur globale Umgebungsvariablen. Verwenden Sie das JSON-Format, um funktionsspezifische Umgebungsvariablen zu deklarieren. ### Werte von Umgebungsvariablen überschreiben Um Umgebungsvariablen mit denen zu überschreiben, die in Ihrer Umgebungsvariablendatei definiert sind, verwenden Sie das `--env-vars` Argument mit den **start-api** Befehlen **invoke** oder. Beispiel: ``` # Using a JSON file sam local invoke --env-vars env.json # Using a .env file sam local invoke --env-vars .env ``` ## Layer Wenn Ihre Anwendung Ebenen enthält, finden Sie Informationen zum Debuggen von Problemen mit Layern auf Ihrem lokalen Host unter[Steigern Sie die Effizienz mithilfe von Lambda-Schichten mit AWS SAM](serverless-sam-cli-layers.md). ## Weitere Informationen Ein praktisches Beispiel für das lokale Aufrufen von Funktionen finden Sie in [Modul 2 — Lokal ausführen](https://s12d.com/sam-ws-en-local) in *The Complete AWS SAM Workshop*. # Lokal ausgeführtes API Gateway mit AWS SAM Die lokale Ausführung von Amazon API Gateway kann eine Vielzahl von Vorteilen haben. Wenn Sie API Gateway lokal ausführen, können Sie beispielsweise API-Endpunkte vor der Bereitstellung in der AWS Cloud lokal testen. Wenn Sie zuerst lokal testen, können Sie häufig weniger Tests und Entwicklungen in der Cloud durchführen, was zur Kostensenkung beitragen kann. Darüber hinaus erleichtert die lokale Ausführung das Debuggen. Verwenden Sie den Befehl, um eine lokale Instanz von API Gateway zu starten, mit der Sie die HTTP-Anforderungs-/Antwortfunktionalität testen können. `sam local start-api` AWS SAMCLI Diese Funktion bietet Hot-Reloading, sodass Sie Ihre Funktionen schnell weiterentwickeln und überarbeiten können. **Anmerkung** *Beim erneuten Laden* im laufenden Betrieb werden nur die Dateien aktualisiert, die sich geändert haben, und der Status der Anwendung bleibt unverändert. Im Gegensatz dazu wird *beim Live-Reloading* die gesamte Anwendung aktualisiert und der Status der Anwendung geht verloren. Anweisungen zur Verwendung des `sam local start-api` Befehls finden Sie unter. [Einführung in das Testen mit sam local start-api](using-sam-cli-local-start-api.md) AWS SAM Verwendet standardmäßig AWS Lambda Proxyintegrationen und unterstützt sowohl `HttpApi` `Api` Ressourcentypen als auch. Weitere Informationen zu Proxyintegrationen für `HttpApi` Ressourcentypen finden Sie unter [Arbeiten mit AWS Lambda Proxyintegrationen für HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html) im *API Gateway Developer Guide*. Weitere Informationen zu Proxyintegrationen mit `Api` Ressourcentypen finden Sie unter [Grundlegendes zur API Gateway Lambda-Proxyintegration](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-create-api-as-simple-proxy) im *API Gateway Developer Guide*. **Beispiel:** ``` $ sam local start-api ``` AWS SAM findet automatisch alle Funktionen in Ihrer AWS SAM Vorlage, für die `Api` Ereignisquellen `HttpApi` definiert wurden. Dann hängt es die Funktion an den definierten HTTP-Pfaden ein. Im folgenden `Api` Beispiel wird die `Ratings` Funktion `ratings.py:handler()` bei For-Anfragen eingebunden`/ratings`: `GET` ``` Ratings: Type: AWS::Serverless::Function Properties: Handler: ratings.handler Runtime: python3.9 Events: Api: Type: Api Properties: Path: /ratings Method: get ``` Hier ist ein Beispiel für eine `Api` Antwort: ``` // Example of a Proxy Integration response exports.handler = (event, context, callback) => { callback(null, { statusCode: 200, headers: { "x-custom-header" : "my custom header value" }, body: "hello world" }); } ``` Wenn Sie den Code Ihrer Funktion ändern, führen Sie den `sam build` Befehl for aus, `sam local start-api` um Ihre Änderungen zu erkennen. ## Umgebungsvariablendatei Gehen Sie wie folgt vor, um Umgebungsvariablen lokal zu deklarieren, die die in Ihren Vorlagen definierten Werte überschreiben: 1. Erstellen Sie eine JSON-Datei, die die zu überschreibenden Umgebungsvariablen enthält. 1. Verwenden Sie das `--env-vars` Argument, um die in Ihren Vorlagen definierten Werte zu überschreiben. ### Umgebungsvariablen deklarieren Um Umgebungsvariablen zu deklarieren, die global für alle Ressourcen gelten, geben Sie ein `Parameters` Objekt wie das Folgende an: ``` { "Parameters": { "TABLE_NAME": "localtable", "BUCKET_NAME": "amzn-s3-demo-bucket", "STAGE": "dev" } } ``` Um unterschiedliche Umgebungsvariablen für jede Ressource zu deklarieren, geben Sie Objekte für jede Ressource wie folgt an: ``` { "MyFunction1": { "TABLE_NAME": "localtable", "BUCKET_NAME": "amzn-s3-demo-bucket", }, "MyFunction2": { "TABLE_NAME": "localtable", "STAGE": "dev" } } ``` Bei der Angabe von Objekten für jede Ressource können Sie die folgenden Bezeichner verwenden, die in der Reihenfolge von höchster bis niedrigster Priorität aufgeführt sind: 1. `logical_id` 1. `function_id` 1. `function_name` 1. Vollständige Pfadkennung Sie können beide oben genannten Methoden zum Deklarieren von Umgebungsvariablen zusammen in einer einzigen Datei verwenden. Dabei haben Umgebungsvariablen, die Sie für bestimmte Ressourcen bereitgestellt haben, Vorrang vor globalen Umgebungsvariablen. Speichern Sie Ihre Umgebungsvariablen in einer JSON-Datei, z. B. `env.json` ### Werte von Umgebungsvariablen überschreiben Um Umgebungsvariablen mit den in Ihrer JSON-Datei definierten Variablen zu überschreiben, verwenden Sie das `--env-vars` Argument mit den **start-api** Befehlen **invoke** oder. Beispiel: ``` $ sam local start-api --env-vars env.json ``` ## Layer Wenn Ihre Anwendung Ebenen enthält, finden Sie Informationen zum Debuggen von Problemen mit Layern auf Ihrem lokalen Host unter[Steigern Sie die Effizienz mithilfe von Lambda-Schichten mit AWS SAM](serverless-sam-cli-layers.md). # Einführung in Cloud-Tests mit sam remote test-event Verwenden Sie den AWS Serverless Application Model Befehl Command Line Interface (AWS SAM CLI)`sam remote test-event`, um auf gemeinsam nutzbare Testereignisse für Ihre AWS Lambda Funktionen zuzugreifen und diese zu verwalten. *Weitere Informationen zu gemeinsam nutzbaren Testereignissen finden Sie unter Gemeinsam [nutzbare Testereignisse im AWS Lambda Entwicklerhandbuch](https://docs.aws.amazon.com/lambda/latest/dg/testing-functions.html#creating-shareable-events).* **Topics** + [Richten Sie das ein AWS SAMCLI, um es zu verwenden sam remote test-event](#using-sam-cli-remote-test-event-setup) + [Verwenden Sie den Befehl sam remote test-event](#using-sam-cli-remote-test-event-use) + [Testereignisse verwenden, die gemeinsam genutzt werden können](#using-sam-cli-remote-test-event-invoke) + [Verwaltung gemeinsam nutzbarer Testereignisse](#using-sam-cli-remote-test-event-manage) ## Voraussetzungen Um das zu verwenden`sam remote test-event`, installieren Sie das, AWS SAMCLI indem Sie wie folgt vorgehen: + [AWS SAM Voraussetzungen](prerequisites.md). + [Installieren Sie das AWS SAMCLI](install-sam-cli.md). Wenn Sie die Version bereits AWS SAM CLI installiert haben, empfehlen wir, auf die neueste Version der AWS SAMCLI Version zu aktualisieren. Weitere Informationen hierzu finden Sie unter [Aktualisierung des AWS SAMCLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade). Vor der Verwendung empfehlen wir`sam remote test-event`, sich mit folgenden Grundkenntnissen vertraut zu machen: + [Konfiguration der AWS SAMCLI](using-sam-cli-configure.md). + [Erstellen Sie Ihre Bewerbung in AWS SAM](using-sam-cli-init.md). + [Einführung in das Bauen mit AWS SAM](using-sam-cli-build.md). + [Einführung in die Bereitstellung mit AWS SAM](using-sam-cli-deploy.md). + [Einführung in die Verwendung von sam sync to sync to AWS Cloud](using-sam-cli-sync.md). ## Richten Sie das ein AWS SAMCLI, um es zu verwenden sam remote test-event Führen Sie die folgenden Einrichtungsschritte aus, um den Befehl zu verwenden: AWS SAM CLI `sam remote test-event` 1. **Configure the AWS SAM CLI to use your AWS-Konto** — Gemeinsam nutzbare Testereignisse für Lambda können von Benutzern innerhalb desselben aufgerufen und verwaltet werden. AWS-Konto Informationen zur Konfiguration für AWS SAM CLI die Verwendung Ihres finden Sie AWS-Konto unter. [Konfiguration der AWS SAMCLI](using-sam-cli-configure.md) 1. **Berechtigungen für gemeinsam nutzbare Testereignisse konfigurieren** — Um auf gemeinsam nutzbare Testereignisse zuzugreifen und diese zu verwalten, benötigen Sie die entsprechenden Berechtigungen. *Weitere Informationen finden Sie unter Gemeinsam [nutzbare Testereignisse im Entwicklerhandbuch](https://docs.aws.amazon.com/lambda/latest/dg/testing-functions.html#creating-shareable-events).AWS Lambda * ## Verwenden Sie den Befehl sam remote test-event Der AWS SAM CLI `sam remote test-event` Befehl enthält die folgenden Unterbefehle, mit denen Sie auf Ihre gemeinsam nutzbaren Testereignisse zugreifen und diese verwalten können: + `delete`— Löscht ein gemeinsam nutzbares Testereignis aus der EventBridge Amazon-Schemaregistry. + `get`— Ruft ein gemeinsam nutzbares Testereignis aus der EventBridge Schemaregistry ab. + `list`— Listet die vorhandenen gemeinsam nutzbaren Testereignisse für eine Funktion aus der EventBridge Schemaregistry auf. + `put`— Speichert ein Ereignis aus einer lokalen Datei in der EventBridge Schemaregistrierung. Um diese Unterbefehle mithilfe von aufzulisten AWS SAM CLI, führen Sie den folgenden Befehl aus: ``` $ sam remote test-event --help ``` ### Löschen von gemeinsam nutzbaren Testereignissen Sie können ein gemeinsam nutzbares Testereignis löschen, indem Sie den `delete` Unterbefehl zusammen mit dem folgenden Befehl verwenden: + Geben Sie den Namen des gemeinsam nutzbaren Testereignisses ein, das gelöscht werden soll. + Geben Sie eine akzeptable ID der Lambda-Funktion an, die dem Ereignis zugeordnet ist. + Wenn Sie die logische ID der Lambda-Funktion angeben, müssen Sie auch den AWS CloudFormation Stacknamen angeben, der der Lambda-Funktion zugeordnet ist. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam remote test-event delete HelloWorldFunction --stack-name sam-app --name demo-event ``` Eine Liste der Optionen, die mit dem `delete` Unterbefehl verwendet werden können, finden Sie unter. [sam remote test-event delete](sam-cli-command-reference-remote-test-event-delete.md) Sie können Folgendes auch über den folgenden Befehl ausführen: AWS SAM CLI ``` $ sam remote test-event delete --help ``` ### Testereignisse abrufen, die gemeinsam genutzt werden können Sie können ein gemeinsam nutzbares Testereignis aus der EventBridge Schemaregistrierung abrufen, indem Sie den `get` Unterbefehl zusammen mit dem folgenden Befehl verwenden: + Geben Sie den Namen des gemeinsam nutzbaren Testereignisses ein, das abgerufen werden soll. + Geben Sie eine akzeptable ID der Lambda-Funktion an, die dem Ereignis zugeordnet ist. + Wenn Sie die logische ID der Lambda-Funktion angeben, müssen Sie auch den AWS CloudFormation Stacknamen angeben, der der Lambda-Funktion zugeordnet ist. Im folgenden Beispiel wird ein gemeinsam nutzbares Testereignis benannt`demo-event`, das der `HelloWorldFunction` Lambda-Funktion des `sam-app` Stacks zugeordnet ist. Mit diesem Befehl wird das Ereignis auf Ihrer Konsole gedruckt. ``` $ sam remote test-event get HelloWorldFunction --stack-name sam-app --name demo-event ``` Um ein gemeinsam nutzbares Testereignis abzurufen und es auf Ihrem lokalen Computer zu speichern, verwenden Sie die `--output-file` Option und geben Sie einen Dateipfad und einen Namen an. Im Folgenden finden Sie ein Beispiel, das `demo-event` wie `demo-event.json` im aktuellen Arbeitsverzeichnis gespeichert wird: ``` $ sam remote test-event get HelloWorldFunction --stack-name sam-app --name demo-event --output-file demo-event.json ``` Eine Liste der Optionen, die mit dem `get` Unterbefehl verwendet werden können, finden Sie unter[sam remote test-event get](sam-cli-command-reference-remote-test-event-get.md). Sie können Folgendes auch über den folgenden Befehl ausführen: AWS SAM CLI ``` $ sam remote test-event get --help ``` ### Testereignisse auflisten, die gemeinsam genutzt werden können Sie können alle gemeinsam nutzbaren Testereignisse für eine bestimmte Lambda-Funktion aus der Schemaregistrierung auflisten. Verwenden Sie den `list` Unterbefehl zusammen mit dem Folgenden: + Geben Sie eine akzeptable ID der Lambda-Funktion an, die den Ereignissen zugeordnet ist. + Wenn Sie die logische ID der Lambda-Funktion angeben, müssen Sie auch den CloudFormation Stacknamen angeben, der der Lambda-Funktion zugeordnet ist. Im Folgenden finden Sie ein Beispiel, das eine Liste aller gemeinsam nutzbaren Testereignisse abruft, die mit der `HelloWorldFunction` Lambda-Funktion des Stacks verknüpft sind: `sam-app` ``` $ sam remote test-event list HelloWorldFunction --stack-name sam-app ``` Eine Liste der Optionen, die mit dem `list` Unterbefehl verwendet werden können, finden Sie unter. [sam remote test-event list](sam-cli-command-reference-remote-test-event-list.md) Sie können Folgendes auch über den folgenden Befehl ausführen: AWS SAM CLI ``` $ sam remote test-event list --help ``` ### Testereignisse speichern, die gemeinsam genutzt werden können Sie können gemeinsam nutzbare Testereignisse in der EventBridge Schemaregistrierung speichern. Verwenden Sie den `put` Unterbefehl zusammen mit dem Folgenden: + Geben Sie eine akzeptable ID der Lambda-Funktion an, die dem gemeinsam nutzbaren Testereignis zugeordnet ist. + Geben Sie einen Namen für das gemeinsam nutzbare Testereignis an. + Geben Sie den Dateipfad und den Namen des lokalen Ereignisses an, das hochgeladen werden soll. Das folgende Beispiel speichert das lokale `demo-event.json` Ereignis unter `demo-event` und verknüpft es mit der `HelloWorldFunction` Lambda-Funktion des `sam-app` Stacks: ``` $ sam remote test-event put HelloWorldFunction --stack-name sam-app --name demo-event --file demo-event.json ``` Wenn ein gemeinsam nutzbares Testereignis mit demselben Namen in der EventBridge Schemaregistrierung vorhanden ist, AWS SAM CLI wird es nicht überschrieben. Um zu überschreiben, fügen Sie die `--force` Option zu Ihrem Befehl hinzu. Eine Liste der Optionen, die Sie mit dem `put` Unterbefehl verwenden können, finden Sie unter. [sam remote test-event put](sam-cli-command-reference-remote-test-event-put.md) Sie können Folgendes auch über den folgenden Befehl ausführen: AWS SAM CLI ``` $ sam remote test-event put --help ``` ## Testereignisse verwenden, die gemeinsam genutzt werden können Verwenden Sie gemeinsam nutzbare Testereignisse, um Ihre Lambda-Funktionen AWS Cloud mit dem `sam remote invoke` Befehl zu testen. Weitere Informationen hierzu finden Sie unter [Übergeben Sie gemeinsam nutzbare Testereignisse an eine Lambda-Funktion in der Cloud](using-sam-cli-remote-invoke.md#using-sam-cli-remote-invoke-shareable). ## Verwaltung gemeinsam nutzbarer Testereignisse Dieses Thema enthält Beispiele dafür, wie Sie gemeinsam nutzbare Testereignisse verwalten und verwenden können. ### Holen Sie sich ein gemeinsam nutzbares Testereignis, ändern Sie es und verwenden Sie es Sie können ein gemeinsam nutzbares Testereignis aus der EventBridge Schemaregistrierung abrufen, es lokal ändern und das lokale Testereignis mit Ihrer Lambda-Funktion in der verwenden. AWS Cloud Im Folgenden wird ein Beispiel gezeigt: 1. **Das gemeinsam nutzbare Testereignis abrufen** — Verwenden Sie den `sam remote test-event get` Unterbefehl, um ein gemeinsam nutzbares Testereignis für eine bestimmte Lambda-Funktion abzurufen und lokal zu speichern: ``` $ sam remote test-event get HelloWorldFunction --stack-name sam-app --name demo-event --output-file demo-event.json ``` 1. **Das gemeinsam nutzbare Testereignis ändern** — Verwenden Sie einen Texteditor Ihrer Wahl, um das gemeinsam nutzbare Testereignis zu ändern. 1. **Das gemeinsam nutzbare Testereignis** verwenden — Verwenden Sie den `sam remote invoke` Befehl und geben Sie den Dateipfad und den Namen des Ereignisses mit: `--event-file` ``` $ sam remote invoke HelloWorldFunction --stack-name sam-app --event-file demo-event.json ``` ### Holen Sie sich ein gemeinsam nutzbares Testereignis, ändern Sie es, laden Sie es hoch und verwenden Sie es Sie können ein gemeinsam nutzbares Testereignis aus der EventBridge Schemaregistrierung abrufen, es lokal ändern und hochladen. Anschließend können Sie das gemeinsam nutzbare Testereignis direkt an Ihre Lambda-Funktion in übergeben. AWS Cloud Im Folgenden wird ein Beispiel gezeigt: 1. **Das gemeinsam nutzbare Testereignis abrufen** — Verwenden Sie den `sam remote test-event get` Unterbefehl, um ein gemeinsam nutzbares Testereignis für eine bestimmte Lambda-Funktion abzurufen und lokal zu speichern: ``` $ sam remote test-event get HelloWorldFunction --stack-name sam-app --name demo-event --output-file demo-event.json ``` 1. **Das gemeinsam nutzbare Testereignis ändern** — Verwenden Sie einen Texteditor Ihrer Wahl, um das gemeinsam nutzbare Testereignis zu ändern. 1. **Das gemeinsam nutzbare Testereignis hochladen** — Verwenden Sie den `sam remote test-event put` Unterbefehl, um das gemeinsam nutzbare Testereignis hochzuladen und in der Schemaregistrierung zu speichern. EventBridge In diesem Beispiel verwenden wir die `--force` Option, um eine ältere Version unseres gemeinsam nutzbaren Tests zu überschreiben: ``` $ sam remote test-event put HelloWorldFunction --stack-name sam-app --name demo-event --file demo-event.json --force ``` 1. **Übergeben Sie das gemeinsam nutzbare Testereignis an Ihre Lambda-Funktion** — Verwenden Sie den `sam remote invoke` Befehl, um das gemeinsam nutzbare Testereignis direkt an Ihre Lambda-Funktion zu übergeben in: AWS Cloud ``` $ sam remote invoke HelloWorldFunction --stack-name sam-app --test-event-name demo-event ``` # Einführung in das Testen in der Cloud mit sam remote invoke Verwenden Sie den AWS Serverless Application Model Befehl Command Line Interface (AWS SAM CLI)`sam remote invoke`, um mit unterstützten AWS Ressourcen in der zu interagieren AWS Cloud. Sie können `sam remote invoke` es verwenden, um die folgenden Ressourcen aufzurufen: + **Amazon Kinesis Data Streams** — Senden Sie Datensätze an Kinesis Data Streams Streams-Anwendungen. + **AWS Lambda**— Rufen Sie Ereignisse auf und übergeben Sie sie an Ihre Lambda-Funktionen. + **Amazon Simple Queue Service (Amazon SQS)** — Nachrichten an Amazon SQS SQS-Warteschlangen senden. + **AWS Step Functions**— Ruft Step Functions Functions-Zustandsmaschinen auf, um die Ausführung zu starten. Eine Einführung in die finden Sie AWS SAMCLI unter [Was ist das? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli) Ein Beispiel für die Verwendung `sam remote invoke` während eines typischen Entwicklungsworkflows finden Sie unter[Schritt 5: Interagieren Sie mit Ihrer Funktion im AWS Cloud](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-remote-invoke). **Topics** + [Verwenden Sie den Befehl sam remote invoke](#using-sam-cli-remote-invoke-use) + [Verwenden von Sam Remote Invoke-Befehlsoptionen](#using-sam-cli-remote-invoke-options) + [Konfigurieren Sie Ihre Projektkonfigurationsdatei](#using-sam-cli-remote-invoke-configure) + [Beispiele](#using-sam-cli-remote-invoke-examples) + [Weiterführende Links](#using-sam-cli-remote-invoke-links) ## Voraussetzungen Um das zu verwenden`sam remote invoke`, installieren Sie das, AWS SAMCLI indem Sie wie folgt vorgehen: + [AWS SAM Voraussetzungen](prerequisites.md). + [Installieren Sie das AWS SAMCLI](install-sam-cli.md). Wir empfehlen außerdem, auf die neueste Version von zu aktualisieren AWS SAMCLI. Weitere Informationen hierzu finden Sie unter [Aktualisierung des AWS SAMCLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade). Vor der Verwendung empfehlen wir`sam remote invoke`, sich mit folgenden Grundkenntnissen vertraut zu machen: + [Konfiguration der AWS SAMCLI](using-sam-cli-configure.md). + [Erstellen Sie Ihre Bewerbung in AWS SAM](using-sam-cli-init.md). + [Einführung in das Bauen mit AWS SAM](using-sam-cli-build.md). + [Einführung in die Bereitstellung mit AWS SAM](using-sam-cli-deploy.md). + [Einführung in die Verwendung von sam sync to sync to AWS Cloud](using-sam-cli-sync.md). ## Verwenden Sie den Befehl sam remote invoke Bevor Sie diesen Befehl verwenden können, muss Ihre Ressource auf dem AWS Cloud bereitgestellt werden. Verwenden Sie die folgende Befehlsstruktur und führen Sie sie im Stammverzeichnis Ihres Projekts aus: ``` $ sam remote invoke ``` **Anmerkung** Auf dieser Seite werden Optionen angezeigt, die an der Befehlszeile bereitgestellt werden. Sie können Optionen auch in der Konfigurationsdatei Ihres Projekts konfigurieren, anstatt sie an der Befehlszeile zu übergeben. Weitere Informationen hierzu finden Sie unter [Konfigurieren Sie die Projekteinstellungen](using-sam-cli-configure.md#using-sam-cli-configure-project). Eine Beschreibung der `sam remote invoke` Argumente und Optionen finden Sie unter[sam remote invoke](sam-cli-command-reference-remote-invoke.md). ### Verwendung mit Kinesis Data Streams Sie können Datensätze an eine Kinesis Data Streams Streams-Anwendung senden. Sie AWS SAM CLI sendet Ihren Datensatz und gibt eine Shard-ID und eine Sequenznummer zurück. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam remote invoke KinesisStream --stack-name kinesis-example --event hello-world Putting record to Kinesis data stream KinesisStream Auto converting value 'hello-world' into JSON '"hello-world"'. If you don't want auto-conversion, please provide a JSON string as event { "ShardId": "shardId-000000000000", "SequenceNumber": "49646251411914806775980850790050483811301135051202232322" }% ``` **Um einen Datensatz zu senden** 1. Geben Sie einen Ressourcen-ID-Wert als Argument für Ihre Kinesis Data Streams Streams-Anwendung an. Informationen zu gültigen Ressourcen finden Sie IDs unter [Ressourcen-ID.](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id) 1. Stellen Sie den Datensatz als Ereignis bereit, das an Ihre Kinesis Data Streams Streams-Anwendung gesendet werden soll. Sie können das Ereignis mit der `--event` Option in der Befehlszeile oder mithilfe von aus einer Datei angeben. `--event-file` Wenn Sie kein Ereignis angeben, AWS SAM CLI sendet das ein leeres Ereignis. ### Verwendung mit Lambda-Funktionen Sie können eine Lambda-Funktion in der Cloud aufrufen und ein leeres Ereignis übergeben oder ein Ereignis in der Befehlszeile oder aus einer Datei bereitstellen. Das ruft AWS SAM CLI Ihre Lambda-Funktion auf und gibt ihre Antwort zurück. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam remote invoke HelloWorldFunction --stack-name sam-app Invoking Lambda Function HelloWorldFunction START RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9 Version: $LATEST END RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9 REPORT RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9 Duration: 6.62 ms Billed Duration: 7 ms Memory Size: 128 MB Max Memory Used: 67 MB Init Duration: 164.06 ms {"statusCode":200,"body":"{\"message\":\"hello world\"}"}% ``` **Um eine Lambda-Funktion aufzurufen** 1. Geben Sie einen Ressourcen-ID-Wert als Argument für Ihre Lambda-Funktion an. Informationen zu gültigen Ressourcen finden Sie IDs unter [Ressourcen-ID.](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id) 1. Geben Sie ein Ereignis an, das an Ihre Lambda-Funktion gesendet werden soll. Sie können das Ereignis in der Befehlszeile mit der `--event` Option oder aus einer Datei mit `--event-file` angeben. Wenn Sie kein Ereignis angeben, AWS SAM CLI sendet das ein leeres Ereignis. #### Mit Response-Streaming konfigurierte Lambda-Funktionen Der `sam remote invoke` Befehl unterstützt Lambda-Funktionen, die für das Streamen von Antworten konfiguriert sind. Sie können eine Lambda-Funktion so konfigurieren, dass sie Antworten streamt, indem Sie die `FunctionUrlConfig` Eigenschaft in Ihren AWS SAM Vorlagen verwenden. Wenn Sie es verwenden`sam remote invoke`, erkennt das AWS SAMCLI automatisch Ihre Lambda-Konfiguration und wird mit Antwort-Streaming aufgerufen. Ein Beispiel finden Sie unter [Rufen Sie eine Lambda-Funktion auf, die für das Streamen von Antworten konfiguriert ist](#using-sam-cli-remote-invoke-examples-lambda-stream). #### Übergeben Sie gemeinsam nutzbare Testereignisse an eine Lambda-Funktion in der Cloud Gemeinsam nutzbare Testereignisse sind Testereignisse, die Sie mit anderen teilen können. AWS-Konto Weitere Informationen finden Sie unter Gemeinsam [nutzbare Testereignisse](https://docs.aws.amazon.com/lambda/latest/dg/testing-functions.html#creating-shareable-events) im *AWS Lambda Entwicklerhandbuch*. ##### Auf gemeinsam nutzbare Testereignisse zugreifen und diese verwalten Sie können den AWS SAM CLI `sam remote test-event` Befehl verwenden, um auf gemeinsam nutzbare Testereignisse zuzugreifen und diese zu verwalten. Sie können ihn beispielsweise für Folgendes verwenden`sam remote test-event`: + Rufen Sie gemeinsam nutzbare Testereignisse aus der EventBridge Amazon-Schemaregistry ab. + Ändern Sie gemeinsam nutzbare Testereignisse lokal und laden Sie sie in die EventBridge Schemaregistrierung hoch. + Löschen Sie gemeinsam nutzbare Testereignisse aus der EventBridge Schemaregistrierung. Weitere Informationen hierzu finden Sie unter [Einführung in Cloud-Tests mit sam remote test-event](using-sam-cli-remote-test-event.md). ##### Übergeben Sie ein gemeinsam nutzbares Testereignis an eine Lambda-Funktion in der Cloud Um ein gemeinsam nutzbares Testereignis aus der EventBridge Schemaregistrierung an Ihre Lambda-Funktion in der Cloud zu übergeben, verwenden Sie die `--test-event-name` Option und geben Sie den Namen des gemeinsam nutzbaren Testereignisses an. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam remote invoke HelloWorldFunction --stack-name sam-app --test-event-name demo-event ``` Wenn Sie das gemeinsam nutzbare Testereignis lokal speichern, können Sie die `--event-file` Option verwenden und den Dateipfad und den Namen des lokalen Testereignisses angeben. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam remote invoke HelloWorldFunction --stack-name sam-app --event-file demo-event.json ``` ### Using with Amazon SQS Sie können Nachrichten an Amazon SQS SQS-Warteschlangen senden. Das AWS SAM CLI gibt Folgendes zurück: + Nachrichten-ID + MD5 des Nachrichtentexts + Metadaten der Antwort Im Folgenden wird ein Beispiel gezeigt: ``` $ sam remote invoke MySqsQueue --stack-name sqs-example -event hello Sending message to SQS queue MySqsQueue { "MD5OfMessageBody": "5d41402abc4b2a76b9719d911017c592", "MessageId": "05c7af65-9ae8-4014-ae28-809d6d8ec652" }% ``` **So senden Sie eine Nachricht** 1. Geben Sie einen Ressourcen-ID-Wert als Argument für die Amazon SQS SQS-Warteschlange an. Informationen zu gültigen Ressourcen finden Sie IDs unter [Ressourcen-ID.](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id) 1. Geben Sie ein Ereignis an, das an Ihre Amazon SQS SQS-Warteschlange gesendet werden soll. Sie können das Ereignis in der Befehlszeile mit der `--event` Option oder aus einer Datei mithilfe `--event-file` von. Wenn Sie kein Ereignis angeben, AWS SAM CLI sendet das ein leeres Ereignis. ### Mit Step-Funktionen verwenden Sie können eine Step Functions Functions-Zustandsmaschine aufrufen, um die Ausführung zu starten. Der AWS SAM CLI wartet, bis der State-Machine-Workflow abgeschlossen ist, und gibt eine Ausgabe des letzten Schritts der Ausführung zurück. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam remote invoke HelloWorldStateMachine --stack-name state-machine-example --event '{"is_developer": true}' Invoking Step Function HelloWorldStateMachine "Hello Developer World"% ``` **Um eine Zustandsmaschine aufzurufen** 1. Geben Sie einen Ressourcen-ID-Wert als Argument für die Step Functions Functions-Zustandsmaschine an. Informationen zu einer gültigen Ressource IDs finden Sie unter [Ressourcen-ID](sam-cli-command-reference-remote-invoke.md#sam-cli-command-reference-remote-invoke-args-resource-id). 1. Geben Sie ein Ereignis an, das an Ihre Zustandsmaschine gesendet werden soll. Sie können das Ereignis mit der `--event` Option in der Befehlszeile oder mithilfe von einer Datei bereitstellen`--event-file`. Wenn Sie kein Ereignis angeben, AWS SAM CLI sendet das ein leeres Ereignis. ## Verwenden von Sam Remote Invoke-Befehlsoptionen Dieser Abschnitt behandelt einige der wichtigsten Optionen, die Sie mit dem `sam remote invoke` Befehl verwenden können. Eine vollständige Liste der Optionen finden Sie unter[sam remote invoke](sam-cli-command-reference-remote-invoke.md). ### Übergeben Sie ein Ereignis an Ihre Ressource Verwenden Sie die folgenden Optionen, um Ereignisse an Ihre Ressourcen in der Cloud weiterzuleiten: + `--event`— Übergibt ein Ereignis an der Befehlszeile. + `--event-file`— Übergibt ein Ereignis aus einer Datei. #### Beispiele für Lambda **Wird verwendet`--event`, um ein Ereignis an der Befehlszeile als Zeichenkettenwert zu übergeben:** ``` $ sam remote invoke HelloWorldFunction --stack-name sam-app --event '{"message": "hello!"}' Invoking Lambda Function HelloWorldFunction START RequestId: b992292d-1fac-4aa2-922a-c9dc5c6fceab Version: $LATEST END RequestId: b992292d-1fac-4aa2-922a-c9dc5c6fceab REPORT RequestId: b992292d-1fac-4aa2-922a-c9dc5c6fceab Duration: 16.41 ms Billed Duration: 17 ms Memory Size: 128 MB Max Memory Used: 67 MB Init Duration: 185.96 ms {"statusCode":200,"body":"{\"message\":\"hello!\"}"}% ``` **Wird verwendet`--event-file`, um ein Ereignis aus einer Datei zu übergeben und den Pfad zur Datei anzugeben:** ``` $ cat event.json {"message": "hello from file"}% $ sam remote invoke HelloWorldFunction --stack-name sam-app --event-file event.json Invoking Lambda Function HelloWorldFunction START RequestId: 3bc71f7d-153a-4b1e-8c9a-901d91b1bec9 Version: $LATEST END RequestId: 3bc71f7d-153a-4b1e-8c9a-901d91b1bec9 REPORT RequestId: 3bc71f7d-153a-4b1e-8c9a-901d91b1bec9 Duration: 21.15 ms Billed Duration: 22 ms Memory Size: 128 MB Max Memory Used: 67 MB {"statusCode":200,"body":"{\"message\":\"hello from file\"}"}% ``` **Übergeben Sie ein Ereignis mit`stdin`:** ``` $ cat event.json {"message": "hello from file"}% $ cat event.json | sam remote invoke HelloWorldFunction --stack-name sam-app --event-file - Reading event from stdin (you can also pass it from file with --event-file) Invoking Lambda Function HelloWorldFunction START RequestId: 85ecc902-8ad0-4a2b-a8c8-9bb4f65f5a7a Version: $LATEST END RequestId: 85ecc902-8ad0-4a2b-a8c8-9bb4f65f5a7a REPORT RequestId: 85ecc902-8ad0-4a2b-a8c8-9bb4f65f5a7a Duration: 1.36 ms Billed Duration: 2 ms Memory Size: 128 MB Max Memory Used: 67 MB {"statusCode":200,"body":"{\"message\":\"hello from file\"}"}% ``` ### Konfigurieren Sie die AWS SAMCLI Antwortausgabe Wenn Sie eine unterstützte Ressource mit aufrufen`sam remote invoke`, gibt sie eine Antwort AWS SAMCLI zurück, die Folgendes enthält: + **Metadaten anfordern** — Mit der Anfrage verknüpfte Metadaten. Dazu gehören eine Anforderungs-ID und eine Startzeit der Anfrage. + **Ressourcenantwort** — Die Antwort Ihrer Ressource nach dem Aufruf in der Cloud. Sie können die `--output` Option verwenden, um die AWS SAM CLI Ausgabeantwort zu konfigurieren. Die folgenden Optionswerte sind verfügbar: + `json`— Metadaten und Ressourcenantwort werden in einer JSON Struktur zurückgegeben. Die Antwort enthält die vollständige SDK Ausgabe. + `text`— Metadaten werden in Textstruktur zurückgegeben. Die Ressourcenantwort wird im Ausgabeformat der Ressource zurückgegeben. Das Folgende ist ein Beispiel für eine `json` Ausgabe: ``` $ sam remote invoke --stack-name sam-app --output json Invoking Lambda Function HelloWorldFunction { "ResponseMetadata": { "RequestId": "3bdf9a30-776d-4a90-94a6-4cccc0fc7b41", "HTTPStatusCode": 200, "HTTPHeaders": { "date": "Mon, 19 Jun 2023 17:15:46 GMT", "content-type": "application/json", "content-length": "57", "connection": "keep-alive", "x-amzn-requestid": "3bdf9a30-776d-4a90-94a6-4cccc0fc7b41", "x-amzn-remapped-content-length": "0", "x-amz-executed-version": "$LATEST", "x-amz-log-result": "U1RBUlQgUmVxdWVzdElkOiAzYmRmOWEzMC03NzZkLTRhOTAtOTRhNi00Y2NjYzBmYzdiNDEgVmVyc2lvbjogJExBVEVTVApFTkQgUmVxdWVzdElkOiAzYmRmOWEzMC03NzZkLTRhOTAtOTRhNi00Y2NjYzBmYzdiNDEKUkVQT1JUIFJlcXVlc3RJZDogM2JkZjlhMzAtNzc2ZC00YTkwLTk0YTYtNGNjY2MwZmM3YjQxCUR1cmF0aW9uOiA4LjIzIG1zCUJpbGxlZCBEdXJhdGlvbjogOSBtcwlNZW1vcnkgU2l6ZTogMTI4IE1CCU1heCBNZW1vcnkgVXNlZDogNjggTUIJCg==", "x-amzn-trace-id": "root=1-64908d42-17dab270273fcc6b527dd6b8;sampled=0;lineage=2301f8dc:0" }, "RetryAttempts": 0 }, "StatusCode": 200, "LogResult": "U1RBUlQgUmVxdWVzdElkOiAzYmRmOWEzMC03NzZkLTRhOTAtOTRhNi00Y2NjYzBmYzdiNDEgVmVyc2lvbjogJExBVEVTVApFTkQgUmVxdWVzdElkOiAzYmRmOWEzMC03NzZkLTRhOTAtOTRhNi00Y2NjYzBmYzdiNDEKUkVQT1JUIFJlcXVlc3RJZDogM2JkZjlhMzAtNzc2ZC00YTkwLTk0YTYtNGNjY2MwZmM3YjQxCUR1cmF0aW9uOiA4LjIzIG1zCUJpbGxlZCBEdXJhdGlvbjogOSBtcwlNZW1vcnkgU2l6ZTogMTI4IE1CCU1heCBNZW1vcnkgVXNlZDogNjggTUIJCg==", "ExecutedVersion": "$LATEST", "Payload": "{\"statusCode\":200,\"body\":\"{\\\"message\\\":\\\"hello world\\\"}\"}" }% ``` Wenn Sie eine `json` Ausgabe angeben, wird die gesamte Antwort zurückgegeben`stdout`. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam remote invoke --stack-name sam-app --output json 1> stdout.log Invoking Lambda Function HelloWorldFunction $ cat stdout.log { "ResponseMetadata": { "RequestId": "d30d280f-8188-4372-bc94-ce0f1603b6bb", "HTTPStatusCode": 200, "HTTPHeaders": { "date": "Mon, 19 Jun 2023 17:35:56 GMT", "content-type": "application/json", "content-length": "57", "connection": "keep-alive", "x-amzn-requestid": "d30d280f-8188-4372-bc94-ce0f1603b6bb", "x-amzn-remapped-content-length": "0", "x-amz-executed-version": "$LATEST", "x-amz-log-result": "U1RBUlQgUmVxdWVzdElkOiBkMzBkMjgwZi04MTg4LTQzNzItYmM5NC1jZTBmMTYwM2I2YmIgVmVyc2lvbjogJExBVEVTVApFTkQgUmVxdWVzdElkOiBkMzBkMjgwZi04MTg4LTQzNzItYmM5NC1jZTBmMTYwM2I2YmIKUkVQT1JUIFJlcXVlc3RJZDogZDMwZDI4MGYtODE4OC00MzcyLWJjOTQtY2UwZjE2MDNiNmJiCUR1cmF0aW9uOiA0LjE2IG1zCUJpbGxlZCBEdXJhdGlvbjogNSBtcwlNZW1vcnkgU2l6ZTogMTI4IE1CCU1heCBNZW1vcnkgVXNlZDogNjcgTUIJSW5pdCBEdXJhdGlvbjogMTU4LjM5IG1zCQo=", "x-amzn-trace-id": "root=1-649091fc-771473c7778689627a6122b7;sampled=0;lineage=2301f8dc:0" }, "RetryAttempts": 0 }, "StatusCode": 200, "LogResult": "U1RBUlQgUmVxdWVzdElkOiBkMzBkMjgwZi04MTg4LTQzNzItYmM5NC1jZTBmMTYwM2I2YmIgVmVyc2lvbjogJExBVEVTVApFTkQgUmVxdWVzdElkOiBkMzBkMjgwZi04MTg4LTQzNzItYmM5NC1jZTBmMTYwM2I2YmIKUkVQT1JUIFJlcXVlc3RJZDogZDMwZDI4MGYtODE4OC00MzcyLWJjOTQtY2UwZjE2MDNiNmJiCUR1cmF0aW9uOiA0LjE2IG1zCUJpbGxlZCBEdXJhdGlvbjogNSBtcwlNZW1vcnkgU2l6ZTogMTI4IE1CCU1heCBNZW1vcnkgVXNlZDogNjcgTUIJSW5pdCBEdXJhdGlvbjogMTU4LjM5IG1zCQo=", "ExecutedVersion": "$LATEST", "Payload": "{\"statusCode\":200,\"body\":\"{\\\"message\\\":\\\"hello world\\\"}\"}" }% ``` Im Folgenden finden Sie ein Beispiel für eine `text` Ausgabe: ``` $ sam remote invoke --stack-name sam-app --output text Invoking Lambda Function HelloWorldFunction START RequestId: 4dbacc43-1ec6-47c2-982b-9dc4620144d6 Version: $LATEST END RequestId: 4dbacc43-1ec6-47c2-982b-9dc4620144d6 REPORT RequestId: 4dbacc43-1ec6-47c2-982b-9dc4620144d6 Duration: 9.13 ms Billed Duration: 10 ms Memory Size: 128 MB Max Memory Used: 67 MB Init Duration: 165.50 ms {"statusCode":200,"body":"{\"message\":\"hello world\"}"}% ``` Wenn Sie eine `text` Ausgabe angeben, wird die Laufzeitausgabe der Lambda-Funktion (z. B. Logs) zurückgegeben. `stderr` Die Nutzlast der Lambda-Funktion wird zurückgegeben. `stdout` Im Folgenden wird ein Beispiel gezeigt: ``` $ sam remote invoke --stack-name sam-app --output text 2> stderr.log {"statusCode":200,"body":"{\"message\":\"hello world\"}"}% $ cat stderr.log Invoking Lambda Function HelloWorldFunction START RequestId: 82273c3b-aa3a-4d16-8f1c-1d2ad3ace891 Version: $LATEST END RequestId: 82273c3b-aa3a-4d16-8f1c-1d2ad3ace891 REPORT RequestId: 82273c3b-aa3a-4d16-8f1c-1d2ad3ace891 Duration: 40.62 ms Billed Duration: 41 ms Memory Size: 128 MB Max Memory Used: 68 MB $ sam remote invoke --stack-name sam-app --output text 1> stdout.log Invoking Lambda Function HelloWorldFunction START RequestId: 74acaa9f-5b80-4a5c-b3b8-ffaccb84cbbd Version: $LATEST END RequestId: 74acaa9f-5b80-4a5c-b3b8-ffaccb84cbbd REPORT RequestId: 74acaa9f-5b80-4a5c-b3b8-ffaccb84cbbd Duration: 2.31 ms Billed Duration: 3 ms Memory Size: 128 MB Max Memory Used: 67 MB $ cat stdout.log {"statusCode":200,"body":"{\"message\":\"hello world\"}"}% ``` ### Passen Sie die Parameter an Boto3 Denn `sam remote invoke` AWS SAM CLI verwendet das AWS SDK for Python (Boto3), um mit Ihren Ressourcen in der Cloud zu interagieren. Sie können die `--parameter` Option verwenden, um Parameter anzupassen. Boto3 Eine Liste der unterstützten Parameter, die Sie anpassen können, finden Sie unter`--parameter`. #### Beispiele **Rufen Sie eine Lambda-Funktion auf, um Parameterwerte zu validieren und Berechtigungen zu überprüfen:** ``` $ sam remote invoke HelloWorldFunction --stack-name sam-app --parameter InvocationType="DryRun" ``` **Verwenden Sie die `--parameter` Option mehrmals in einem einzigen Befehl, um mehrere Parameter bereitzustellen:** ``` $ sam remote invoke HelloWorldFunction --stack-name sam-app --parameter InvocationType="Event" --parameter LogType="None" ``` ### Andere Optionen Eine vollständige Liste der `sam remote invoke` Optionen finden Sie unter[sam remote invoke](sam-cli-command-reference-remote-invoke.md). ## Konfigurieren Sie Ihre Projektkonfigurationsdatei Um `sam remote invoke` in Ihrer Konfigurationsdatei zu konfigurieren, verwenden Sie `remote_invoke` in Ihrer Tabelle. Im Folgenden finden Sie ein Beispiel für eine `samconfig.toml` Datei, in der Standardwerte für den `sam remote invoke` Befehl konfiguriert werden. ``` ... version =0.1 [default] ... [default.remote_invoke.parameters] stack_name = "cloud-app" event = '{"message": "Hello!"}' ``` ## Beispiele Ein grundlegendes Anwendungsbeispiel finden Sie unter [AWS Lambda Funktionen mit AWS SAM Remote testen](https://aws.amazon.com/blogs/compute/testing-aws-lambda-functions-with-aws-sam-remote-invoke/) im *AWS Compute-Blog*. `sam remote invoke` ### Beispiele für Kinesis Data Streams #### Grundlegende Beispiele **Senden Sie einen Datensatz aus einer Datei an eine Kinesis Data Streams Streams-Anwendung. Die Kinesis Data Streams Streams-Anwendung wird identifiziert, indem ein ARN für die Ressourcen-ID bereitgestellt wird:** ``` $ sam remote invoke arn:aws:kinesis:us-west-2:01234567890:stream/kinesis-example-KinesisStream-BgnLcAey4xUQ --event-file event.json ``` **Senden Sie ein in der Befehlszeile bereitgestelltes Ereignis an eine Kinesis Data Streams Streams-Anwendung:** ``` $ sam remote invoke KinesisStream --stack-name kinesis-example --event hello-world Putting record to Kinesis data stream KinesisStream Auto converting value 'hello-world' into JSON '"hello-world"'. If you don't want auto-conversion, please provide a JSON string as event { "ShardId": "shardId-000000000000", "SequenceNumber": "49646251411914806775980903986194508740483329854174920706" }% ``` **Rufen Sie die physische ID der Kinesis Data Streams Streams-Anwendung ab. Geben Sie dann ein Ereignis in der Befehlszeile ein:** ``` $ sam list resources --stack-name kinesis-example --output json [ { "LogicalResourceId": "KinesisStream", "PhysicalResourceId": "kinesis-example-KinesisStream-ZgnLcQey4xUQ" } ] $ sam remote invoke kinesis-example-KinesisStream-ZgnLcQey4xUQ --event hello Putting record to Kinesis data stream KinesisStream Auto converting value 'hello' into JSON '"hello"'. If you don't want auto-conversion, please provide a JSON string as event { "ShardId": "shardId-000000000000", "SequenceNumber": "49646251411914806775980904340716841045751814812900261890" }% ``` **Geben Sie in der Befehlszeile eine JSON-Zeichenfolge als Ereignis an:** ``` $ sam remote invoke KinesisStream --stack-name kinesis-example --event '{"method": "GET", "body": ""}' Putting record to Kinesis data stream KinesisStream { "ShardId": "shardId-000000000000", "SequenceNumber": "49646251411914806775980904492868617924990209230536441858" }% ``` **Senden Sie ein leeres Ereignis an die Kinesis Data Streams Streams-Anwendung:** ``` $ sam remote invoke KinesisStream --stack-name kinesis-example Putting record to Kinesis data stream KinesisStream { "ShardId": "shardId-000000000000", "SequenceNumber": "49646251411914806775980904866469008589597168190416224258" }% ``` **Gibt die AWS SAM CLI Antwort im JSON-Format zurück:** ``` $ sam remote invoke KinesisStream --stack-name kinesis-example --event '{"hello": "world"}' --output json Putting record to Kinesis data stream KinesisStream { "ShardId": "shardId-000000000000", "SequenceNumber": "49646251411914806775980905078409420803696667195489648642", "ResponseMetadata": { "RequestId": "ebbbd307-3e9f-4431-b67c-f0715e9e353e", "HTTPStatusCode": 200, "HTTPHeaders": { "x-amzn-requestid": "ebbbd307-3e9f-4431-b67c-f0715e9e353e", "x-amz-id-2": "Q3yBcgTwtPaQTV26IKclbECmZikUYOzKY+CzcxA84ZHgCkc5T2N/ITWg6RPOQcWw8Gn0tNPcEJBEHyVVqboJAPgCritqsvCu", "date": "Thu, 09 Nov 2023 18:13:10 GMT", "content-type": "application/x-amz-json-1.1", "content-length": "110" }, "RetryAttempts": 0 } }% ``` **Geben Sie die JSON-Ausgabe an stdout zurück:** ``` $ sam remote invoke KinesisStream --stack-name kinesis-example --event '{"hello": "world"}' --output json 1> stdout.log Putting record to Kinesis data stream KinesisStream $ cat stdout.log { "ShardId": "shardId-000000000000", "SequenceNumber": "49646251411914806775980906397777867595039988349006774274", "ResponseMetadata": { "RequestId": "f4290006-d84b-b1cd-a9ee-28306eeb2939", "HTTPStatusCode": 200, "HTTPHeaders": { "x-amzn-requestid": "f4290006-d84b-b1cd-a9ee-28306eeb2939", "x-amz-id-2": "npCqz+IBKpoL4sQ1ClbUmxuJlbeA24Fx1UgpIrS6mm2NoIeV2qdZSN5AhNurdssykXajBrXaC9anMhj2eG/h7Hnbf+bPuotU", "date": "Thu, 09 Nov 2023 18:33:26 GMT", "content-type": "application/x-amz-json-1.1", "content-length": "110" }, "RetryAttempts": 0 } }% ``` ### Beispiele für Lambda #### Grundlegende Beispiele **Rufen Sie eine Lambda-Funktion auf, indem Sie den ARN als Ressourcen-ID angeben:** ``` $ sam remote invoke arn:aws:lambda:us-west-2:012345678910:function:sam-app-HelloWorldFunction-ohRFEn2RuAvp ``` **Rufen Sie eine Lambda-Funktion auf, indem Sie die logische ID als Ressourcen-ID angeben:** Sie müssen auch den CloudFormation Stack-Namen mithilfe der `--stack-name` Option angeben. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam remote invoke HelloWorldFunction --stack-name sam-app ``` Wenn Ihre Anwendung eine einzelne Lambda-Funktion enthält, müssen Sie deren logische ID nicht angeben. Sie können nur die `--stack-name` Option angeben. Im Folgenden wird ein Beispiel gezeigt: ``` $ sam remote invoke --stack-name sam-app ``` **Rufen Sie eine Lambda-Funktion auf, indem Sie die physische ID als Ressourcen-ID angeben:** Die physische ID wird erstellt, wenn Sie sie bereitstellen mit. CloudFormation ``` $ sam remote invoke sam-app-HelloWorldFunction-TZvxQRFNv0k4 ``` **Rufen Sie eine Lambda-Funktion eines untergeordneten Stacks auf:** In diesem Beispiel enthält unsere Anwendung die folgende Verzeichnisstruktur: ``` lambda-example ├── childstack │ ├── function │ │ ├── __init__.py │ │ ├── app.py │ │ └── requirements.txt │ └── template.yaml ├── events │ └── event.json ├── samconfig.toml └── template.yaml ``` Um die Lambda-Funktion von our aufzurufen`childstack`, führen wir Folgendes aus: ``` $ sam remote invoke ChildStack/HelloWorldFunction --stack-name lambda-example Invoking Lambda Function HelloWorldFunction START RequestId: 207a864b-e67c-4307-8478-365b004d4bcd Version: $LATEST END RequestId: 207a864b-e67c-4307-8478-365b004d4bcd REPORT RequestId: 207a864b-e67c-4307-8478-365b004d4bcd Duration: 1.27 ms Billed Duration: 2 ms Memory Size: 128 MB Max Memory Used: 36 MB Init Duration: 111.07 ms {"statusCode": 200, "body": "{\"message\": \"Hello\", \"received_event\": {}}"}% ``` #### Rufen Sie eine Lambda-Funktion auf, die für das Streamen von Antworten konfiguriert ist In diesem Beispiel verwenden wir die, um eine neue serverlose Anwendung AWS SAMCLI zu initialisieren, die eine Lambda-Funktion enthält, die so konfiguriert ist, dass sie ihre Antwort streamt. Wir stellen unsere Anwendung in der Cloud bereit AWS Cloud und verwenden `sam remote invoke` sie, um mit unserer Funktion in der Cloud zu interagieren. Wir beginnen damit, den `sam init` Befehl auszuführen, um eine neue serverlose Anwendung zu erstellen. Wir wählen die **Lambda Response Streaming-Schnellstartvorlage** aus und geben unserer Anwendung **lambda-streaming-nodejs-app**einen Namen. ``` $ sam init You can preselect a particular runtime or package type when using the `sam init` experience. Call `sam init --help` to learn more. Which template source would you like to use? 1 - AWS Quick Start Templates 2 - Custom Template Location Choice: 1 Choose an AWS Quick Start application template 1 - Hello World Example ... 9 - Lambda Response Streaming ... 15 - Machine Learning Template: 9 Which runtime would you like to use? 1 - go (provided.al2) 2 - nodejs18.x 3 - nodejs16.x Runtime: 2 Based on your selections, the only Package type available is Zip. We will proceed to selecting the Package type as Zip. Based on your selections, the only dependency manager available is npm. We will proceed copying the template using npm. Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER Would you like to enable monitoring using CloudWatch Application Insights? For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER Project name [sam-app]: lambda-streaming-nodejs-app ----------------------- Generating application: ----------------------- Name: lambda-streaming-nodejs-app Runtime: nodejs18.x Architectures: x86_64 Dependency Manager: npm Application Template: response-streaming Output Directory: . Configuration file: lambda-streaming-nodejs-app/samconfig.toml Next steps can be found in the README file at lambda-streaming-nodejs-app/README.md Commands you can use next ========================= [*] Create pipeline: cd lambda-streaming-nodejs-app && sam pipeline init --bootstrap [*] Validate SAM template: cd lambda-streaming-nodejs-app && sam validate [*] Test Function in the Cloud: cd lambda-streaming-nodejs-app && sam sync --stack-name {stack-name} --watch ``` Das AWS SAMCLI erstellt unser Projekt mit der folgenden Struktur: ``` lambda-streaming-nodejs-app ├── README.md ├── __tests__ │ └── unit │ └── index.test.js ├── package.json ├── samconfig.toml ├── src │ └── index.js └── template.yaml ``` Das Folgende ist ein Beispiel für unseren Lambda-Funktionscode: ``` exports.handler = awslambda.streamifyResponse( async (event, responseStream, context) => { const httpResponseMetadata = { statusCode: 200, headers: { "Content-Type": "text/html", "X-Custom-Header": "Example-Custom-Header" } }; responseStream = awslambda.HttpResponseStream.from(responseStream, httpResponseMetadata); // It's recommended to use a `pipeline` over the `write` method for more complex use cases. // Learn more: https://docs.aws.amazon.com/lambda/latest/dg/configuration-response-streaming.html responseStream.write(""); responseStream.write("

First write!

"); responseStream.write("

Streaming h1

"); await new Promise(r => setTimeout(r, 1000)); responseStream.write("

Streaming h2

"); await new Promise(r => setTimeout(r, 1000)); responseStream.write("

Streaming h3

"); await new Promise(r => setTimeout(r, 1000)); // Long strings will be streamed const loremIpsum1 = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque vitae mi tincidunt tellus ultricies dignissim id et diam. Morbi pharetra eu nisi et finibus. Vivamus diam nulla, vulputate et nisl cursus, pellentesque vehicula libero. Cras imperdiet lorem ante, non posuere dolor sollicitudin a. Vestibulum ipsum lacus, blandit nec augue id, lobortis dictum urna. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Morbi auctor orci eget tellus aliquam, non maximus massa porta. In diam ante, pulvinar aliquam nisl non, elementum hendrerit sapien. Vestibulum massa nunc, mattis non congue vitae, placerat in quam. Nam vulputate lectus metus, et dignissim erat varius a."; responseStream.write(`

${loremIpsum1}

`); await new Promise(r => setTimeout(r, 1000)); responseStream.write("

DONE!

"); responseStream.write(""); responseStream.end(); } ); ``` Das Folgende ist ein Beispiel für unsere `template.yaml` Datei. Das Antwort-Streaming für unsere Lambda-Funktion wird mithilfe der `FunctionUrlConfig` Eigenschaft konfiguriert. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: > Sample SAM Template for lambda-streaming-nodejs-app Resources: StreamingFunction: Type: AWS::Serverless::Function Properties: CodeUri: src/ Handler: index.handler Runtime: nodejs18.x Architectures: - x86_64 Timeout: 10 FunctionUrlConfig: AuthType: AWS_IAM InvokeMode: RESPONSE_STREAM Outputs: StreamingFunction: Description: "Streaming Lambda Function ARN" Value: !GetAtt StreamingFunction.Arn StreamingFunctionURL: Description: "Streaming Lambda Function URL" Value: !GetAtt StreamingFunctionUrl.FunctionUrl ``` In der Regel können Sie `sam build` und verwenden`sam deploy --guided`, um eine Produktionsanwendung zu erstellen und bereitzustellen. In diesem Beispiel gehen wir von einer Entwicklungsumgebung aus und verwenden den `sam sync` Befehl, um unsere Anwendung zu erstellen und bereitzustellen. **Anmerkung** Der `sam sync` Befehl wird für Entwicklungsumgebungen empfohlen. Weitere Informationen hierzu finden Sie unter [Einführung in die Verwendung von sam sync to sync to AWS Cloud](using-sam-cli-sync.md). Vor der Ausführung überprüfen wir`sam sync`, ob unser Projekt in unserer `samconfig.toml` Datei korrekt konfiguriert ist. Am wichtigsten ist, dass wir die Werte für `stack_name` und überprüfen`watch`. Da diese Werte in unserer Konfigurationsdatei angegeben sind, müssen wir sie nicht in der Befehlszeile angeben. ``` version = 0.1 [default] [default.global.parameters] stack_name = "lambda-streaming-nodejs-app" [default.build.parameters] cached = true parallel = true [default.validate.parameters] lint = true [default.deploy.parameters] capabilities = "CAPABILITY_IAM" confirm_changeset = true resolve_s3 = true s3_prefix = "lambda-streaming-nodejs-app" region = "us-west-2" image_repositories = [] [default.package.parameters] resolve_s3 = true [default.sync.parameters] watch = true [default.local_start_api.parameters] warm_containers = "EAGER" [default.local_start_lambda.parameters] warm_containers = "EAGER" ``` Als Nächstes erstellen und implementieren wir unsere Anwendung. `sam sync` Da die `--watch` Option in unserer Konfigurationsdatei konfiguriert ist, AWS SAMCLI wird sie unsere Anwendung erstellen, unsere Anwendung bereitstellen und auf Änderungen achten. ``` $ sam sync The SAM CLI will use the AWS Lambda, Amazon API Gateway, and AWS StepFunctions APIs to upload your code without performing a CloudFormation deployment. This will cause drift in your CloudFormation stack. **The sync command should only be used against a development stack**. Queued infra sync. Waiting for in progress code syncs to complete... Starting infra sync. Building codeuri: /Users/.../lambda-streaming-nodejs-app/src runtime: nodejs18.x metadata: {} architecture: x86_64 functions: StreamingFunction package.json file not found. Continuing the build without dependencies. Running NodejsNpmBuilder:CopySource Build Succeeded Successfully packaged artifacts and wrote output template to file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpavrzdhgp. Execute the following command to deploy the packaged template sam deploy --template-file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpavrzdhgp --stack-name Deploying with following values =============================== Stack name : lambda-streaming-nodejs-app Region : us-west-2 Disable rollback : False Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr Capabilities : ["CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"] Parameter overrides : {} Signing Profiles : null Initiating deployment ===================== 2023-06-20 12:11:16 - Waiting for stack create/update to complete CloudFormation events from stack operations (refresh every 0.5 seconds) ----------------------------------------------------------------------------------------------------- ResourceStatus ResourceType LogicalResourceId ResourceStatusReason ----------------------------------------------------------------------------------------------------- CREATE_IN_PROGRESS AWS::CloudFormation::St lambda-streaming- Transformation ack nodejs-app succeeded CREATE_IN_PROGRESS AWS::IAM::Role StreamingFunctionRole - CREATE_IN_PROGRESS AWS::CloudFormation::St AwsSamAutoDependencyLay - ack erNestedStack CREATE_IN_PROGRESS AWS::IAM::Role StreamingFunctionRole Resource creation Initiated CREATE_IN_PROGRESS AWS::CloudFormation::St AwsSamAutoDependencyLay Resource creation ack erNestedStack Initiated CREATE_COMPLETE AWS::IAM::Role StreamingFunctionRole - CREATE_COMPLETE AWS::CloudFormation::St AwsSamAutoDependencyLay - ack erNestedStack CREATE_IN_PROGRESS AWS::Lambda::Function StreamingFunction - CREATE_IN_PROGRESS AWS::Lambda::Function StreamingFunction Resource creation Initiated CREATE_COMPLETE AWS::Lambda::Function StreamingFunction - CREATE_IN_PROGRESS AWS::Lambda::Url StreamingFunctionUrl - CREATE_IN_PROGRESS AWS::Lambda::Url StreamingFunctionUrl Resource creation Initiated CREATE_COMPLETE AWS::Lambda::Url StreamingFunctionUrl - CREATE_COMPLETE AWS::CloudFormation::St lambda-streaming- - ack nodejs-app ----------------------------------------------------------------------------------------------------- CloudFormation outputs from deployed stack ------------------------------------------------------------------------------------------------------- Outputs ------------------------------------------------------------------------------------------------------- Key StreamingFunction Description Streaming Lambda Function ARN Value arn:aws:lambda:us-west-2:012345678910:function:lambda-streaming-nodejs-app- StreamingFunction-gUmhO833A0vZ Key StreamingFunctionURL Description Streaming Lambda Function URL Value https://wxgkcc2dyntgtrwhf2dgdcvylu0rnnof.lambda-url.us-west-2.on.aws/ ------------------------------------------------------------------------------------------------------- Stack creation succeeded. Sync infra completed. Infra sync completed. ``` Jetzt, da unsere Funktion in der Cloud bereitgestellt ist, können wir `sam remote invoke` sie verwenden, um mit unserer Funktion zu interagieren. Die erkennt AWS SAMCLI automatisch, dass unsere Funktion für Antwort-Streaming konfiguriert ist, und beginnt sofort mit der Ausgabe einer gestreamten Antwort unserer Funktion in Echtzeit. ``` $ sam remote invoke StreamingFunction Invoking Lambda Function StreamingFunction {"statusCode":200,"headers":{"Content-Type":"text/html","X-Custom-Header":"Example-Custom-Header"}}

First write!

Streaming h1

Streaming h2

Streaming h3

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque vitae mi tincidunt tellus ultricies dignissim id et diam. Morbi pharetra eu nisi et finibus. Vivamus diam nulla, vulputate et nisl cursus, pellentesque vehicula libero. Cras imperdiet lorem ante, non posuere dolor sollicitudin a. Vestibulum ipsum lacus, blandit nec augue id, lobortis dictum urna. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Morbi auctor orci eget tellus aliquam, non maximus massa porta. In diam ante, pulvinar aliquam nisl non, elementum hendrerit sapien. Vestibulum massa nunc, mattis non congue vitae, placerat in quam. Nam vulputate lectus metus, et dignissim erat varius a.

DONE!

START RequestId: 1e4cdf04-60de-4769-b3a2-c1481982deb4 Version: $LATEST END RequestId: 1e4cdf04-60de-4769-b3a2-c1481982deb4 REPORT RequestId: 1e4cdf04-60de-4769-b3a2-c1481982deb4 Duration: 4088.66 ms Billed Duration: 4089 ms Memory Size: 128 MB Max Memory Used: 68 MB Init Duration: 168.45 ms ``` Wenn wir unseren Funktionscode ändern, erkennt der unsere Änderungen AWS SAMCLI sofort und implementiert sie sofort. Hier ist ein Beispiel für die AWS SAMCLI Ausgabe, nachdem Änderungen an unserem Funktionscode vorgenommen wurden: ``` Syncing Lambda Function StreamingFunction... Building codeuri: /Users/.../lambda-streaming-nodejs-app/src runtime: nodejs18.x metadata: {} architecture: x86_64 functions: StreamingFunction package.json file not found. Continuing the build without dependencies. Running NodejsNpmBuilder:CopySource Finished syncing Lambda Function StreamingFunction. Syncing Layer StreamingFunctione9cfe924DepLayer... SyncFlow [Layer StreamingFunctione9cfe924DepLayer]: Skipping resource update as the content didn't change Finished syncing Layer StreamingFunctione9cfe924DepLayer. ``` Wir können es jetzt `sam remote invoke` wieder verwenden, um mit unserer Funktion in der Cloud zu interagieren und unsere Änderungen zu testen. ### SQS-Beispiele #### Grundlegende Beispiele **Rufen Sie eine Amazon SQS SQS-Warteschlange auf, indem Sie den ARN als Ressourcen-ID angeben:** ``` $ sam remote invoke arn:aws:sqs:us-west-2:01234567890:sqs-example-4DonhBsjsW1b --event '{"hello": "world"}' --output json Sending message to SQS queue MySqsQueue { "MD5OfMessageBody": "49dfdd54b01cbcd2d2ab5e9e5ee6b9b9", "MessageId": "4f464cdd-15ef-4b57-bd72-3ad225d80adc", "ResponseMetadata": { "RequestId": "95d39377-8323-5ef0-9223-ceb198bd09bd", "HTTPStatusCode": 200, "HTTPHeaders": { "x-amzn-requestid": "95d39377-8323-5ef0-9223-ceb198bd09bd", "date": "Wed, 08 Nov 2023 23:27:26 GMT", "content-type": "application/x-amz-json-1.0", "content-length": "106", "connection": "keep-alive" }, "RetryAttempts": 0 } }% ``` ### Beispiele Step Functions #### Grundlegende Beispiele **Rufen Sie eine Zustandsmaschine auf, indem Sie ihre physische ID als Ressourcen-ID angeben:** Zuerst verwenden wir, `sam list resources` um unsere physische ID zu erhalten: ``` $ sam list resources --stack-name state-machine-example --output json [ { "LogicalResourceId": "HelloWorldStateMachine", "PhysicalResourceId": "arn:aws:states:us-west-2:513423067560:stateMachine:HelloWorldStateMachine-z69tFEUx0F66" }, { "LogicalResourceId": "HelloWorldStateMachineRole", "PhysicalResourceId": "simple-state-machine-HelloWorldStateMachineRole-PduA0BDGuFXw" } ] ``` Als Nächstes rufen wir unsere Zustandsmaschine auf, wobei wir die physische ID als Ressourcen-ID verwenden. Wir übergeben ein Ereignis an der Befehlszeile mit der `--event` Option: ``` $ sam remote invoke arn:aws:states:us-west-2:01234567890:stateMachine:HelloWorldStateMachine-z69tFEUx0F66 --event '{"is_developer": true}' Invoking Step Function arn:aws:states:us-west-2:01234567890:stateMachine:HelloWorldStateMachine-z69tFEUx0F66 "Hello Developer World"% ``` **Rufen Sie eine Zustandsmaschine auf, indem Sie ein leeres Ereignis übergeben:** ``` $ sam remote invoke HelloWorldStateMachine --stack-name state-machine-example Invoking Step Function HelloWorldStateMachine "Hello World"% ``` ## Weiterführende Links Dokumentation zu `sam remote invoke` und zur Verwendung von finden Sie im Folgenden: AWS SAMCLI + [sam remote invoke](sam-cli-command-reference-remote-invoke.md) + [AWS SAMCLIProblembehandlung](sam-cli-troubleshooting.md) # Automatisieren Sie lokale Integrationstests mit AWS SAM Sie können [Einführung in das Testen mit sam local invoke](using-sam-cli-local-invoke.md) damit zwar Code manuell testen, AWS SAM aber Sie können Ihren Code auch mithilfe automatisierter Integrationstests testen. Integrationstests helfen Ihnen dabei, Probleme früh im Entwicklungszyklus zu erkennen, die Qualität Ihres Codes zu verbessern, Zeit zu sparen und gleichzeitig Kosten zu senken. Um automatisierte Integrationstests zu erstellen AWS SAM, führen Sie zunächst Tests mit lokalen Lambda-Funktionen durch, bevor Sie sie in der AWS Cloud bereitstellen. Der [Einführung in das Testen mit sam local start-lambda](using-sam-cli-local-start-lambda.md) Befehl startet einen lokalen Endpunkt, der den Lambda-Aufrufendpunkt emuliert. Sie können ihn von Ihren automatisierten Tests aus aufrufen. Da dieser Endpunkt den Lambda-Aufrufendpunkt emuliert, können Sie Tests einmal schreiben und sie dann (ohne Änderungen) für die lokale Lambda-Funktion oder für eine bereitgestellte Lambda-Funktion ausführen. Sie können dieselben Tests auch für einen bereitgestellten AWS SAM Stack in Ihrer Pipeline ausführen. CI/CD So funktioniert der Prozess: 1. Starten Sie den lokalen Lambda-Endpunkt. Starten Sie den lokalen Lambda-Endpunkt, indem Sie den folgenden Befehl in dem Verzeichnis ausführen, das Ihre AWS SAM Vorlage enthält: ``` sam local start-lambda ``` Mit diesem Befehl wird ein lokaler Endpunkt gestartet`http://127.0.0.1:3001`, der emuliert AWS Lambda. Sie können Ihre automatisierten Tests für diesen lokalen Lambda-Endpunkt ausführen. Wenn Sie diesen Endpunkt mit dem AWS CLI oder SDK aufrufen, führt er lokal die in der Anfrage angegebene Lambda-Funktion aus und gibt eine Antwort zurück. 1. Führen Sie einen Integrationstest für den lokalen Lambda-Endpunkt durch. In Ihrem Integrationstest können Sie das AWS SDK verwenden, um Ihre Lambda-Funktion mit Testdaten aufzurufen, auf eine Antwort zu warten und zu überprüfen, ob die Antwort Ihren Erwartungen entspricht. Um den Integrationstest lokal auszuführen, sollten Sie das AWS SDK so konfigurieren, dass es einen Lambda Invoke-API-Aufruf sendet, um den lokalen Lambda-Endpunkt aufzurufen, den Sie im vorherigen Schritt gestartet haben. Das Folgende ist ein Python-Beispiel (die AWS SDKs vier anderen Sprachen haben ähnliche Konfigurationen): ``` import boto3 import botocore # Set "running_locally" flag if you are running the integration test locally running_locally = True if running_locally: # Create Lambda SDK client to connect to appropriate Lambda endpoint lambda_client = boto3.client('lambda', region_name="us-west-2", endpoint_url="http://127.0.0.1:3001", use_ssl=False, verify=False, config=botocore.client.Config( signature_version=botocore.UNSIGNED, read_timeout=15, retries={'max_attempts': 0}, ) ) else: lambda_client = boto3.client('lambda') # Invoke your Lambda function as you normally usually do. The function will run # locally if it is configured to do so response = lambda_client.invoke(FunctionName="HelloWorldFunction") # Verify the response assert response == "Hello World" ``` Sie können diesen Code verwenden, um bereitgestellte Lambda-Funktionen zu testen, indem Sie `running_locally` auf `False` setzen. Dadurch wird das AWS SDK für die Verbindung AWS Lambda in der AWS Cloud eingerichtet. # Generieren Sie Beispielereignis-Payloads mit AWS SAM Um Ihre Lambda-Funktionen zu testen, können Sie Beispielereignis-Payloads generieren und anpassen, die die Daten imitieren, die Ihre Lambda-Funktionen erhalten, wenn sie von anderen Diensten ausgelöst werden. AWS Dazu gehören Dienste wie API Gateway CloudFormation, Amazon S3 und mehr. Durch das Generieren von Nutzlasten für Beispielereignisse können Sie das Verhalten Ihrer Lambda-Funktion mit einer Vielzahl verschiedener Eingaben testen, ohne in einer Live-Umgebung arbeiten zu müssen. Dieser Ansatz spart auch Zeit im Vergleich zur manuellen Erstellung von Beispielen für AWS Serviceereignisse zum Testen von Funktionen. Eine vollständige Liste der Dienste, für die Sie Beispielereignis-Payloads generieren können, finden Sie mit diesem Befehl: ``` sam local generate-event --help ``` Eine Liste der Optionen, die Sie für einen bestimmten Dienst verwenden können, finden Sie mit diesem Befehl: ``` sam local generate-event [SERVICE] --help ``` Beispiele: ``` #Generates the event from S3 when a new object is created sam local generate-event s3 put # Generates the event from S3 when an object is deleted sam local generate-event s3 delete ``` # Testen und Debuggen langlebiger Funktionen Das lokale Testen und Debuggen langlebiger Funktionen funktioniert ähnlich wie reguläre Lambda-Funktionen, mit automatischer Unterstützung für Checkpointing und Replay. Dieses Handbuch behandelt gängige Testszenarien und Techniken zur Fehlerbehebung. ## Lokaler Test-Workflow Wenn langlebige Funktionen lokal getestet werden, unterscheidet sich der Workflow von regulären Lambda-Funktionen: **Arbeitsablauf beim Testen dauerhafter Funktionen** 1. Erstellen Sie Ihre Anwendung: ``` $ sam build ``` 1. Rufen Sie Ihre dauerhafte Funktion auf: ``` $ sam local invoke MyDurableFunction --durable-execution-name test ``` 1. Überprüfen Sie bei Bedarf den Ausführungsverlauf: ``` $ sam local execution history execution-id ``` ## Allgemeine Testszenarien ### Testen des Checkpointing-Verhaltens Um zu testen, ob Ihre Funktion ordnungsgemäß funktioniert, gehen Sie wie folgt vor: ``` # Example Python durable function def handler(event, context): # This will create a checkpoint context.wait(10) # Wait 10 seconds # Function resumes here after wait return {"message": "Function resumed after wait"} ``` Wenn Sie diese Funktion lokal aufrufen, wird die Wartezeit automatisch behandelt. ### Callback-Szenarien testen Für Funktionen, die auf externe Rückrufe warten: 1. Starten Sie Ihre dauerhafte Funktion, die auf einen Rückruf wartet 1. Löse den Rückruf in einem anderen Terminal auf: ``` $ sam local callback succeed callback-id ``` 1. Beobachten Sie, wie die Funktion die Ausführung fortsetzt ## Fehlerbehebung ### Dauerhafte Funktion wird nicht ordnungsgemäß ausgeführt **Problem:** Die Funktion verhält sich nicht wie eine dauerhafte Funktion. **Lösungen:** + Vergewissern Sie `DurableConfig` sich, dass dies in Ihrer SAM-Vorlage festgelegt ist + Stellen Sie sicher, dass Ihr Funktionscode SDK-Methoden für dauerhafte Funktionen verwendet `context.wait()` (z. B. + Überprüfe, ob du eine unterstützte Runtime (TypeScript, JavaScript, Python) verwendest ### Der Ausführungsverlauf kann nicht abgerufen werden **Problem:** Der `local execution history` Befehl gibt keine Ergebnisse zurück. **Lösungen:** + Stellen Sie sicher, dass die Ausführungs-ID korrekt ist + Vergewissern Sie sich, dass die Funktion mindestens einmal aufgerufen wurde ### Callback-Befehle funktionieren nicht **Problem:** Callback-Befehle lösen ausstehende Operationen nicht auf. **Lösungen:** + Stellen Sie sicher, dass die Rückruf-ID korrekt ist + Stellen Sie sicher, dass die Funktion tatsächlich auf einen Rückruf wartet + Stellen Sie sicher, dass Sie die richtige Callback-Befehlssyntax verwenden ## Tipps zum Debuggen + **Ausführungshistorie verwenden** — Sehen Sie sich den Ausführungsverlauf an, um den Ablauf Ihrer dauerhaften Funktion nachzuvollziehen + **Testen Sie inkrementell** — Beginnen Sie mit einfachen Warteoperationen, bevor Sie komplexe Logik hinzufügen + **Ausführliche Protokollierung verwenden — Aktivieren Sie die detaillierte Protokollierung**, um den Ausführungsablauf nachzuverfolgen ## Weitere Informationen Weitere Informationen zum Testen und Debuggen finden Sie unter: + [Einführung in das Testen mit sam local invoke](using-sam-cli-local-invoke.md)- Dokumentation zum lokalen Aufrufen + [sam local execution history](sam-cli-command-reference-sam-local-execution-history.md)- Ausführungshistorie