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.
# OpenAPI-Erweiterungen für API Gateway
Die API Gateway Gateway-Erweiterungen unterstützen die AWS-spezifische Autorisierung und die API Gateway Gateway-spezifischen API-Integrationen für REST und HTTP. APIs APIs In diesem Abschnitt beschreiben wir die API Gateway-Erweiterungen der OpenAPI-Spezifikation.
**Tipp**
Um zu verstehen, wie die API Gateway-Erweiterungen in einer Anwendung verwendet werden, können Sie die API Gateway-Konsole verwenden, um eine REST-API oder HTTP-API zu erstellen und diese in eine OpenAPI-Definitionsdatei zu exportieren. Weitere Informationen zum Exportieren einer API finden Sie unter [REST-API von API Gateway importieren](api-gateway-export-api.md) und [Exportieren Sie HTTP APIs aus dem API Gateway](http-api-export.md).
**Topics**
+ [x-amazon-apigateway-any-method-Objekt](api-gateway-swagger-extensions-any-method.md)
+ [x-amazon-apigateway-cors Objekt](api-gateway-swagger-extensions-cors-configuration.md)
+ [x-amazon-apigateway-apiEigenschaft -key-source](api-gateway-swagger-extensions-api-key-source.md)
+ [x-amazon-apigateway-auth Objekt](api-gateway-swagger-extensions-auth.md)
+ [x-amazon-apigateway-authorizer Objekt](api-gateway-swagger-extensions-authorizer.md)
+ [x-amazon-apigateway-authtype Eigentum](api-gateway-swagger-extensions-authtype.md)
+ [x-amazon-apigateway-binaryEigenschaft -media-types](api-gateway-swagger-extensions-binary-media-types.md)
+ [x-amazon-apigateway-documentation Objekt](api-gateway-swagger-extensions-documentation.md)
+ [x-amazon-apigateway-endpoint-Zugriffsmodus](openapi-extensions-endpoint-access-mode.md)
+ [x-amazon-apigateway-endpoint-Konfigurationsobjekt](api-gateway-swagger-extensions-endpoint-configuration.md)
+ [x-amazon-apigateway-gatewayObjekt -Responses](api-gateway-swagger-extensions-gateway-responses.md)
+ [x-amazon-apigateway-gateway-Responses.GatewayResponse-Objekt](api-gateway-swagger-extensions-gateway-responses.gatewayResponse.md)
+ [x-amazon-apigateway-gateway-Responses.ResponseParameters-Objekt](api-gateway-swagger-extensions-gateway-responses.responseParameters.md)
+ [x-amazon-apigateway-gateway-Responses.ResponseTemplates-Objekt](api-gateway-swagger-extensions-gateway-responses.responseTemplates.md)
+ [x-amazon-apigateway-importexport-Version](api-gateway-extensions-importexport-version.md)
+ [x-amazon-apigateway-integration Objekt](api-gateway-swagger-extensions-integration.md)
+ [x-amazon-apigateway-integrations Objekt](api-gateway-extensions-integrations.md)
+ [x-amazon-apigateway-integration.requestTemplates-Objekt](api-gateway-swagger-extensions-integration-requestTemplates.md)
+ [x-amazon-apigateway-integration.RequestParameters Objekt](api-gateway-swagger-extensions-integration-requestParameters.md)
+ [x-amazon-apigateway-integration.responses-Objekt](api-gateway-swagger-extensions-integration-responses.md)
+ [x-amazon-apigateway-integration.response-Objekt](api-gateway-swagger-extensions-integration-response.md)
+ [x-amazon-apigateway-integration.responseTemplates-Objekt](api-gateway-swagger-extensions-integration-responseTemplates.md)
+ [x-amazon-apigateway-integration.responseParameters-Objekt](api-gateway-swagger-extensions-integration-responseParameters.md)
+ [x-amazon-apigateway-integration.tlsConfig-Objekt](api-gateway-extensions-integration-tls-config.md)
+ [x-amazon-apigateway-minimum-Kompressionsgröße](api-gateway-openapi-minimum-compression-size.md)
+ [x-amazon-apigateway-policy](openapi-extensions-policy.md)
+ [x-amazon-apigateway-request-validator-Eigenschaft](api-gateway-swagger-extensions-request-validator.md)
+ [x-amazon-apigateway-request-validators-Objekt](api-gateway-swagger-extensions-request-validators.md)
+ [x-amazon-apigateway-request-Validators.RequestValidator-Objekt](api-gateway-swagger-extensions-request-validators.requestValidator.md)
+ [x-amazon-apigateway-security-Richtlinie](openapi-extensions-security-policy.md)
+ [x-amazon-apigateway-tagEigenschaft -value](api-gateway-openapi-extensions-x-amazon-apigateway-tag-value.md)
# x-amazon-apigateway-any-method-Objekt
Gibt das [OpenAPI-Operations-Objekt](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#operation-object) für die Catch-all-Methode `ANY` von API Gateways in einem [OpenAPI-Pfad-Element-Objekt](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#path-item-object) an. Dieses Objekt kann neben anderen Operation-Objekten bestehen und fängt sämtliche HTTP-Methoden ab, die nicht explizit deklariert wurden.
Die folgende Tabelle listet die durch API Gateway erweiterten Eigenschaften auf. Andere OpenAPI-Operation-Eigenschaften finden Sie in der OpenAPI-Spezifikation.
| Eigenschaftenname | Typ | Beschreibung |
| --- | --- | --- |
| isDefaultRoute | Boolean | Gibt an, ob eine Route die \$1default-Route ist. Wird nur für HTTP APIs unterstützt. Weitere Informationen hierzu finden Sie unter [Routen für HTTP APIs in API Gateway erstellen](http-api-develop-routes.md). |
| x-amazon-apigateway-integration | [x-amazon-apigateway-integration Objekt](api-gateway-swagger-extensions-integration.md) | Gibt die Integration der Methode mit dem Backend an. Hierbei handelt es sich um eine erweiterte Eigenschaft des Objekts [OpenAPI-Operation](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#operation-object). Die Integration kann vom Typ AWS, AWS\$1PROXY, HTTP, HTTP\$1PROXY oder MOCK sein. |
## x-amazon-apigateway-any-Methodenbeispiele
Im folgenden Beispiel wird die `ANY`-Methode auf einer Proxy-Ressource `{proxy+}` mit einer Lambda-Funktion `TestSimpleProxy` integriert.
```
"/{proxy+}": {
"x-amazon-apigateway-any-method": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "proxy",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {},
"x-amazon-apigateway-integration": {
"uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:TestSimpleProxy/invocations",
"httpMethod": "POST",
"type": "aws_proxy"
}
```
Das folgende Beispiel erstellt eine `$default`-Route für eine HTTP-API, die sich in eine Lambda-Funktion (`HelloWorld`) integriert.
```
"/$default": {
"x-amazon-apigateway-any-method": {
"isDefaultRoute": true,
"x-amazon-apigateway-integration": {
"type": "AWS_PROXY",
"httpMethod": "POST",
"uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:HelloWorld/invocations",
"timeoutInMillis": 1000,
"connectionType": "INTERNET",
"payloadFormatVersion": 1.0
}
}
}
```
# x-amazon-apigateway-cors Objekt
Gibt die CORS-Konfiguration (Cross-Origin Resource Sharing) für eine HTTP-API an. Die Erweiterung gilt für die OpenAPI-Struktur auf Stammebene. Weitere Informationen hierzu finden Sie unter [CORS für HTTP APIs im API Gateway konfigurieren](http-api-cors.md).
| Eigenschaftenname | Typ | Beschreibung |
| --- | --- | --- |
| allowOrigins | Array | Gibt die zulässigen Ursprünge an. |
| allowCredentials | Boolean | Gibt an, ob Anmeldeinformationen in der CORS-Anforderung enthalten sind. |
| exposeHeaders | Array | Gibt die Header an, die bereitgestellt werden. |
| maxAge | Integer | Gibt die Anzahl der Sekunden an, während der der Browser Preflight-Anfrageergebnisse zwischenspeichern soll. |
| allowMethods | Array | Gibt die zulässigen HTTP-Methoden an. |
| allowHeaders | Array | Gibt die zulässigen Header an. |
## x-amazon-apigateway-cors Beispiel
Das folgende Beispiel zeigt eine CORS-Konfiguration für eine HTTP-API.
```
"x-amazon-apigateway-cors": {
"allowOrigins": [
"https://www.example.com"
],
"allowCredentials": true,
"exposeHeaders": [
"x-apigateway-header",
"x-amz-date",
"content-type"
],
"maxAge": 3600,
"allowMethods": [
"GET",
"OPTIONS",
"POST"
],
"allowHeaders": [
"x-apigateway-header",
"x-amz-date",
"content-type"
]
}
```
# x-amazon-apigateway-apiEigenschaft -key-source
Geben Sie die Quelle eines API-Schlüssels an, um die API-Methoden, die einen Schlüssel fordern, zu drosseln. Diese Eigenschaft auf API-Ebene ist vom Typ `String`. Weitere Informationen zur Methodenkonfigurierung für eine API-Schlüsselabfrage finden Sie unter [Konfigurieren einer Methode zur Verwendung von API-Schlüsseln mit einer OpenAPI-Definition](api-key-usage-plan-oas.md).
Geben Sie die Quelle des API-Schlüssels für Anforderungen an. Folgende Werte sind zulässig:
+ `HEADER` für den Empfang des API-Schlüssels aus dem `X-API-Key`-Header einer Anforderung.
+ `AUTHORIZER` für den Empfang des API-Schlüssels von `UsageIdentifierKey` von einem Lambda Genehmiger (ehemals als benutzerdefinierter Genehmiger bezeichnet).
## x-amazon-apigateway-apiBeispiel für -key-source
Im folgenden Beispiel wird der `X-API-Key`-Header als Quelle des API-Schlüssels festgelegt.
------
#### [ OpenAPI 2.0 ]
```
{
"swagger" : "2.0",
"info" : {
"title" : "Test1"
},
"schemes" : [ "https" ],
"basePath" : "/import",
"x-amazon-apigateway-api-key-source" : "HEADER",
.
.
.
}
```
------
#### [ OpenAPI 3.0.1 ]
```
{
"openapi" : "3.0.1",
"info" : {
"title" : "Test1"
},
"servers" : [ {
"url" : "/{basePath}",
"variables" : {
"basePath" : {
"default" : "import"
}
}
} ],
"x-amazon-apigateway-api-key-source" : "HEADER",
.
.
.
}
```
------
# x-amazon-apigateway-auth Objekt
Definiert einen Autorisierungstyp, der für die Autorisierung von Methodenaufrufen in API Gateway angewendet werden soll.
| Eigenschaftenname | Typ | Beschreibung |
| --- | --- | --- |
| type | string | Gibt den Autorisierungstyp an. Geben Sie "NONE" für einen offenen Zugriff an. Geben Sie "AWS\$1IAM" an, um IAM-Berechtigungen zu verwenden. Bei Werten wird die Groß- und Kleinschreibung nicht berücksichtigt. |
## x-amazon-apigateway-auth Beispiel
Das folgende Beispiel legt den Autorisierungstyp für eine API-Methode fest.
------
#### [ OpenAPI 3.0.1 ]
```
{
"openapi": "3.0.1",
"info": {
"title": "openapi3",
"version": "1.0"
},
"paths": {
"/protected-by-iam": {
"get": {
"x-amazon-apigateway-auth": {
"type": "AWS_IAM"
}
}
}
}
}
```
------
# x-amazon-apigateway-authorizer Objekt
Definiert einen Lambda-Genehmiger, Amazon Cognito-Benutzerpool oder JWT-Genehmiger, der für die Autorisierung von Methodenaufrufen in API Gateway angewendet werden soll. Diese Erweiterung gilt für die Sicherheitsdefinition in [OpenAPI 2](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#security-definitions-object) und das Sicherheitsschema in [OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.1.md#security-scheme-object).
| Name der Eigenschaft | Typ | Beschreibung |
| --- | --- | --- |
| type | string | Der Typ des Genehmigers. Diese Eigenschaft ist erforderlich. Geben Sie für REST `token` für einen Autorisierer an APIs, bei dem die Identität des Anrufers in ein Autorisierungstoken eingebettet ist. Geben Sie `request` für einen Genehmiger an, wobei die Aufruferidentität in den Anforderungsparametern enthalten ist. Geben Sie `cognito_user_pools` für einen Genehmiger an, der einen Amazon Cognito-Benutzerpool verwendet, um den Zugriff auf Ihre API zu kontrollieren. Geben Sie für HTTP APIs `request` für einen Lambda-Authorizer mit der Anruferidentität in den Anforderungsparametern an. Geben Sie `jwt` für einen JWT-Genehmiger an. |
| authorizerUri | string | Der Uniform Resource Identifier (URI) der Lambda-Funktion des Genehmigers. Die Syntax ist wie folgt: "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:account-id:function:auth_function_name/invocations"
|
| authorizerCredentials | string | Für den Aufruf des Genehmigers erforderliche Anmeldeinformationen, sofern vorhanden, in Form eines ARN einer IAM-Ausführungsrolle. Zum Beispiel „arn:aws:iam:::“. *account-id* *IAM\$1role* |
| authorizerPayloadFormatVersion | string | Gibt für HTTP das Format der Daten an APIs, die API Gateway an einen Lambda-Autorisierer sendet, und wie API Gateway die Antwort von Lambda interpretiert. Weitere Informationen hierzu finden Sie unter [Nutzlastformatversion](http-api-lambda-authorizer.md#http-api-lambda-authorizer.payload-format). |
| enableSimpleResponses | Boolean | Gibt für HTTP an APIs, ob ein `request` Autorisierer einen booleschen Wert oder eine IAM-Richtlinie zurückgibt. Wird nur für Genehmiger mit `authorizerPayloadFormatVersion` `2.0` unterstützt. Falls aktiviert, gibt die Lambda-Genehmiger-Funktion einen booleschen Wert zurück. Weitere Informationen hierzu finden Sie unter [Lambda-Funktionsantwort für Format 2.0](http-api-lambda-authorizer.md#http-api-lambda-authorizer.v2). |
| identitySource | string | Eine CSV-Liste der Mapping-Ausdrücke der Anforderungsparameter als Identitätsquelle. Gilt nur für die Genehmiger des Typs `request` und `jwt`. |
| jwtConfiguration | Object | Gibt den Aussteller und die Zielgruppen für einen JWT-Genehmiger an. Weitere Informationen finden Sie [JWTConfiguration](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-authorizers-authorizerid.html#apis-apiid-authorizers-authorizerid-model-jwtconfiguration)in der API-Referenz zu API Gateway Version 2. Wird nur für HTTP unterstützt APIs. |
| identityValidationExpression | string | Ein regulärer Ausdruck für die Validierung des Tokens als eingehende Identität. Beispiel: "^x-[a-z]\$1". Wird nur für `TOKEN` Autorisierer für REST unterstützt. APIs |
| authorizerResultTtlInSeconds | string | Die Anzahl der Sekunden, über die hinweg das Genehmiger-Ergebnis zwischengespeichert wird. |
| providerARNs | Ein Array von string | Eine Liste des Amazon Cognito Cognito-Benutzerpools ARNs für die`COGNITO_USER_POOLS`. |
## x-amazon-apigateway-authorizer Beispiele für REST APIs
Das folgende Beispiel für OpenAPI-Sicherheitsdefinitionen gibt einen Lambda-Genehmiger des Typs "token" des Namens a `test-authorizer`.
```
"securityDefinitions" : {
"test-authorizer" : {
"type" : "apiKey", // Required and the value must be "apiKey" for an API Gateway API.
"name" : "Authorization", // The name of the header containing the authorization token.
"in" : "header", // Required and the value must be "header" for an API Gateway API.
"x-amazon-apigateway-authtype" : "custom", // Specifies the authorization mechanism for the client.
"x-amazon-apigateway-authorizer" : { // An API Gateway Lambda authorizer definition
"type" : "token", // Required property and the value must "token"
"authorizerUri" : "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:account-id:function:function-name/invocations",
"authorizerCredentials" : "arn:aws:iam::account-id:role",
"identityValidationExpression" : "^x-[a-z]+",
"authorizerResultTtlInSeconds" : 60
}
}
}
```
Das folgende OpenAPI-Operations-Objekt-Snippet legt `GET /http` auf die Verwendung des vorhergehenden Lambda-Genehmigers fest.
```
"/http" : {
"get" : {
"responses" : { },
"security" : [ {
"test-authorizer" : [ ]
} ],
"x-amazon-apigateway-integration" : {
"type" : "http",
"responses" : {
"default" : {
"statusCode" : "200"
}
},
"httpMethod" : "GET",
"uri" : "http://api.example.com"
}
}
}
```
Das folgende Beispiel für OpenAPI-Sicherheitsdefinitionen spezifiziert einen Lambda-Genehmiger des Typs "request" mit einem einzigen Header-Parameter (`auth`) als Identitätsquelle. Die `securityDefinitions` heißt `request_authorizer_single_header`.
```
"securityDefinitions": {
"request_authorizer_single_header" : {
"type" : "apiKey",
"name" : "auth", // The name of a single header or query parameter as the identity source.
"in" : "header", // The location of the single identity source request parameter. The valid value is "header" or "query"
"x-amazon-apigateway-authtype" : "custom",
"x-amazon-apigateway-authorizer" : {
"type" : "request",
"identitySource" : "method.request.header.auth", // Request parameter mapping expression of the identity source. In this example, it is the 'auth' header.
"authorizerCredentials" : "arn:aws:iam::123456789012:role/AWSepIntegTest-CS-LambdaRole",
"authorizerUri" : "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:APIGateway-Request-Authorizer:vtwo/invocations",
"authorizerResultTtlInSeconds" : 300
}
}
}
```
Das folgende Beispiel für OpenAPI-Sicherheitsdefinitionen spezifiziert einen Lambda-Genehmiger des Typs "request" mit einem Header (`HeaderAuth1`) und einem Abfragezeichenfolgenparameter `QueryString1` als Identitätsquellen.
```
"securityDefinitions": {
"request_authorizer_header_query" : {
"type" : "apiKey",
"name" : "Unused", // Must be "Unused" for multiple identity sources or non header or query type of request parameters.
"in" : "header", // Must be "header" for multiple identity sources or non header or query type of request parameters.
"x-amazon-apigateway-authtype" : "custom",
"x-amazon-apigateway-authorizer" : {
"type" : "request",
"identitySource" : "method.request.header.HeaderAuth1, method.request.querystring.QueryString1", // Request parameter mapping expressions of the identity sources.
"authorizerCredentials" : "arn:aws:iam::123456789012:role/AWSepIntegTest-CS-LambdaRole",
"authorizerUri" : "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:APIGateway-Request-Authorizer:vtwo/invocations",
"authorizerResultTtlInSeconds" : 300
}
}
}
```
Das folgende OpenAPI-Sicherheitsdefinitionsbeispiel gibt einen API Gateway Lambda-Genehmiger vom Typ "request" mit einer einstufigen Variablen (`stage`) als Identitätsquelle an.
```
"securityDefinitions": {
"request_authorizer_single_stagevar" : {
"type" : "apiKey",
"name" : "Unused", // Must be "Unused", for multiple identity sources or non header or query type of request parameters.
"in" : "header", // Must be "header", for multiple identity sources or non header or query type of request parameters.
"x-amazon-apigateway-authtype" : "custom",
"x-amazon-apigateway-authorizer" : {
"type" : "request",
"identitySource" : "stageVariables.stage", // Request parameter mapping expression of the identity source. In this example, it is the stage variable.
"authorizerCredentials" : "arn:aws:iam::123456789012:role/AWSepIntegTest-CS-LambdaRole",
"authorizerUri" : "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:APIGateway-Request-Authorizer:vtwo/invocations",
"authorizerResultTtlInSeconds" : 300
}
}
}
```
Das folgende Beispiel für eine OpenAPI-Sicherheitsdefinition gibt einen Amazon Cognito-Benutzerpool als Genehmiger an.
```
"securityDefinitions": {
"cognito-pool": {
"type": "apiKey",
"name": "Authorization",
"in": "header",
"x-amazon-apigateway-authtype": "cognito_user_pools",
"x-amazon-apigateway-authorizer": {
"type": "cognito_user_pools",
"providerARNs": [
"arn:aws:cognito-idp:us-east-1:123456789012:userpool/us-east-1_ABC123"
]
}
}
```
Der folgende OpenAPI-Operationsobjektausschnitt legt `GET /http` fest, um den vorherigen Amazon Cognito-Benutzerpool als Genehmiger ohne benutzerdefinierte Bereiche zu verwenden.
```
"/http" : {
"get" : {
"responses" : { },
"security" : [ {
"cognito-pool" : [ ]
} ],
"x-amazon-apigateway-integration" : {
"type" : "http",
"responses" : {
"default" : {
"statusCode" : "200"
}
},
"httpMethod" : "GET",
"uri" : "http://api.example.com"
}
}
}
```
## x-amazon-apigateway-authorizer Beispiele für HTTP APIs
Das folgende OpenAPI 3.0-Beispiel erstellt einen JWT-Genehmiger für eine HTTP-API, die Amazon Cognito als Identitätsanbieter verwendet, mit dem `Authorization`-Header als Identitätsquelle.
```
"securitySchemes": {
"jwt-authorizer-oauth": {
"type": "oauth2",
"x-amazon-apigateway-authorizer": {
"type": "jwt",
"jwtConfiguration": {
"issuer": "https://cognito-idp.region.amazonaws.com/userPoolId",
"audience": [
"audience1",
"audience2"
]
},
"identitySource": "$request.header.Authorization"
}
}
}
```
Im folgenden Beispiel für OpenAPI 3.0 wird derselbe JWT-Genehmiger erstellt wie im vorherigen Beispiel. In diesem Beispiel wird jedoch die OpenAPI-`openIdConnectUrl`-Eigenschaft verwendet, damit der Aussteller automatisch erkannt wird. Die `openIdConnectUrl` muss vollständig gebildet sein.
```
"securitySchemes": {
"jwt-authorizer-autofind": {
"type": "openIdConnect",
"openIdConnectUrl": "https://cognito-idp.region.amazonaws.com/userPoolId/.well-known/openid-configuration",
"x-amazon-apigateway-authorizer": {
"type": "jwt",
"jwtConfiguration": {
"audience": [
"audience1",
"audience2"
]
},
"identitySource": "$request.header.Authorization"
}
}
}
```
Das folgende Beispiel erstellt einen Lambda-Genehmiger für eine HTTP-API. Dieser Beispiel-Genehmiger verwendet den `Authorization`-Header als Identitätsquelle. Der Genehmiger verwendet Nutzlast-Formatversion `2.0` und gibt den booleschen Wert zurück, da `enableSimpleResponses` auf `true` gesetzt ist.
```
"securitySchemes" : {
"lambda-authorizer" : {
"type" : "apiKey",
"name" : "Authorization",
"in" : "header",
"x-amazon-apigateway-authorizer" : {
"type" : "request",
"identitySource" : "$request.header.Authorization",
"authorizerUri" : "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:function-name/invocations",
"authorizerPayloadFormatVersion" : "2.0",
"authorizerResultTtlInSeconds" : 300,
"enableSimpleResponses" : true
}
}
}
```
# x-amazon-apigateway-authtype Eigentum
Für REST kann diese Erweiterung verwendet werden APIs, um einen benutzerdefinierten Typ eines Lambda-Autorisierers zu definieren. In diesem Fall liegt der Wert in Freiform vor. Beispielsweise kann eine API mehrere Lambda-Genehmiger haben, die verschiedene interne Schemata verwenden. Sie können diese Erweiterung verwenden, um das interne Schema eines Lambda-Genehmigers zu identifizieren.
In HTTP APIs und REST kann sie häufiger auch verwendet werden APIs, um die IAM-Autorisierung für mehrere Operationen zu definieren, die dasselbe Sicherheitsschema verwenden. In diesem Fall ist der Begriff `awsSigv4` ein reservierter Begriff, zusammen mit jedem Begriff, dem ein Präfix `aws` vorangestellt ist.
Diese Erweiterung gilt für das Sicherheitsschema des Typs `apiKey` in [OpenAPI 2](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#security-scheme-object) und [OpenAPI 3](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.1.md#security-scheme-object).
## x-amazon-apigateway-authtype Beispiel
Das folgende OpenAPI 3-Beispiel definiert die IAM-Genehmigung für mehrere Ressourcen in einer REST-API oder HTTP API:
```
{
"openapi" : "3.0.1",
"info" : {
"title" : "openapi3",
"version" : "1.0"
},
"paths" : {
"/operation1" : {
"get" : {
"responses" : {
"default" : {
"description" : "Default response"
}
},
"security" : [ {
"sigv4Reference" : [ ]
} ]
}
},
"/operation2" : {
"get" : {
"responses" : {
"default" : {
"description" : "Default response"
}
},
"security" : [ {
"sigv4Reference" : [ ]
} ]
}
}
},
"components" : {
"securitySchemes" : {
"sigv4Reference" : {
"type" : "apiKey",
"name" : "Authorization",
"in" : "header",
"x-amazon-apigateway-authtype": "awsSigv4"
}
}
}
}
```
Das folgende OpenAPI 3-Beispiel definiert einen Lambda-Genehmiger mit einem benutzerdefinierten Schema für eine REST-API:
```
{
"openapi" : "3.0.1",
"info" : {
"title" : "openapi3 for REST API",
"version" : "1.0"
},
"paths" : {
"/protected-by-lambda-authorizer" : {
"get" : {
"responses" : {
"200" : {
"description" : "Default response"
}
},
"security" : [ {
"myAuthorizer" : [ ]
} ]
}
}
},
"components" : {
"securitySchemes" : {
"myAuthorizer" : {
"type" : "apiKey",
"name" : "Authorization",
"in" : "header",
"x-amazon-apigateway-authorizer" : {
"identitySource" : "method.request.header.Authorization",
"authorizerUri" : "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:account-id:function:function-name/invocations",
"authorizerResultTtlInSeconds" : 300,
"type" : "request",
"enableSimpleResponses" : false
},
"x-amazon-apigateway-authtype": "Custom scheme with corporate claims"
}
}
},
"x-amazon-apigateway-importexport-version" : "1.0"
}
```
## Weitere Informationen finden Sie auch unter
[authorizer.authType](https://docs.aws.amazon.com/apigateway/latest/api/API_Authorizer.html#apigw-Type-Authorizer-authType)
# x-amazon-apigateway-binaryEigenschaft -media-types
Gibt die Liste der binären Medientypen an, die von API Gateway unterstützt werden sollen, z. B. `application/octet-stream` und `image/jpeg`. Diese Erweiterung ist ein JSON-Array. Dies sollte als Top-Level-Erweiterung des Herstellers im OpenAPI-Dokument eingeschlossen werden.
## x-amazon-apigateway-binaryBeispiel für -Medientypen
Das folgende Beispiel zeigt die Codierungs-Suchreihenfolge einer API.
```
"x-amazon-apigateway-binary-media-types": [ "application/octet", "image/jpeg" ]
```
# x-amazon-apigateway-documentation Objekt
Definiert die Dokumentationsteile, die in API Gateway importiert werden sollen. Dieses Objekt ist ein JSON-Objekt, das ein Array der `DocumentationPart`-Instances enthält.
| Eigenschaftenname | Typ | Beschreibung |
| --- | --- | --- |
| documentationParts | Array | Ein Array der exportierten oder importierten `DocumentationPart`-Instances. |
| version | String | Die Versions-ID des Snapshots der exportierten Dokumentationsbausteine. |
## x-amazon-apigateway-documentation Beispiel
Das folgende Beispiel einer API Gateway-Erweiterung für OpenAPI definiert `DocumentationParts`-Instances, die in eine API in API Gateway importiert oder von einer API in API Gateway exportiert werden sollen.
```
{ ...
"x-amazon-apigateway-documentation": {
"version": "1.0.3",
"documentationParts": [
{
"location": {
"type": "API"
},
"properties": {
"description": "API description",
"info": {
"description": "API info description 4",
"version": "API info version 3"
}
}
},
{
… // Another DocumentationPart instance
}
]
}
}
```
# x-amazon-apigateway-endpoint-Zugriffsmodus
Gibt den Endpunktzugriffsmodus für eine REST-API oder einen benutzerdefinierten Domainnamen an. Weitere Informationen zum Endpunktzugriffsmodus finden Sie unter[Endpunktzugriffsmodus](apigateway-security-policies.md#apigateway-security-policies-endpoint-access-mode).
## `x-amazon-apigateway-endpoint-access-mode`Beispiel für
Im folgenden Beispiel wird der Endpunktzugriffsmodus auf Strict festgelegt.
```
"x-amazon-apigateway-endpoint-access-mode": "STRICT"
```
# x-amazon-apigateway-endpoint-Konfigurationsobjekt
Gibt Details der Endpunktkonfiguration für eine API an. Diese Erweiterung ist eine erweiterte Eigenschaft des Objekts [OpenAPI-Operation](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.0.md#operation-object). Dieses Objekt sollte in [Top-Level-Anbietererweiterungen](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#specification-extensions) für Swagger 2.0 vorhanden sein. Für OpenAPI 3.0 sollte es unter den Anbietererweiterungen des [Server-Objekts](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.0.md#server-object) vorhanden sein.
| Eigenschaftenname | Typ | Beschreibung |
| --- | --- | --- |
| disableExecuteApiEndpoint | Boolesch | Gibt an, ob Clients Ihre API mithilfe des `execute-api`-Standardendpunkts aufrufen können. Standardmäßig können Kunden Ihre API mit dem standardmäßigen `https://{api_id}.execute-api.{region}.amazonaws.com`-Endpunkt aufrufen. Wenn Sie erzwingen möchten, dass Kunden einen benutzerdefinierten Domänennamen verwenden, um Ihre API aufzurufen, geben Sie a `true`. |
| vpcEndpointIds | Ein Array von String | Eine Liste von VpcEndpoint Bezeichnern, anhand derer Route 53-Aliaseinträge für eine REST-API erstellt werden sollen. Es wird nur für REST, APIs den `PRIVATE` Endpunkttyp, unterstützt. |
| ipAddressType | string | Die IP-Adresstypen, die eine HTTP-API aufrufen können. Wird verwendet`ipv4`, damit IPv4 Adresstypen eine HTTP-API aufrufen können. Wird verwendet`dualstack`, um Typen das Aufrufen einer HTTP-API zu ermöglichen IPv4 und zu IPv6 adressieren. Sie wird nur für HTTP APIs unterstützt. |
## x-amazon-apigateway-endpoint-Konfigurationsbeispiele
Im folgenden Beispiel werden die angegebenen VPC-Endpunkte der REST-API zugeordnet.
```
"x-amazon-apigateway-endpoint-configuration": {
"vpcEndpointIds": ["vpce-0212a4ababd5b8c3e", "vpce-01d622316a7df47f9"]
}
```
Das folgende Beispiel deaktiviert den Standardendpunkt für eine API.
```
"x-amazon-apigateway-endpoint-configuration": {
"disableExecuteApiEndpoint": true
}
```
Das folgende Beispiel legt den IP-Adresstyp für eine HTTP-API auf Dualstack fest.
```
"x-amazon-apigateway-endpoint-configuration": {
"ipAddressType": "dualstack"
}
```
# x-amazon-apigateway-gatewayObjekt -Responses
Definiert die Gateway-Antworten für eine API als eine String-zu-Zuordnung von [GatewayResponse](https://docs.aws.amazon.com/apigateway/latest/api/API_GatewayResponse.html)Schlüssel-Wert-Paaren. Die Erweiterung gilt für die OpenAPI-Struktur auf Stammebene.
| Name der Eigenschaft | Typ | Description |
| --- | --- | --- |
| responseType | [x-amazon-apigateway-gateway-responses.GatewayResponse](api-gateway-swagger-extensions-gateway-responses.gatewayResponse.md) | A für den angegebenen. `GatewayResponse` *responseType* |
## x-amazon-apigateway-gatewayBeispiel für -Antworten
Die folgende API Gateway Gateway-Erweiterung für das OpenAPI-Beispiel definiert eine [GatewayResponses](https://docs.aws.amazon.com/apigateway/latest/api/API_GetGatewayResponses.html)Map, die zwei [GatewayResponse](https://docs.aws.amazon.com/apigateway/latest/api/API_GatewayResponse.html)Instanzen enthält — eine für den `DEFAULT_4XX` Typ und eine weitere für den Typ. `INVALID_API_KEY`
```
{
"x-amazon-apigateway-gateway-responses": {
"DEFAULT_4XX": {
"responseParameters": {
"gatewayresponse.header.Access-Control-Allow-Origin": "'domain.com'"
},
"responseTemplates": {
"application/json": "{\"message\": test 4xx b }"
}
},
"INVALID_API_KEY": {
"statusCode": "429",
"responseTemplates": {
"application/json": "{\"message\": test forbidden }"
}
}
}
}
```
# x-amazon-apigateway-gateway-Responses.GatewayResponse-Objekt
Definiert eine Gateway-Antwort eines bestimmten Antworttyps, einschließlich des Statuscodes, sämtlicher geltender Antwortparameter oder Antwortvorlagen.
| Eigenschaftenname | Typ | Description |
| --- | --- | --- |
| responseParameters | [x-amazon-apigateway-gateway-Responses.Response-Parameter](api-gateway-swagger-extensions-gateway-responses.responseParameters.md) | Spezifiziert die Parameter, nämlich die [GatewayResponse](https://docs.aws.amazon.com/apigateway/latest/api/API_GatewayResponse.html)Header-Parameter. Die Parameterwerte können jeden beliebigen eingehenden [request parameter](rest-api-parameter-mapping.md)-Wert oder einen statischen benutzerdefinierten Wert übernehmen. |
| responseTemplates | [x-amazon-apigateway-gateway-Responses.ResponseTemplates](api-gateway-swagger-extensions-gateway-responses.responseTemplates.md) | Gibt die Mapping-Vorlagen der Gateway-Antwort an. Die Vorlagen werden nicht von der VTL-Engine verarbeitet. |
| statusCode | string | Ein HTTP-Statuscode für die Gateway-Antwort. |
## x-amazon-apigateway-gateway-Responses.GatewayResponse-Beispiel
Das folgende Beispiel für die API Gateway Gateway-Erweiterung für OpenAPI definiert, [GatewayResponse](https://docs.aws.amazon.com/apigateway/latest/api/API_GatewayResponse.html)dass die `INVALID_API_KEY` Antwort so angepasst werden soll, dass sie den Statuscode von`456`, den `api-key` Header-Wert der eingehenden Anfrage und eine `"Bad api-key"` Nachricht zurückgibt.
```
"INVALID_API_KEY": {
"statusCode": "456",
"responseParameters": {
"gatewayresponse.header.api-key": "method.request.header.api-key"
},
"responseTemplates": {
"application/json": "{\"message\": \"Bad api-key\" }"
}
}
```
# x-amazon-apigateway-gateway-Responses.ResponseParameters-Objekt
Definiert eine string-to-string Zuordnung von Schlüssel-Wert-Paaren, um Gateway-Antwortparameter aus den eingehenden Anforderungsparametern oder unter Verwendung von Literalzeichenfolgen zu generieren. Wird nur für REST unterstützt. APIs
| Name der Eigenschaft | Typ | Beschreibung |
| --- | --- | --- |
| gatewayresponse.param-position.param-name | string | `param-position` kann `header`, `path` oder `querystring` sein. Weitere Informationen finden Sie unter [Parameterzuordnung für REST APIs in API Gateway](rest-api-parameter-mapping.md). |
## x-amazon-apigateway-gateway-Responses.ResponseParameters — Beispiel
Das folgende Beispiel für OpenAPI-Erweiterungen zeigt einen Ausdruck für die Zuordnung von [GatewayResponse](https://docs.aws.amazon.com/apigateway/latest/api/API_GatewayResponse.html)Antwortparametern, um die CORS-Unterstützung für Ressourcen auf den `*.example.domain` Domänen zu aktivieren.
```
"responseParameters": {
"gatewayresponse.header.Access-Control-Allow-Origin": '*.example.domain',
"gatewayresponse.header.from-request-header" : method.request.header.Accept,
"gatewayresponse.header.from-request-path" : method.request.path.petId,
"gatewayresponse.header.from-request-query" : method.request.querystring.qname
}
```
# x-amazon-apigateway-gateway-Responses.ResponseTemplates-Objekt
Definiert [GatewayResponse](https://docs.aws.amazon.com/apigateway/latest/api/API_GatewayResponse.html)Zuordnungsvorlagen als string-to-string Zuordnung von Schlüssel-Wert-Paaren für eine bestimmte Gateway-Antwort. Für jedes Schlüssel-Wert-Paar ist der Schlüssel der Inhaltstyp. Zum Beispiel ist "application/json" und der Wert eine "stringify"-Mapping-Vorlage für einfache Variablenersetzungen. Eine `GatewayResponse`-Mapping-Vorlage wird nicht vom [Velocity Template Language (VTL)](https://velocity.apache.org/engine/devel/vtl-reference.html)-Modul verarbeitet.
| Eigenschaftenname | Typ | Beschreibung |
| --- | --- | --- |
| content-type | string | Eine `GatewayResponse`-Text-Mapping-Vorlage, die nur einfache Variablenersetzungen unterstützt, um einen Gateway-Antworttext anzupassen. |
## x-amazon-apigateway-gateway-Responses.ResponseTemplates — Beispiel
Das folgende Beispiel für OpenAPI-Erweiterungen zeigt eine [GatewayResponse](https://docs.aws.amazon.com/apigateway/latest/api/API_GatewayResponse.html)Mapping-Vorlage zum Anpassen einer vom API Gateway generierten Fehlerantwort in ein anwendungsspezifisches Format.
```
"responseTemplates": {
"application/json": "{ \"message\": $context.error.messageString, \"type\":$context.error.responseType, \"statusCode\": '488' }"
}
```
Das folgende Beispiel für OpenAPI-Erweiterungen zeigt eine [GatewayResponse](https://docs.aws.amazon.com/apigateway/latest/api/API_GatewayResponse.html)Mapping-Vorlage zum Überschreiben einer vom API Gateway generierten Fehlerantwort mit einer statischen Fehlermeldung.
```
"responseTemplates": {
"application/json": "{ \"message\": 'API-specific errors' }"
}
```
# x-amazon-apigateway-importexport-Version
Gibt die Version des API Gateway Gateway-Import- und Exportalgorithmus für HTTP an APIs. Derzeit wird als einziger Wert unterstütz `1.0`. Weitere Informationen finden Sie unter [exportVersion](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-exports-specification.html#w125aab9c10b3b1b4) in der *API Gateway Version 2 API-Referenz*.
## x-amazon-apigateway-importexportBeispiel für eine Version
Im folgenden Beispiel wird die Import- und Exportversion auf festgeleg `1.0`.
```
{
"openapi": "3.0.1",
"x-amazon-apigateway-importexport-version": "1.0",
"info": { ...
```
# x-amazon-apigateway-integration Objekt
Gibt die Details der für diese Methode verwendeten Backend-Integration an. Diese Erweiterung ist eine erweiterte Eigenschaft des Objekts [OpenAPI-Operation](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#operation-object). Das Ergebnis ist ein [API Gateway-Integration](https://docs.aws.amazon.com/apigateway/latest/api/API_Integration.html)-Objekt.
| Eigenschaftenname | Typ | Beschreibung |
| --- | --- | --- |
| cacheKeyParameters | Ein Array von string | Eine Liste an Anforderungsparametern, deren Werte zwischengespeichert werden sollen. |
| cacheNamespace | string | Eine API-spezifische Tag-Gruppe zugehöriger zwischengespeicherter Parameter. |
| connectionId | string | Die ID von a [VpcLink](https://docs.aws.amazon.com/apigateway/latest/api/API_VpcLink.html)für die private Integration. |
| connectionType | string | Der Verbindungstyp der Integration. Der gültige Wert ist "VPC\$1LINK" für die private Integration oder andernfalls "INTERNET". |
| credentials | string | Geben Sie für rollenbasierte AWS IAM-Anmeldeinformationen den ARN einer entsprechenden IAM-Rolle an. Wenn sie nicht angegeben sind, werden als Anmeldeinformationen standardmäßig ressourcenbasierte Berechtigungen festgelegt, die manuell hinzugefügt werden, damit die API auf die Ressource zugreifen kann. Weitere Informationen finden Sie unter [Gewähren von Berechtigungen mit einer Ressourcenrichtlinie](https://docs.aws.amazon.com/lambda/latest/dg/lambda-permissions.html#intro-permission-model-access-policy). Hinweis: Stellen Sie bei der Verwendung von IAM-Anmeldeinformationen sicher, dass [regionale AWS -STS-Endpunkte](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html) für die Region aktiviert sind, in der diese API für maximale Leistung bereitgestellt wird. |
| contentHandling | string | Fordern Sie Nutzlast-Kodierungs-Umwandlungstypen an. Gültige Werte sind 1) CONVERT\$1TO\$1TEXT für die Umwandlung einer binären Nutzlast in eine base64-kodierte Zeichenfolge oder die Umwandlung einer Textnutzlast in eine utf-8-kodierte Zeichenfolge oder die native Weiterleitung der Textnutzlast ohne Änderung und 2) CONVERT\$1TO\$1BINARY für die Umwandlung einer Textnutzlast in einen base64-dekodierten Blob oder die native Weiterleitung einer binären Nutzlast ohne Änderung. |
| httpMethod | string | Die in der Integrationsanforderung verwendete HTTP-Methode. Für Lambda-Funktionsaufrufe muss der Wert sei POST. |
| integrationSubtype | string | Gibt den Integrationsuntertyp für eine Serviceintegration an. AWS Wird nur für HTTP APIs unterstützt. Unterstützte Integration-Subtypen finden Sie unter [Integration-Subtypreferenz](http-api-develop-integrations-aws-services-reference.md). |
| integrationTarget | string | Der ALB- oder NLB-Listener, an den die Anfrage gesendet werden soll. Wird nur für private Integrationen unterstützt, die VPC-Links V2 verwenden. Weitere Informationen finden Sie unter [VPC-Links V2 im API Gateway einrichten](apigateway-vpc-links-v2.md). |
| passthroughBehavior | string | Gibt an, wie eine Anforderungsnutzlast eines nicht zugeordneten Inhaltstyps unverändert an die Integrationsanforderung weitergeleitet wurde. Unterstützte Werte sind when\$1no\$1templates, when\$1no\$1match und never. Weitere Informationen finden Sie unter [Integration.passthroughBehavior](https://docs.aws.amazon.com/apigateway/latest/api/API_Integration.html#passthroughBehavior). |
| payloadFormatVersion | string | Gibt das Format der an eine Integration gesendeten Nutzlast an. Für HTTP erforderlich. APIs Für HTTP sind APIs die unterstützten Werte für Lambda-Proxyintegrationen 1.0 und. 2.0 Für alle anderen Integrationen ist 1.0 der einzige unterstützte Wert. Weitere Informationen hierzu finden Sie unter [Erstellen Sie AWS Lambda Proxy-Integrationen für HTTP APIs in API Gateway](http-api-develop-integrations-lambda.md) und [Integration-Subtypreferenz](http-api-develop-integrations-aws-services-reference.md). |
| requestParameters | [x-amazon-apigateway-integration.RequestParameters Objekt](api-gateway-swagger-extensions-integration-requestParameters.md) | Gibt für REST APIs Zuordnungen von Methodenanforderungsparametern zu Integrationsanforderungsparametern an. Die unterstützten Anforderungsparameter sind `querystring`, `path`, `header` und `body`. Für HTTP sind Anforderungsparameter eine Schlüssel-Wert-Zuordnung APIs, die Parameter spezifiziert, die an `AWS_PROXY` Integrationen mit einem bestimmten Wert übergeben werden. `integrationSubtype` Sie können statische Werte angeben oder Anforderungsdaten, Stufenvariablen oder Kontextvariablen zuordnen, die zur Laufzeit ausgewertet werden. Weitere Informationen hierzu finden Sie unter [Erstellen Sie AWS Dienstintegrationen für HTTP APIs in API Gateway](http-api-develop-integrations-aws-services.md). |
| requestTemplates | [x-amazon-apigateway-integration.requestTemplates-Objekt](api-gateway-swagger-extensions-integration-requestTemplates.md) | Mapping-Vorlagen für eine Anforderungsnutzlast angegebener MIME-Typen. |
| responses | [x-amazon-apigateway-integration.responses-Objekt](api-gateway-swagger-extensions-integration-responses.md) | Definiert die Antworten der Methode und gibt gewünschte Parameter-Mappings oder Nutzlast-Mappings von Integrationsantworten auf Methodenantworten an. |
| responseTransferMode | string | Der Antwortübertragungsmodus der Integration. Wird verwendetBUFFERED, damit API Gateway auf den Empfang der vollständigen Antwort wartet, bevor es mit der Übertragung beginnt. Wird verwendetSTREAM, damit API Gateway Teilantworten an den Client zurücksendet, sobald sie verfügbar sind. Weitere Informationen hierzu finden Sie unter [Streamen Sie die Integrationsantwort für Ihre Proxy-Integrationen in API Gateway](response-transfer-mode.md). |
| timeoutInMillis | integer | Integrationszeitüberschreitungen zwischen 50 ms und 29.000 ms. |
| type | string | Der Typ der Integration mit dem angegebenen Backend. Folgende Werte sind zulässig: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/api-gateway-swagger-extensions-integration.html) Weitere Informationen über die Integrationstypen finden Sie unter [integration:type](https://docs.aws.amazon.com/apigateway/latest/api/API_Integration.html#type). |
| tlsConfig | [x-amazon-apigateway-integration.tlsConfig-Objekt](api-gateway-extensions-integration-tls-config.md) | Gibt die TLS-Konfiguration für eine Integration an. |
| uri | string | Die Endpunkt-URI des Backends. Für Integrationen des aws-Typs ist es ein ARN-Wert. Für die HTTP-Integration ist dies die URL des HTTP-Endpunkts einschließlich des https- oder http-Schemas. |
## x-amazon-apigateway-integration Beispiele
Für HTTP APIs können Sie Integrationen im Komponentenbereich Ihrer OpenAPI-Definition definieren. Weitere Informationen hierzu finden Sie unter [x-amazon-apigateway-integrations Objekt](api-gateway-extensions-integrations.md).
```
"x-amazon-apigateway-integration": {
"$ref": "#/components/x-amazon-apigateway-integrations/integration1"
}
```
Im folgenden Beispiel wird eine Integration mit einer Lambda-Funktion erstellt. Zu Demonstrationszwecken wird für die Beispiel-Mapping-Vorlagen, die in `requestTemplates` und `responseTemplates` der Beispiele unten gezeigt werden, angenommen, dass die folgenden JSON-formatierten Nutzlasten angewendet werden: `{ "name":"value_1", "key":"value_2", "redirect": {"url" :"..."} }` zur Generierung einer JSON-Ausgabe von `{ "stage":"value_1", "user-id":"value_2" }` oder einer XML-Ausgabe von `value_1`.
```
"x-amazon-apigateway-integration" : {
"type" : "aws",
"uri" : "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:012345678901:function:HelloWorld/invocations",
"httpMethod" : "POST",
"credentials" : "arn:aws:iam::012345678901:role/apigateway-invoke-lambda-exec-role",
"requestTemplates" : {
"application/json" : "#set ($root=$input.path('$')) { \"stage\": \"$root.name\", \"user-id\": \"$root.key\" }",
"application/xml" : "#set ($root=$input.path('$')) $root.name "
},
"requestParameters" : {
"integration.request.path.stage" : "method.request.querystring.version",
"integration.request.querystring.provider" : "method.request.querystring.vendor"
},
"cacheNamespace" : "cache namespace",
"cacheKeyParameters" : [],
"responses" : {
"2\\d{2}" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.requestId" : "integration.response.header.cid"
},
"responseTemplates" : {
"application/json" : "#set ($root=$input.path('$')) { \"stage\": \"$root.name\", \"user-id\": \"$root.key\" }",
"application/xml" : "#set ($root=$input.path('$')) $root.name "
}
},
"302" : {
"statusCode" : "302",
"responseParameters" : {
"method.response.header.Location" : "integration.response.body.redirect.url"
}
},
"default" : {
"statusCode" : "400",
"responseParameters" : {
"method.response.header.test-method-response-header" : "'static value'"
}
}
}
}
```
Beachten Sie, dass doppelte Anführungszeichen (") für die JSON-Zeichenfolge in den Mapping-Vorlagen durch einen umgekehrten Schrägstrich (\$1") geschützt sein müssen.
# x-amazon-apigateway-integrations Objekt
Definiert eine Sammlung von Integrationen. Sie können Integrationen im Komponentenbereich Ihrer OpenAPI-Definition definieren und die Integrationen für mehrere Routen wiederverwenden. Wird nur für HTTP unterstützt APIs.
| Name der Eigenschaft | Typ | Description |
| --- | --- | --- |
| integration | [x-amazon-apigateway-integration Objekt](api-gateway-swagger-extensions-integration.md) | Eine Sammlung von Integrationsobjekten. |
## x-amazon-apigateway-integrations Beispiel
Im folgenden Beispiel wird eine HTTP-API erstellt, die zwei Integrationen definiert und die Integrationen über referenzier `$ref": "#/components/x-amazon-apigateway-integrations/integration-name`.
```
{
"openapi": "3.0.1",
"info":
{
"title": "Integrations",
"description": "An API that reuses integrations",
"version": "1.0"
},
"servers": [
{
"url": "https://example.com/{basePath}",
"description": "The production API server",
"variables":
{
"basePath":
{
"default": "example/path"
}
}
}],
"paths":
{
"/":
{
"get":
{
"x-amazon-apigateway-integration":
{
"$ref": "#/components/x-amazon-apigateway-integrations/integration1"
}
}
},
"/pets":
{
"get":
{
"x-amazon-apigateway-integration":
{
"$ref": "#/components/x-amazon-apigateway-integrations/integration1"
}
}
},
"/checkout":
{
"get":
{
"x-amazon-apigateway-integration":
{
"$ref": "#/components/x-amazon-apigateway-integrations/integration2"
}
}
}
},
"components": {
"x-amazon-apigateway-integrations":
{
"integration1":
{
"type": "aws_proxy",
"httpMethod": "POST",
"uri": "arn:aws:apigateway:us-east-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-2:123456789012:function:my-function/invocations",
"passthroughBehavior": "when_no_templates",
"payloadFormatVersion": "1.0"
},
"integration2":
{
"type": "aws_proxy",
"httpMethod": "POST",
"uri": "arn:aws:apigateway:us-east-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-2:123456789012:function:example-function/invocations",
"passthroughBehavior": "when_no_templates",
"payloadFormatVersion" : "1.0"
}
}
}
}
```
# x-amazon-apigateway-integration.requestTemplates-Objekt
Gibt die Mapping-Vorlagen für eine Anforderungsnutzlast der angegebenen MIME-Typen an.
| Eigenschaftenname | Typ | Beschreibung |
| --- | --- | --- |
| MIME type | string | Ein Beispiel für den MIME-Typ ist `application/json`. Weitere Informationen zum Erstellen einer Mapping-Vorlage finden Sie unter [Zuordnen von Vorlagentransformationen für REST APIs in API Gateway](models-mappings.md). |
## x-amazon-apigateway-integration.requestTemplates Beispiel
Im folgenden Beispiel werden Mapping-Vorlagen für eine Anforderungsnutzlast der `application/json`- und `application/xml`-MIME-Typen festgelegt.
```
"requestTemplates" : {
"application/json" : "#set ($root=$input.path('$')) { \"stage\": \"$root.name\", \"user-id\": \"$root.key\" }",
"application/xml" : "#set ($root=$input.path('$')) $root.name "
}
```
# x-amazon-apigateway-integration.RequestParameters Objekt
Gibt für REST APIs Zuordnungen von benannten Methodenanforderungsparametern zu Integrationsanforderungsparametern an. Die Methodenanforderungsparameter müssen definiert werden, bevor auf sie verwiesen wird.
Gibt für HTTP Parameter an APIs, die an `AWS_PROXY` Integrationen mit einem bestimmten Wert übergeben werden. `integrationSubtype`
| Name der Eigenschaft | Typ | Description |
| --- | --- | --- |
| integration.request.. | string | Für REST APIs ist der Wert in der Regel ein vordefinierter Methodenanforderungsparameter des `method.request..` Formats, wobei`querystring`, `path``header`, oder `body` sein `` kann. `$context.VARIABLE_NAME`, `$stageVariables.VARIABLE_NAME` und `STATIC_VALUE` sind jedoch ebenfalls gültig. Für den `body`-Parameter ist der `` ein JSON-Pfadausdruck ohne das `$.`-Präfix. |
| parameter | string | Für HTTP sind Anforderungsparameter eine Key-Value-Map APIs, die Parameter spezifiziert, die an `AWS_PROXY` Integrationen mit einem bestimmten Wert übergeben werden. `integrationSubtype` Sie können statische Werte angeben oder Anforderungsdaten, Stufenvariablen oder Kontextvariablen zuordnen, die zur Laufzeit ausgewertet werden. Weitere Informationen hierzu finden Sie unter [Erstellen Sie AWS Dienstintegrationen für HTTP APIs in API Gateway](http-api-develop-integrations-aws-services.md). |
## `x-amazon-apigateway-integration.requestParameters`Beispiel für
Im folgenden Beispiel für Anforderungsparameter-Mappings werden die Abfrage- (`version`), Header- (`x-user-id`) und Pfad- (`service`) Parameter einer Methodenanforderung in die Abfrage- (`stage`), Header- (`x-userid`) und Pfad- (`op`) Parameter der Integrationsanforderung übersetzt.
**Anmerkung**
Wenn Sie Ressourcen über OpenAPI oder erstellen CloudFormation, sollten statische Werte in einfache Anführungszeichen gesetzt werden.
Um diesen Wert über die Konsole hinzuzufügen, geben Sie `application/json` ohne Anführungszeichen in das Feld ein.
```
"requestParameters" : {
"integration.request.querystring.stage" : "method.request.querystring.version",
"integration.request.header.x-userid" : "method.request.header.x-user-id",
"integration.request.path.op" : "method.request.path.service"
},
```
# x-amazon-apigateway-integration.responses-Objekt
Definiert die Antworten der Methode und gibt Parameter-Mappings oder Nutzlast-Mappings von Integrationsantworten auf Methodenantworten an.
| Eigenschaftenname | Typ | Description |
| --- | --- | --- |
| Response status pattern | [x-amazon-apigateway-integration.response-Objekt](api-gateway-swagger-extensions-integration-response.md) | Entweder ein regulärer Ausdruck, der verwendet wird, um die Integrationsantwort mit der Methodenantwort abzugleichen, oder `default`, um eine Antwort zu erfassen, die noch nicht konfiguriert wurde. Für HTTP-Integrationen gilt der Regex für den Integrationsantwort-Statuscode. Bei Lambda-Aufrufen gilt der reguläre Ausdruck für das `errorMessage` Feld des Fehlerinformationsobjekts, das AWS Lambda als Fehlerantworttext zurückgegeben wird, wenn die Ausführung der Lambda-Funktion eine Ausnahme auslöst. Der *Response status pattern* Eigenschaftsname bezieht sich auf einen Antwortstatuscode oder einen regulären Ausdruck, der eine Gruppe von Antwortstatuscodes beschreibt. Es entspricht keinem Bezeichner einer [IntegrationResponse](https://docs.aws.amazon.com/apigateway/latest/api/API_IntegrationResponse.html)Ressource in der API Gateway REST API. |
## `x-amazon-apigateway-integration.responses`Beispiel für
Im folgenden Beispiel wird eine Liste mit Antworten von `2xx`- und `302`-Antworten gezeigt. Für die `2xx`-Antwort wird die Methodenantwort von der Nutzlast der Integrationsantwort des `application/json`- oder `application/xml`-MIME-Typs zugeordnet. Diese Antwort verwendet die bereitgestellten Mapping-Vorlagen. Für die `302`-Antwort gibt die Methodenantwort einen `Location`-Header zurück, dessen Wert von der `redirect.url`-Eigenschaft auf der Nutzlast der Integrationsantwort abgerufen wird.
```
"responses" : {
"2\\d{2}" : {
"statusCode" : "200",
"responseTemplates" : {
"application/json" : "#set ($root=$input.path('$')) { \"stage\": \"$root.name\", \"user-id\": \"$root.key\" }",
"application/xml" : "#set ($root=$input.path('$')) $root.name "
}
},
"302" : {
"statusCode" : "302",
"responseParameters" : {
"method.response.header.Location": "integration.response.body.redirect.url"
}
}
}
```
# x-amazon-apigateway-integration.response-Objekt
Definiert eine Antwort und gibt Parameter-Mappings oder Nutzlast-Mappings aus der Integrationsantwort in die Methodenantwort an.
| Eigenschaftenname | Typ | Beschreibung |
| --- | --- | --- |
| statusCode | string | HTTP-Statuscode für die Methodenantwort, zum Beispiel, `"200"`. Dieser muss einer übereinstimmenden Antwort im [OpenAPI-Operation](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md#operation-object) `responses`-Feld entsprechen. |
| responseTemplates | [x-amazon-apigateway-integration.responseTemplates-Objekt](api-gateway-swagger-extensions-integration-responseTemplates.md) | Gibt MIME-typenspezifische Mapping-Vorlagen für die Nutzlast der Antwort an. |
| responseParameters | [x-amazon-apigateway-integration.responseParameters-Objekt](api-gateway-swagger-extensions-integration-responseParameters.md) | Gibt Parameter-Mappings für die Antwort an. Nur die `header`- und `body`-Parameter der Integrationsantwort können den `header`-Parametern der Methode zugeordnet werden. |
| contentHandling | string | Umwandlungstypen für Antwortnutzlastenkodierung. Gültige Werte sind 1) CONVERT\$1TO\$1TEXT für die Umwandlung einer binären Nutzlast in eine base64-kodierte Zeichenfolge oder die Umwandlung einer Textnutzlast in eine utf-8-kodierte Zeichenfolge oder die native Weiterleitung der Textnutzlast ohne Änderung und 2) CONVERT\$1TO\$1BINARY für die Umwandlung einer Textnutzlast in einen base64-dekodierten Blob oder die native Weiterleitung einer binären Nutzlast ohne Änderung. |
## `x-amazon-apigateway-integration.response`Beispiel für
Im folgenden Beispiel wird eine `302`-Antwort für die Methode definiert, die eine Nutzlast des `application/json`- oder `application/xml`-MIME-Typs vom Backend ableitet. Die Antwort verwendet die bereitgestellten Mapping-Vorlagen und gibt die Umleitungs-URL von der Integrationsantwort im `Location`-Header der Methode zurück.
```
{
"statusCode" : "302",
"responseTemplates" : {
"application/json" : "#set ($root=$input.path('$')) { \"stage\": \"$root.name\", \"user-id\": \"$root.key\" }",
"application/xml" : "#set ($root=$input.path('$')) $root.name "
},
"responseParameters" : {
"method.response.header.Location": "integration.response.body.redirect.url"
}
}
```
# x-amazon-apigateway-integration.responseTemplates-Objekt
Gibt die Mapping-Vorlagen für eine Antwortnutzlast der angegebenen MIME-Typen an.
| Eigenschaftenname | Typ | Beschreibung |
| --- | --- | --- |
| MIME type | string | Gibt eine Mapping-Vorlage an, um den Integrationsantworttext für einen bestimmten MIME-Typ in den Methodenantworttext umzuwandeln. Weitere Informationen zum Erstellen einer Mapping-Vorlage finden Sie unter [Zuordnen von Vorlagentransformationen für REST APIs in API Gateway](models-mappings.md). Ein Beispiel für das ist. *MIME type* `application/json` |
## x-amazon-apigateway-integration.responseTemplate-Beispiel
Im folgenden Beispiel werden Mapping-Vorlagen für eine Anforderungsnutzlast der `application/json`- und `application/xml`-MIME-Typen festgelegt.
```
"responseTemplates" : {
"application/json" : "#set ($root=$input.path('$')) { \"stage\": \"$root.name\", \"user-id\": \"$root.key\" }",
"application/xml" : "#set ($root=$input.path('$')) $root.name "
}
```
# x-amazon-apigateway-integration.responseParameters-Objekt
Gibt Mappings von Integrationsmethoden-Antwortparameter auf Methodenantwortparameter an. Sie können `header`, `body` oder statische Werte dem `header`-Typ der Methodenantwort zuordnen. Wird nur für REST unterstützt. APIs
| Name der Eigenschaft | Typ | Description |
| --- | --- | --- |
| method.response.header. | string | Der benannte Parameterwert kann von den `header`- und `body`-Typen der Integrationsantwortparameter abgeleitet werden. |
## `x-amazon-apigateway-integration.responseParameters`Beispiel für
Im folgenden Beispiel werden der `body`- und `header`-Parameter der Integrationsantwort auf zwei `header`-Parameter der Methodenantwort zugewiesen.
```
"responseParameters" : {
"method.response.header.Location" : "integration.response.body.redirect.url",
"method.response.header.x-user-id" : "integration.response.header.x-userid"
}
```
# x-amazon-apigateway-integration.tlsConfig-Objekt
Gibt die TLS-Konfiguration für eine Integration an.
| Eigenschaftenname | Typ | Description |
| --- | --- | --- |
| insecureSkipVerification | Boolean | Wird nur für REST unterstützt. APIs Gibt an, ob API Gateway die Überprüfung der Ausstellung des Zertifikats für einen Integrationsendpunkt durch eine [unterstützte Zertifizierungsstelle](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-supported-certificate-authorities-for-http-endpoints.html) überspringt oder nicht. Dies wird nicht empfohlen, ermöglicht Ihnen aber, Zertifikate zu verwenden, die von privaten Zertifizierungsstellen signiert sind, oder Zertifikate, die selbstsigniert sind. Wenn diese Option aktiviert ist, führt API Gateway dennoch eine grundlegende Zertifikatüberprüfung durch, wobei Ablaufdatum, Hostname und das Vorhandensein einer Stammzertifizierungsstelle des Zertifikats geprüft werden. Das Stammzertifikat der privaten Behörde muss die folgenden Einschränkungen erfüllen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/api-gateway-extensions-integration-tls-config.html) Wird nur für `HTTP`- und `HTTP_PROXY`-Integrationen unterstützt. Aktivieren von `insecureSkipVerification` wird nicht empfohlen, insbesondere für Integrationen mit öffentlichen HTTPS-Endpunkten. Wenn Sie diese Option aktivieren`insecureSkipVerification`, erhöhen Sie das Risiko von man-in-the-middle Angriffen. |
| serverNameToVerify | string | Wird nur für private HTTP-API-Integrationen unterstützt. Wenn Sie einen Servernamen angeben, verwendet API Gateway diesen, um den Hostnamen auf dem Integrationszertifikat zu überprüfen. Der Servername ist auch im TLS-Handshake enthalten, um Server Name Indication (SNI, Servernamenanzeige) oder virtuelles Hosting zu unterstützen. |
## x-amazon-apigateway-integration.tlsConfig-Beispiele
Das folgende OpenAPI 3.0-Beispiel aktiviert `insecureSkipVerification` für eine REST-API HTTP-Proxy-Integration.
```
"x-amazon-apigateway-integration": {
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"responses": {
default": {
"statusCode": "200"
}
},
"passthroughBehavior": "when_no_match",
"httpMethod": "ANY",
"tlsConfig" : {
"insecureSkipVerification" : true
}
"type": "http_proxy",
}
```
Das folgende OpenAPI 3.0-Beispiel gibt einen `serverNameToVerify` für eine private HTTP-API-Integration an.
```
"x-amazon-apigateway-integration" : {
"payloadFormatVersion" : "1.0",
"connectionId" : "abc123",
"type" : "http_proxy",
"httpMethod" : "ANY",
"uri" : "arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/0467ef3c8400ae65",
"connectionType" : "VPC_LINK",
"tlsConfig" : {
"serverNameToVerify" : "example.com"
}
}
```
# x-amazon-apigateway-minimum-Kompressionsgröße
Gibt die minimale Komprimierungsgröße für eine REST-API an. Um die Komprimierung zu aktivieren, geben Sie eine ganze Zahl zwischen 0 und 10485760 an. Weitere Informationen hierzu finden Sie unter [Payload-Komprimierung für REST APIs in API Gateway](api-gateway-gzip-compression-decompression.md).
## x-amazon-apigateway-minimumBeispiel für eine Kompressionsgröße
Das folgende Beispiel gibt eine minimale Komprimierungsgröße von `5242880` Bytes für eine REST-API an.
```
"x-amazon-apigateway-minimum-compression-size": 5242880
```
# x-amazon-apigateway-policy
Gibt eine Ressourcen-Richtlinie für eine REST-API an. Weitere Informationen zu den Ressourcenrichtlinien finden Sie unter [Zugriff auf eine REST-API mit API Gateway-Ressourcenrichtlinien steuern](apigateway-resource-policies.md). Beispiele für Ressourcenrichtlinien finden Sie unter [Beispiele für API Gateway-Ressourcenrichtlinien](apigateway-resource-policies-examples.md).
## `x-amazon-apigateway-policy`Beispiel für
Das folgende Beispiel gibt eine Ressourcen-Richtlinie für eine REST-API an. Die Ressourcenrichtlinie verweigert (blockiert) eingehenden Datenverkehr von einem angegebenen Quell-IP-Adressblock an eine API. Wird beim Import unter Verwendung der aktuellen Region in Ihre AWS Konto-ID und die aktuelle REST-API-ID konvertiert. `"execute-api:/*"` `arn:aws:execute-api:region:account-id:api-id/*`
```
"x-amazon-apigateway-policy": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": [
"execute-api:/*"
]
},
{
"Effect": "Deny",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": [
"execute-api:/*"
],
"Condition" : {
"IpAddress": {
"aws:SourceIp": "192.0.2.0/24"
}
}
}
]
}
```
# x-amazon-apigateway-request-validator-Eigenschaft
Gibt eine Anforderungsvalidierung an, indem auf einen `request_validator_name` der [x-amazon-apigateway-request-validators-Objekt](api-gateway-swagger-extensions-request-validators.md)-Zuweisung verwiesen wird, um die Anforderungsvalidierung auf der enthaltenen API oder einer Methode zu aktivieren. Der Wert dieser Erweiterung ist eine JSON-Zeichenfolge.
Diese Erweiterung kann auf API-Ebene oder auf Methodenebene angegeben werden. Die Validierung auf API-Ebene gilt für alle Methoden, es sei denn, sie wird von der Validierung auf Methodenebene außer Kraft gesetzt.
## `x-amazon-apigateway-request-validator`Beispiel für
Im folgenden Beispiel wird die `basic`-Anforderungsvalidierung auf API-Ebene angewendet, während die `parameter-only`-Anforderungsvalidierung auf der `POST /validation`-Anforderung angewendet wird.
------
#### [ OpenAPI 2.0 ]
```
{
"swagger": "2.0",
"x-amazon-apigateway-request-validators" : {
"basic" : {
"validateRequestBody" : true,
"validateRequestParameters" : true
},
"params-only" : {
"validateRequestBody" : false,
"validateRequestParameters" : true
}
},
"x-amazon-apigateway-request-validator" : "basic",
"paths": {
"/validation": {
"post": {
"x-amazon-apigateway-request-validator" : "params-only",
...
}
}
```
------
# x-amazon-apigateway-request-validators-Objekt
Definiert die unterstützten Anforderungsvalidierungen für die enthaltene API als eine Zuweisung zwischen einem Validierungsnamen und den zugehörigen Anforderungsvalidierungsregeln. Diese Erweiterung gilt für eine REST-API.
| Eigenschaftenname | Typ | Beschreibung |
| --- | --- | --- |
| `request_validator_name` | [x-amazon-apigateway-request-Validators.RequestValidator-Objekt](api-gateway-swagger-extensions-request-validators.requestValidator.md) | Gibt die Validierungsregeln an, die aus der benannten Validierung bestehen. Zum Beispiel: "basic" : {
"validateRequestBody" : true,
"validateRequestParameters" : true
},
Um diese Validierung auf eine bestimmte Methode anzuwenden, muss der Validierungsname (`basic`) als der Wert der [x-amazon-apigateway-request-validator-Eigenschaft](api-gateway-swagger-extensions-request-validator.md)-Eigenschaft referenziert werden. |
## `x-amazon-apigateway-request-validators`Beispiel für
Das folgende Beispiel zeigt eine Reihe von Anforderungsvalidierungen für eine API als eine Zuweisung zwischen einem Validierungsnamen und den zugehörigen Anforderungsvalidierungsregeln.
------
#### [ OpenAPI 2.0 ]
```
{
"swagger": "2.0",
...
"x-amazon-apigateway-request-validators" : {
"basic" : {
"validateRequestBody" : true,
"validateRequestParameters" : true
},
"params-only" : {
"validateRequestBody" : false,
"validateRequestParameters" : true
}
},
...
}
```
------
# x-amazon-apigateway-request-Validators.RequestValidator-Objekt
Gibt die Validierungsregeln einer Anforderungsvalidierung als Teil der [x-amazon-apigateway-request-validators-Objekt](api-gateway-swagger-extensions-request-validators.md)-Zuweisungsdefinition an.
| Eigenschaftenname | Typ | Beschreibung |
| --- | --- | --- |
| `validateRequestBody` | Boolean | Gibt an, ob der Anforderungstext (`true`) oder nicht (`false`) validiert werden soll. |
| `validateRequestParameters` | Boolean | Gibt an, ob die erforderlichen Anforderungsparameter (`true`) oder nicht (`false`) validiert werden. |
## `x-amazon-apigateway-request-validators.requestValidator`Beispiel für
Das folgende Beispiel zeigt eine Anforderungsvalidierung nur für den Parameter:
```
"params-only": {
"validateRequestBody" : false,
"validateRequestParameters" : true
}
```
# x-amazon-apigateway-security-Richtlinie
Gibt eine Sicherheitsrichtlinie für eine REST-API an. Wenn Sie eine Sicherheitsrichtlinie erstellen, die mit beginnt`"SecurityPolicy_"`, müssen Sie auch den [Endpunktzugriffsmodus](openapi-extensions-endpoint-access-mode.md) festlegen. Weitere Informationen zu Sicherheitsrichtlinien finden Sie unter[Sicherheitsrichtlinien für REST APIs in API Gateway](apigateway-security-policies.md).
## `x-amazon-apigateway-security-policy`Beispiel für
Das folgende Beispiel spezifiziert `SecurityPolicy_TLS13_1_3_2025_0` für eine REST-API.
```
"x-amazon-apigateway-security-policy": "SecurityPolicy_TLS13_1_3_2025_09"
```
# x-amazon-apigateway-tagEigenschaft -value
Gibt den Wert eines [AWS -Tags](https://docs.aws.amazon.com/tag-editor/latest/userguide/tagging.html) für eine HTTP-API an. Sie können die `x-amazon-apigateway-tag-value` Eigenschaft als Teil des [OpenAPI-Tag-Objekts auf Stammebene verwenden, um AWS Tags für eine HTTP-API](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.0.md#tag-object) anzugeben. Wenn Sie einen Tag-Namen ohne die `x-amazon-apigateway-tag-value`-Eigenschaft angeben, erstellt API Gateway für einen Wert ein Tag mit einer leeren Zeichenfolge.
Weitere Informationen zum Taggen finden Sie unter [API Gateway-Ressourcen taggen](apigateway-tagging.md).
| Eigenschaftenname | Typ | Beschreibung |
| --- | --- | --- |
| `name` | String | Gibt den Tag-Schlüssel an. |
| `x-amazon-apigateway-tag-value` | String | Gibt den Tag-Wert an. |
## `x-amazon-apigateway-tag-value`Beispiel für
Das folgende Beispiel gibt zwei Tags für eine HTTP-API an:
+ "Owner": "Admin"
+ "Prod": ""
```
"tags": [
{
"name": "Owner",
"x-amazon-apigateway-tag-value": "Admin"
},
{
"name": "Prod"
}
]
```