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);
};
```