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. # Aufrufen einer Lambda-Funktion über einen Amazon API Gateway-Endpunkt Sie können eine Web-API mit einem HTTP-Endpunkt für Ihre Lambda Funktion erstellen, indem Sie Amazon API Gateway verwenden. API Gateway bietet Tools zum Erstellen und Dokumentieren von Websites APIs , die HTTP-Anfragen an Lambda-Funktionen weiterleiten. Sie können den Zugriff auf Ihre API mit Authentifizierungs- und Autorisierungskontrollen sichern. Sie APIs können Traffic über das Internet bereitstellen oder nur innerhalb Ihrer VPC darauf zugreifen. **Tipp** Lambda bietet zwei Möglichkeiten, Ihre Funktion über einen HTTP-Endpunkt aufzurufen: API Gateway und Lambda-Funktion. URLs Wenn Sie sich nicht sicher sind, welche Methode für Ihren Anwendungsfall am besten geeignet ist, siehe [Wählen Sie eine Methode, um Ihre Lambda-Funktion über eine HTTP-Anfrage aufzurufen](apig-http-invoke-decision.md). Ressourcen in Ihrer API definieren mindestens eine Methode, z. B. GET oder POST. Methoden haben eine Integration, die Anfragen an eine Lambda-Funktion oder einen anderen Integrationstyp weiterleitet. Sie können jede Ressource und jede Methode einzeln definieren oder spezielle Ressourcen- und Methodenarten verwenden, um alle Anforderungen abzugleichen, die einem Muster entsprechen. Eine [Proxy-Ressource](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html) fängt alle Pfade unter einer Ressource ab. Die `ANY`-Methode fängt alle HTTP-Methoden ab. **Topics** + [ ## Auswählen eines API-Typs ](#services-apigateway-apitypes) + [ ## Hinzufügen eines Endpunkts zur Lambda-Funktion ](#apigateway-add) + [ ## Proxy-Integration ](#apigateway-proxy) + [ ## Ereignisformat ](#apigateway-example-event) + [ ## Reaktionsformat ](#apigateway-types-transforms) + [ ## Berechtigungen ](#apigateway-permissions) + [ ## Beispielanwendung ](#services-apigateway-samples) + [ ## Der Event-Handler von Powertools für Lambda AWS ](#services-apigateway-powertools) + [ # Tutorial: Verwenden von Lambda mit API Gateway ](services-apigateway-tutorial.md) + [ # Behandlung von Lambda-Fehlern mit einer API-Gateway-API ](services-apigateway-errors.md) + [ # Wählen Sie eine Methode, um Ihre Lambda-Funktion über eine HTTP-Anfrage aufzurufen ](apig-http-invoke-decision.md) ## Auswählen eines API-Typs API Gateway unterstützt drei Typen von APIs Lambda-Funktionen: + [HTTP-API](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html): Eine schlanke API mit niedriger RESTful Latenz. + [REST-API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html): Eine anpassbare, funktionsreiche RESTful API. + [WebSocket API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html): Eine Web-API, die persistente Verbindungen zu Clients für die Vollduplex-Kommunikation unterhält. APIs Sowohl HTTP als APIs RESTful APIs auch REST verarbeiten HTTP-Anfragen und geben Antworten zurück. HTTP APIs sind neuer und wurden mit der API Gateway Version 2 API erstellt. Die folgenden Funktionen sind neu für HTTP APIs: **HTTP-API-Features** + **Automatische Bereitstellungen** – wenn Sie Routen oder Integrationen ändern, werden Änderungen automatisch in Phasen bereitgestellt, bei denen die automatische Bereitstellung aktiviert ist. + **Standardphase** – Sie können eine Standardphase (`$default`) erstellen, um Anforderungen am Stammpfad der URL Ihrer API zu bedienen. Bei benannten Phasen müssen Sie den Schrittnamen am Anfang des Pfades angeben. + **CORS-Konfiguration** – Sie können Ihre API so konfigurieren, dass ausgehenden Antworten CORS-Header hinzugefügt werden, anstatt sie manuell in Ihrem Funktionscode hinzufügen zu müssen. REST APIs sind der Klassiker RESTful APIs , den API Gateway seit dem Start unterstützt. REST bietet APIs derzeit mehr Anpassungs-, Integrations- und Verwaltungsfunktionen. **REST-API-Funktionen** + **Integrationstypen** — REST APIs unterstützt benutzerdefinierte Lambda-Integrationen. Mit einer benutzerdefinierten Integration können Sie nur den Text der Anforderung an die Funktion senden oder eine Transformationsvorlage auf den Anforderungstext anwenden, bevor Sie sie an die Funktion senden. + **Zugriffskontrolle** — REST APIs unterstützt mehr Optionen für Authentifizierung und Autorisierung. + **Überwachung und Ablaufverfolgung** — REST APIs unterstützt AWS X-Ray Tracing und zusätzliche Protokollierungsoptionen. Einen ausführlichen Vergleich finden [Sie unter Wählen Sie zwischen HTTP APIs und REST APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vs-rest.html) im *API Gateway Developer Guide*. WebSocket APIs Verwenden Sie auch die API Gateway Version 2 API und unterstützen Sie einen ähnlichen Funktionsumfang. Verwenden Sie eine WebSocket API für Anwendungen, die von einer dauerhaften Verbindung zwischen dem Client und der API profitieren. WebSocket APIs bieten Vollduplex-Kommunikation, was bedeutet, dass sowohl der Client als auch die API kontinuierlich Nachrichten senden können, ohne auf eine Antwort warten zu müssen. HTTP APIs unterstützt ein vereinfachtes Ereignisformat (Version 2.0). Ein Beispiel für ein Ereignis aus einer HTTP-API finden Sie unter [Erstellen von AWS Lambda Proxyintegrationen für HTTP APIs in API Gateway](https://docs.aws.amazon.com//apigateway/latest/developerguide/http-api-develop-integrations-lambda.html). Weitere Informationen finden Sie unter [AWS Lambda Proxyintegrationen für HTTP APIs in API Gateway erstellen](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html). ## Hinzufügen eines Endpunkts zur Lambda-Funktion **So fügen Sie Ihrer Lambda-Funktion einen öffentlichen Endpunkt hinzu** 1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole. 1. Wählen Sie eine Funktion aus. 1. Wählen Sie unter **Function overview (Funktionsübersicht)** die Option **Add trigger (Trigger hinzufügen)**. 1. Wählen Sie **API Gateway** aus. 1. Wählen Sie **Create an API** (API erstellen) oder **Use an existing API** (Vorhandene API verwenden). 1. **Neue API:** Wählen Sie als **API type** (API-Typ) **HTTP API** aus. Weitere Informationen finden Sie unter [Auswählen eines API-Typs](#services-apigateway-apitypes). 1. **Vorhandene API:** Wählen Sie die API aus der Dropdown-Liste aus oder geben Sie die API-ID ein (z. B. r3pmxmplak). 1. Wählen Sie unter **Security (Sicherheit)** die Option **Open (Öffnen)** aus. 1. Wählen Sie **Add** aus. ## Proxy-Integration API Gateway APIs besteht aus Stufen, Ressourcen, Methoden und Integrationen. Die Phase und die Ressource bestimmen den Pfad des Endpunkts: **API-Pfadformat** + `/prod/` – Die `prod`-Phase und die Root-Ressource. + `/prod/user` – Die `prod`-Phase und die `user`-Ressource. + `/dev/{proxy+}` – Jede Route in der `dev`-Phase. + `/`— (HTTP APIs) Die Standard-Stage- und Root-Ressource. Eine Lambda-Integration ordnet einer Lambda-Funktion eine Pfad- und HTTP-Methodenkombination zu. Sie können API Gateway so konfigurieren, dass der Hauptteil der HTTP-Anforderung unverändert (benutzerdefinierte Integration) übergeben oder der Anforderungstext in einem Dokument mit allen Anforderungsinformationen, einschließlich Header, Ressource, Pfad und Methode, gekapselt wird. Weitere Informationen finden Sie unter [Lambda-Proxy-Integrationen in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html). ## Ereignisformat Amazon API Gateway ruft Ihre Funktion [synchron](invocation-sync.md) mit einem Ereignis auf, das eine JSON-Darstellung der HTTP-Anforderung enthält. Bei einer benutzerdefinierten Integration ist das Ereignis der Text der Anforderung. Bei einer Proxy-Integration hat das Ereignis eine definierte Struktur. Ein Beispiel für ein Proxy-Ereignis von einer API Gateway REST API finden Sie unter [Eingabeformat einer Lambda-Funktion für die Proxy-Integration](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format) im *API Gateway Developer Guide*. ## Reaktionsformat API Gateway wartet auf eine Antwort von Ihrer Funktion und leitet das Ergebnis an den Aufrufer weiter. Für eine benutzerdefinierte Integration definieren Sie eine Integrationsantwort und eine Methodenantwort, um die Ausgabe von der Funktion in eine HTTP-Antwort zu konvertieren. Für eine Proxy-Integration muss die Funktion mit einer Darstellung der Antwort in einem bestimmten Format antworten. Das folgende Beispiel zeigt ein Antwortobjekt aus einer Node.js-Funktion. Das Antwortobjekt stellt eine erfolgreiche HTTP-Antwort dar, die ein JSON-Dokument enthält. **Example index.mjs – Antwortobjekt der Proxy-Integration (Node.js)** ``` var response = { "statusCode": 200, "headers": { "Content-Type": "application/json" }, "isBase64Encoded": false, "multiValueHeaders": { "X-Custom-Header": ["My value", "My other value"], }, "body": "{\n \"TotalCodeSize\": 104330022,\n \"FunctionCount\": 26\n}" } ``` Die Lambda-Laufzeit serialisiert das Antwortobjekt in JSON und sendet es an die API. Die API analysiert die Antwort und verwendet sie zur Erstellung einer HTTP-Antwort verwendet, die sie dann an den Client sendet, der die ursprüngliche Anforderung gestellt hat. **Example HTTP-Antwort** ``` < HTTP/1.1 200 OK < Content-Type: application/json < Content-Length: 55 < Connection: keep-alive < x-amzn-RequestId: 32998fea-xmpl-4268-8c72-16138d629356 < X-Custom-Header: My value < X-Custom-Header: My other value < X-Amzn-Trace-Id: Root=1-5e6aa925-ccecxmplbae116148e52f036 < { "TotalCodeSize": 104330022, "FunctionCount": 26 } ``` ## Berechtigungen Amazon API Gateway erhält die Berechtigung zum Aufrufen Ihrer Funktion über die [ressourcenbasierte Richtlinie](access-control-resource-based.md) der Funktion. Sie können eine Aufrufberechtigung für eine gesamte API erteilen oder einen eingeschränkten Zugriff auf eine Phase, eine Ressource oder eine Methode gewähren. Wenn Sie Ihrer Funktion mithilfe der Lambda-Konsole, mithilfe der API-Gateway-Konsole oder in einer AWS SAM -Vorlage eine API hinzufügen, wird die ressourcenbasierte Richtlinie der Funktion automatisch aktualisiert. Es folgt eine Beispiel-Funktionsrichtlinie. **Example Funktionsrichtlinie** **** ``` { "Version":"2012-10-17", "Id": "default", "Statement": [ { "Sid": "nodejs-apig-functiongetEndpointPermissionProd-BWDBXMPLXE2F", "Effect": "Allow", "Principal": { "Service": "apigateway.amazonaws.com" }, "Action": "lambda:InvokeFunction", "Resource": "arn:aws:lambda:us-east-2:111122223333:function:nodejs-apig-function-1G3MXMPLXVXYI", "Condition": { "StringEquals": { "aws:SourceAccount": "111122223333" }, "ArnLike": { "aws:SourceArn": "arn:aws:execute-api:us-east-2:111122223333:ktyvxmpls1/*/GET/" } } } ] } ``` Sie können Funktionsrichtlinienberechtigungen manuell mit den folgenden API-Operationen verwalten: + [AddPermission](https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html) + [RemovePermission](https://docs.aws.amazon.com/lambda/latest/api/API_RemovePermission.html) + [GetPolicy](https://docs.aws.amazon.com/lambda/latest/api/API_GetPolicy.html) Mit dem `add-permission`-Befehl können Sie einer vorhandenen API Aufrufberechtigung erteilen. Beispiel: ``` aws lambda add-permission \ --function-name my-function \ --statement-id apigateway-get --action lambda:InvokeFunction \ --principal apigateway.amazonaws.com \ --source-arn "arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET/" ``` Die Ausgabe sollte folgendermaßen aussehen: ``` { "Statement": "{\"Sid\":\"apigateway-test-2\",\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"apigateway.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":\"arn:aws:lambda:us-east-2:123456789012:function:my-function\",\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET\"}}}" } ``` **Anmerkung** Wenn sich Ihre Funktion und API unterscheiden AWS-Regionen, muss die Regionskennung im Quell-ARN mit der Region der Funktion übereinstimmen, nicht mit der Region der API. Bei Aufruf einer API-Gateway-Funktion verwendet diese einen Ressourcen-ARN, der auf dem ARN der API basiert, aber so geändert wird, dass er dem Bereich der Funktion entspricht. Der Quell-ARN in diesem Beispiel erteilt eine Berechtigung für eine Integration in die GET-Methode der Root-Ressource in der Standardphase einer API mit ID `mnh1xmpli7`. Sie können ein Sternchen im Quell-ARN verwenden, um Berechtigungen für mehrere Phasen, Methoden oder Ressourcen zu erteilen. **Ressourcenmuster** + `mnh1xmpli7/*/GET/*` – GET-Methode bei allen Ressourcen in allen Phasen. + `mnh1xmpli7/prod/ANY/user` – JEDE Methode bei der `user`-Ressource in der `prod`-Phase. + `mnh1xmpli7/*/*/*` – Jede Methode bei allen Ressourcen in allen Phasen. Weitere Informationen zum Anzeigen der Richtlinie und zum Entfernen von Anweisungen finden Sie unter [Anzeigen von ressourcenbasierten IAM-Richtlinien in Lambda](access-control-resource-based.md). ## Beispielanwendung Die Beispiel-App [API Gateway with Node.js](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/nodejs-apig) enthält eine Funktion mit einer AWS SAM Vorlage, die eine REST-API erstellt, für die die AWS X-Ray Ablaufverfolgung aktiviert ist. Es enthält auch Skripte zum Bereitstellen und Aufrufen der Funktion sowie zum Testen der API und zum Bereinigen. ## Der Event-Handler von Powertools für Lambda AWS Der Event-Handler aus dem Powertools for AWS Lambda-Toolkit bietet Routing, Middleware, CORS-Konfiguration, Generierung von OpenAPI-Spezifikationen, Anforderungsvalidierung, Fehlerbehandlung und andere nützliche Funktionen beim Schreiben von Lambda-Funktionen, die von einem API-Gateway-Endpunkt (HTTP oder REST) aufgerufen werden. Das Event-Handler-Hilfsprogramm ist für Python TypeScript und/ verfügbarJavaScript. Weitere Informationen finden Sie unter [Event Handler REST API](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/api_gateway/) in der *Powertools for AWS Lambda (Python) -Dokumentation* und [Event Handler HTTP API](https://docs.aws.amazon.com/powertools/typescript/latest/features/event-handler/http/) in der *Powertools for AWS Lambda* () -Dokumentation. TypeScript ### Python ``` from aws_lambda_powertools import Logger from aws_lambda_powertools.event_handler import APIGatewayRestResolver from aws_lambda_powertools.logging import correlation_paths from aws_lambda_powertools.utilities.typing.lambda_context import LambdaContext app = APIGatewayRestResolver() logger = Logger() @app.get("/healthz") def ping(): return {"message": "health status ok"} @logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST) def lambda_handler(event: dict, context: LambdaContext) -> dict: return app.resolve(event, context) ``` ### TypeScript ``` import { Router } from '@aws-lambda-powertools/event-handler/experimental-rest'; import { Logger } from '@aws-lambda-powertools/logger'; import { correlationPaths, search, } from '@aws-lambda-powertools/logger/correlationId'; import type { Context } from 'aws-lambda/handler'; const logger = new Logger({ correlationIdSearchFn: search, }); const app = new Router({ logger }); app.get("/healthz", async () => { return { message: "health status ok" }; }); export const handler = async (event: unknown, context: Context) => { // You can continue using other utilities just as before logger.addContext(context); logger.setCorrelationId(event, correlationPaths.API_GATEWAY_REST); return app.resolve(event, context); }; ``` # Tutorial: Verwenden von Lambda mit API Gateway In diesem Tutorial erstellen Sie eine REST-API, über die Sie eine Lambda-Funktion mithilfe einer HTTP-Anfrage aufrufen. Ihre Lambda-Funktion führt CRUD-Operationen (Erstellen, Lesen, Aktualisieren und Löschen) für eine DynamoDB-Tabelle durch. Diese Funktion wird hier zu Demonstrationszwecken bereitgestellt, aber Sie werden lernen, eine API-Gateway-REST-API zu konfigurieren, die jede Lambda-Funktion aufrufen kann. ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/APIG_tut_resources.png) Die Verwendung von API-Gateway bietet Benutzern einen sicheren HTTP-Endpunkt zum Aufrufen Ihrer Lambda-Funktion und kann dabei helfen, große Mengen an Aufrufen an Ihre Funktion zu verwalten, indem der Datenverkehr gedrosselt und API-Aufrufe automatisch validiert und autorisiert werden. API Gateway bietet auch flexible Sicherheitskontrollen mithilfe von AWS Identity and Access Management (IAM) und Amazon Cognito. Dies ist nützlich für Anwendungsfälle, in denen eine vorherige Autorisierung für Aufrufe zu Ihrer Anwendung erforderlich ist. **Tipp** Lambda bietet zwei Möglichkeiten, Ihre Funktion über einen HTTP-Endpunkt aufzurufen: API Gateway und Lambda-Funktion. URLs Wenn Sie sich nicht sicher sind, welche Methode für Ihren Anwendungsfall am besten geeignet ist, siehe [Wählen Sie eine Methode, um Ihre Lambda-Funktion über eine HTTP-Anfrage aufzurufen](apig-http-invoke-decision.md). Um dieses Tutorial abzuschließen, werden Sie die folgenden Phasen durchlaufen: 1. Erstellen und Konfigurieren einer Lambda-Funktion in Python oder Node.js, um Operationen in einer DynamoDB-Tabelle auszuführen. 1. Erstellen einer REST-API in API Gateway, um eine Verbindung zu Ihrer Lambda-Funktion herzustellen. 1. Erstellen einer DynamoDB-Tabelle und Testen dieser Tabelle mit Ihrer Lambda-Funktion in der Konsole. 1. Bereitstellen Ihrer API und Testen der vollständigen Einrichtung mithilfe von curl in einem Terminal. Durch Abschluss dieser Phasen lernen Sie, wie Sie mit API Gateway einen HTTP-Endpunkt erstellen, der eine Lambda-Funktion in jeder Größenordnung sicher aufrufen kann. Sie erfahren auch, wie Sie Ihre API bereitstellen und wie Sie sie in der Konsole und durch Senden einer HTTP-Anfrage über ein Terminal testen. ## Erstellen einer Berechtigungsrichtlinie Bevor Sie eine [Ausführungsrolle](lambda-intro-execution-role.md) für Ihre Lambda-Funktion erstellen können, müssen Sie zunächst eine Berechtigungsrichtlinie erstellen, um Ihrer Funktion die Erlaubnis zu erteilen, auf die erforderlichen AWS Ressourcen zuzugreifen. In diesem Tutorial ermöglicht die Richtlinie Lambda, CRUD-Operationen in einer DynamoDB-Tabelle durchzuführen und in Amazon Logs zu schreiben. CloudWatch **So erstellen Sie die Richtlinie** 1. Öffnen Sie die Seite [Richtlinien](https://console.aws.amazon.com/iam/home#/policies) in der IAM-Konsole. 1. Wählen Sie **Richtlinie erstellen** aus. 1. Wählen Sie die Registerkarte **JSON** aus und kopieren Sie dann die folgende benutzerdefinierte JSON-Richtlinie in den JSON-Editor. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "Stmt1428341300017", "Action": [ "dynamodb:DeleteItem", "dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:Query", "dynamodb:Scan", "dynamodb:UpdateItem" ], "Effect": "Allow", "Resource": "*" }, { "Sid": "", "Resource": "*", "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], "Effect": "Allow" } ] } ``` ------ 1. Wählen Sie **Next: Tags** (Weiter: Tags) aus. 1. Klicken Sie auf **Weiter: Prüfen**. 1. Geben Sie unter **Review policy (Richtlinie prüfen) ** für den Richtlinien-**Namen** **lambda-apigateway-policy** ein. 1. Wählen Sie **Richtlinie erstellen** aus. ## Erstellen einer Ausführungsrolle Eine [Ausführungsrolle](lambda-intro-execution-role.md) ist eine AWS Identity and Access Management (IAM-) Rolle, die einer Lambda-Funktion Zugriffsberechtigungen AWS-Services und Ressourcen gewährt. Damit Ihre Funktion Vorgänge an einer DynamoDB-Tabelle ausführen kann, fügen Sie die Berechtigungsrichtlinie an, die Sie im vorherigen Schritt erstellt haben. **So erstellen Sie eine Ausführungsrolle und fügen Ihre benutzerdefinierte Berechtigungsrichtlinie hinzu** 1. Öffnen Sie die Seite [Roles (Rollen)](https://console.aws.amazon.com/iam/home#/roles) in der IAM-Konsole. 1. Wählen Sie **Rolle erstellen** aus. 1. Wählen Sie als Typ der vertrauenswürdigen Entität **AWS -Service** und dann als Anwendungsfall **Lambda** aus. 1. Wählen Sie **Weiter** aus. 1. Geben Sie im Feld für die Richtliniensuche **lambda-apigateway-policy** ein. 1. Wählen Sie in den Suchergebnissen die von Ihnen erstellte Richtlinie (`lambda-apigateway-policy`) und dann die Option **Next** (Weiter) aus. 1. Geben Sie unter **Role details** (Rollendetails) für den **Role name** (Rollennamen) **lambda-apigateway-role** ein und wählen Sie dann **Create role** (Rolle erstellen) aus. ## So erstellen Sie die Lambda-Funktion: 1. Öffnen Sie die [Funktionsseite](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie **Funktion erstellen** aus. 1. Wählen Sie **Von Grund auf neu schreiben** aus. 1. Geben Sie für **Function name** (Funktionsname) `LambdaFunctionOverHttps` ein. 1. Wählen Sie für **Laufzeit** die neueste Node.js- oder Python-Laufzeit aus. 1. Erweitern Sie unter **Berechtigungen** die Option **Standardausführungsrolle ändern**. 1. Wählen Sie **Vorhandene Rolle verwenden** und anschließend die zuvor erstellte Rolle „**lambda-apigateway-role**“ aus. 1. Wählen Sie **Funktion erstellen**. 1. Ersetzen Sie im Bereich **Codequelle** den Standardcode durch den folgenden Node.js- oder Python-Code. ------ #### [ Node.js ] Die `region` Einstellung muss mit dem AWS-Region Ort übereinstimmen, an dem Sie die Funktion bereitstellen und [die DynamoDB-Tabelle erstellen](#services-apigateway-tutorial-table). **Example index.mjs** ``` import { DynamoDBDocumentClient, PutCommand, GetCommand, UpdateCommand, DeleteCommand} from "@aws-sdk/lib-dynamodb"; import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; const ddbClient = new DynamoDBClient({ region: "us-east-2" }); const ddbDocClient = DynamoDBDocumentClient.from(ddbClient); // Define the name of the DDB table to perform the CRUD operations on const tablename = "lambda-apigateway"; /** * Provide an event that contains the following keys: * * - operation: one of 'create,' 'read,' 'update,' 'delete,' or 'echo' * - payload: a JSON object containing the parameters for the table item * to perform the operation on */ export const handler = async (event, context) => { const operation = event.operation; if (operation == 'echo'){ return(event.payload); } else { event.payload.TableName = tablename; let response; switch (operation) { case 'create': response = await ddbDocClient.send(new PutCommand(event.payload)); break; case 'read': response = await ddbDocClient.send(new GetCommand(event.payload)); break; case 'update': response = ddbDocClient.send(new UpdateCommand(event.payload)); break; case 'delete': response = ddbDocClient.send(new DeleteCommand(event.payload)); break; default: response = 'Unknown operation: ${operation}'; } console.log(response); return response; } }; ``` ------ #### [ Python ] **Example lambda\$1function.py** ``` import boto3 # Define the DynamoDB table that Lambda will connect to table_name = "lambda-apigateway" # Create the DynamoDB resource dynamo = boto3.resource('dynamodb').Table(table_name) # Define some functions to perform the CRUD operations def create(payload): return dynamo.put_item(Item=payload['Item']) def read(payload): return dynamo.get_item(Key=payload['Key']) def update(payload): return dynamo.update_item(**{k: payload[k] for k in ['Key', 'UpdateExpression', 'ExpressionAttributeNames', 'ExpressionAttributeValues'] if k in payload}) def delete(payload): return dynamo.delete_item(Key=payload['Key']) def echo(payload): return payload operations = { 'create': create, 'read': read, 'update': update, 'delete': delete, 'echo': echo, } def lambda_handler(event, context): '''Provide an event that contains the following keys: - operation: one of the operations in the operations dict below - payload: a JSON object containing parameters to pass to the operation being performed ''' operation = event['operation'] payload = event['payload'] if operation in operations: return operations[operation](payload) else: raise ValueError(f'Unrecognized operation "{operation}"') ``` ------ **Anmerkung** In diesem Beispiel ist der Name der DynamoDB-Tabelle als Variable in Ihrem Funktionscode definiert. In einer realen Anwendung besteht die bewährte Methode darin, diesen Parameter als Umgebungsvariable zu übergeben und den Tabellennamen nicht fest zu codieren. Weitere Informationen finden Sie unter [AWS Lambda Umgebungsvariablen verwenden.](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html) 1. Wählen Sie im Abschnitt **BEREITSTELLEN** die Option **Bereitstellen** aus, um den Code Ihrer Funktion zu aktualisieren: ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png) ## Testen der Funktion Bestätigen Sie vor der Integration Ihrer Funktion mit API-Gateway, dass Sie die Funktion erfolgreich bereitgestellt haben. Senden Sie mithilfe der Lambda-Konsole ein Testereignis an Ihre Funktion. 1. Wählen Sie auf der Lambda-Konsolenseite für Ihre Funktion die Registerkarte **Test** aus. ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/test-tab.png) 1. Scrollen Sie nach unten zum Abschnitt **Ereignis-JSON** und ersetzen Sie das Standardereignis durch Folgendes. Dieses Ereignis entspricht der von der Lambda-Funktion erwarteten Struktur. ``` { "operation": "echo", "payload": { "somekey1": "somevalue1", "somekey2": "somevalue2" } } ``` 1. Wählen Sie **Test** aus. 1. Erweitern Sie unter **Funktionsausführung: erfolgreich** die Option **Details**. Sie sollten die folgende Antwort sehen: ``` { "somekey1": "somevalue1", "somekey2": "somevalue2" } ``` ## Erstellen Sie eine REST-API mit API Gateway In diesem Schritt erstellen Sie die API-Gateway-REST-API, die Sie zum Aufrufen Ihrer Lambda-Funktion verwenden. **So erstellen Sie die API** 1. Öffnen Sie die [API Gateway-Konsole](https://console.aws.amazon.com/apigateway). 1. Wählen Sie **Create API (API erstellen)** aus. 1. Wählen Sie im Feld **REST-API** die Option **Entwickeln** aus. 1. Lassen Sie unter **API details** (API-Details) die Option **New API** (Neue API) ausgewählt und geben Sie für **API Name** (API-Name) **DynamoDBOperations** ein. 1. Wählen Sie **Create API** (API erstellen) aus. ## Erstellen einer Ressource für Ihre REST-API Um Ihrer API eine HTTP-Methode hinzuzufügen, müssen Sie zunächst eine Ressource erstellen, mit der diese Methode ausgeführt werden kann. Hier erstellen Sie die Ressource zur Verwaltung Ihrer DynamoDB-Tabelle. **So erstellen Sie die Ressource** 1. Wählen Sie in der [API-Gateway-Konsole](https://console.aws.amazon.com/apigateway) auf der Seite **Ressourcen** für Ihre API die Option **Ressource erstellen** aus. 1. Geben Sie im Feld **Resource details** (Ressourcendetails) für **Resource name** (Ressourcenname) **DynamoDBManager** ein. 1. Wählen Sie **Create Resource** (Ressource erstellen) aus. ## Erstellen einer HTTP-POST-Methode In diesem Schritt erstellen Sie eine Methode (`POST`) für Ihre `DynamoDBManager`-Ressource. Sie verknüpfen diese `POST`-Methode mit Ihrer Lambda-Funktion, sodass API-Gateway Ihre Lambda-Funktion aufruft, wenn die Methode eine HTTP-Anfrage empfängt. **Anmerkung** Für die Zwecke dieses Tutorials wird eine HTTP-Methode (`POST`) verwendet, um eine einzelne Lambda-Funktion aufzurufen, die alle Operationen in Ihrer DynamoDB-Tabelle ausführt. In einer realen Anwendung besteht die bewährte Methode darin, für jede Operation eine andere Lambda-Funktion und HTTP-Methode zu verwenden. Weitere Informationen finden Sie bei Serverless Land unter [The Lambda monolith](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/monolith). **So erstellen Sie die POST-Methode** 1. Vergewissern Sie sich, dass die `/DynamoDBManager`-Ressource auf der Seite **Resources** (Ressourcen) für Ihre API markiert ist. Wählen Sie dann im Bereich **Methods** (Methoden) die Option **Create Method** (Methode erstellen) aus. 1. Wählen Sie in **Method type** (Methodentyp) **POST**. 1. Lassen Sie für den **Integration type** (Integrationstyp) die Option **Lambda function** (Lambda-Funktion) ausgewählt. 1. Wählen Sie für die **Lambda function** (Lambda-Funktion) den Amazon Ressourcennamen (ARN) für Ihre Funktion (`LambdaFunctionOverHttps`). 1. Wählen Sie **Methode erstellen** aus. ## Erstellen einer DynamoDB-Tabelle Erstellen Sie eine leere DynamoDB-Tabelle, an der Ihre Lambda-Funktion CRUD-Operationen ausführt. **Erstellen einer DynamoDB-Tabelle** 1. Öffnen Sie die Seite [Tables (Tabellen)](https://console.aws.amazon.com/dynamodbv2#tables) in der DynamoDB-Konsole. 1. Wählen Sie **Create table** (Tabelle erstellen) aus. 1. Führen Sie unter **Tabellendetails** die folgenden Schritte aus: 1. Geben Sie unter **Tabellenname** **lambda-apigateway** ein. 1. Geben Sie für **Partitionsschlüssel** **id** ein und behalten Sie den Datentyp als **Zeichenfolge** bei. 1. Behalten Sie unter **Table settings** (Tabelleneinstellungen) die **Default settings** (Standardeinstellungen) bei. 1. Wählen Sie **Create table** (Tabelle erstellen) aus. ## Testen der Integration von API-Gateway, Lambda und DynamoDB Sie können nun die Integration Ihrer APIä-Gateway-API-Methode mit Ihrer Lambda-Funktion und Ihrer DynamoDB-Tabelle testen. Mit der API Gateway-Konsole senden Sie Anfragen mithilfe der Testfunktion der Konsole direkt an Ihre `POST`-Methode. In diesem Schritt verwenden Sie zuerst eine `create`-Operation, um Ihrer DynamoDB-Tabelle ein neues Element hinzuzufügen, und verwenden dann eine `update`-Operation, um das Element zu ändern. **Test 1: So erstellen Sie ein neues Element in Ihrer DynamoDB-Tabelle** 1. Wählen Sie in der [API-Gateway-Konsole](https://console.aws.amazon.com/apigateway) Ihre API aus (`DynamoDBOperations`). 1. Wählen Sie unter der Ressource `DynamoDBManager` die Methode **POST**. 1. Wählen Sie die Registerkarte **Test**. Möglicherweise müssen Sie die rechte Pfeiltaste wählen, um die Registerkarte anzuzeigen. 1. Lassen Sie unter **Test method** (Testmethode) die Felder **Query strings** (Query-Strings) und **Headers** (Header) leer. Fügen Sie für **Request body** (Anforderungstext) den folgenden JSON-Code ein: ``` { "operation": "create", "payload": { "Item": { "id": "1234ABCD", "number": 5 } } } ``` 1. Wählen Sie **Test** aus. Die Ergebnisse, die nach Abschluss des Tests angezeigt werden, sollten den Status `200` anzeigen. Dieser Statuscode zeigt an, dass die `create`-Operation erfolgreich war. Überprüfen Sie zur Bestätigung, ob Ihre DynamoDB-Tabelle jetzt das neue Element enthält. 1. Öffnen Sie die [Seite Tabellen](https://console.aws.amazon.com/dynamodbv2#tables) der DynamoDB-Konsole und wählen Sie die `lambda-apigateway`-Tabelle aus. 1. Wählen Sie **Explore table items** (Tabellenelemente erkunden) aus. Im Bereich **Items returned** (Zurückgegebene Elemente) sollten ein Element mit der **id** (ID) `1234ABCD` und der **number** (Nummer) `5` angezeigt werden. Beispiel: ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/items-returned.png) **Test 2: So aktualisieren Sie das Element in Ihrer DynamoDB-Tabelle** 1. Kehren Sie in der [API-Gateway-Konsole](https://console.aws.amazon.com/apigateway) zum Bereich **Test** Ihrer POST-Methode zurück. 1. Lassen Sie unter **Test method** (Testmethode) die Felder **Query strings** (Query-Strings) und **Headers** (Header) leer. Fügen Sie für **Request body** (Anforderungstext) den folgenden JSON-Code ein: ``` { "operation": "update", "payload": { "Key": { "id": "1234ABCD" }, "UpdateExpression": "SET #num = :newNum", "ExpressionAttributeNames": { "#num": "number" }, "ExpressionAttributeValues": { ":newNum": 10 } } } ``` 1. Wählen Sie **Test** aus. Die Ergebnisse, die nach Abschluss des Tests angezeigt werden, sollten den Status `200` anzeigen. Dieser Statuscode zeigt an, dass die `update`-Operation erfolgreich war. Überprüfen Sie zur Bestätigung, ob das Element in Ihrer DynamoDB-Tabelle geändert wurde. 1. Öffnen Sie die [Seite Tabellen](https://console.aws.amazon.com/dynamodbv2#tables) der DynamoDB-Konsole und wählen Sie die `lambda-apigateway`-Tabelle aus. 1. Wählen Sie **Explore table items** (Tabellenelemente erkunden) aus. Im Bereich **Items returned** (Zurückgegebene Elemente) sollten ein Element mit der **id** (ID) `1234ABCD` und der **number** (Nummer) `10` angezeigt werden. ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/items-returned-2.png) ## Bereitstellen der API Damit ein Client die API aufrufen kann, müssen Sie eine Bereitstellung und eine zugehörige Stufe erstellen. Eine Phase stellt eine Momentaufnahme Ihrer API dar, einschließlich ihrer Methoden und Integrationen. **So stellen Sie die API bereit** 1. Öffnen Sie die **APIs**Seite der [API Gateway Gateway-Konsole](https://console.aws.amazon.com/apigateway) und wählen Sie die `DynamoDBOperations` API aus. 1. Wählen Sie auf der Seite **Resources** (Ressourcen) für Ihre API die Option **Deploy API** (API bereitstellen) aus. 1. Wählen Sie für **Stage** (Stufe) **\$1New stage\$1** (\$1Neue Stufe\$1) und geben Sie dann als **Stage name** (Phasenname) **test** ein. 1. Wählen Sie **Bereitstellen**. 1. Kopieren Sie im Bereich **Stage details** (Stufendetails) die **Invoke URL** (Aufruf-URL). Sie werden diese im nächsten Schritt verwenden, um Ihre Funktion mithilfe einer HTTP-Anfrage aufzurufen. ## Verwenden von curl zum Aufrufen Ihrer Funktion mithilfe von HTTP-Anfragen Sie können Ihre Lambda-Funktion jetzt aufrufen, indem Sie eine HTTP-Anfrage an Ihre API senden. In diesem Schritt erstellen Sie ein neues Element in Ihrer DynamoDB-Tabelle und führen dann Lese-, Aktualisierungs- und Löschvorgänge für dieses Element durch. **So erstellen Sie mit curl ein Element in Ihrer DynamoDB-Tabelle** 1. Öffnen Sie ein Terminal oder eine Eingabeaufforderung auf Ihrem lokalen Computer und führen Sie den folgenden `curl`-Befehl mit der im vorherigen Schritt kopierten Aufruf-URL aus. Dieser Befehl verwendet die folgenden Optionen: + `-H`: Fügt der Anforderung einen benutzerdefinierten Header hinzu. Hier wird der Inhaltstyp als JSON angegeben. + `-d`: Sendet Daten im Anforderungstext. Diese Option verwendet standardmäßig eine HTTP-POST-Methode. ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "create", "payload": {"Item": {"id": "5678EFGH", "number": 15}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"create\", \"payload\": {\"Item\": {\"id\": \"5678EFGH\", \"number\": 15}}}' ``` ------ Wenn der Vorgang erfolgreich war, sollten Sie eine Antwort mit einem HTTP-Statuscode von 200 erhalten. 1. Sie können auch die DynamoDB-Konsole verwenden, um zu überprüfen, ob sich das neue Element in Ihrer Tabelle befindet, indem Sie Folgendes tun: 1. Öffnen Sie die [Seite Tabellen](https://console.aws.amazon.com/dynamodbv2#tables) in der DynamoDB-Konsole und wählen Sie die `lambda-apigateway`-Tabelle aus. 1. Wählen Sie **Explore Table Items** (Tabellenelemente erkudnen) aus. Im Bereich **Items returned** (Zurückgegebene Elemente) sollte ein Element mit der **id** (ID) `5678EFGH` und der **number** (Nummer) `15` angezeigt werden. **So lesen Sie das Element in Ihrer DynamoDB-Tabelle mit curl** + Führen Sie in Ihrem Terminal oder Ihrer Eingabeaufforderung den folgenden `curl`-Befehl aus, um den Wert des soeben erstellten Elements zu lesen. Verwenden Sie Ihre eigene Aufruf-URL. ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "read", "payload": {"Key": {"id": "5678EFGH"}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"read\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}' ``` ------ Je nachdem, ob Sie den Node.js-Funktionscode oder den Python-Funktionscode gewählt haben, sollten Sie eine der folgenden Ausgaben sehen: ------ #### [ Node.js ] ``` {"$metadata":{"httpStatusCode":200,"requestId":"7BP3G5Q0C0O1E50FBQI9NS099JVV4KQNSO5AEMVJF66Q9ASUAAJG", "attempts":1,"totalRetryDelay":0},"Item":{"id":"5678EFGH","number":15}} ``` ------ #### [ Python ] ``` {"Item":{"id":"5678EFGH","number":15},"ResponseMetadata":{"RequestId":"QNDJICE52E86B82VETR6RKBE5BVV4KQNSO5AEMVJF66Q9ASUAAJG", "HTTPStatusCode":200,"HTTPHeaders":{"server":"Server","date":"Wed, 31 Jul 2024 00:37:01 GMT","content-type":"application/x-amz-json-1.0", "content-length":"52","connection":"keep-alive","x-amzn-requestid":"QNDJICE52E86B82VETR6RKBE5BVV4KQNSO5AEMVJF66Q9ASUAAJG","x-amz-crc32":"2589610852"}, "RetryAttempts":0}} ``` ------ **So aktualisieren Sie das Element in Ihrer DynamoDB-Tabelle mit curl** 1. Führen Sie in Ihrem Terminal oder Ihrer Eingabeaufforderung den folgenden `curl`-Befehl aus, um das soeben erstellte Element durch Ändern des `number`-Werts zu aktualisieren. Verwenden Sie Ihre eigene Aufruf-URL. ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "update", "payload": {"Key": {"id": "5678EFGH"}, "UpdateExpression": "SET #num = :new_value", "ExpressionAttributeNames": {"#num": "number"}, "ExpressionAttributeValues": {":new_value": 42}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"update\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}, \"UpdateExpression\": \"SET #num = :new_value\", \"ExpressionAttributeNames\": {\"#num\": \"number\"}, \"ExpressionAttributeValues\": {\":new_value\": 42}}}' ``` ------ 1. Um zu bestätigen, dass der Wert von `number` für das Element aktualisiert wurde, führen Sie einen weiteren Lesebefehl aus: ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "read", "payload": {"Key": {"id": "5678EFGH"}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"read\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}' ``` ------ **So löschen Sie das Element in Ihrer DynamoDB-Tabelle mit curl** 1. Führen Sie in Ihrem Terminal oder Ihrer Eingabeaufforderung den folgenden `curl`-Befehl aus, um das soeben erstellte Element zu löschen. Verwenden Sie Ihre eigene Aufruf-URL. ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "delete", "payload": {"Key": {"id": "5678EFGH"}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"delete\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}' ``` ------ 1. Bestätigen Sie, dass der Löschvorgang erfolgreich war. Stellen Sie im Bereich **Zurückgegebene Elemente** der Seite **Elemente entdecken** der DynamoDB-Konsole sicher, dass das Element mit der **ID** `5678EFGH` nicht mehr in der Tabelle enthalten ist. ## Bereinigen Ihrer Ressourcen (optional) Sie können jetzt die Ressourcen, die Sie für dieses Tutorial erstellt haben, löschen, es sei denn, Sie möchten sie behalten. Durch das Löschen von AWS Ressourcen, die Sie nicht mehr verwenden, vermeiden Sie unnötige Kosten für Ihre AWS-Konto. **So löschen Sie die Lambda-Funktion:** 1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole. 1. Wählen Sie die Funktion aus, die Sie erstellt haben. 1. Wählen Sie **Aktionen**, **Löschen** aus. 1. Geben Sie **confirm** in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus. **So löschen Sie die Ausführungsrolle** 1. Öffnen Sie die Seite [Roles](https://console.aws.amazon.com/iam/home#/roles) in der IAM-Konsole. 1. Wählen Sie die von Ihnen erstellte Ausführungsrolle aus. 1. Wählen Sie **Löschen** aus. 1. Geben Sie den Namen der Rolle in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus. **So löschen Sie die API** 1. Öffnen Sie die [APIs Seite](https://console.aws.amazon.com/apigateway/main/apis) der API Gateway Gateway-Konsole. 1. Wählen Sie die von Ihnen erstellte API aus. 1. Wählen Sie **Aktionen**, **Löschen** aus. 1. Wählen Sie **Löschen** aus. **So löschen Sie die DynamoDB-Tabelle** 1. Öffnen Sie die Seite [Tables (Tabellen)](https://console.aws.amazon.com//dynamodb/home#tables:) in der DynamoDB-Konsole. 1. Wählen Sie die von Ihnen erstellte Tabelle aus. 1. Wählen Sie **Löschen** aus. 1. Geben Sie **delete** in das Textfeld ein. 1. Wählen Sie **Delete Table** (Tabelle löschen). # Behandlung von Lambda-Fehlern mit einer API-Gateway-API API Gateway behandelt alle Aufruf- und Funktionsfehler als interne Fehler. Wenn die Lambda-API die Aufruf-Anforderung ablehnt, gibt API Gateway einen 500-Fehlercode zurück. Wenn die Funktion ausgeführt wird, aber einen Fehler oder eine Antwort im falschen Format zurückgibt, gibt API Gateway den Fehlercode 502 zurück. In beiden Fällen lautet der Text der Antwort von API Gateway „`{"message": "Internal server error"}`“. **Anmerkung** API Gateway wiederholt keine Lambda-Aufrufe. Wenn Lambda einen Fehler zurückgibt, gibt API Gateway eine Fehlerantwort an den Client zurück. Das folgende Beispiel zeigt eine X-Ray-Ablaufverfolgungszuordnung für eine Anforderung, die zu einem Funktionsfehler und einen 502-Fehler von API Gateway führte. Der Client erhält die generische Fehlermeldung. ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/tracemap-apig-502.png) Um die Fehlerantwort anzupassen, müssen Sie Fehler im Code abfangen und eine Antwort im erforderlichen Format formatieren. **Example [index.mjs](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/nodejs-apig/function/index.mjs) – Formatierfehler** ``` var formatError = function(error){ var response = { "statusCode": error.statusCode, "headers": { "Content-Type": "text/plain", "x-amzn-ErrorType": error.code }, "isBase64Encoded": false, "body": error.code + ": " + error.message } return response } ``` API Gateway konvertiert diese Antwort in einen HTTP-Fehler mit einem benutzerdefinierten Statuscode und Text. In der Ablaufverfolgungszuweisung ist der Funktionsknoten grün, da er den Fehler behandelt hat. ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/tracemap-apig-404.png) # Wählen Sie eine Methode, um Ihre Lambda-Funktion über eine HTTP-Anfrage aufzurufen Viele häufige Anwendungsfälle für Lambda beinhalten den Aufruf Ihrer Funktion über eine HTTP-Anfrage. Beispielsweise möchten Sie möglicherweise, dass eine Webanwendung Ihre Funktion über eine Browseranforderung aufruft. Lambda-Funktionen können auch verwendet werden, um vollständige REST zu erstellen APIs, Benutzerinteraktionen von mobilen Apps aus abzuwickeln, Daten von externen Diensten über HTTP-Aufrufe zu verarbeiten oder benutzerdefinierte Webhooks zu erstellen. In den folgenden Abschnitten wird erläutert, welche Möglichkeiten Sie haben, Lambda über HTTP aufzurufen und es werden Informationen bereitgestellt, die Ihnen helfen, die richtige Entscheidung für Ihren speziellen Anwendungsfall zu treffen. ## Welche Optionen stehen Ihnen bei der Auswahl einer HTTP-Aufrufmethode zur Verfügung? Lambda bietet zwei Hauptmethoden zum Aufrufen einer Funktion mithilfe einer HTTP-Anfrage: [Funktion URLs](urls-configuration.md) und [API](services-apigateway.md) Gateway. Die wichtigsten Unterschiede zwischen diesen beiden Optionen sind die folgenden: + Die **Lambda-Funktion URLs** bietet einen einfachen, direkten HTTP-Endpunkt für eine Lambda-Funktion. Sie sind auf Einfachheit und Kosteneffizienz optimiert und bieten den schnellsten Weg, um eine Lambda-Funktion über HTTP bereitzustellen. + **API Gateway** ist ein fortschrittlicherer Dienst zum Erstellen von Funktionen mit vollem Funktionsumfang APIs. API Gateway ist für den Aufbau und die Verwaltung von Produktionen APIs in großem Maßstab optimiert und bietet umfassende Tools für Sicherheit, Überwachung und Verkehrsmanagement. ## Empfehlungen, falls Sie Ihre Anforderungen bereits kennen Wenn Sie sich über Ihre Anforderungen bereits im Klaren sind, finden Sie hier unsere grundlegenden Empfehlungen: Wir empfehlen **[Funktionen URLs](urls-configuration.md)** für einfache Anwendungen oder für die Prototypenentwicklung, bei denen Sie nur grundlegende Authentifizierungsmethoden und request/response deren Handhabung benötigen und bei denen Sie Kosten und Komplexität auf ein Minimum reduzieren möchten. **[API Gateway](services-apigateway.md)** ist eine bessere Wahl für Produktionsanwendungen in großem Maßstab oder für Fälle, in denen Sie erweiterte Funktionen wie [OpenAPI-Description](https://www.openapis.org/), eine Auswahl an Authentifizierungsoptionen, benutzerdefinierte Domainnamen oder umfangreiche request/response Funktionen wie Drosselung, Caching und Transformation benötigen. request/response ## Was ist bei der Auswahl einer Methode zum Aufrufen Ihrer Lambda-Funktion zu beachten? Bei der Auswahl zwischen Funktion URLs und API Gateway müssen Sie die folgenden Faktoren berücksichtigen: + Ihre Authentifizierungsanforderungen, z. B. ob Sie Amazon Cognito für die Benutzerauthentifizierung benötigen OAuth + Ihre Skalierungsanforderungen und die Komplexität der API, die Sie implementieren möchten + Ob Sie erweiterte Funktionen wie die Validierung und Formatierung von Anfragen benötigen request/response + Ihre Überwachungsanforderungen + Was sind Ihre Ziele? Wenn Sie diese Faktoren verstehen, können Sie die Option auswählen, die Ihren Anforderungen an Sicherheit, Komplexität und Kosten am besten gerecht wird. Die folgenden Informationen fassen die wichtigsten Unterschiede zwischen den beiden Optionen zusammen. ### Authentifizierung + **Die Funktion URLs** bietet grundlegende Authentifizierungsoptionen über AWS Identity and Access Management (IAM). Sie können Ihre Endpunkte so konfigurieren, dass sie entweder öffentlich sind (keine Authentifizierung) oder dass sie eine IAM-Authentifizierung erfordern. Mit der IAM-Authentifizierung können Sie AWS Standardanmeldedaten oder IAM-Rollen verwenden, um den Zugriff zu steuern. Dieser Ansatz ist zwar einfach einzurichten, bietet aber im Vergleich zu anderen Authentifizierungsmethoden nur begrenzte Optionen. + **API Gateway** bietet Zugriff auf eine umfassendere Palette von Authentifizierungsoptionen. Neben der IAM-Authentifizierung können Sie [Lambda-Autorisierer](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) (benutzerdefinierte Authentifizierungslogik), [Amazon Cognito Cognito-Benutzerpools](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) und .0-Flows verwenden. OAuth2 Diese Flexibilität ermöglicht es Ihnen, komplexe Authentifizierungsschemata zu implementieren, darunter Authentifizierungsanbieter von Drittanbietern, tokenbasierte Authentifizierung und Multi-Faktor-Authentifizierung. ### Anfrage-/Antwort-Anforderungen + **Die Funktion URLs bietet eine** grundlegende Behandlung von HTTP-Anfragen und -Antworten. Sie unterstützen Standard-HTTP-Methoden und bieten integrierte CORS-Unterstützung (Cross-Origin Resource Sharing). Sie können zwar JSON-Nutzdaten und Abfrageparameter auf natürliche Weise verarbeiten, bieten jedoch keine Funktionen zur Transformation oder Validierung von Anfragen. Die Bearbeitung von Antworten ist ähnlich einfach – der Client erhält die Antwort von Ihrer Lambda-Funktion genau so, wie Lambda sie zurückgibt. + **API Gateway** bietet ausgefeilte Funktionen zur Bearbeitung von Anfragen und Antworten. Sie können Anforderungsvalidatoren definieren, Anfragen und Antworten mithilfe von Zuordnungsvorlagen transformieren, request/response Header einrichten und das Zwischenspeichern von Antworten implementieren. API Gateway unterstützt auch binäre Nutzdaten und benutzerdefinierte Domainnamen und kann Antworten ändern, bevor sie den Client erreichen. Sie können Modelle für die request/response Validierung und Transformation mithilfe des JSON-Schemas einrichten. ### Skalierung + Die **Funktion URLs** skaliert direkt mit den Parallelitätsgrenzen Ihrer Lambda-Funktion und bewältigt Verkehrsspitzen, indem Sie Ihre Funktion bis zum konfigurierten Maximallimit skalieren. Sobald dieses Limit erreicht ist, reagiert Lambda auf weitere Anfragen mit HTTP 429-Antworten. Es gibt keinen integrierten Warteschlangenmechanismus, sodass der Umgang mit der Skalierung vollständig von der Konfiguration Ihrer Lambda-Funktion abhängt. Standardmäßig haben Lambda-Funktionen ein Limit von 1.000 gleichzeitigen Ausführungen pro. AWS-Region + **API Gateway** bietet zusätzlich zur Lambda-eigenen Skalierung zusätzliche Skalierungsfunktionen. Es umfasst integrierte Funktionen zur Warteschleife und Drosselung von Anfragen, sodass Sie Datenverkehrsspitzen besser bewältigen können. API Gateway kann standardmäßig bis zu 10.000 Anfragen pro Sekunde pro Region verarbeiten, mit einer Burst-Kapazität von 5.000 Anfragen pro Sekunde. Es bietet auch Tools zum Drosseln von Anfragen auf verschiedenen Ebenen (API, Phase oder Methode), um Ihr Backend zu schützen. ### Überwachen + **Function URLs** bietet eine grundlegende Überwachung anhand von CloudWatch Amazon-Metriken, einschließlich Anzahl der Anfragen, Latenz und Fehlerraten. Sie erhalten Zugriff auf standardmäßige Lambda-Metriken und -Protokolle, die die Rohanfragen anzeigen, die in Ihre Funktion eingehen. Dies bietet zwar wichtige betriebliche Transparenz, die Metriken konzentrieren sich jedoch hauptsächlich auf die Funktionsausführung. + **API Gateway** bietet umfassende Überwachungsfunktionen, einschließlich detaillierter Metriken, Protokollierungs- und Verfolgungsoptionen. Sie können API-Aufrufe, Latenz, Fehlerraten und hit/miss Cache-Raten über überwachen CloudWatch. API Gateway lässt sich auch AWS X-Ray für verteiltes Tracing integrieren und bietet anpassbare Protokollierungsformate. ### Cost (Kosten) + Die **Funktionen URLs** folgen dem Standard-Lambda-Preismodell — Sie zahlen nur für Funktionsaufrufe und Rechenzeit. Für den URL-Endpunkt selbst fallen keine zusätzlichen Gebühren an. Dies macht es zu einer kostengünstigen Wahl für einfache Anwendungen APIs oder Anwendungen mit geringem Datenverkehr, wenn Sie die zusätzlichen Funktionen von API Gateway nicht benötigen. + **API Gateway** bietet ein [kostenloses Kontingent](https://aws.amazon.com/api-gateway/pricing/#Free_Tier), das eine Million API-Aufrufe für REST APIs und eine Million API-Aufrufe für HTTP umfasst APIs. Danach berechnet API Gateway Gebühren für API-Aufrufe, Datenübertragung und Caching (falls aktiviert). Weitere Informationen zu den Kosten für Ihren eigenen Anwendungsfall finden Sie auf der [Seite mit den Preisen](https://aws.amazon.com/api-gateway/pricing/) für API Gateway. ### Weitere Funktionen + URLsDie **Funktionen** sind auf Einfachheit und direkte Lambda-Integration ausgelegt. Sie unterstützen sowohl HTTP- als auch HTTPS-Endpunkte, bieten integrierte CORS-Unterstützung und bieten Dual-Stack- (IPv4 und) Endpunkte. IPv6 Ihnen fehlen zwar erweiterte Features, sie zeichnen sich jedoch in Szenarien aus, in denen Sie Lambda-Funktionen schnell und unkompliziert über HTTP verfügbar machen müssen. + **API Gateway** umfasst zahlreiche zusätzliche Funktionen wie API-Versionierung, Stagemanagement, API-Schlüssel für Nutzungspläne, API-Dokumentation über Swagger/OpenAPI WebSocket APIs, private Funktionen APIs innerhalb einer VPC und WAF-Integration für zusätzliche Sicherheit. Es unterstützt auch kanarische Implementierungen, Scheinintegrationen zum Testen und die Integration mit anderen Systemen AWS-Services als Lambda. ## Wählen Sie eine Methode, um Ihre Lambda-Funktion aufzurufen Nachdem Sie sich mit den Kriterien für die Auswahl zwischen Lambda-Funktion URLs und API Gateway und den wichtigsten Unterschieden zwischen ihnen vertraut gemacht haben, können Sie die Option auswählen, die Ihren Anforderungen am besten entspricht, und die folgenden Ressourcen verwenden, um Ihnen den Einstieg in die Verwendung zu erleichtern. ------ #### [ Function URLs ] **Nutzen Sie die folgenden Ressourcen, um URLs mit Function zu beginnen** + Folgen Sie dem Tutorial [Erstellen einer Lambda-Funktion mit einer Funktions-URL](urls-webhook-tutorial.md) + Weitere Informationen zur Funktion finden Sie URLs im [Lambda-Funktion erstellen und verwalten URLs](urls-configuration.md) Kapitel dieses Handbuchs + Probieren Sie das in der Konsole enthaltene Tutorial **Erstellen Sie eine einfache Web-App** aus, indem Sie wie folgt vorgehen: 1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole. 1. Öffnen Sie das Hilfe-Panel, indem Sie das Symbol in der oberen rechten Ecke des Bildschirms wählen. ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/console_help_screenshot.png) 1. Wählen Sie **Tutorials** aus. 1. Wählen Sie unter **Einfache Web-App erstellen** die Option **Tutorial starten** aus. ------ #### [ API Gateway ] **Beginnen Sie mit Lambda und API Gateway mit den folgenden Ressourcen** + Folgen Sie dem Tutorial [Verwenden von Lambda mit API Gateway](services-apigateway-tutorial.md), um eine REST-API zu erstellen, die in eine Backend-Lambda-Funktion integriert ist. + In den folgenden Abschnitten des *Amazon API Gateway Developer Guide* erfahren Sie mehr über die verschiedenen Arten von APIs, die von API Gateway angeboten werden: + [API-Gateway-REST APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html) + [API Gateway HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html) + [API Gateway WebSocket APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html) + Probieren Sie eines oder mehrere der Beispiele im Abschnitt [Tutorials und Workshops](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-tutorials.html) im *Amazon API Gateway Developer Guide* aus. ------