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.
# Integrationen für das WebSocket APIs API Gateway
Nach dem Einrichten einer API-Route müssen Sie diese in einen Endpunkt im Backend integrieren. Ein Backend-Endpunkt wird auch als Integrationsendpunkt bezeichnet und kann eine Lambda-Funktion, ein HTTP-Endpunkt oder eine AWS Serviceaktion sein. Die API-Integration beinhaltet eine Integrationsanforderung und eine Integrationsantwort.
In diesem Abschnitt erfahren Sie, wie Sie Integrationsanfragen und Integrationsantworten für Ihre WebSocket API einrichten.
**Topics**
+ [Richten Sie eine WebSocket API-Integrationsanfrage in API Gateway ein](apigateway-websocket-api-integration-requests.md)
+ [Richten Sie eine WebSocket API-Integrationsantwort in API Gateway ein](apigateway-websocket-api-integration-responses.md)
# Richten Sie eine WebSocket API-Integrationsanfrage in API Gateway ein
Das Einrichten einer Integrationsanforderung umfasst die folgenden Schritte:
+ Auswählen eines Routenschlüssels zum Integrieren im Backend.
+ Angabe des aufzurufenden Backend-Endpunkts. WebSocket APIs unterstützt die folgenden Integrationstypen:
+ `AWS_PROXY`
+ `AWS`
+ `HTTP_PROXY`
+ `HTTP`
+ `MOCK`
Weitere Informationen zu Integrationstypen finden Sie [IntegrationType](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-integrations-integrationid.html#apis-apiid-integrations-integrationid-prop-integration-integrationtype)in der API Gateway V2 REST API.
+ Konfigurieren, wie die Routenanforderungsdaten bei Bedarf in Integrationsanforderungsdaten konvertiert werden, durch Angabe einer oder mehrerer Anforderungsvorlagen.
## Richten Sie mit der WebSocket API Gateway-Konsole eine API-Integrationsanfrage ein
**So fügen Sie mithilfe der API-Gateway-Konsole eine Integrationsanfrage zu einer Route in einer WebSocket API hinzu**
1. Melden Sie sich bei der API Gateway-Konsole an, wählen Sie die API und wählen Sie **Routes (Routen)**.
1. Wählen Sie unter **Routes (Routen)** die Route aus.
1. Wählen Sie die Registerkarte **Integration request** (Integrationsanforderung) und dann im Abschnitt **Integration request settings** (Einstellungen für Integrationsanforderungen) die Option **Edit** (Bearbeiten) aus.
1. Wählen Sie für **Integration type** (Integrationstyp) eine der folgenden Optionen:
+ Wählen Sie die **Lambda-Funktion** nur, wenn Ihre API in eine AWS Lambda Funktion integriert wird, die Sie bereits in diesem Konto oder in einem anderen Konto erstellt haben.
**Um eine neue Lambda-Funktion in zu erstellen AWS Lambda, eine Ressourcenberechtigung für die Lambda-Funktion festzulegen oder andere Lambda-Serviceaktionen auszuführen, wählen Sie AWS stattdessen Service.**
+ Wählen Sie **HTTP**, wenn Ihre API in einen vorhandenen HTTP-Endpunkt integriert wird. Weitere Informationen finden Sie unter [HTTP-Integrationen für REST APIs in API Gateway](setup-http-integrations.md).
+ Wählen Sie **Mock**, wenn Sie API-Antworten direkt von API Gateway generieren möchten, ohne dass ein Integrations-Backend erforderlich ist. Weitere Informationen finden Sie unter [Scheinintegrationen für REST APIs in API Gateway](how-to-mock-integration.md).
+ Wählen Sie **AWS Service**, wenn Ihre API in einen Dienst integriert werden soll. AWS
+ Wählen Sie **VPC Link** (VPC-Link), wenn Ihre API einen `VpcLink` als privaten Integrations-Endpunkt verwenden wird. Weitere Informationen finden Sie unter [Richten Sie eine private Integration ein](set-up-private-integration.md).
1. Wenn Sie **Lambda Function** (Lambda-Funktion) wählen, gehen Sie wie folgt vor:
1. Markieren Sie unter **Use Lambda Proxy integration** (Lambda-Proxy-Integration verwenden) das Kontrollkästchen, wenn Sie die [Lambda-Proxy-Integration](set-up-lambda-proxy-integrations.md#api-gateway-create-api-as-simple-proxy) oder die [kontoübergreifende Lambda-Proxy-Integration](apigateway-cross-account-lambda-integrations.md) verwenden möchten.
1. Geben Sie für **Lambda Function** (Lambda-Funktion) die Funktion auf eine der folgenden Arten an:
+ Wenn sich Ihre Lambda-Funktion in demselben Konto befindet, geben Sie den Funktionsnamen ein und wählen Sie dann die Funktion aus der Dropdown-Liste aus.
**Anmerkung**
Der Funktionsname kann optional seinen Alias oder seine Versionsangabe, wie in `HelloWorld`, `HelloWorld:1` oder `HelloWorld:alpha`, enthalten.
+ Wenn sich die Funktion in einem anderen Konto befindet, geben Sie den ARN für die Funktion ein.
1. Wenn Sie den Timeout-Standardwert von 29 Sekunden verwenden möchten, lassen Sie das Kontrollkästchen **Default timeout** (Standardzeitüberschreitung) aktiviert. Wenn Sie einen benutzerdefinierten Zeitüberschreitungswert festlegen möchten, wählen Sie **Default timeout** (Standardzeitüberschreitung) aus und geben Sie einen Zeitüberschreitungswert zwischen `50` und `29000` Millisekunden ein.
1. Befolgen Sie bei Wahl von **HTTP** die Anweisungen in Schritt 4 von [API-Integrationsanfrage über die API Gateway-Konsole einrichten](how-to-method-settings-console.md).
1. Befolgen Sie bei Wahl von **Mock (Pseudo)** die Anweisungen unter dem Schritt **Request Templates (Vorlagen anfordern)**.
1. Befolgen Sie bei Wahl von **AWS -Service** die Anweisungen in Schritt 6 von [API-Integrationsanfrage über die API Gateway-Konsole einrichten](how-to-method-settings-console.md).
1. Wenn Sie **VPC Link** (VPC-Link) ausgewählt haben, gehen Sie wie folgt vor:
1. Markieren Sie für **VPC proxy integration** (Proxy-Integration verwenden) das Kontrollkästchen, wenn Anforderungen über einen Proxy an Ihren `VPCLink`-Endpunkt gesendet werden sollen.
1. Wählen Sie als **HTTP method** die HTTP-Methode aus, die am ehesten der Methode im HTTP-Backend entspricht.
1. Wählen Sie in der Dropdownliste **VPC link** (VPC-Link) einen VPC-Link aus. Sie können `[Use Stage Variables]` auswählen und **\$1\$1stageVariables.vpcLinkId\$1** in das Textfeld unter der Liste eingeben.
Sie können die `vpcLinkId`-Stufenvariable nach der Bereitstellung der API für eine Stufe definieren und ihren Wert auf die ID des `VpcLink` festlegen.
1. Geben Sie als **Endpunkt-URL** die URL des HTTP-Backends ein, das von dieser Integration verwendet werden soll.
1. Wenn Sie die Standardzeitüberschreitung von 29 Sekunden verwenden möchten, lassen Sie das Kontrollkästchen **Default timeout** (Standardzeitüberschreitung) aktiviert. Wenn Sie einen benutzerdefinierten Zeitüberschreitungswert festlegen möchten, wählen Sie **Default timeout** (Standardzeitüberschreitung) aus und geben Sie einen Zeitüberschreitungswert zwischen `50` und `29000` Millisekunden ein.
1. Wählen Sie **Änderungen speichern ** aus.
1. Führen Sie unter **Request Templates** (Vorlagen anfordern) die folgenden Schritte durch:
1. Um einen **Template selection expression** (Vorlagen-Auswahlausdruck) einzugeben, wählen Sie unter **Request templates** (Vorlagen anfordern) die Option **Edit** (Bearbeiten).
1. Geben Sie einen **Template selection expression** (Vorlagen-Auswahlausdruck) ein. Verwenden Sie einen Ausdruck, nach dem API Gateway in der Nachrichtennutzlast sucht. Wenn er gefunden wird, wird er ausgewertet. Das Ergebnis ist ein Vorlagen-Schlüsselwert zur Auswahl der Datenzuweisungsvorlage, die auf die Daten in der Nachrichtennutzlast anzuwenden ist. Die Datenzuweisungsvorlage erstellen Sie im nächsten Schritt. Wählen Sie **Edit** (Bearbeiten) aus, um Ihre Änderungen zu speichern.
1. Wählen Sie **Create template** (Vorlage erstellen), um die Datenzuweisungsvorlage zu erstellen. Geben Sie für **Template key** (Vorlagenschlüssel) einen Vorlagenschlüsselwert zur Auswahl der Datenzuweisungsvorlage ein, die auf die Daten in der Nachrichtennutzlast anzuwenden ist. Definieren Sie anschließend eine Zuweisungsvorlage. Wählen Sie **Create template (Vorlage erstellen)** aus.
Weitere Informationen zu Vorlagen-Auswahlausdrücken finden Sie unter [Vorlagen-Auswahlausdrücke](websocket-api-data-transformations.md#apigateway-websocket-api-template-selection-expressions).
## Richten Sie eine Integrationsanfrage ein, indem Sie AWS CLI
Sie können eine Integrationsanfrage für eine Route in einer WebSocket API einrichten, indem Sie AWS CLI wie im folgenden Beispiel vorgehen, wodurch eine Scheinintegration erstellt wird:
1. Erstellen Sie eine Datei mit dem Namen `integration-params.json` und dem folgenden Inhalt:
```
{"PassthroughBehavior": "WHEN_NO_MATCH", "TimeoutInMillis": 29000, "ConnectionType": "INTERNET", "RequestTemplates": {"application/json": "{\"statusCode\":200}"}, "IntegrationType": "MOCK"}
```
1. Verwenden Sie den folgenden [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html)-Befehl, um die Mock-Integration zu erstellen.
```
aws apigatewayv2 --region us-east-1 create-integration --api-id aabbccddee --cli-input-json file://integration-params.json
```
Die Ausgabe sieht wie folgt aus:
```
{
"PassthroughBehavior": "WHEN_NO_MATCH",
"TimeoutInMillis": 29000,
"ConnectionType": "INTERNET",
"IntegrationResponseSelectionExpression": "${response.statuscode}",
"RequestTemplates": {
"application/json": "{\"statusCode\":200}"
},
"IntegrationId": "0abcdef",
"IntegrationType": "MOCK"
}
```
Alternativ können Sie eine Integrationsanfrage für eine Proxyintegration einrichten, indem Sie den verwenden AWS CLI.
1. Erstellen Sie eine Lambda-Funktion in der Lambda-Konsole und geben Sie ihr eine grundlegende Lambda-Ausführungsrolle.
1. Verwenden Sie den folgenden [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html)–Befehl, um eine Integration zu erstellen.
```
aws apigatewayv2 create-integration --api-id aabbccddee --integration-type AWS_PROXY --integration-method POST --integration-uri arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123412341234:function:simpleproxy-echo-e2e/invocations
```
Die Ausgabe sieht wie folgt aus:
```
{
"PassthroughBehavior": "WHEN_NO_MATCH",
"IntegrationMethod": "POST",
"TimeoutInMillis": 29000,
"ConnectionType": "INTERNET",
"IntegrationUri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123412341234:function:simpleproxy-echo-e2e/invocations",
"IntegrationId": "abcdefg",
"IntegrationType": "AWS_PROXY"
}
```
## Eingabeformat einer Lambda-Funktion für die Proxyintegration für WebSocket APIs
Bei der Lambda-Proxy-Integration ordnet API Gateway die gesamte Client-Anforderung dem `event`-Eingabeparameter der Backend-Lambda-Funktion zu. Im folgenden Beispiel sehen Sie die Struktur des Eingabeereignisses der `$connect`-Route und des Eingabeereignisses der `$disconnect`-Route, die das API Gateway an eine Lambda-Proxy-Integration sendet.
------
#### [ Input from the \$1connect route ]
```
{
headers: {
Host: 'abcd123.execute-api.us-east-1.amazonaws.com',
'Sec-WebSocket-Extensions': 'permessage-deflate; client_max_window_bits',
'Sec-WebSocket-Key': '...',
'Sec-WebSocket-Version': '13',
'X-Amzn-Trace-Id': '...',
'X-Forwarded-For': '192.0.2.1',
'X-Forwarded-Port': '443',
'X-Forwarded-Proto': 'https'
},
multiValueHeaders: {
Host: [ 'abcd123.execute-api.us-east-1.amazonaws.com' ],
'Sec-WebSocket-Extensions': [ 'permessage-deflate; client_max_window_bits' ],
'Sec-WebSocket-Key': [ '...' ],
'Sec-WebSocket-Version': [ '13' ],
'X-Amzn-Trace-Id': [ '...' ],
'X-Forwarded-For': [ '192.0.2.1' ],
'X-Forwarded-Port': [ '443' ],
'X-Forwarded-Proto': [ 'https' ]
},
requestContext: {
routeKey: '$connect',
eventType: 'CONNECT',
extendedRequestId: 'ABCD1234=',
requestTime: '09/Feb/2024:18:11:43 +0000',
messageDirection: 'IN',
stage: 'prod',
connectedAt: 1707502303419,
requestTimeEpoch: 1707502303420,
identity: { sourceIp: '192.0.2.1' },
requestId: 'ABCD1234=',
domainName: 'abcd1234.execute-api.us-east-1.amazonaws.com',
connectionId: 'AAAA1234=',
apiId: 'abcd1234'
},
isBase64Encoded: false
}
```
------
#### [ Input from the \$1disconnect route ]
```
{
headers: {
Host: 'abcd1234.execute-api.us-east-1.amazonaws.com',
'x-api-key': '',
'X-Forwarded-For': '',
'x-restapi': ''
},
multiValueHeaders: {
Host: [ 'abcd1234.execute-api.us-east-1.amazonaws.com' ],
'x-api-key': [ '' ],
'X-Forwarded-For': [ '' ],
'x-restapi': [ '' ]
},
requestContext: {
routeKey: '$disconnect',
disconnectStatusCode: 1005,
eventType: 'DISCONNECT',
extendedRequestId: 'ABCD1234=',
requestTime: '09/Feb/2024:18:23:28 +0000',
messageDirection: 'IN',
disconnectReason: 'Client-side close frame status not set',
stage: 'prod',
connectedAt: 1707503007396,
requestTimeEpoch: 1707503008941,
identity: { sourceIp: '192.0.2.1' },
requestId: 'ABCD1234=',
domainName: 'abcd1234.execute-api.us-east-1.amazonaws.com',
connectionId: 'AAAA1234=',
apiId: 'abcd1234'
},
isBase64Encoded: false
}
```
------
# Richten Sie eine WebSocket API-Integrationsantwort in API Gateway ein
Der folgende Abschnitt bietet einen kurzen Überblick über Integrationsantworten für WebSocket API und wie eine Integrationsantwort für eine WebSocket API eingerichtet wird.
**Topics**
+ [Übersicht über Integrationsantworten](#apigateway-websocket-api-integration-response-overview)
+ [Integrationsantworten für bidirektionale Kommunikation](#apigateway-websocket-api-integration-response-for-two-way-communication)
+ [Integrationsantwort mit der API Gateway-Konsole einrichten](#apigateway-websocket-api-integration-response-using-console)
+ [Richten Sie eine Integrationsantwort mit dem ein AWS CLI](#apigateway-websocket-api-integration-response-using-awscli)
## Übersicht über Integrationsantworten
Die Integrationsantwort von API Gateway ist eine Möglichkeit, die Antwort von einem Backend-Service zu modellieren und zu manipulieren. Es gibt einige Unterschiede bei der Einrichtung einer REST-API und einer WebSocket API-Integrationsantwort, aber konzeptionell ist das Verhalten dasselbe.
WebSocket Routen können für bidirektionale oder unidirektionale Kommunikation konfiguriert werden.
+ Wenn eine Route für bidirektionale Kommunikation konfiguriert ist, können Sie mit einer Integrationsantwort Transformationen für die zurückgegebene Nachrichtennutzlast konfigurieren, ähnlich wie bei Integrationsantworten für REST. APIs
+ Wenn eine Route für unidirektionale Kommunikation konfiguriert ist, wird unabhängig von der Konfiguration der Integrationsantwort nach der Verarbeitung der Nachricht keine Antwort über den WebSocket Kanal zurückgegeben.
API Gateway übergibt die Backend-Antwort nicht über die Routenantwort, es sei denn, Sie richten eine Routenantwort ein. Weitere Informationen zum Einrichten einer Routenreaktion finden Sie unter [Richten Sie Routenantworten für WebSocket APIs in API Gateway ein](apigateway-websocket-api-route-response.md).
## Integrationsantworten für bidirektionale Kommunikation
Integrationen lassen sich in *Proxy*-Integrationen und *Nicht-Proxy*-Integrationen unterteilen.
**Wichtig**
Bei *Proxy-Integrationen* gibt API Gateway automatisch die Backend-Ausgabe als vollständigen Payload an den Aufrufer weiter. Es gibt keine Integrationsantwort.
Bei *Nicht-Proxy-Integrationen* müssen Sie mindestens eine Integrationsantwort einrichten:
+ Im Idealfall sollte eine Ihrer Integrationsantworten als Catch-all-Methode dienen, wenn keine explizite Wahl vorgenommen werden kann. Dieser Standardfall wird durch Festlegen des Integrationsantwort-Schlüssels dargestell `$default`.
+ In allen anderen Fällen fungiert der Integrationsantwort-Schlüssel als regulärer Ausdruck. Er sollte dem Format folge `"/expression/"`.
Bei Nicht-Proxy-HTTP-Integrationen:
+ API Gateway versucht, den HTTP-Statuscode der Backend-Antwort zuzuordnen. Der Integrationsantwort-Schlüssel fungiert in diesem Fall als regulärer Ausdruck. Wenn keine Übereinstimmung gefunden wird, dann wird `$default` als Integrationsantwort gewählt.
+ Der Vorlagen-Auswahlausdruck funktioniert wie oben beschrieben identisch. Zum Beispiel:
+ `/2\d\d/`: Erfolgreiche Antworten empfangen und transformieren
+ `/4\d\d/`: Fehler (ungültige Anforderung) empfangen und transformieren
+ `$default`: Alle unerwarteten Antworten empfangen und transformieren
Weitere Informationen zu Vorlagen-Auswahlausdrücken finden Sie unter [Vorlagen-Auswahlausdrücke](websocket-api-data-transformations.md#apigateway-websocket-api-template-selection-expressions).
## Integrationsantwort mit der API Gateway-Konsole einrichten
So richten Sie mithilfe der API-Gateway-Konsole eine Antwort zur Routenintegration für eine WebSocket API ein:
1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway).
1. Wählen Sie Ihre WebSocket API und wählen Sie Ihre Route.
1. Wählen Sie die Registerkarte **Integration request** (Integrationsanforderung) und dann im Abschnitt **Integration request settings** (Einstellungen für Integrationsanforderungen) die Option **Create integration response** (Integrationsantwort erstellen) aus.
1. Geben Sie für **Antwortschlüssel** einen Wert ein, der nach Auswertung des Ausdrucks der Antwortauswahl im Antwortschlüssel der ausgehenden Nachricht zu finden ist. Sie können beispielsweise **/4\$1d\$1d/** eingeben, um Anforderungsfehler zu empfangen und umzuwandeln, oder Sie können **\$1default** eingeben, um alle Antworten zu empfangen und umzuwandeln, die dem Ausdruck für die Vorlagenauswahl entsprechen.
1. Geben Sie unter **Template selection expression** (Ausdruck für die Vorlagenauswahl) einen Auswahlausdruck ein, um die ausgehende Nachricht auszuwerten.
1. Wählen Sie **Create response** (Antwort erstellen) aus.
1. Sie können auch eine Zuordnungsvorlage definieren, um Transformationen Ihrer Payload für zurückgegebene Nachrichten zu konfigurieren. Wählen Sie **Create template (Vorlage erstellen)** aus.
1. Geben Sie einen Schlüsselnamen ein. Wenn Sie den Standardausdruck für die Vorlagenauswahl auswählen, geben Sie **\$1\$1default** ein.
1. Geben Sie unter **Response template** (Antwortvorlage) Ihre Zuordnungsvorlage in den Code-Editor ein.
1. Wählen Sie **Create template (Vorlage erstellen)** aus.
1. Wählen Sie **Deploy API** (API bereitstellen) aus, um Ihre API bereitzustellen.
Stellen Sie mit dem folgenden [wscat](https://www.npmjs.com/package/wscat)-Befehl eine Verbindung mit Ihrer API her. Mehr über `wscat` erfahren Sie unter [Wird verwendet`wscat`, um eine Verbindung zu einer WebSocket API herzustellen und Nachrichten an diese zu senden](apigateway-how-to-call-websocket-api-wscat.md).
```
wscat -c wss://api-id.execute-api.us-east-2.amazonaws.com/test
```
Wenn Sie Ihre Route aufrufen, sollte die Payload der zurückgegebenen Nachricht zurückgegeben werden.
## Richten Sie eine Integrationsantwort mit dem ein AWS CLI
Der folgende [create-integration-response](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration-response.html)Befehl erstellt eine `$default` Integrationsantwort:
```
aws apigatewayv2 create-integration-response \
--api-id vaz7da96z6 \
--integration-id a1b2c3 \
--integration-response-key '$default'
```