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.
# Entwickeln Sie HTTP APIs in API Gateway
Dieser Abschnitt enthält Einzelheiten zu den API Gateway Gateway-Funktionen, die Sie bei der Entwicklung Ihres API Gateway benötigen APIs.
Während Sie Ihre API Gateway-API entwickeln, entscheiden Sie sich für eine Reihe von Merkmalen Ihrer API. Diese Eigenschaften hängen davon ab, wofür Ihre API verwendet werden soll. So könnte es beispielsweise sein, dass Sie es nur bestimmten Clients gestatten möchten, die API aufzurufen. Vielleicht soll die API aber auch für alle verfügbar sein. Vielleicht benötigen Sie einen API-Aufruf, um eine Lambda-Funktion auszuführen, eine Datenbankabfrage durchzuführen oder eine Anwendung aufzurufen.
**Topics**
+ [Erstellen einer HTTP-API](#http-api-examples)
+ [Routen für HTTP APIs in API Gateway erstellen](http-api-develop-routes.md)
+ [IP-Adresstypen für HTTP-APIs in API Gateway](http-api-ip-address-type.md)
+ [Steuern und verwalten Sie den Zugriff auf HTTP APIs in API Gateway](http-api-access-control.md)
+ [Erstellen von Integrationen für HTTP-APIs in API Gateway](http-api-develop-integrations.md)
+ [CORS für HTTP APIs im API Gateway konfigurieren](http-api-cors.md)
+ [API-Anforderungen und -Antworten für HTTP-APIs in API Gateway transformieren](http-api-parameter-mapping.md)
+ [Verwenden Sie OpenAPI-Definitionen für HTTP APIs in API Gateway](http-api-open-api.md)
## Erstellen einer HTTP-API
Um eine funktionale API erstellen zu können, benötigen Sie mindestens eine Route, eine Integration, eine Phase und eine Bereitstellung.
Die folgenden Beispiele zeigen, wie Sie eine API mit einer AWS Lambda oder HTTP-Integration, einer Route und einer Standardstufe erstellen, die so konfiguriert ist, dass Änderungen automatisch bereitgestellt werden.
In diesem Leitfaden wird davon ausgegangen, dass Sie bereits mit API Gateway und Lambda vertraut sind. Einen ausführlicheren Leitfaden finden Sie unter [Erste Schritte mit API-Gateway](getting-started.md).
**Topics**
+ [Erstellen Sie eine HTTP-API mithilfe der AWS-Managementkonsole](#apigateway-http-api-create.console)
+ [Erstellen Sie eine HTTP-API mithilfe der AWS CLI](#http-api-examples.cli.quick-create)
### Erstellen Sie eine HTTP-API mithilfe der AWS-Managementkonsole
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 unter **HTTP-API** die Option **Entwickeln** aus.
1. Wählen Sie **Add integration (Integration hinzufügen)** und wählen Sie dann eine AWS Lambda -Funktion oder geben Sie einen HTTP-Endpunkt ein.
1. Geben Sie im Feld **Name** einen Namen für Ihre API ein.
1. Wählen Sie **Review and create**.
1. Wählen Sie **Create** aus.
Jetzt kann Ihre API aufgerufen werden. Sie können Ihre API testen, indem Sie die Aufruf-URL in einem Browser eingeben oder cURL verwenden.
```
curl https://api-id.execute-api.us-east-2.amazonaws.com
```
### Erstellen Sie eine HTTP-API mithilfe der AWS CLI
Sie können Quick Create verwenden, um eine API mit einer Lambda- oder HTTP-Integration, eine Catch-All-Standardroute und eine Standardphase zu erstellen, die für die automatische Bereitstellung von Änderungen konfiguriert ist. Der folgende [create-api](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-api.html)-Befehl verwendet Quick Create, um eine API zu erstellen, die in eine Lambda-Funktion im Backend integriert werden kann.
**Anmerkung**
Um eine Lambda-Integration aufzurufen, muss API Gateway über die erforderlichen Berechtigungen verfügen. Sie können eine ressourcenbasierte Richtlinie oder eine IAM-Rolle verwenden, um API-Gateway Berechtigungen zum Aufrufen einer Lambda-Funktion zu erteilen. Weitere Informationen finden Sie unter [AWS Lambda Berechtigungen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-permissions.html) im * AWS Lambda Entwicklerhandbuch*.
**Example**
```
aws apigatewayv2 create-api --name my-api --protocol-type HTTP --target arn:aws:lambda:us-east-2:123456789012:function:function-name
```
Jetzt kann Ihre API aufgerufen werden. Sie können Ihre API testen, indem Sie die Aufruf-URL in einem Browser eingeben oder cURL verwenden.
```
curl https://api-id.execute-api.us-east-2.amazonaws.com
```
# Routen für HTTP APIs in API Gateway erstellen
Routen leiten eingehende API-Anfragen an Backend-Ressourcen. Routen bestehen aus zwei Teilen: einer HTTP-Methode und einem Ressourcenpfad, zum Beispie, `GET /pets`. Sie können spezifische HTTP-Methoden für Ihre Route definieren. Sie können auch die Methode `ANY` verwenden, um alle Methoden abzugleichen, die Sie nicht für eine Ressource definiert haben. Sie können eine `$default`-Route erstellen, die als Catch-All für Anfragen fungiert, die nicht mit anderen Routen übereinstimmen.
**Anmerkung**
API Gateway dekodiert URL-kodierte Anforderungsparameter vor deren Übergabe an Ihre Backend-Integration.
## Arbeiten mit Pfadvariablen
Sie können Pfadvariablen in HTTP-API-Routen verwenden.
Beispielsweise fängt die Route `GET /pets/{petID}` eine `GET`-Anforderung ab, die ein Client an `https://api-id.execute-api.us-east-2.amazonaws.com/pets/6` sendet.
Eine *gierige Pfadvariable* fängt alle untergeordneten Ressourcen einer Route ab. Um eine gierige Pfadvariable zu erstellen, fügen Sie `+` dem Variablennamen hinzu, z. B. `{proxy+}`. Die gierige Pfadvariable muss am Ende des Ressourcenpfads stehen.
## Arbeiten mit Abfragezeichenfolgenparametern
API Gateway sendet standardmäßig Abfragezeichenfolgenparameter an Ihre Backend-Integration, sofern sie in einer Anforderung an eine HTTP-API enthalten sind.
Wenn beispielsweise ein Client eine Anforderung an `https://api-id.execute-api.us-east-2.amazonaws.com/pets?id=4&type=dog` sendet, werden die Abfragezeichenfolgenparameter `?id=4&type=dog` an Ihre Integration gesendet.
## Arbeiten mit der `$default`-Route
Die `$default`-Route fängt Anforderungen ab, die nicht explizit mit anderen Routen in Ihrer API übereinstimmen.
Wenn die `$default`-Route eine Anforderung empfängt, sendet API Gateway den vollständigen Anforderungspfad an die Integration. Beispielsweise können Sie eine API nur mit einer `$default`-Route erstellen und sie in der Methode `ANY` mit dem HTTP-Endpunkt `https://petstore-demo-endpoint.execute-api.com` integrieren. Wenn Sie eine Anforderung an `https://api-id.execute-api.us-east-2.amazonaws.com/store/checkout` senden, sendet API Gateway eine Anforderung an `https://petstore-demo-endpoint.execute-api.com/store/checkout`.
Weitere Informationen zu HTTP-Integrationen finden Sie unter [Erstellen Sie HTTP-Proxyintegrationen für HTTP APIs](http-api-develop-integrations-http.md).
## Weiterleiten von API-Anforderungen
Wenn ein Client eine API-Anforderung sendet, bestimmt API Gateway zuerst, an welche [Stufe](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-stages.html) die Anforderung weitergeleitet werden soll. Wenn die Anforderung explizit mit einer Stufe übereinstimmt, sendet API Gateway die Anforderung an diese Stufe. Wenn keine Stufe vollständig mit der Anforderung übereinstimmt, sendet API Gateway die Anforderung an die `$default`-Stufe. Wenn es keine `$default` Phase gibt, kehrt die API zurück `{"message":"Not Found"}` und generiert keine CloudWatch Protokolle.
Nachdem Sie eine Stufe ausgewählt haben, wählt API Gateway eine Route aus. API Gateway wählt die Route mit der spezifischsten Übereinstimmung aus, wobei die folgenden Prioritäten verwendet werden:
1. Vollständige Übereinstimmung für eine Route und Methode.
1. Übereinstimmung für eine Route und eine Methode mit einer gierigen Pfadvariable (`{proxy+}`).
1. Die `$default`-Route.
Wenn keine Routen mit einer Anforderung übereinstimmen, gibt API Gateway `{"message":"Not Found"}` an den Client zurück.
Betrachten Sie beispielsweise eine API mit einer `$default`-Stufe und den folgenden Beispielrouten:
1. `GET /pets/dog/1`
1. `GET /pets/dog/{id}`
1. `GET /pets/{proxy+}`
1. `ANY /{proxy+}`
1. `$default`
In der folgenden Tabelle wird zusammengefasst, wie API Gateway Anforderungen an die Beispielrouten weiterleitet.
| Anfrage | Ausgewählte Route | Erklärung |
| --- | --- | --- |
| `GET https://api-id.execute-api.region.amazonaws.com/pets/dog/1` | `GET /pets/dog/1` | Die Anforderung entspricht vollständig dieser statischen Route. |
| `GET https://api-id.execute-api.region.amazonaws.com/pets/dog/2` | `GET /pets/dog/{id}` | Die Anforderung stimmt vollständig mit dieser Route überein. |
| `GET https://api-id.execute-api.region.amazonaws.com/pets/cat/1` | `GET /pets/{proxy+}` | Die Anforderung stimmt nicht vollständig mit einer Route überein. Die Route mit einer `GET`-Methode und einer gierigen Pfadvariablen fängt diese Anforderung ab. |
| `POST https://api-id.execute-api.region.amazonaws.com/test/5` | `ANY /{proxy+}` | Die Methode `ANY` entspricht allen Methoden, die Sie nicht für eine Route definiert haben. Routen mit gierigen Pfadvariablen haben eine höhere Priorität als die `$default`-Route. |
# IP-Adresstypen für HTTP-APIs in API Gateway
Beim Erstellen einer API geben Sie den Typ der IP-Adressen an, die Ihre API aufrufen dürfen. Sie können IPv4 auswählen, um IPv4-Adressen für den Aufruf Ihrer API zuzulassen, oder Sie können Dualstack auswählen, um sowohl IPv4- als auch IPv6-Adressen zuzulassen. Es kann sinnvoll sein, den IP-Adresstyp auf Dualstack zu setzen, um Engpässe im IP-Adressraum zu vermeiden oder Ihre Sicherheitslage zu verbessern. Weitere Informationen zu den Vorteilen eines Dualstack-IP-Adresstyps finden Sie unter [IPv6 in AWS](https://docs.aws.amazon.com/whitepapers/latest/ipv6-on-aws/internet-protocol-version-6.html).
## Überlegungen zu IP-Adresstypen
Die folgenden Überlegungen können Ihre Verwendung von IP-Adresstypen beeinflussen:
+ Der Standard-IP-Adresstyp für HTTP-APIs ist IPv4.
+ Wenn Sie den IP-Adresstyp einer bestehende API von IPv4 in Dualstack ändern, stellen Sie sicher, dass alle Richtlinien, die den Zugriff auf Ihre APIs steuern, aktualisiert wurden, um IPv6-Aufrufe zu berücksichtigen. Wenn Sie den IP-Adresstyp ändern, wird die Änderung sofort wirksam.
+ Ihre API kann einem benutzerdefinierten Domainnamen mit einem anderen IP-Adresstyp als Ihre API zugewiesen werden. Wenn Sie Ihren Standard-API-Endpunkt deaktivieren, kann dies die Art und Weise beeinflussen, wie Aufrufer Ihre API aufrufen können.
## Ändern des IP-Adresstyps einer HTTP-API
Sie können den IP-Adresstyp ändern, indem Sie die API-Konfiguration aktualisieren. Dies ist über die AWS-Managementkonsole, die AWS CLI, CloudFormation oder ein AWS SDK möglich. Wenn Sie den IP-Adresstyp der API ändern, müssen Sie Ihre API nicht erneut bereitstellen, damit die Änderungen wirksam werden.
------
#### [ AWS-Managementkonsole ]
**So ändern Sie den IP-Adresstyp einer HTTP-API**
1. Melden Sie sich bei der API-Gateway-Konsole unter [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway) an.
1. Wählen Sie eine HTTP-API.
1. Wählen Sie unter **API-Einstellungen** die Option **Bearbeiten** aus.
1. Wählen Sie unter „IP-Adresstyp“ entweder **IPv4** oder **Dualstack** aus.
1. Wählen Sie **Speichern** aus.
Die Änderung der API-Konfiguration wird sofort wirksam.
------
#### [ AWS CLI ]
Der folgende [update-api](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/update-api.html)-Befehl aktualisiert eine API, sodass sie den IP-Adresstyp Dualstack verwendet:
```
aws apigatewayv2 update-api \
--api-id abcd1234 \
--ip-address-type dualstack
```
Die Ausgabe sieht wie folgt aus:
```
{
"ApiEndpoint": "https://abcd1234.execute-api.us-east-1.amazonaws.com",
"ApiId": "abcd1234",
"ApiKeySelectionExpression": "$request.header.x-api-key",
"CreatedDate": "2025-02-04T22:20:20+00:00",
"DisableExecuteApiEndpoint": false,
"Name": "My-HTTP-API",
"ProtocolType": "HTTP",
"RouteSelectionExpression": "$request.method $request.path",
"Tags": {},
"NotificationUris": [],
"IpAddressType": "dualstack"
}
```
------
# Steuern und verwalten Sie den Zugriff auf HTTP APIs in API Gateway
API Gateway unterstützt mehrere Mechanismen zur Steuerung und Verwaltung des Zugriffs auf Ihre HTTP-API:
+ **Lambda-Autorisierer** verwenden Lambda-Funktionen, um den Zugriff auf zu kontrollieren. APIs Weitere Informationen finden Sie unter [Steuern Sie den Zugriff auf HTTP APIs mit AWS Lambda Autorisierern](http-api-lambda-authorizer.md).
+ **JWT-Autorisierer** verwenden JSON-Webtoken, um den Zugriff auf zu kontrollieren. APIs Weitere Informationen finden Sie unter [Steuern Sie den Zugriff auf HTTP APIs mit JWT-Autorisierern in API Gateway](http-api-jwt-authorizer.md).
+ ** AWS Standard-IAM-Rollen und -Richtlinien bieten flexible und robuste Zugriffskontrollen**. Mithilfe von IAM-Rollen und -Richtlinien können Sie steuern, wer Ihre APIs Rollen erstellen und verwalten darf und wer sie aufrufen kann. Weitere Informationen finden Sie unter [Steuern Sie den Zugriff auf HTTP APIs mit der IAM-Autorisierung in API Gateway](http-api-access-control-iam.md).
Um Ihre Sicherheitslage zu verbessern, empfehlen wir, für alle Routen Ihrer HTTP-API einen Genehmiger zu konfigurieren. Dies kann erforderlich sein, um verschiedene Compliance-Rahmenwerke einzuhalten. Weitere Informationen finden Sie unter [Amazon-API-Gateway-Steuerelemente](https://docs.aws.amazon.com/securityhub/latest/userguide/apigateway-controls.html) im *Benutzerhandbuch für AWS Security Hub *.
# Steuern Sie den Zugriff auf HTTP APIs mit AWS Lambda Autorisierern
Sie verwenden einen Lambda-Genehmiger, um den Zugriff auf Ihre HTTP-API mit einer Lambda-Funktion zu steuern. Wenn dann ein Client Ihre API aufruft, ruft API Gateway Ihre Lambda-Funktion auf. API Gateway verwendet die Antwort Ihrer Lambda-Funktion, um festzustellen, ob der Client auf Ihre API zugreifen kann.
## Nutzlastformatversion
Die Nutzlastformatversion des Genehmigers gibt das Format der Daten an, die API Gateway an einen Lambda-Genehmiger sendet, und wie API Gateway die Antwort von Lambda interpretiert. Wenn Sie keine Version im Payload-Format angeben, wird standardmäßig die neueste Version AWS-Managementkonsole verwendet. Wenn Sie einen Lambda-Autorisierer mithilfe des AWS CLI, CloudFormation, oder eines SDK erstellen, müssen Sie einen angeben. `authorizerPayloadFormatVersion` Die unterstützten Werte sind `1.0` und `2.0`.
Wenn Sie Kompatibilität mit REST benötigen APIs, verwenden Sie Version. `1.0`
Die folgenden Beispiele zeigen die Struktur jeder Nutzlastformatversion.
------
#### [ 2.0 ]
```
{
"version": "2.0",
"type": "REQUEST",
"routeArn": "arn:aws:execute-api:us-east-1:123456789012:abcdef123/test/GET/request",
"identitySource": ["user1", "123"],
"routeKey": "$default",
"rawPath": "/my/path",
"rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value",
"cookies": ["cookie1", "cookie2"],
"headers": {
"header1": "value1",
"header2": "value2"
},
"queryStringParameters": {
"parameter1": "value1,value2",
"parameter2": "value"
},
"requestContext": {
"accountId": "123456789012",
"apiId": "api-id",
"authentication": {
"clientCert": {
"clientCertPem": "CERT_CONTENT",
"subjectDN": "www.example.com",
"issuerDN": "Example issuer",
"serialNumber": "1",
"validity": {
"notBefore": "May 28 12:30:02 2019 GMT",
"notAfter": "Aug 5 09:36:04 2021 GMT"
}
}
},
"domainName": "id.execute-api.us-east-1.amazonaws.com",
"domainPrefix": "id",
"http": {
"method": "POST",
"path": "/my/path",
"protocol": "HTTP/1.1",
"sourceIp": "IP",
"userAgent": "agent"
},
"requestId": "id",
"routeKey": "$default",
"stage": "$default",
"time": "12/Mar/2020:19:03:58 +0000",
"timeEpoch": 1583348638390
},
"pathParameters": { "parameter1": "value1" },
"stageVariables": { "stageVariable1": "value1", "stageVariable2": "value2" }
}
```
------
#### [ 1.0 ]
```
{
"version": "1.0",
"type": "REQUEST",
"methodArn": "arn:aws:execute-api:us-east-1:123456789012:abcdef123/test/GET/request",
"identitySource": "user1,123",
"authorizationToken": "user1,123",
"resource": "/request",
"path": "/request",
"httpMethod": "GET",
"headers": {
"X-AMZ-Date": "20170718T062915Z",
"Accept": "*/*",
"HeaderAuth1": "headerValue1",
"CloudFront-Viewer-Country": "US",
"CloudFront-Forwarded-Proto": "https",
"CloudFront-Is-Tablet-Viewer": "false",
"CloudFront-Is-Mobile-Viewer": "false",
"User-Agent": "..."
},
"queryStringParameters": {
"QueryString1": "queryValue1"
},
"pathParameters": {},
"stageVariables": {
"StageVar1": "stageValue1"
},
"requestContext": {
"path": "/request",
"accountId": "123456789012",
"resourceId": "05c7jb",
"stage": "test",
"requestId": "...",
"identity": {
"apiKey": "...",
"sourceIp": "...",
"clientCert": {
"clientCertPem": "CERT_CONTENT",
"subjectDN": "www.example.com",
"issuerDN": "Example issuer",
"serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1",
"validity": {
"notBefore": "May 28 12:30:02 2019 GMT",
"notAfter": "Aug 5 09:36:04 2021 GMT"
}
}
},
"resourcePath": "/request",
"httpMethod": "GET",
"apiId": "abcdef123"
}
}
```
------
## Antwortformat des Lambda-Genehmigers
Die Nutzlastformatversion bestimmt auch die Struktur der Antwort, die von Ihrer Lambda-Funktion zurückgeben werden muss.
### Lambda-Funktionsantwort für Format 1.0
Wenn Sie Formatversion `1.0` auswählen, müssen Lambda-Genehmiger eine IAM-Richtlinie zurückgeben, die den Zugriff auf Ihre API-Route zulässt oder verweigert. Sie können die IAM-Standardrichtliniensyntax in der Richtlinie verwenden. Beispiele für IAM-Richtlinien finden Sie unter [Kontrollieren des Zugriffs für den API-Aufruf](api-gateway-control-access-using-iam-policies-to-invoke-api.md). Mit können Sie Kontexteigenschaften an Lambda-Integrationen oder -Zugriffsprotokolle übergebe `$context.authorizer.property`. Das `context`-Objekt ist optional und `claims` ist ein reservierter Platzhalter, der nicht als Kontextobjekt verwendet werden kann. Weitere Informationen hierzu finden Sie unter [HTTP-API-Zugriffsprotokolle anpassen](http-api-logging-variables.md).
**Example**
****
```
{
"principalId": "abcdef",
"policyDocument": {
"Version":"2012-10-17",
"Statement": [
{
"Action": "execute-api:Invoke",
"Effect": "Allow|Deny",
"Resource": "arn:aws:execute-api:{regionId}:{accountId}:{apiId}/{stage}/{httpVerb}/[{resource}/[{child-resources}]]"
}
]
},
"context": {
"exampleKey": "exampleValue"
}
}
```
### Lambda-Funktionsantwort für Format 2.0
Wenn Sie Formatversion `2.0` auswählen, können Sie einen booleschen Wert oder eine IAM-Richtlinie zurückgeben, die die IAM-Standardrichtliniensyntax Ihrer Lambda-Funktion verwendet. Um einen booleschen Wert zurückzugeben, aktivieren Sie einfache Antworten für den Genehmiger. Die folgenden Beispiele veranschaulichen das Format, das Sie für die Rückgabe Ihrer Lambda-Funktion codieren müssen. Das Objekt `context` ist optional. Mit können Sie Kontexteigenschaften an Lambda-Integrationen oder -Zugriffsprotokolle übergebe `$context.authorizer.property`. Weitere Informationen hierzu finden Sie unter [HTTP-API-Zugriffsprotokolle anpassen](http-api-logging-variables.md).
------
#### [ Simple response ]
```
{
"isAuthorized": true/false,
"context": {
"exampleKey": "exampleValue"
}
}
```
------
#### [ IAM policy ]
****
```
{
"principalId": "abcdef",
"policyDocument": {
"Version":"2012-10-17",
"Statement": [
{
"Action": "execute-api:Invoke",
"Effect": "Allow|Deny",
"Resource": "arn:aws:execute-api:{regionId}:{accountId}:{apiId}/{stage}/{httpVerb}/[{resource}/[{child-resources}]]"
}
]
},
"context": {
"exampleKey": "exampleValue"
}
}
```
------
## Beispiel für Lambda-Genehmiger-Funktionen
Die Lambda-Funktionen des folgenden Node.js-Beispiels veranschaulichen die erforderlichen Antwortformate, die Sie von Ihrer Lambda-Funktion für Formatversion `2.0` der Nutzlast zurückgeben müssen.
------
#### [ Simple response - Node.js ]
```
export const handler = async(event) => {
let response = {
"isAuthorized": false,
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": true,
"arrayKey": ["value1", "value2"],
"mapKey": {"value1": "value2"}
}
};
if (event.headers.authorization === "secretToken") {
console.log("allowed");
response = {
"isAuthorized": true,
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": true,
"arrayKey": ["value1", "value2"],
"mapKey": {"value1": "value2"}
}
};
}
return response;
};
```
------
#### [ Simple response - Python ]
```
import json
def lambda_handler(event, context):
response = {
"isAuthorized": False,
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": True,
"arrayKey": ["value1", "value2"],
"mapKey": {"value1": "value2"}
}
}
try:
if (event["headers"]["authorization"] == "secretToken"):
response = {
"isAuthorized": True,
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": True,
"arrayKey": ["value1", "value2"],
"mapKey": {"value1": "value2"}
}
}
print('allowed')
return response
else:
print('denied')
return response
except BaseException:
print('denied')
return response
```
------
#### [ IAM policy - Node.js ]
```
export const handler = async(event) => {
if (event.headers.authorization == "secretToken") {
console.log("allowed");
return {
"principalId": "abcdef", // The principal user identification associated with the token sent by the client.
"policyDocument": {
"Version": "2012-10-17",
"Statement": [{
"Action": "execute-api:Invoke",
"Effect": "Allow",
"Resource": event.routeArn
}]
},
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": true,
"arrayKey": ["value1", "value2"],
"mapKey": { "value1": "value2" }
}
};
}
else {
console.log("denied");
return {
"principalId": "abcdef", // The principal user identification associated with the token sent by the client.
"policyDocument": {
"Version": "2012-10-17",
"Statement": [{
"Action": "execute-api:Invoke",
"Effect": "Deny",
"Resource": event.routeArn
}]
},
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": true,
"arrayKey": ["value1", "value2"],
"mapKey": { "value1": "value2" }
}
};
}
};
```
------
#### [ IAM policy - Python ]
```
import json
def lambda_handler(event, context):
response = {
# The principal user identification associated with the token sent by
# the client.
"principalId": "abcdef",
"policyDocument": {
"Version": "2012-10-17",
"Statement": [{
"Action": "execute-api:Invoke",
"Effect": "Deny",
"Resource": event["routeArn"]
}]
},
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": True,
"arrayKey": ["value1", "value2"],
"mapKey": {"value1": "value2"}
}
}
try:
if (event["headers"]["authorization"] == "secretToken"):
response = {
# The principal user identification associated with the token
# sent by the client.
"principalId": "abcdef",
"policyDocument": {
"Version": "2012-10-17",
"Statement": [{
"Action": "execute-api:Invoke",
"Effect": "Allow",
"Resource": event["routeArn"]
}]
},
"context": {
"stringKey": "value",
"numberKey": 1,
"booleanKey": True,
"arrayKey": ["value1", "value2"],
"mapKey": {"value1": "value2"}
}
}
print('allowed')
return response
else:
print('denied')
return response
except BaseException:
print('denied')
return response
```
------
## Identitätsquellen
Sie können optional Identitätsquellen für einen Lambda-Genehmiger angeben. Identitätsquellen geben den Speicherort der Daten an, die für die Autorisierung einer Anforderung erforderlich sind. Beispielsweise können Sie Header- oder Abfragezeichenfolgenwerte als Identitätsquellen angeben. Wenn Sie Identitätsquellen angeben, müssen Clients diese in die Anforderung aufnehmen. Wenn die Anforderung des Clients die Identitätsquellen nicht enthält, ruft API Gateway Ihren Lambda-Genehmiger nicht auf, und der Client erhält einen `401`-Fehler.
In der folgenden Tabelle werden die unterstützten Identitätsquellen für einen Lambda-Genehmiger beschrieben.
| **Typ** | **Beispiel** | **Hinweise** |
| --- | --- | --- |
| Header-Wert | \$1request.header. name | Bei Header-Namen wird nicht zwischen Groß- und Kleinschreibung unterschieden. |
| Abfragezeichenfolgenwert | \$1request.querystring. name | Abfragezeichenfolgennamen unterscheiden zwischen Groß- und Kleinschreibung. |
| Kontextvariable | \$1kontext. variableName | Der Wert einer unterstützten [Kontextvariablen](http-api-logging-variables.md). |
| Stufenvariable | \$1stageVariablen. variableName | Der Wert einer [Stufenvariablen](http-api-stages.stage-variables.md). |
Sie können auch direkt ` {"errorMessage" : "Unauthorized"}` aus Ihrer Lambda-Funktion zurückgeben, um einen `401`-Fehler an die Clients zurückzugeben. Wenn Sie einen `401`-Fehler direkt aus Ihrer Lambda-Funktion an die Clients zurückgeben, geben Sie beim Erstellen Ihres Lambda-Genehmigers keine Identitätsquellen an.
## Zwischenspeichern der Antworten des Genehmigers
Sie können das Caching für einen Lambda-Autorisierer aktivieren, indem Sie einen angeben. [authorizerResultTtlInSeconds](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers.html#apis-apiid-authorizers-prop-createauthorizerinput-authorizerresultttlinseconds) Wenn für einen Genehmiger Zwischenspeicherung aktiviert ist, verwendet API Gateway die Identitätsquellen des Genehmigers als Cache-Schlüssel. Wenn ein Client dieselben Parameter in Identitätsquellen innerhalb der konfigurierten TTL angibt, verwendet API Gateway das zwischengespeicherte Genehmiger-Ergebnis, anstatt Ihre Lambda-Funktion aufzurufen.
Um das Caching zu aktivieren, muss der Genehmiger über mindestens eine Identitätsquelle verfügen.
Wenn Sie einfache Antworten für einen Genehmiger aktivieren, erlaubt oder verweigert die Antwort des Genehmigers alle API-Anforderungen, die mit den zwischengespeicherten Identitätsquellwerten übereinstimmen, vollständig. Um detailliertere Berechtigungen zu erhalten, deaktivieren Sie einfache Antworten und geben Sie eine IAM-Richtlinie zurück. Je nach Genehmiger muss Ihre IAM-Richtlinie möglicherweise den Zugriff auf mehrere Ressourcen steuern.
Standardmäßig verwendet API Gateway die zwischengespeicherte Genehmiger-Antwort für alle Routen einer API, die den Genehmiger verwenden. Um Antworten pro Route zwischenzuspeichern, fügen Sie den Identitätsquellen Ihres Genehmigers `$context.routeKey` hinzu.
## Erstellen eines Lambda-Genehmigers
Wenn Sie einen Lambda-Genehmiger erstellen, geben Sie die Lambda-Funktion an, die API Gateway verwenden soll. Sie müssen API Gateway die Berechtigung zum Aufrufen der Lambda-Funktion erteilen, indem Sie entweder die Ressourcenrichtlinie der Funktion oder eine IAM-Rolle verwenden. Der [create-authorizer](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-authorizer.html)-Befehl erstellt einen Lambda-Genehmiger:
```
aws apigatewayv2 create-authorizer \
--api-id abcdef123 \
--authorizer-type REQUEST \
--identity-source '$request.header.Authorization' \
--name lambda-authorizer \
--authorizer-uri 'arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:my-function/invocations' \
--authorizer-payload-format-version '2.0' \
--enable-simple-responses
```
Der folgende [add-permission](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html)-Befehl aktualisiert die Ressourcenrichtlinie der Lambda-Funktion, um API Gateway die Berechtigung zum Aufrufen der Funktion zu erteilen. Wenn API Gateway nicht zum Aufrufen Ihrer Funktion berechtigt ist, erhalten Clients einen `500 Internal Server Error`.
```
aws lambda add-permission \
--function-name my-authorizer-function \
--statement-id apigateway-invoke-permissions-abc123 \
--action lambda:InvokeFunction \
--principal apigateway.amazonaws.com \
--source-arn "arn:aws:execute-api:us-west-2:123456789012:api-id/authorizers/authorizer-id"
```
Nachdem Sie einen Genehmiger erstellt und API Gateway die Berechtigung zum Aufrufen erteilt haben, aktualisieren Sie Ihre Route, um den Genehmiger zu verwenden. Der folgende [update-route](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/update-route.html)-Befehl fügt der Route den Lambda-Genehmiger hinzu. Wenn Ihr Lambda-Genehmiger eine Richtlinienspeicherung verwendet, stellen Sie sicher, dass Sie die Richtlinie aktualisieren, um den Zugriff für die zusätzliche Route zu steuern.
```
aws apigatewayv2 update-route \
--api-id abcdef123 \
--route-id abc123 \
--authorization-type CUSTOM \
--authorizer-id def123
```
## Fehlerbehebung für Lambda-Genehmiger
Wenn API Gateway Ihren Lambda-Genehmiger nicht aufrufen kann oder Ihr Lambda-Genehmiger eine Antwort in einem ungültigen Format zurückgibt, erhalten Clients einen `500 Internal Server Error`.
Um Fehler zu beheben, [aktivieren Sie die Zugriffsprotokollierung](http-api-logging.md) für Ihre API-Stufe. Fügen Sie die `$context.authorizer.error`-Protokollierungsvariable in Ihr Protokollformat ein.
Wenn die Protokolle darauf hinweisen, dass API Gateway keine Berechtigung zum Aufrufen Ihrer Funktion besitzt, aktualisieren Sie die Ressourcenrichtlinie Ihrer Funktion oder stellen Sie eine IAM-Rolle bereit, um die API Gateway-Berechtigung zum Aufrufen des Genehmigers zu erteilen.
Wenn die Protokolle darauf hinweisen, dass Ihre Lambda-Funktion eine ungültige Antwort zurückgibt, überprüfen Sie, ob Ihre Lambda-Funktion eine Antwort im [erforderlichen Format](#http-api-lambda-authorizer.payload-format-response) zurückgibt.
# Steuern Sie den Zugriff auf HTTP APIs mit JWT-Autorisierern in API Gateway
Sie können JSON Web Tokens (JWTs) als Teil der Frameworks [OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) und [OAuth 2.0](https://oauth.net/2/) verwenden, um den Client-Zugriff auf Ihre zu beschränken. APIs
Wenn Sie einen JWT-Authorizer für eine Route Ihrer API konfigurieren, validiert API Gateway die, JWTs die Clients mit API-Anfragen einreichen. API Gateway genehmigt oder lehnt Anfragen basierend auf der Token-Validierung und optional Bereichen im Token ab. Wenn Sie Bereiche für eine Route konfigurieren, muss das Token mindestens einen der Bereiche der Route enthalten.
Sie können unterschiedliche Genehmiger für jede Route einer API konfigurieren oder denselben Genehmiger für mehrere Routen verwenden.
**Anmerkung**
Es gibt keinen Standardmechanismus, um JWT-Zugriffstoken von anderen Typen wie OpenID Connect ID-Tokens zu unterscheiden. JWTs Wir empfehlen, Ihre Routen so zu konfigurieren, dass Autorisierungsbereiche erforderlich sind, es sei denn, Sie benötigen ID-Token für die API-Autorisierung Sie können Ihre JWT-Genehmiger auch so konfigurieren, dass Aussteller oder Zielgruppen erforderlich sind, die Ihr Identitätsanbieter nur bei der Ausgabe von JWT-Zugriffstoken verwendet.
## Autorisieren von API-Anfragen mit einem JWT-Genehmiger
API Gateway verwendet den folgenden allgemeinen Workflow, um Anfragen an Routen zu autorisieren, die für die Verwendung eines JWT-Genehmigers konfiguriert sind.
1. Überprüfen Sie die [https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers-authorizerid.html#apis-apiid-authorizers-authorizerid-prop-authorizer-identitysource](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers-authorizerid.html#apis-apiid-authorizers-authorizerid-prop-authorizer-identitysource) auf ein Token. Der `identitySource` kann nur das Token oder das Token mit dem Präfix `Bearer` enthalten.
1. Decodieren Sie das Token.
1. Überprüfen Sie den Algorithmus und die Signatur des Tokens mit dem vom des Ausstellers abgerufenen öffentlichen Schlüsse `jwks_uri`. Derzeit werden nur RSA-basierte Algorithmen unterstützt. API Gateway kann den öffentlichen Schlüssel zwei Stunden lang zwischenspeichern. Es hat sich bewährt, beim Wechseln von Schlüsseln eine bestimmte Frist einzuräumen, während der sowohl der alte als auch der neue Schlüssel gültig sind.
1. Validieren Sie die Ansprüche. API Gateway evaluiert die folgenden Token-Ansprüche:
+ [https://datatracker.ietf.org/doc/html/rfc7517#section-4.5](https://datatracker.ietf.org/doc/html/rfc7517#section-4.5) – Das Token muss einen Header-Anspruch haben, der mit dem Schlüssel in dem `jwks_uri` übereinstimmt, der das Token signiert hat.
+ [https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.1](https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.1) – Muss mit dem für den Genehmiger konfigurierten [https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers-authorizerid.html#apis-apiid-authorizers-authorizerid-model-jwtconfiguration](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers-authorizerid.html#apis-apiid-authorizers-authorizerid-model-jwtconfiguration) übereinstimmen.
+ [https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.3](https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.3) oder `client_id` – Muss mit einem der für den Genehmiger konfigurierten [https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers-authorizerid.html#apis-apiid-authorizers-authorizerid-model-jwtconfiguration](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers-authorizerid.html#apis-apiid-authorizers-authorizerid-model-jwtconfiguration)-Einträge übereinstimmen. API Gateway validiert `client_id` nur dann, wenn `aud` nicht vorhanden ist. Wenn sowohl `aud` als auch `client_id` vorhanden sind, bewertet API Gateway `aud`.
+ [https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.4](https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.4) – Muss nach der aktuellen Uhrzeit in UTC liegen.
+ [https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.5](https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.5) – muss vor der aktuellen Uhrzeit in UTC liegen.
+ [https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.6](https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.6) – Muss vor der aktuellen Uhrzeit in UTC liegen.
+ [https://datatracker.ietf.org/doc/html/rfc6749#section-3.3](https://datatracker.ietf.org/doc/html/rfc6749#section-3.3) oder `scp` – Das Token muss mindestens einen der Bereiche in den [https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-routes-routeid.html#apis-apiid-routes-routeid-prop-updaterouteinput-authorizationscopes](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-routes-routeid.html#apis-apiid-routes-routeid-prop-updaterouteinput-authorizationscopes) der Route enthalten.
Wenn einer dieser Schritte fehlschlägt, lehnt API Gateway die API-Anfrage ab.
Nach der Validierung des JWT übergibt API Gateway die Ansprüche im Token an die Integration der API-Route. Backend-Ressourcen, wie beispielsweise Lambda-Funktionen, können auf die JWT-Ansprüche zugreifen. Wenn das JWT beispielsweise den Identitätsanspruch `emailID` enthält, ist er für eine Lambda-Integration in `$event.requestContext.authorizer.jwt.claims.emailID` verfügbar. Weitere Informationen zur Nutzlast, die API Gateway an Lambda-Integrationen sendet, finden Sie unter [Erstellen Sie AWS Lambda Proxy-Integrationen für HTTP APIs in API Gateway](http-api-develop-integrations-lambda.md).
## Erstellen eines JWT-Genehmigers
Bevor Sie einen JWT-Genehmiger erstellen, müssen Sie eine Clientanwendung bei einem Identitätsanbieter registrieren. Sie müssen darüber hinaus eine HTTP-API erstellt haben. Beispiele zum Erstellen einer HTTP-API finden Sie unter [Erstellen einer HTTP-API](http-api-develop.md#http-api-examples).
### Erstellen eines JWT-Genehmigers mit der Konsole
Die folgenden Schritte zeigen, wie Sie mit der Konsole einen JWT-Genehmiger erstellen.
**So erstellen Sie mit der Konsole einen JWT-Genehmiger**
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 eine HTTP-API.
1. Wählen Sie im Hauptnavigationsbereich **Autorisierung** aus.
1. Wählen Sie die Registerkarte **Genehmiger verwalten** aus.
1. Wählen Sie **Erstellen** aus.
1. Wählen Sie unter **Genehmiger-Typ** den Wert **JWT** aus.
1. Konfigurieren Sie Ihren JWT-Genehmiger und geben Sie eine **Identitätsquelle** an, die die Quelle des Tokens definiert.
1. Wählen Sie **Erstellen** aus.
#### Erstellen Sie einen JWT-Autorisierer mit dem AWS CLI
Der folgende [create-authorizer](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-authorizer.html)-Befehl erstellt einen JWT-Genehmiger. Bei `jwt-configuration` geben Sie das `Audience` und `Issuer` als Ihren Identitätsanbieter an. Wenn Sie Amazon Cognito als Identitätsanbieter verwenden, lautet die `IssuerUrl` `https://cognito-idp.us-east-2.amazonaws.com/userPoolID`.
```
aws apigatewayv2 create-authorizer \
--name authorizer-name \
--api-id api-id \
--authorizer-type JWT \
--identity-source '$request.header.Authorization' \
--jwt-configuration Audience=audience,Issuer=IssuerUrl
```
##### Erstellen Sie einen JWT-Autorisierer mit AWS CloudFormation
Die folgende CloudFormation Vorlage erstellt eine HTTP-API mit einem JWT-Autorisierer, der Amazon Cognito als Identitätsanbieter verwendet.
Die Ausgabe der CloudFormation Vorlage ist eine URL für eine von Amazon Cognito gehostete Benutzeroberfläche, über die sich Kunden registrieren und anmelden können, um ein JWT zu erhalten. Nachdem sich ein Client angemeldet hat, wird er mit einem Zugriffstoken in der URL zu Ihrer HTTP-API weitergeleitet. Um die API mit dem Zugriffstoken aufzurufen, ändern Sie das `#` in der URL in ein `?`, um das Token als Abfragezeichenfolgenparameter zu verwenden.
##### Beispielvorlage CloudFormation
```
AWSTemplateFormatVersion: '2010-09-09'
Description: |
Example HTTP API with a JWT authorizer. This template includes an Amazon Cognito user pool as the issuer for the JWT authorizer
and an Amazon Cognito app client as the audience for the authorizer. The outputs include a URL for an Amazon Cognito hosted UI where clients can
sign up and sign in to receive a JWT. After a client signs in, the client is redirected to your HTTP API with an access token
in the URL. To invoke the API with the access token, change the '#' in the URL to a '?' to use the token as a query string parameter.
Resources:
MyAPI:
Type: AWS::ApiGatewayV2::Api
Properties:
Description: Example HTTP API
Name: api-with-auth
ProtocolType: HTTP
Target: !GetAtt MyLambdaFunction.Arn
DefaultRouteOverrides:
Type: AWS::ApiGatewayV2::ApiGatewayManagedOverrides
Properties:
ApiId: !Ref MyAPI
Route:
AuthorizationType: JWT
AuthorizerId: !Ref JWTAuthorizer
JWTAuthorizer:
Type: AWS::ApiGatewayV2::Authorizer
Properties:
ApiId: !Ref MyAPI
AuthorizerType: JWT
IdentitySource:
- '$request.querystring.access_token'
JwtConfiguration:
Audience:
- !Ref AppClient
Issuer: !Sub https://cognito-idp.${AWS::Region}.amazonaws.com/${UserPool}
Name: test-jwt-authorizer
MyLambdaFunction:
Type: AWS::Lambda::Function
Properties:
Runtime: nodejs18.x
Role: !GetAtt FunctionExecutionRole.Arn
Handler: index.handler
Code:
ZipFile: |
exports.handler = async (event) => {
const response = {
statusCode: 200,
body: JSON.stringify('Hello from the ' + event.routeKey + ' route!'),
};
return response;
};
APIInvokeLambdaPermission:
Type: AWS::Lambda::Permission
Properties:
FunctionName: !Ref MyLambdaFunction
Action: lambda:InvokeFunction
Principal: apigateway.amazonaws.com
SourceArn: !Sub arn:${AWS::Partition}:execute-api:${AWS::Region}:${AWS::AccountId}:${MyAPI}/$default/$default
FunctionExecutionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17 '
Statement:
- Effect: Allow
Principal:
Service:
- lambda.amazonaws.com
Action:
- 'sts:AssumeRole'
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
UserPool:
Type: AWS::Cognito::UserPool
Properties:
UserPoolName: http-api-user-pool
AutoVerifiedAttributes:
- email
Schema:
- Name: name
AttributeDataType: String
Mutable: true
Required: true
- Name: email
AttributeDataType: String
Mutable: false
Required: true
AppClient:
Type: AWS::Cognito::UserPoolClient
Properties:
AllowedOAuthFlows:
- implicit
AllowedOAuthScopes:
- aws.cognito.signin.user.admin
- email
- openid
- profile
AllowedOAuthFlowsUserPoolClient: true
ClientName: api-app-client
CallbackURLs:
- !Sub https://${MyAPI}.execute-api.${AWS::Region}.amazonaws.com
ExplicitAuthFlows:
- ALLOW_USER_PASSWORD_AUTH
- ALLOW_REFRESH_TOKEN_AUTH
UserPoolId: !Ref UserPool
SupportedIdentityProviders:
- COGNITO
HostedUI:
Type: AWS::Cognito::UserPoolDomain
Properties:
Domain: !Join
- '-'
- - !Ref MyAPI
- !Ref AppClient
UserPoolId: !Ref UserPool
Outputs:
SignupURL:
Value: !Sub https://${HostedUI}.auth.${AWS::Region}.amazoncognito.com/login?client_id=${AppClient}&response_type=token&scope=email+profile&redirect_uri=https://${MyAPI}.execute-api.${AWS::Region}.amazonaws.com
```
## Aktualisieren einer Route zum Verwenden eines JWT-Genehmigers
Sie können die Konsole, das oder ein AWS SDK verwenden AWS CLI, um eine Route so zu aktualisieren, dass sie einen JWT-Autorisierer verwendet.
### Aktualisieren einer Route zum Verwenden eines JWT-Genehmigers mit der Konsole
Die folgenden Schritte zeigen, wie Sie mit der Konsole eine Route so aktualisieren, dass sie einen JWT-Genehmiger verwendet.
**So erstellen Sie mit der Konsole einen JWT-Genehmiger**
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 eine HTTP-API.
1. Wählen Sie im Hauptnavigationsbereich **Autorisierung** aus.
1. Wählen Sie zunächst eine Methode und anschließend Ihren Genehmiger aus dem Dropdown-Menü aus und klicken Sie auf **Genehmiger anfügen**.
#### Aktualisieren Sie eine Route, um einen JWT-Autorisierer zu verwenden, indem Sie AWS CLI
Mit dem folgenden [update-route](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/update-route.html)-Befehl wird eine Route so aktualisiert, dass sie einen JWT-Genehmiger verwendet.
```
aws apigatewayv2 update-route \
--api-id api-id \
--route-id route-id \
--authorization-type JWT \
--authorizer-id authorizer-id \
--authorization-scopes user.email
```
# Steuern Sie den Zugriff auf HTTP APIs mit der IAM-Autorisierung in API Gateway
Sie können die IAM-Autorisierung für HTTP-API-Routen aktivieren. Wenn die IAM-Autorisierung aktiviert ist, müssen Clients [Signature Version 4 (Sigv4)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) verwenden, um ihre Anfragen mit AWS Anmeldeinformationen zu signieren. API Gateway ruft Ihre API-Route nur auf, wenn der Client über die `execute-api`-Berechtigung für die Route verfügt.
[Die IAM-Autorisierung für HTTP APIs ähnelt der für REST. APIs](api-gateway-control-access-using-iam-policies-to-invoke-api.md)
**Anmerkung**
Ressourcenrichtlinien werden derzeit für HTTP APIs nicht unterstützt.
Beispiele für IAM-Richtlinien, die Clients die Berechtigung zum Aufrufen gewähren APIs, finden Sie unter. [Kontrollieren des Zugriffs für den API-Aufruf](api-gateway-control-access-using-iam-policies-to-invoke-api.md)
## Aktivieren der IAM-Autorisierung für eine Route
Der folgende [update-route](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/update-route.html)-Befehl aktiviert die IAM-Autorisierung für eine HTTP-API-Route.
```
aws apigatewayv2 update-route \
--api-id abc123 \
--route-id abcdef \
--authorization-type AWS_IAM
```
# Erstellen von Integrationen für HTTP-APIs in API Gateway
*Integrationen* verbinden eine Route mit Backend-Ressourcen. HTTP-APIs unterstützen Lambda-Proxy-, AWS-Service- und HTTP-Proxy-Integrationen. Beispielsweise können Sie eine `POST`-Anfrage an die `/signup`-Route Ihrer API so konfigurieren, dass sie in eine Lambda-Funktion integriert wird, die die Registrierung von Kunden übernimmt.
**Topics**
+ [Erstellen Sie AWS Lambda Proxy-Integrationen für HTTP APIs in API Gateway](http-api-develop-integrations-lambda.md)
+ [Erstellen Sie HTTP-Proxyintegrationen für HTTP APIs](http-api-develop-integrations-http.md)
+ [Erstellen Sie AWS Dienstintegrationen für HTTP APIs in API Gateway](http-api-develop-integrations-aws-services.md)
+ [Erstellen Sie private Integrationen für HTTP APIs in API Gateway](http-api-develop-integrations-private.md)
# Erstellen Sie AWS Lambda Proxy-Integrationen für HTTP APIs in API Gateway
Eine Lambda-Proxy-Integration ermöglicht es Ihnen, eine API-Route in eine Lambda-Funktion zu integrieren. Wenn ein Client Ihre API aufruft, sendet API Gateway die Anfrage an die Lambda-Funktion und gibt die Antwort der Funktion an den Client zurück. Beispiele zum Erstellen einer HTTP-API finden Sie unter [Erstellen einer HTTP-API](http-api-develop.md#http-api-examples).
## Nutzlastformatversion
Die Nutzlastformatversion gibt das Format des Ereignisses an, das API Gateway an eine Lambda-Integration sendet und wie API Gateway die Lambda-Antwort interpretiert. Wenn Sie keine Version im Payload-Format angeben, AWS-Managementkonsole wird standardmäßig die neueste Version verwendet. Wenn Sie eine Lambda-Integration mithilfe des AWS CLI, CloudFormation, oder eines SDK erstellen, müssen Sie a `payloadFormatVersion` angeben. Die unterstützten Werte sind `1.0` und `2.0`.
Weitere Informationen zum Einrichten von `payloadFormatVersion`, finden Sie unter [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html). Weitere Informationen zur Ermittlung des `payloadFormatVersion` einer vorhandenen Integration finden Sie unter [get-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/get-integration.html)
### Nutzlastformatunterschiede
In der folgenden Liste sehen Sie die Unterschiede zwischen den Payload-Formatversionen `1.0` und `2.0`:
+ Das Format `2.0` hat keine `multiValueHeaders`- oder `multiValueQueryStringParameters`-Felder. Doppelte Header werden mit Kommas kombiniert und in das `headers`-Feld aufgenommen. Doppelte Abfragezeichenfolgen werden mit Kommas kombiniert und in das `queryStringParameters`-Feld aufgenommen.
+ Das Format `2.0` hat `rawPath`. Wenn Sie eine API-Zuordnung verwenden, um Ihre Stufe mit einem benutzerdefinierten Domainnamen zu verbinden, stellt `rawPath` den API-Zuordnungswert nicht bereit. Verwenden Sie die Formate `1.0` und `path`, um auf die API-Zuordnung für Ihren benutzerdefinierten Domainnamen zuzugreifen.
+ Das Format `2.0` enthält ein neues `cookies`-Feld. Alle Cookie-Header in der Anforderung werden mit Kommas kombiniert und dem `cookies`-Feld hinzugefügt. In der Antwort an den Client wird jedes Cookie zu einem `set-cookie`-Header.
### Nutzdatenformatstruktur
Die folgenden Beispiele zeigen die Struktur jeder Nutzlastformatversion. Alle Header-Namen werden in Kleinbuchstaben angegeben.
------
#### [ 2.0 ]
```
{
"version": "2.0",
"routeKey": "$default",
"rawPath": "/my/path",
"rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value",
"cookies": [
"cookie1",
"cookie2"
],
"headers": {
"header1": "value1",
"header2": "value1,value2"
},
"queryStringParameters": {
"parameter1": "value1,value2",
"parameter2": "value"
},
"requestContext": {
"accountId": "123456789012",
"apiId": "api-id",
"authentication": {
"clientCert": {
"clientCertPem": "CERT_CONTENT",
"subjectDN": "www.example.com",
"issuerDN": "Example issuer",
"serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1",
"validity": {
"notBefore": "May 28 12:30:02 2019 GMT",
"notAfter": "Aug 5 09:36:04 2021 GMT"
}
}
},
"authorizer": {
"jwt": {
"claims": {
"claim1": "value1",
"claim2": "value2"
},
"scopes": [
"scope1",
"scope2"
]
}
},
"domainName": "id.execute-api.us-east-1.amazonaws.com",
"domainPrefix": "id",
"http": {
"method": "POST",
"path": "/my/path",
"protocol": "HTTP/1.1",
"sourceIp": "192.0.2.1",
"userAgent": "agent"
},
"requestId": "id",
"routeKey": "$default",
"stage": "$default",
"time": "12/Mar/2020:19:03:58 +0000",
"timeEpoch": 1583348638390
},
"body": "Hello from Lambda",
"pathParameters": {
"parameter1": "value1"
},
"isBase64Encoded": false,
"stageVariables": {
"stageVariable1": "value1",
"stageVariable2": "value2"
}
}
```
------
#### [ 1.0 ]
```
{
"version": "1.0",
"resource": "/my/path",
"path": "/my/path",
"httpMethod": "GET",
"headers": {
"header1": "value1",
"header2": "value2"
},
"multiValueHeaders": {
"header1": [
"value1"
],
"header2": [
"value1",
"value2"
]
},
"queryStringParameters": {
"parameter1": "value1",
"parameter2": "value"
},
"multiValueQueryStringParameters": {
"parameter1": [
"value1",
"value2"
],
"parameter2": [
"value"
]
},
"requestContext": {
"accountId": "123456789012",
"apiId": "id",
"authorizer": {
"claims": null,
"scopes": null
},
"domainName": "id.execute-api.us-east-1.amazonaws.com",
"domainPrefix": "id",
"extendedRequestId": "request-id",
"httpMethod": "GET",
"identity": {
"accessKey": null,
"accountId": null,
"caller": null,
"cognitoAuthenticationProvider": null,
"cognitoAuthenticationType": null,
"cognitoIdentityId": null,
"cognitoIdentityPoolId": null,
"principalOrgId": null,
"sourceIp": "192.0.2.1",
"user": null,
"userAgent": "user-agent",
"userArn": null,
"clientCert": {
"clientCertPem": "CERT_CONTENT",
"subjectDN": "www.example.com",
"issuerDN": "Example issuer",
"serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1",
"validity": {
"notBefore": "May 28 12:30:02 2019 GMT",
"notAfter": "Aug 5 09:36:04 2021 GMT"
}
}
},
"path": "/my/path",
"protocol": "HTTP/1.1",
"requestId": "id=",
"requestTime": "04/Mar/2020:19:15:17 +0000",
"requestTimeEpoch": 1583349317135,
"resourceId": null,
"resourcePath": "/my/path",
"stage": "$default"
},
"pathParameters": null,
"stageVariables": null,
"body": "Hello from Lambda!",
"isBase64Encoded": false
}
```
------
## Antwortformat der Lambda-Funktion
Die Nutzlastformatversion bestimmt die Struktur der Antwort, die Ihre Lambda-Funktion zurückgeben muss.
### Lambda-Funktionsantwort für Format 1.0
Bei der `1.0`-Formatversion müssen Lambda-Integrationen eine Antwort im folgenden JSON-Format zurückgeben.
**Example**
```
{
"isBase64Encoded": true|false,
"statusCode": httpStatusCode,
"headers": { "headername": "headervalue", ... },
"multiValueHeaders": { "headername": ["headervalue", "headervalue2", ...], ... },
"body": "..."
}
```
### Lambda-Funktionsantwort für Format 2.0
Bei der `2.0`-Formatversion kann API Gateway das Antwortformat für Sie ableiten. API Gateway geht von den folgenden Annahmen aus, wenn Ihre Lambda-Funktion gültigen JSON-Code und keinen zurückgib `statusCode`:
+ `isBase64Encoded` ist `false`.
+ `statusCode` ist `200`.
+ `content-type` ist `application/json`.
+ `body` ist die Antwort der Funktion.
Die folgenden Beispiele zeigen die Ausgabe einer Lambda-Funktion und die Interpretation von API Gateway.
| Lambda-Funktionsausgabe | API Gateway-Interpretation |
| --- | --- |
| "Hello from Lambda!"
| {
"isBase64Encoded": false,
"statusCode": 200,
"body": "Hello from Lambda!",
"headers": {
"content-type": "application/json"
}
} |
| { "message": "Hello from Lambda!" } | {
"isBase64Encoded": false,
"statusCode": 200,
"body": "{ \"message\": \"Hello from Lambda!\" }",
"headers": {
"content-type": "application/json"
}
} |
Um die Antwort anzupassen, sollte Ihre Lambda-Funktion eine Antwort im folgenden Format zurückgeben.
```
{
"cookies" : ["cookie1", "cookie2"],
"isBase64Encoded": true|false,
"statusCode": httpStatusCode,
"headers": { "headername": "headervalue", ... },
"body": "Hello from Lambda!"
}
```
# Erstellen Sie HTTP-Proxyintegrationen für HTTP APIs
Eine HTTP-Proxy-Integration ermöglicht es Ihnen, eine API-Route mit einem öffentlich routingfähigen HTTP-Endpunkt zu verbinden. Bei diesem Integrationstyp wird die gesamte Anforderung und Antwort von API Gateway zwischen dem Frontend und dem Backend übergeben.
Geben Sie die URL eines öffentlich routingfähigen HTTP-Endpunkts an, um eine HTTP-Proxy-Integration zu erstellen.
## HTTP-Proxy-Integration mit Pfadvariablen
Sie können Pfadvariablen in HTTP-API-Routen verwenden.
Beispielsweise fängt die Route `/pets/{petID}` Anforderungen an `/pets/6` ab. Sie können Pfadvariablen im Integrations-URI referenzieren, um den Inhalt der Variablen an eine Integration zu senden. Ein Beispiel ist `/pets/extendedpath/{petID}`.
Sie können gierige Pfadvariablen verwenden, um alle untergeordneten Ressourcen einer Route zu erfassen. Um eine gierige Pfadvariable zu erstellen, fügen Sie `+` dem Variablennamen hinzu, z. B. `{proxy+}`.
Um eine Route mit einer HTTP-Proxy-Integration einzurichten, die alle Anforderungen abfängt, erstellen Sie eine API-Route mit einer gierigen Pfadvariable (z. B, `/parent/{proxy+}`). Integrieren Sie die Route mit einem HTTP-Endpunkt (z. B. `https://petstore-demo-endpoint.execute-api.com/petstore/{proxy}`) für die `ANY`-Methode. Die gierige Pfadvariable muss am Ende des Ressourcenpfads stehen.
# Erstellen Sie AWS Dienstintegrationen für HTTP APIs in API Gateway
Sie können Ihre HTTP-API mithilfe *erstklassiger Integrationen* in AWS Dienste integrieren. Eine erstklassige Integration verbindet eine HTTP-API-Route mit einer AWS -Service-API. Wenn ein Client eine Route aufruft, die durch eine erstklassige Integration unterstützt wird, ruft API Gateway eine AWS Service-API für Sie auf. Sie können beispielsweise erstklassige Integrationen verwenden, um eine Nachricht an eine Amazon Simple Queue Service-Warteschlange zu senden oder eine AWS Step Functions Zustandsmaschine zu starten. Unterstützte Serviceaktionen finden Sie unter [Integration-Subtypreferenz](http-api-develop-integrations-aws-services-reference.md).
## Mapping von Anforderungsparametern
Erstklassige Integrationen verfügen über erforderliche und optionale Parameter. Sie müssen alle erforderlichen Parameter zum Erstellen einer Integration konfigurieren. Sie können statische Werte oder Mapping-Parameter verwenden, die zur Laufzeit dynamisch ausgewertet werden. Eine vollständige Liste der unterstützten Integrationen und Parameter finden Sie unter [Integration-Subtypreferenz](http-api-develop-integrations-aws-services-reference.md).
In der Tabelle unten sind die unterstützten Anforderungsparameter der Zuordnung beschrieben.
| Typ | Beispiel | Hinweise |
| --- | --- | --- |
| Header-Wert | \$1request.header. name | Bei Header-Namen wird nicht zwischen Groß- und Kleinschreibung unterschieden. API Gateway kombiniert mehrere Headerwerte mit Kommas, z. B. "header1": "value1,value2". |
| Abfragezeichenfolgenwert | \$1request.querystring. name | Abfragezeichenfolgennamen unterscheiden zwischen Groß- und Kleinschreibung. API Gateway kombiniert mehrere Werte mit Kommas, z. B. "querystring1": "Value1,Value2". |
| Path-Parameter | \$1request.path. name | Der Wert eines Pfadparameters in der Anforderung. Beispiel: Wenn die Route /pets/\$1petId\$1 ist, können Sie den Parameter petId aus der Anforderung mit \$1request.path.petId zuordnen. |
| Übergeben des Anforderungstexts | \$1request.body | API Gateway übergibt den gesamten Anforderungstext. |
| Anforderungstext | \$1request.body. name | Ein [JSON-Pfadausdruck](https://goessner.net/articles/JsonPath/index.html#e2). Rekursiver Abstieg (\$1request.body..name) und Filterausdrücke (?(expression)) werden nicht unterstützt. Wenn Sie einen JSON-Pfad angeben, schneidet API Gateway den Anfragetext auf 100 KB ab und wendet dann den Auswahlausdruck an. Um Payloads mit mehr als 100 KB zu senden, geben Sie an `$request.body`. |
| Kontextvariable | \$1kontext. variableName | Der Wert einer unterstützten [Kontextvariablen](http-api-logging-variables.md). |
| Stufenvariable | \$1stageVariablen. variableName | Der Wert einer [Stufenvariablen](http-api-stages.stage-variables.md). |
| Statischer Wert | string | Ein konstanter Wert. |
## Erstellen Sie einer erstklassigen Integration
Bevor Sie eine erstklassige Integration erstellen, müssen Sie eine IAM-Rolle erstellen, die API Gateway Gateway-Berechtigungen zum Aufrufen der AWS Serviceaktion gewährt, mit der Sie die Integration durchführen. Weitere Informationen finden Sie unter [Erstellen einer Rolle für einen AWS -Service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html).
Um eine erstklassige Integration zu erstellen, wählen Sie eine unterstützte AWS Serviceaktion aus, z. B. `SQS-SendMessage` konfigurieren Sie die Anforderungsparameter, und stellen Sie eine Rolle bereit, die API Gateway Gateway-Berechtigungen zum Aufrufen der integrierten AWS Service-API gewährt. Je nach Integration-Subtyp sind unterschiedliche Anforderungsparameter erforderlich. Weitere Informationen hierzu finden Sie unter [Integration-Subtypreferenz](http-api-develop-integrations-aws-services-reference.md).
Der folgende [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html)-Befehl erstellt eine Integration, die eine Amazon-SQS-Nachricht sendet:
```
aws apigatewayv2 create-integration \
--api-id abcdef123 \
--integration-subtype SQS-SendMessage \
--integration-type AWS_PROXY \
--payload-format-version 1.0 \
--credentials-arn arn:aws:iam::123456789012:role/apigateway-sqs \
--request-parameters '{"QueueUrl": "$request.header.queueUrl", "MessageBody": "$request.body.message"}'
```
## Erstellen Sie eine erstklassige Integration mit CloudFormation
Das folgende Beispiel zeigt ein CloudFormation Snippet, das eine `/{source}/{detailType}` Route mit einer erstklassigen Integration mit Amazon erstellt. EventBridge
Der Parameter `Source` wird dem Pfadparameter `{source}`, der `DetailType` dem Pfadparameter `{DetailType}` und der Parameter `Detail` dem Anforderungstext zugeordnet.
Das Snippet zeigt weder den Event Bus noch die IAM-Rolle, die API-Gateway-Berechtigungen zum Aufrufen der Aktion `PutEvents` gewährt.
```
Route:
Type: AWS::ApiGatewayV2::Route
Properties:
ApiId: !Ref HttpApi
AuthorizationType: None
RouteKey: 'POST /{source}/{detailType}'
Target: !Join
- /
- - integrations
- !Ref Integration
Integration:
Type: AWS::ApiGatewayV2::Integration
Properties:
ApiId: !Ref HttpApi
IntegrationType: AWS_PROXY
IntegrationSubtype: EventBridge-PutEvents
CredentialsArn: !GetAtt EventBridgeRole.Arn
RequestParameters:
Source: $request.path.source
DetailType: $request.path.detailType
Detail: $request.body
EventBusName: !GetAtt EventBus.Arn
PayloadFormatVersion: "1.0"
```
# Integration-Subtypreferenz
Die folgenden [Integration-Subtypen](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-integrations-integrationid.html#apis-apiid-integrations-integrationid-prop-integration-integrationsubtype) werden für HTTP-APIs unterstützt.
**Topics**
+ [EventBridge-PutEvents 1.0](#EventBridge-PutEvents)
+ [SQS-SendMessage 1.0](#SQS-SendMessage)
+ [SQS-ReceiveMessage 1.0](#SQS-ReceiveMessage)
+ [SQS-DeleteMessage 1.0](#SQS-DeleteMessage)
+ [SQS-PurgeQueue 1.0](#SQS-PurgeQueue)
+ [AppConfig-GetConfiguration 1.0](#AppConfig-GetConfiguration)
+ [Kinesis-PutRecord 1.0](#Kinesis-PutRecord)
+ [StepFunctions-StartExecution 1.0](#StepFunctions-StartExecution)
+ [StepFunctions-StartSyncExecution 1.0](#StepFunctions-StartSyncExecution)
+ [StepFunctions-StopExecution 1.0](#StepFunctions-StopExecution)
## EventBridge-PutEvents 1.0
Sendet benutzerdefinierte Ereignisse an Amazon EventBridge, damit sie Regeln zugeordnet werden können.
| Parameter | Erforderlich |
| --- | --- |
| Detail | Wahr |
| DetailType | Wahr |
| Source | Wahr |
| Zeit | Falsch |
| EventBusName | Falsch |
| Ressourcen | Falsch |
| Region | Falsch |
| TraceHeader | Falsch |
Weitere Informationen finden Sie unter [PutEvents](https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html) in der *Amazon EventBridge-API-Referenz*.
## SQS-SendMessage 1.0
Übergibt eine Nachricht an die angegebene Warteschlange
| Parameter | Erforderlich |
| --- | --- |
| QueueUrl | Wahr |
| MessageBody | Wahr |
| DelaySeconds | Falsch |
| MessageAttributes | Falsch |
| MessageDeduplicationId | Falsch |
| MessageGroupId | Falsch |
| MessageSystemAttributes | Falsch |
| Region | Falsch |
Weitere Informationen finden Sie unter [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html) in der *Amazon Simple Queue Service – API-Referenz*.
## SQS-ReceiveMessage 1.0
Ruft eine oder mehrere Nachrichten (bis zu 10) aus der angegebenen Warteschlange ab.
| Parameter | Erforderlich |
| --- | --- |
| QueueUrl | Wahr |
| AttributeNames | Falsch |
| MaxNumberOfMessages | Falsch |
| MessageAttributeNames | Falsch |
| ReceiveRequestAttemptId | Falsch |
| VisibilityTimeout | Falsch |
| WaitTimeSeconds | Falsch |
| Region | Falsch |
Weitere Informationen finden Sie unter [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html) in der *Amazon Simple Queue Service – API-Referenz*.
## SQS-DeleteMessage 1.0
Löscht die angegebene Nachricht aus der angegebenen Warteschlange
| Parameter | Erforderlich |
| --- | --- |
| ReceiptHandle | Wahr |
| QueueUrl | Wahr |
| Region | Falsch |
Weitere Informationen finden Sie unter [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html) in der *Amazon Simple Queue Service – API-Referenz*.
## SQS-PurgeQueue 1.0
Löscht alle Nachrichten in der angegebenen Warteschlange.
| Parameter | Erforderlich |
| --- | --- |
| QueueUrl | Wahr |
| Region | Falsch |
Weitere Informationen finden Sie unter [PurgeQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_PurgeQueue.html) in der *Amazon Simple Queue Service – API-Referenz*.
## AppConfig-GetConfiguration 1.0
Fordert Informationen zu einer Konfiguration an.
| Parameter | Erforderlich |
| --- | --- |
| Anwendung | Wahr |
| Umgebung | Wahr |
| Konfiguration | Wahr |
| ClientId | Wahr |
| ClientConfigurationVersion | Falsch |
| Region | Falsch |
Weitere Informationen finden Sie unter [GetConfiguration](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_GetConfiguration.html) in der *AWS-AppConfig-API-Referenz*.
## Kinesis-PutRecord 1.0
Schreibt einen einzelnen Datensatz in einen Amazon Kinesis-Daten-Stream.
| Parameter | Erforderlich |
| --- | --- |
| StreamName | Wahr |
| Daten | Wahr |
| PartitionKey | Wahr |
| SequenceNumberForOrdering | Falsch |
| ExplicitHashKey | Falsch |
| Region | Falsch |
Weitere Informationen finden Sie unter [PutRecord](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html) in der *Amazon Kinesis Data Streams – API-Referenz*.
## StepFunctions-StartExecution 1.0
Startet eine Ausführung des Zustandsautomaten.
| Parameter | Erforderlich |
| --- | --- |
| StateMachineArn | Wahr |
| Name | Falsch |
| Eingabe | Falsch |
| Region | Falsch |
Weitere Informationen finden Sie unter [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html) in der *AWS Step Functions-API-Referenz*.
## StepFunctions-StartSyncExecution 1.0
Startet eine synchrone Ausführung des Zustandsautomaten.
| Parameter | Erforderlich |
| --- | --- |
| StateMachineArn | Wahr |
| Name | Falsch |
| Eingabe | Falsch |
| Region | Falsch |
| TraceHeader | Falsch |
Weitere Informationen finden Sie unter [StartSyncExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartSyncExecution.html) in der *AWS Step Functions-API-Referenz*.
## StepFunctions-StopExecution 1.0
Stoppt eine Ausführung.
| Parameter | Erforderlich |
| --- | --- |
| ExecutionArn | Wahr |
| Ursache | Falsch |
| Fehler | Falsch |
| Region | Falsch |
Weitere Informationen finden Sie unter [StopExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StopExecution.html) in der *AWS Step Functions-API-Referenz*.
# Erstellen Sie private Integrationen für HTTP APIs in API Gateway
Private Integrationen ermöglichen es Ihnen, API-Integrationen mit privaten Ressourcen in einer VPC zu erstellen, z. B. Application Load Balancer oder containerbasierte Amazon ECS-Anwendungen.
Sie können Ihre Ressourcen in einer VPC für den Zugriff von Clients außerhalb der VPC bereitstellen, indem Sie private Integrationen verwenden. Sie können den Zugriff auf Ihre API steuern, indem Sie eine der von API Gateway unterstützten [Autorisierungsmethoden](http-api-access-control.md) verwenden.
**Anmerkung**
Um eine private Integration zu erstellen, müssen Sie zunächst einen VPC-Link erstellen. VPC-Links V2 werden jetzt sowohl für HTTP als auch für REST APIs unterstützt. Weitere Informationen zu VPC-Links V2 finden Sie unter[VPC-Links V2 im API Gateway einrichten](apigateway-vpc-links-v2.md).
Nachdem Sie einen VPC-Link V2 erstellt haben, können Sie private Integrationen einrichten, die eine Verbindung zu einem Application Load Balancer, Network Load Balancer oder Ressourcen herstellen, die bei einem Service registriert sind. AWS Cloud Map
## Überlegungen
Die folgenden Überlegungen könnten sich auf Ihre Verwendung privater Integrationen auswirken:
+ Alle Ressourcen müssen sich im Besitz derselben AWS-Konto Person befinden. Dazu gehören der Load Balancer oder AWS Cloud Map Service, der VPC-Link und die HTTP-API.
+ Standardmäßig verwendet der private Integrationsdatenverkehr das HTTP-Protokoll. Um HTTPS zu verwenden, geben Sie a an. [https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-integrations-integrationid.html](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-integrations-integrationid.html) Um dies mithilfe von zu tun AWS-Managementkonsole, wählen Sie bei der Erstellung Ihrer privaten Integration **Erweiterte Einstellungen** und geben Sie dann einen sicheren Servernamen ein.
+ Bei privaten Integrationen schließt API Gateway den [Stufen](http-api-stages.md)-Teil des API-Endpunkts in die Anforderung an Ihre Backend-Ressourcen ein. Beispielsweise enthält eine Anforderung an die Stufe `test` einer API in der Anforderung an Ihre private Integration `test/route-path`. Um den Künstlernamen aus der Anforderung an Ihre Back-End-Ressourcen zu entfernen, verwenden Sie [Parameterzuordnung](http-api-parameter-mapping.md), um den Anforderungspfad nach `$request.path` zu überschreiben.
## Erstellen einer privaten Integration mit einem Application Load Balancer oder Network Load Balancer
Bevor Sie eine private Integration erstellen, müssen Sie einen VPC-Link V2 erstellen. Weitere Informationen zu VPC-Links V2 finden Sie unter[VPC-Links V2 im API Gateway einrichten](apigateway-vpc-links-v2.md).
Um eine private Integration mit einem Application Load Balancer oder Network Load Balancer zu erstellen, erstellen Sie eine HTTP-Proxy-Integration, geben Sie den zu verwendenden VPC-Link an und stellen Sie den Listener-ARN des Load Balancers bereit.
Der folgende [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html)-Befehl erstellt eine private Integration, die über einen VPC-Link eine Verbindung mit einem Load Balancer herstellt.
```
aws apigatewayv2 create-integration --api-id api-id --integration-type HTTP_PROXY \
--integration-method GET --connection-type VPC_LINK \
--connection-id VPC-link-ID \
--integration-uri arn:aws:elasticloadbalancing:us-east-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/0467ef3c8400ae65
--payload-format-version 1.0
```
## Erstellen Sie mithilfe von AWS Cloud Map Service Discovery eine private Integration
Bevor Sie eine private Integration erstellen, müssen Sie einen VPC-Link V2 erstellen. Weitere Informationen zu VPC-Links finden Sie unter [VPC-Links V2 im API Gateway einrichten](apigateway-vpc-links-v2.md).
Bei Integrationen mit AWS Cloud Map verwendet `DiscoverInstances` API Gateway Ressourcen. Sie können Abfrageparameter verwenden, um bestimmte Ressourcen zu adressieren. Die Attribute der registrierten Ressourcen müssen IP-Adressen und Ports enthalten. API Gateway verteilt Anforderungen auf fehlerfreie Ressourcen, die von zurückgegeben werde `DiscoverInstances`. Weitere Informationen finden Sie [DiscoverInstances](https://docs.aws.amazon.com/cloud-map/latest/api/API_DiscoverInstances.html)in der AWS Cloud Map API-Referenz.
**Anmerkung**
Wenn Sie Amazon ECS zum Ausfüllen von Einträgen verwenden AWS Cloud Map, müssen Sie Ihre Amazon ECS-Aufgabe so konfigurieren, dass sie SRV-Datensätze mit Amazon ECS Service Discovery verwendet, oder Amazon ECS Service Connect aktivieren. Weitere Informationen finden Sie unter [Services miteinander verbinden](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/interconnecting-services.html) im Amazon Elastic Container Service-Entwicklerhandbuch.
Um eine private Integration mit zu erstellen AWS Cloud Map, erstellen Sie eine HTTP-Proxyintegration, geben Sie den zu verwendenden VPC-Link an und geben Sie den ARN des AWS Cloud Map Dienstes an.
Der folgende Befehl [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html) erstellt eine private Integration, die AWS Cloud Map Service Discovery verwendet, um Ressourcen zu identifizieren:
```
aws apigatewayv2 create-integration --api-id api-id --integration-type HTTP_PROXY \
--integration-method GET --connection-type VPC_LINK \
--connection-id VPC-link-ID \
--integration-uri arn:aws:servicediscovery:us-east-2:123456789012:service/srv-id?stage=prod&deployment=green_deployment
--payload-format-version 1.0
```
# CORS für HTTP APIs im API Gateway konfigurieren
[Cross-Origin Resource Sharing (CORS)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) ist eine Browser-Sicherheitsfunktion, die HTTP-Anfragen einschränkt, die von im Browser ausgeführten Skripts eingeleitet werden. Wenn Sie nicht auf Ihre API zugreifen können und eine Fehlermeldung erhalten, die `Cross-Origin Request Blocked` enthält, müssen Sie möglicherweise CORS aktivieren. Weitere Informationen finden Sie unter [Was ist CORS?](https://aws.amazon.com/what-is/cross-origin-resource-sharing/).
CORS ist in der Regel erforderlich, um Webanwendungen zu erstellen, die auf einer anderen Domain oder einem anderen Ursprung APIs gehostet werden. Sie können CORS aktivieren, um Anfragen an Ihre API von einer Webanwendung zuzulassen, die auf einer anderen Domäne gehostet wird. Wenn Ihre API beispielsweise auf `https://{api_id}.execute-api.{region}.amazonaws.com/` gehostet wird und Sie Ihre API über eine Webanwendung aufrufen möchten, die auf `example.com` gehostet wird, muss Ihre API CORS unterstützen.
Wenn Sie CORS für eine API konfigurieren, sendet API Gateway automatisch eine Antwort auf Preflight-OPTIONS-Anfragen, selbst wenn keine OPTIONS-Route für Ihre API konfiguriert ist. Bei einer CORS-Anfrage fügt API Gateway die konfigurierten CORS-Header zur Antwort einer Integration hinzu.
**Anmerkung**
Wenn Sie CORS für eine API konfigurieren, ignoriert API Gateway CORS-Header, die von Ihrer Backend-Integration zurückgegeben werden.
Sie können die folgenden Parameter in einer CORS-Konfiguration angeben. Um diese Parameter mithilfe der HTTP-API-Konsole des API Gateway hinzuzufügen, wählen Sie **Add** (Hinzufügen), nachdem Sie Ihren Wert eingegeben haben.
| CORS-Header | CORS-Konfigurationseigenschaft | Beispielwerte |
| --- | --- | --- |
| Access-Control-Allow-Origin | allowOrigins | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/http-api-cors.html) |
| Access-Control-Allow-Credentials | allowCredentials | true |
| Access-Control-Expose-Headers | exposeHeaders | Datum, \$1 x-api-id |
| Access-Control-Max-Age | maxAge | 300 |
| Access-Control-Allow-Methods | allowMethods | GET, POST, DELETE, \$1 |
| Access-Control-Allow-Headers | allowHeaders | authorization, \$1 |
Um CORS-Header zurückzugeben, muss Ihre Anfrage einen `origin`-Header enthalten. Für die `OPTIONS`-Methode muss Ihre Anfrage einen `origin`-Header und einen `Access-Control-Request-Method`-Header enthalten.
Ihre CORS-Konfiguration sieht möglicherweise wie folgt aus:
![\[CORS-Konfiguration für HTTP APIs\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/http-cors-console.png)
## Konfigurieren von CORS für eine HTTP-API mit einer `$default`-Route und einem Genehmiger
Sie können CORS aktivieren und die Autorisierung für jede Route einer HTTP-API konfigurieren. Wenn Sie CORS und die Autorisierung für die [`$default`-Route](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-routes.html#http-api-develop-routes.default) aktivieren, gibt es einige besondere Überlegungen. Die `$default`-Route fängt Anforderungen für alle Methoden und Routen ab, die Sie nicht explizit definiert haben, einschließlich `OPTIONS`-Anforderungen. Fügen Sie Ihrer API zur Unterstützung von nicht autorisierten `OPTIONS`-Anforderungen eine `OPTIONS /{proxy+}`-Route hinzu, die keine Autorisierung erfordert. Die Route `OPTIONS /{proxy+}` hat eine höhere Priorität als die Route `$default`. Dadurch können Clients ohne Autorisierung `OPTIONS`-Anforderungen an Ihre API senden. Weitere Informationen zu Weiterleitungsprioritäten finden Sie unter [Weiterleiten von API-Anforderungen](http-api-develop-routes.md#http-api-develop-routes.evaluation).
## Konfigurieren Sie CORS für eine HTTP-API mithilfe der CLI AWS
Der folgende [update-api](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/update-api.html)-Befehl aktiviert CORS-Anfragen von `https://www.example.com`:
**Example**
```
aws apigatewayv2 update-api --api-id api-id --cors-configuration AllowOrigins="https://www.example.com"
```
Weitere Informationen finden Sie unter [CORS](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid.html#apis-apiid-model-cors) in der API-Referenz für Amazon API Gateway Version 2.
# API-Anforderungen und -Antworten für HTTP-APIs in API Gateway transformieren
Sie können API-Anforderungen von Clients ändern, bevor sie Ihre Backend-Integrationen erreichen. Sie können auch die Antwort von Integrationen ändern, bevor API Gateway die Antwort an Clients zurückgibt. Sie verwenden das *Parameter-Mapping*, um API-Anforderungen und -Antworten für HTTP-APIs zu ändern. Um das Parameter-Mapping zu verwenden, geben Sie zu ändernde API-Anforderungs- oder Antwortparameter an und wie diese Parameter geändert werden sollen.
## Transformieren von API-Anforderungen
Sie verwenden Anforderungsparameter, um Anforderungen zu ändern, bevor sie Ihre Backend-Integrationen erreichen. Sie können Header, Abfragezeichenfolgen oder den Anforderungspfad ändern.
Anforderungsparameter sind eine Schlüssel-Wert-Zuordnung. Der Schlüssel gibt den Speicherort des zu ändernden Anforderungsparameters und an, wie er geändert werden soll. Der Wert gibt die neuen Daten für den Parameter an.
Die folgende Tabelle zeigt unterstützte Schlüssel.
| Typ | Syntax |
| --- | --- |
| Header | append\$1overwrite\$1remove:header.headername |
| Abfragezeichenfolge | append\$1overwrite\$1remove:querystring.querystring-name |
| Pfad | overwrite:path |
Die folgende Tabelle zeigt unterstützte Werte, die Sie Parametern zuordnen können.
| Typ | Syntax | Hinweise |
| --- | --- | --- |
| Header-Wert | \$1request.header.name oder \$1\$1request.header.name\$1 | Bei Header-Namen wird nicht zwischen Groß- und Kleinschreibung unterschieden. API Gateway kombiniert mehrere Headerwerte mit Kommas, z. B. "header1": "value1,value2". Einige Header sind reserviert. Weitere Informationen hierzu finden Sie unter [Reservierte Header](#http-api-mapping-reserved-headers). |
| Abfragezeichenfolgenwert | \$1request.querystring.name oder \$1\$1request.querystring.name\$1 | Abfragezeichenfolgennamen unterscheiden zwischen Groß- und Kleinschreibung. API Gateway kombiniert mehrere Werte mit Kommas, z. B. "querystring1" "Value1,Value2". |
| Anforderungstext | \$1request.body.name oder \$1\$1request.body.name\$1 | Ein JSON-Pfadausdruck. Rekursiver Abstieg (\$1request.body..name)) und Filterausdrücke (?(expression)) werden nicht unterstützt. Wenn Sie einen JSON-Pfad angeben, schneidet API Gateway den Anfragetext auf 100 KB ab und wendet dann den Auswahlausdruck an. Um Payloads mit mehr als 100 KB zu senden, geben Sie an `$request.body`. |
| Anforderungspfad | \$1request.path oder \$1\$1request.path\$1 | Der Anforderungspfad ohne den Namen der Stufe. |
| Path-Parameter | \$1request.path.name oder \$1\$1request.path.name\$1 | Der Wert eines Pfadparameters in der Anforderung. Beispiel: Wenn die Route /pets/\$1petId\$1 ist, können Sie den Parameter petId aus der Anforderung mit \$1request.path.petId zuordnen. |
| Kontextvariable | \$1context.variableName oder \$1\$1context.variableName\$1 | Der Wert einer [Kontextvariablen](http-api-logging-variables.md). NEs werden ausschließlich die Sonderzeichen `.` und `_` unterstützt. |
| Stufenvariable | \$1stageVariables.variableName oder \$1\$1stageVariables.variableName\$1 | Der Wert einer [Stufenvariablen](http-api-stages.stage-variables.md). |
| Statischer Wert | string | Ein konstanter Wert. |
**Anmerkung**
Um mehrere Variablen in einem Auswahlausdruck zu verwenden, schließen Sie die Variable in Klammern ein. Beispiel, `${request.path.name} ${request.path.id}`.
## Transformieren von API-Antworten
Sie verwenden Antwortparameter, um die HTTP-Antwort einer Backend-Integration zu transformieren, bevor Sie die Antwort an Clients zurückgeben. Sie können Header oder den Statuscode einer Antwort ändern, bevor API Gateway die Antwort an Clients zurückgibt.
Sie konfigurieren die Antwortparameter für jeden Statuscode, den Ihre Integration zurückgibt. Antwortparameter sind eine Schlüssel-Wert-Zuordnung. Der Schlüssel gibt den Speicherort des zu ändernden Anforderungsparameters und an, wie er geändert werden soll. Der Wert gibt die neuen Daten für den Parameter an.
Die folgende Tabelle zeigt unterstützte Schlüssel.
| Typ | Syntax |
| --- | --- |
| Header | append\$1overwrite\$1remove:header.headername |
| Statuscode | overwrite:statuscode |
Die folgende Tabelle zeigt unterstützte Werte, die Sie Parametern zuordnen können.
| Typ | Syntax | Hinweise |
| --- | --- | --- |
| Header-Wert | \$1response.header.Name oder \$1 \$1response.header.name\$1 | Bei Header-Namen wird nicht zwischen Groß- und Kleinschreibung unterschieden. API Gateway kombiniert mehrere Headerwerte mit Kommas, z. B. "header1": "value1,value2". Einige Header sind reserviert. Weitere Informationen hierzu finden Sie unter [Reservierte Header](#http-api-mapping-reserved-headers). |
| Antworttext | \$1response.body.name oder \$1\$1response.body.name\$1 | Ein JSON-Pfadausdruck. Rekursiver Abstieg (\$1response.body..name) und Filterausdrücke (?(expression)) werden nicht unterstützt. Wenn Sie einen JSON-Pfad angeben, kürzt API Gateway den Antworttext auf 100 KB und wendet dann den Auswahlausdruck an. Um Payloads mit mehr als 100 KB zu senden, geben Sie an `$response.body`. |
| Kontextvariable | \$1context.variableName oder \$1\$1context.variableName\$1 | Der Wert einer unterstützten [Kontextvariablen](http-api-logging-variables.md). |
| Stufenvariable | \$1stageVariables.variableName oder \$1\$1stageVariables.variableName\$1 | Der Wert einer [Stufenvariablen](http-api-stages.stage-variables.md). |
| Statischer Wert | string | Ein konstanter Wert. |
**Anmerkung**
Um mehrere Variablen in einem Auswahlausdruck zu verwenden, schließen Sie die Variable in Klammern ein. Beispiel, `${request.path.name} ${request.path.id}`.
## Reservierte Header
Die folgenden Header sind reserviert. Sie können keine Anforderungs- oder Antwort-Mappings für diese Header konfigurieren.
+ access-control-\$1
+ apigw-\$1
+ Autorisierung
+ Verbindung
+ Content-Encoding
+ Content-Length
+ Content-Location
+ Forwarded
+ Keep-Alive
+ Urspung
+ Proxy-Authenticate
+ Proxy-Authorization
+ TE
+ Trailers
+ Transfer-Encoding
+ Upgrade
+ x-amz-\$1
+ x-amzn-\$1
+ X-Forwarded-For
+ X-Forwarded-Host
+ X-Forwarded-Proto
+ Via
## Beispiele
Mit den folgenden AWS CLI-Beispielen werden Parameter-Mappings konfiguriert. CloudFormation-Beispielvorlagen finden Sie auf [GitHub](https://github.com/awsdocs/amazon-api-gateway-developer-guide/tree/main/cloudformation-templates).
### Hinzufügen eines Headers zu einer API-Anforderung
Der folgende [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html)-Befehl erstellt einen Header mit dem Namen `header1` für eine API-Anfrage, bevor diese Ihre Backend-Integration erreicht. API Gateway füllt den Header mit der Anforderungs-ID auf.
```
aws apigatewayv2 create-integration \
--api-id abcdef123 \
--integration-type HTTP_PROXY \
--payload-format-version 1.0 \
--integration-uri 'https://api.example.com' \
--integration-method ANY \
--request-parameters '{ "append:header.header1": "$context.requestId" }'
```
### Umbenennen eines Anforderungsheaders
Der folgende [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html)-Befehl benennt einen Anfrage-Header von `header1` in `header2` um:
```
aws apigatewayv2 create-integration \
--api-id abcdef123 \
--integration-type HTTP_PROXY \
--payload-format-version 1.0 \
--integration-uri 'https://api.example.com' \
--integration-method ANY \
--request-parameters '{ "append:header.header2": "$request.header.header1", "remove:header.header1": "''"}'
```
### Ändern der Antwort aus einer Integration
Der folgende [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html)-Befehl konfiguriert Antwortparameter für eine Integration. Wenn die Integrationen einen 500-Statuscode zurückgeben, ändert API Gateway den Statuscode auf 403 und fügt der Antwort `header1`1 hinzu. Wenn die Integration einen 404-Statuscode zurückgibt, fügt API Gateway der Antwort einen `error`-Header hinzu.
```
aws apigatewayv2 create-integration \
--api-id abcdef123 \
--integration-type HTTP_PROXY \
--payload-format-version 1.0 \
--integration-uri 'https://api.example.com' \
--integration-method ANY \
--response-parameters '{"500" : {"append:header.header1": "$context.requestId", "overwrite:statuscode" : "403"}, "404" : {"append:header.error" : "$stageVariables.environmentId"} }'
```
### Entfernen konfigurierter Parameter-Mappings
Der folgende [update-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html)-Befehl entfernt zuvor konfigurierte Anforderungsparameter für `append:header.header1`. Außerdem werden zuvor konfigurierte Antwortparameter für einen 200-Statuscode entfernt.
```
aws apigatewayv2 update-integration \
--api-id abcdef123 \
--integration-id hijk456 \
--request-parameters '{"append:header.header1" : ""}' \
--response-parameters '{"200" : {}}'
```
# Verwenden Sie OpenAPI-Definitionen für HTTP APIs in API Gateway
Sie können Ihre HTTP-API definieren, indem Sie eine OpenAPI 3.0-Definitionsdatei verwenden. Anschließend können Sie die Definition in API Gateway importieren, um eine API zu erstellen. Weitere Informationen zu API Gateway-Erweiterungen für OpenAPI finden Sie unter [OpenAPI-Erweiterungen für API Gateway](api-gateway-swagger-extensions.md).
## Importieren einer HTTP-API
Sie können eine HTTP-API erstellen, indem Sie eine OpenAPI 3.0-Definitionsdatei importieren.
Um von einer REST-API zu einer HTTP-API zu migrieren, können Sie Ihre REST-API als OpenAPI 3.0-Definitionsdatei exportieren. Importieren Sie dann die API-Definition als HTTP-API. Weitere Informationen zum Exportieren einer REST-API finden Sie unter [REST-API von API Gateway importieren](api-gateway-export-api.md).
**Anmerkung**
HTTP APIs unterstützt dieselben AWS Variablen wie REST APIs. Weitere Informationen hierzu finden Sie unter [AWS Variablen für den OpenAPI-Import](import-api-aws-variables.md).
### Importieren von Validierungsinformationen
Beim Importieren einer API stellt API Gateway drei Kategorien von Validierungsinformationen bereit.
**Info**
Eine Eigenschaft ist gemäß der OpenAPI-Spezifikation gültig, aber diese Eigenschaft wird für HTTP APIs nicht unterstützt.
Das folgende OpenAPI 3.0-Snippet erzeugt beispielsweise Informationen beim Import, da HTTP die Überprüfung von Anfragen APIs nicht unterstützt. API Gateway ignoriert die Felder `requestBody` und `schema`.
```
"paths": {
"/": {
"get": {
"x-amazon-apigateway-integration": {
"type": "AWS_PROXY",
"httpMethod": "POST",
"uri": "arn:aws:lambda:us-east-2:123456789012:function:HelloWorld",
"payloadFormatVersion": "1.0"
},
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Body"
}
}
}
}
}
}
...
},
"components": {
"schemas": {
"Body": {
"type": "object",
"properties": {
"key": {
"type": "string"
}
}
}
...
}
...
}
```
**Warnung**
Eine Eigenschaft oder Struktur ist gemäß der OpenAPI-Spezifikation ungültig, blockiert die API-Erstellung jedoch nicht. Sie können angeben, ob API Gateway diese Warnungen ignorieren und mit der API-Erstellung fortfahren oder die API-Erstellung bei Warnungen beenden soll.
Das folgende OpenAPI 3.0-Dokument erzeugt Warnungen beim Import, da HTTP nur Lambda-Proxy- und HTTP-Proxyintegrationen APIs unterstützt.
```
"x-amazon-apigateway-integration": {
"type": "AWS",
"httpMethod": "POST",
"uri": "arn:aws:lambda:us-east-2:123456789012:function:HelloWorld",
"payloadFormatVersion": "1.0"
}
```
**Fehler**
Die OpenAPI-Spezifikation ist ungültig oder fehlerhaft. API Gateway kann keine Ressourcen aus dem fehlerhaften Dokument erstellen. Sie müssen die Fehler beheben und es anschließend erneut versuchen.
Die folgende API-Definition erzeugt Fehler beim Import, da HTTP nur die OpenAPI 3.0-Spezifikation APIs unterstützt.
```
{
"swagger": "2.0.0",
"info": {
"title": "My API",
"description": "An Example OpenAPI definition for Errors/Warnings/ImportInfo",
"version": "1.0"
}
...
}
```
Ein weiteres Beispiel: Während OpenAPI es Benutzern ermöglicht, eine API mit mehreren Sicherheitsanforderungen zu definieren, die mit einer bestimmten Operation verbunden sind, wird dies von API Gateway nicht unterstützt. Jede Operation kann nur eine IAM-Autorisierung, einen Lambda-Genehmiger oder einen JWT-Genehmiger haben. Der Versuch, mehrere Sicherheitsanforderungen zu modellieren, führt zu einem Fehler.
### Importieren Sie eine API mithilfe der AWS CLI
Der folgende [import-api](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/import-api.html)-Befehl importiert die OpenAPI 3.0-Definitionsdatei `api-definition.json` als HTTP-API:
**Example**
```
aws apigatewayv2 import-api --body file://api-definition.json
```
**Example**
Sie können das folgende Beispiel einer OpenAPI 3.0-Definition importieren, um eine HTTP-API zu erstellen.
```
{
"openapi": "3.0.1",
"info": {
"title": "Example Pet Store",
"description": "A Pet Store API.",
"version": "1.0"
},
"paths": {
"/pets": {
"get": {
"operationId": "GET HTTP",
"parameters": [
{
"name": "type",
"in": "query",
"schema": {
"type": "string"
}
},
{
"name": "page",
"in": "query",
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"headers": {
"Access-Control-Allow-Origin": {
"schema": {
"type": "string"
}
}
},
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Pets"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "HTTP_PROXY",
"httpMethod": "GET",
"uri": "http://petstore.execute-api.us-west-1.amazonaws.com/petstore/pets",
"payloadFormatVersion": 1.0
}
},
"post": {
"operationId": "Create Pet",
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/NewPet"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "200 response",
"headers": {
"Access-Control-Allow-Origin": {
"schema": {
"type": "string"
}
}
},
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/NewPetResponse"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "HTTP_PROXY",
"httpMethod": "POST",
"uri": "http://petstore.execute-api.us-west-1.amazonaws.com/petstore/pets",
"payloadFormatVersion": 1.0
}
}
},
"/pets/{petId}": {
"get": {
"operationId": "Get Pet",
"parameters": [
{
"name": "petId",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"headers": {
"Access-Control-Allow-Origin": {
"schema": {
"type": "string"
}
}
},
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Pet"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "HTTP_PROXY",
"httpMethod": "GET",
"uri": "http://petstore.execute-api.us-west-1.amazonaws.com/petstore/pets/{petId}",
"payloadFormatVersion": 1.0
}
}
}
},
"x-amazon-apigateway-cors": {
"allowOrigins": [
"*"
],
"allowMethods": [
"GET",
"OPTIONS",
"POST"
],
"allowHeaders": [
"x-amzm-header",
"x-apigateway-header",
"x-api-key",
"authorization",
"x-amz-date",
"content-type"
]
},
"components": {
"schemas": {
"Pets": {
"type": "array",
"items": {
"$ref": "#/components/schemas/Pet"
}
},
"Empty": {
"type": "object"
},
"NewPetResponse": {
"type": "object",
"properties": {
"pet": {
"$ref": "#/components/schemas/Pet"
},
"message": {
"type": "string"
}
}
},
"Pet": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"type": {
"type": "string"
},
"price": {
"type": "number"
}
}
},
"NewPet": {
"type": "object",
"properties": {
"type": {
"$ref": "#/components/schemas/PetType"
},
"price": {
"type": "number"
}
}
},
"PetType": {
"type": "string",
"enum": [
"dog",
"cat",
"fish",
"bird",
"gecko"
]
}
}
}
}
```
# Exportieren Sie HTTP APIs aus dem API Gateway
Nachdem Sie ein HTTP-API erstellt haben, können Sie eine OpenAPI 3.0-Definition Ihrer API aus API Gateway exportieren. Sie können entweder eine Stufe auswählen, die exportiert werden soll, oder die neueste Konfiguration Ihrer API exportieren. Sie können auch eine exportierte API-Definition nach API Gateway importieren, um eine weitere, identische API zu erstellen. Weitere Informationen zum Importieren von API-Definitionen finden Sie unter [Importieren einer HTTP-API](http-api-open-api.md#http-api-import).
## Exportieren Sie eine OpenAPI 3.0-Definition einer Phase mithilfe der CLI AWS
Der folgende [export-api](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/export-api.html)-Befehl exportiert eine OpenAPI-Definition einer API-Stufe namens `prod` in eine YAML-Datei mit dem Namen `stage-definition.yaml`. Die exportierte Definitionsdatei enthält standardmäßig [API Gateway-Erweiterungen](api-gateway-swagger-extensions.md).
```
aws apigatewayv2 export-api \
--api-id api-id \
--output-type YAML \
--specification OAS30 \
--stage-name prod \
stage-definition.yaml
```
## Exportieren Sie eine OpenAPI 3.0-Definition der neuesten Änderungen Ihrer API mithilfe der CLI AWS
Der folgende [export-api](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/export-api.html)-Befehl exportiert eine OpenAPI-Definition einer HTTP-API in eine JSON-Datei mit dem Namen `latest-api-definition.json`. Da der Befehl keine Stufe angibt, exportiert API Gateway die neueste Konfiguration Ihrer API, unabhängig davon, ob sie auf einer Stufe bereitgestellt wurde oder nicht. Die exportierte Definitionsdatei enthält keine [API Gateway-Erweiterungen](api-gateway-swagger-extensions.md).
```
aws apigatewayv2 export-api \
--api-id api-id \
--output-type JSON \
--specification OAS30 \
--no-include-extensions \
latest-api-definition.json
```
Weitere Informationen finden Sie unter [ExportAPI](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-exports-specification.html#apis-apiid-exports-specification-http-methods) in der *API-Referenz für Amazon API Gateway Version 2*.
## Exportieren einer OpenAPI 3.0-Definition mithilfe der API-Gateway-Konsole
Das folgende Verfahren zeigt, wie Sie eine OpenAPI-Definition einer HTTP-API exportieren.
**Exportieren einer OpenAPI 3.0-Definition mithilfe der API-Gateway-Konsole**
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 eine HTTP-API.
1. Wählen Sie im Hauptnavigationsbereich unter **Entwickeln** die Option **Exportieren** aus.
1. Wählen Sie aus den folgenden Optionen, um Ihre API zu exportieren:
![\[Exportoptionen für HTTP. APIs\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/export-http-api.png)
1. Wählen Sie unter **Quelle** eine Quelle für die OpenAPI 3.0-Definition aus. Sie können entweder eine Stufe auswählen, die exportiert werden soll, oder die neueste Konfiguration Ihrer API exportieren.
1. Aktivieren Sie **API Gateway-Erweiterungen einschließen**, um [API-Gateway-Erweiterungen](api-gateway-swagger-extensions.md) einzubeziehen.
1. Wählen Sie unter **Ausgabeformat** ein Ausgabeformat aus.
1. Wählen Sie **Herunterladen** aus.