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.
# Validierung für REST APIs in API Gateway anfordern
Sie können API Gateway so konfigurieren, dass es eine grundlegende Validierung einer API-Anfrage durchführt, bevor es mit der Integrationsanfrage fortfährt. Wenn die Validierung fehlschlägt, schlägt API Gateway die Anfrage sofort fehl, gibt eine 400-Fehlerantwort an den Aufrufer zurück und veröffentlicht die Überprüfungsergebnisse in CloudWatch Logs. Damit werden unnötige Aufrufe im Backend vermieden. Vor allem aber können Sie die Validierung so speziell auf die Anwendung ausrichten. Sie können einen Anforderungstext validieren, indem Sie überprüfen, ob die erforderlichen Anforderungsparameter gültig sind und nicht den Wert Null haben, oder indem Sie für komplexere Datenvalidierungen ein Modellschema angeben.
**Topics**
+ [Überblick über die grundlegende Anforderungsvalidierung in API Gateway](#api-gateway-request-validation-basic-definitions)
+ [Datenmodelle für REST APIs](models-mappings-models.md)
+ [Grundlegende Anforderungsvalidierung in API Gateway einrichten](api-gateway-request-validation-set-up.md)
+ [AWS CloudFormation Vorlage einer Beispiel-API mit grundlegender Anforderungsvalidierung](api-gateway-request-validation-sample-cloudformation.md)
## Überblick über die grundlegende Anforderungsvalidierung in API Gateway
API Gateway kann die grundlegende Anforderungsvalidierung durchführen, sodass Sie sich auf die anwendungsspezifische Validierung im Backend konzentrieren können. Für die grundlegende Validierung überprüft API Gateway eine oder beide der folgenden Bedingungen:
+ Die erforderlichen Anforderungsparameter in der URI, der Abfragezeichenfolge und dem Header einer eingehenden Anforderung sind vorhanden und nicht leer. API Gateway überprüft nur das Vorhandensein eines Parameters und nicht den Typ oder das Format.
+ Die entsprechenden Anforderungsnutzdaten entsprechen dem konfigurierten [JSON-Schema](https://datatracker.ietf.org/doc/html/draft-zyp-json-schema-04) der Methodenanforderung für einen bestimmten Inhaltstyp. Wenn kein passender Inhaltstyp gefunden wird, wird die Anforderungsvalidierung nicht durchgeführt. Um dasselbe Modell unabhängig vom Inhaltstyp zu verwenden, legen Sie den Inhaltstyp für Ihr Datenmodell auf `$default` fest.
Zum Aktivieren der grundlegenden Validierung legen Sie Validierungsregeln für eine [Anforderungsvalidierung](https://docs.aws.amazon.com/apigateway/latest/api/API_RequestValidator.html) fest, fügen diese dem [Schema der Anforderungsvalidierungen](https://docs.aws.amazon.com/apigateway/latest/api/API_RequestValidator.html) für die API hinzu und ordnen anschließend die Validierung den einzelnen API-Methoden zu.
**Anmerkung**
Das Anfordern einer Textüberprüfung an und [Verhalten bei Methodenanfragen für Payloads ohne Zuordnungsvorlagen für REST APIs in API Gateway](integration-passthrough-behaviors.md) sind zwei separate Themen. Wenn die Nutzlast einer Anforderung kein passendes Modellschema hat, können Sie Pass-Through wählen oder die ursprüngliche Nutzlast blockieren. Weitere Informationen finden Sie unter [Verhalten bei Methodenanfragen für Payloads ohne Zuordnungsvorlagen für REST APIs in API Gateway](integration-passthrough-behaviors.md).
# Datenmodelle für REST APIs
In API Gateway definiert ein Modell die Datenstruktur eines Payloads. In API Gateway werden Modelle unter Verwendung des [JSON-Schemaentwurfs 4](https://tools.ietf.org/html/draft-zyp-json-schema-04) definiert. Das folgende JSON-Objekt enthält Beispieldaten im Tierhandlungsbeispiel.
```
{
"id": 1,
"type": "dog",
"price": 249.99
}
```
Die Daten enthalten die `id`, den `type` und den `price` des Haustiers. Ein Modell dieser Daten ermöglicht Ihnen Folgendes:
+ Verwenden der grundlegenden Anforderungsvalidierung.
+ Erstellen von Zuweisungsvorlagen für die Datentransformation.
+ Erstellen eines benutzerdefinierten Datentyps (UDT), wenn Sie ein SDK generieren.
![\[Beispiel für ein JSON-Datenmodell für PetStore API.\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/how-to-validate-requests.png)
In diesem Modell gilt:
1. Das Objekt `$schema` stellt eine gültige JSON-Schema-Versionskennung dar. Dieses Schema ist der JSON-Schemaentwurf v4.
1. Das Objekt `title` ist eine lesbare Kennung des Modells. Dieser Titel ist `PetStoreModel`.
1. Das `required`-Validierungsschlüsselwort erfordert `type` und `price` für die grundlegende Anforderungsvalidierung.
1. Die `properties` des Modells sind `id`, `type` und `price`. Jedes Objekt hat Eigenschaften, die im Modell beschrieben werden.
1. Das Objekt `type` kann nur die Werte `dog`, `cat` oder `fish` haben.
1. Das Objekt `price` ist eine Zahl und auf einen `minimum`-Wert von 25 und einen `maximum`-Wert von 500 beschränkt.
## PetStore Modell
```
1 {
2 "$schema": "http://json-schema.org/draft-04/schema#",
3 "title": "PetStoreModel",
4 "type" : "object",
5 "required" : [ "price", "type" ],
6 "properties" : {
7 "id" : {
8 "type" : "integer"
9 },
10 "type" : {
11 "type" : "string",
12 "enum" : [ "dog", "cat", "fish" ]
13 },
14 "price" : {
15 "type" : "number",
16 "minimum" : 25.0,
17 "maximum" : 500.0
18 }
19 }
20 }
```
In diesem Modell gilt:
1. In Zeile 2 stellt das Objekt `$schema` eine gültige JSON-Schema-Versionskennung dar. Dieses Schema ist der JSON-Schemaentwurf v4.
1. In Zeile 3 ist das Objekt `title` eine lesbare Kennung des Modells. Dieser Titel ist `PetStoreModel`.
1. In Zeile 5 erfordert das `required` Validierungsschlüsselwort `type` und `price` für die grundlegende Anforderungsvalidierung.
1. In den Zeilen 6 bis 17 sind die `properties` des Modells `id` ,`type` und `price`. Jedes Objekt hat Eigenschaften, die im Modell beschrieben werden.
1. In Zeile 12 `type` kann das Objekt nur die Werte `dog`, `cat` oder `fish` haben.
1. In den Zeilen 14 bis 17 ist das Objekt `price` eine Zahl und durch einen `minimum`-Wert von 25 und einen `maximum`-Wert von 500 eingeschränkt.
## Erstellen komplexerer Modelle
Sie können das `$ref`-Primitiv verwenden, um wiederverwendbare Definitionen für längere Modelle zu erstellen. Sie können beispielsweise eine Definition mit der Bezeichnung `Price` im `definitions`-Abschnitt zur Beschreibung des `price`-Objekts erstellen. Der Wert von `$ref` ist die `Price`-Definition.
```
{
"$schema" : "http://json-schema.org/draft-04/schema#",
"title" : "PetStoreModelReUsableRef",
"required" : ["price", "type" ],
"type" : "object",
"properties" : {
"id" : {
"type" : "integer"
},
"type" : {
"type" : "string",
"enum" : [ "dog", "cat", "fish" ]
},
"price" : {
"$ref": "#/definitions/Price"
}
},
"definitions" : {
"Price": {
"type" : "number",
"minimum" : 25.0,
"maximum" : 500.0
}
}
}
```
Sie können auch auf ein anderes Modellschema verweisen, das in einer externen Modelldatei definiert ist. Stellen Sie den Wert der `$ref`-Eigenschaft auf die Position des Modells ein. Im folgenden Beispiel ist das `Price`-Modell im `PetStorePrice`-Modell in der API `a1234` definiert.
```
{
"$schema" : "http://json-schema.org/draft-04/schema#",
"title" : "PetStorePrice",
"type": "number",
"minimum": 25,
"maximum": 500
}
```
Das längere Modell kann auf das `PetStorePrice`-Modell verweisen.
```
{
"$schema" : "http://json-schema.org/draft-04/schema#",
"title" : "PetStoreModelReusableRefAPI",
"required" : [ "price", "type" ],
"type" : "object",
"properties" : {
"id" : {
"type" : "integer"
},
"type" : {
"type" : "string",
"enum" : [ "dog", "cat", "fish" ]
},
"price" : {
"$ref": "https://apigateway.amazonaws.com/restapis/a1234/models/PetStorePrice"
}
}
}
```
## Verwendung von Ausgabedatenmodellen
Wenn Sie Ihre Daten umwandeln, können Sie in der Integrationsantwort ein Nutzlastmodell definieren. Ein Nutzlastmodell kann verwendet werden, wenn Sie ein SDK generieren. Bei stark typisierten Sprachen wie Java, Objective-C oder Swift entspricht das Objekt einem benutzerdefinierten Datentyp (UDT). API Gateway erstellt eine UDT, wenn Sie ihm bei der Generierung eines SDK ein Datenmodell zur Verfügung stellen. Weitere Informationen zu Datentransformationen finden Sie unter [Zuordnen von Vorlagentransformationen für REST APIs in API Gateway](models-mappings.md).
Im folgenden Beispiel sehen Sie die Ausgabedaten einer Integrationsantwort.
```
{
[
{
"description" : "Item 1 is a dog.",
"askingPrice" : 249.99
},
{
"description" : "Item 2 is a cat.",
"askingPrice" : 124.99
},
{
"description" : "Item 3 is a fish.",
"askingPrice" : 0.99
}
]
}
```
Im folgenden Beispiel sehen Sie ein Payload-Modell, das die Ausgabedaten beschreibt.
```
{
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "PetStoreOutputModel",
"type" : "object",
"required" : [ "description", "askingPrice" ],
"properties" : {
"description" : {
"type" : "string"
},
"askingPrice" : {
"type" : "number",
"minimum" : 25.0,
"maximum" : 500.0
}
}
}
```
Mit diesem Modell können Sie ein SDK aufrufen, um die Eigenschaftswerte `description` und `askingPrice` durch Lesen der Eigenschaften `PetStoreOutputModel[i].description` und `PetStoreOutputModel[i].askingPrice` abzurufen. Wenn kein Modell zur Verfügung gestellt wird, verwendet API Gateway das leere Modell zur Erstellung einer Standard-UDT.
## Nächste Schritte
+ In diesem Abschnitt finden Sie Ressourcen, die Sie verwenden können, um mehr über die in diesem Thema vorgestellten Konzepte zu erfahren.
Sie können den Tutorials zur Validierung von Anfragen folgen:
+ [Einrichten der grundlegenden Anforderungsvalidierung über die API-Gateway-Konsole](api-gateway-request-validation-set-up.md#api-gateway-request-validation-setup-in-console)
+ [Richten Sie die grundlegende Anforderungsvalidierung mit dem ein AWS CLI](api-gateway-request-validation-set-up.md#api-gateway-request-validation-setup-cli)
+ [Einrichten der grundlegenden Anforderungsvalidierung mithilfe einer OpenAPI-Definition](api-gateway-request-validation-set-up.md#api-gateway-request-validation-setup-importing-swagger)
+ Weitere Informationen zu Datentransformations- und Zuweisungsvorlagen finden Sie unter [Zuordnen von Vorlagentransformationen für REST APIs in API Gateway](models-mappings.md).
# Grundlegende Anforderungsvalidierung in API Gateway einrichten
In diesem Abschnitt wird gezeigt, wie die Anforderungsvalidierung für API Gateway mithilfe der Konsole und einer OpenAPI-Definition eingerichtet wird. AWS CLI
**Topics**
+ [Einrichten der grundlegenden Anforderungsvalidierung über die API-Gateway-Konsole](#api-gateway-request-validation-setup-in-console)
+ [Richten Sie die grundlegende Anforderungsvalidierung mit dem ein AWS CLI](#api-gateway-request-validation-setup-cli)
+ [Einrichten der grundlegenden Anforderungsvalidierung mithilfe einer OpenAPI-Definition](#api-gateway-request-validation-setup-importing-swagger)
## Einrichten der grundlegenden Anforderungsvalidierung über die API-Gateway-Konsole
Sie können die API-Gateway-Konsole verwenden, um eine Anfrage zu validieren, indem Sie einen von drei Validatoren für eine API-Anfrage auswählen:
+ **Text validieren**.
+ **Abfragezeichenfolgeparameter und Header validieren**.
+ **Text, Abfragezeichenfolgeparameter und Header validieren**.
Wenn Sie einen der Validatoren auf eine API-Methode anwenden, fügt die API-Gateway-Konsole den Validator zur API-Map hinzu. [RequestValidators](https://docs.aws.amazon.com/apigateway/latest/api/API_RequestValidator.html)
Um diesem Tutorial zu folgen, verwenden Sie eine CloudFormation Vorlage, um eine unvollständige API Gateway zu erstellen. Diese API hat eine `/validator`-Ressource mit den Methoden `GET` und `POST`. Beide Methoden sind in den `http://petstore-demo-endpoint.execute-api.com/petstore/pets`-HTTP-Endpunkt integriert. Sie werden zwei Arten der Anforderungsvalidierung konfigurieren:
+ In der `GET`-Methode konfigurieren Sie die Anforderungsvalidierung für URL-Abfragezeichenfolgen-Parameter.
+ In der `POST`-Methode konfigurieren Sie die Anforderungsvalidierung für den Anforderungstext.
Dadurch können nur bestimmte API-Aufrufe an die API weitergeleitet werden.
Laden Sie [die Vorlage zur App-Erstellung für CloudFormation](samples/request-validation-tutorial-console.zip) herunter und entpacken Sie sie. Sie verwenden diese Vorlage, um eine unvollständige API zu erstellen. Sie schließen die restlichen Schritte in der API-Gateway-Konsole ab.
**Um einen Stack zu erstellen CloudFormation**
1. Öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Wählen Sie **Stack erstellen** und dann **Mit neuen Ressourcen (Standard)** aus.
1. Wählen Sie unter **Vorlage angeben** die Option **Vorlagendatei hochladen** aus.
1. Wählen Sie die Vorlage aus, die Sie heruntergeladen haben.
1. Wählen Sie **Weiter** aus.
1. Geben Sie für **Stack-Name** die Zeichenfolge **request-validation-tutorial-console** ein und klicken Sie auf **Weiter**.
1. Wählen Sie in **Stack-Optionen konfigurieren** die Option **Weiter** aus.
1. Bestätigen Sie bei **Capabilities**, dass IAM-Ressourcen in Ihrem Konto erstellt werden CloudFormation können.
1. Wählen Sie **Weiter** und anschließend **Absenden** aus.
CloudFormation stellt die in der Vorlage angegebenen Ressourcen bereit. Die Bereitstellung der Ressourcen kann einige Minuten dauern. Wenn der Status Ihres CloudFormation Stacks **CREATE\$1COMPLETE** lautet, können Sie mit dem nächsten Schritt fortfahren.
**So wählen Sie Ihre neu erstellte API aus**
1. Wählen Sie den neu erstellten **request-validation-tutorial-console**-Stack aus.
1. Wählen Sie **Resources** aus.
1. Wählen Sie unter **Physische ID** Ihre API aus. Dieser Link leitet Sie zur API-Gateway-Konsole weiter.
Bevor Sie die Methoden `GET` und `POST` ändern, müssen Sie ein Modell erstellen.
**So erstellen Sie ein Modell**
1. Ein Modell ist erforderlich, um die Anforderungsvalidierung für den Text einer eingehenden Anfrage zu verwenden. Klicken Sie im Hauptnavigationsbereich auf **Modelle**, um ein Modell zu erstellen.
1. Wählen Sie **Modell erstellen** aus.
1. Geben Sie unter **Name** **PetStoreModel** ein.
1. Geben Sie für **Inhaltstyp** **application/json** ein. Wenn kein passender Inhaltstyp gefunden wird, wird die Anforderungsvalidierung nicht durchgeführt. Geben Sie **\$1default** ein, um das gleiche Modell unabhängig vom Inhaltstyp zu verwenden.
1. Geben Sie für **Beschreibung** **My PetStore Model** als die Modellbeschreibung ein.
1. Für **Modellschema** kopieren Sie das folgende Modell in den Code-Editor ein und klicken dann auf **Modell erstellen**.
```
{
"type" : "object",
"required" : [ "name", "price", "type" ],
"properties" : {
"id" : {
"type" : "integer"
},
"type" : {
"type" : "string",
"enum" : [ "dog", "cat", "fish" ]
},
"name" : {
"type" : "string"
},
"price" : {
"type" : "number",
"minimum" : 25.0,
"maximum" : 500.0
}
}
}
```
Weitere Informationen zum Modell finden Sie unter [Datenmodelle für REST APIs](models-mappings-models.md).
**Konfigurieren einer Anforderungsvalidierung für eine `GET`-Methode**
1. Klicken Sie im Hauptnavigationsbereich auf **Ressourcen** und wählen Sie dann die **GET**-Methode in der Ressourcenstruktur aus.
1. Wählen Sie auf der Registerkarte **Methodenanfrage** unter **Methodenanfrage-Einstellungen** die Option **Bearbeiten** aus.
1. Wählen Sie für **Anforderungs-Validierer** die Option **Abfragezeichenfolgeparameter und -Header validieren** aus.
1. Wählen Sie **URL-Abfragezeichenfolgen-Parameter** aus und gehen Sie dann wie folgt vor:
1. Wählen Sie **Abfragezeichenfolge hinzufügen** aus.
1. Geben Sie unter **Name** **petType** ein.
1. Aktivieren Sie die Option **Erforderlich**.
1. **Caching** bleibt ausgeschaltet.
1. Wählen Sie **Speichern**.
1. Klicken Sie auf der Registerkarte **Integrationsanfrage** unter **Einstellungen für Integrationsanfragen** auf **Bearbeiten**.
1. Wählen Sie **URL-Abfragezeichenfolgen-Parameter** aus und gehen Sie dann wie folgt vor:
1. Wählen Sie **Abfragezeichenfolge hinzufügen** aus.
1. Geben Sie unter **Name** **petType** ein.
1. Geben Sie für **Zugeordnet von** **method.request.querystring.petType** ein. Dadurch wird **petType** dem Typ des Haustiers zugeordnet.
Weitere Informationen zur Datenzuordnung finden Sie [im Tutorial zur Datenzuordnung](set-up-data-transformations-in-api-gateway.md#mapping-example-console).
1. **Caching** bleibt ausgeschaltet.
1. Wählen Sie **Speichern**.
**So testen Sie die Anforderungsvalidierung für die `GET`-Methode**
1. Wählen Sie die Registerkarte **Test**. Möglicherweise müssen Sie die rechte Pfeiltaste wählen, um die Registerkarte anzuzeigen.
1. Für **Abfragezeichenfolgen** geben Sie **petType=dog** ein und klicken dann auf **Test**.
1. Der Methodentest gibt `200 OK` und eine Liste von Hunden zurück.
Informationen zur Umwandlung dieser Ausgabedaten finden Sie im [Tutorial zur Datenzuordnung.](set-up-data-transformations-in-api-gateway.md#mapping-example-console)
1. Entfernen Sie **petType=dog** und wählen Sie **Test** aus.
1. Der Methodentest gibt einen `400`-Fehler mit der folgenden Fehlermeldung zurück:
```
{
"message": "Missing required request parameters: [petType]"
}
```
**Konfigurieren der Anforderungsvalidierung für die `POST`-Methode**
1. Klicken Sie im Hauptnavigationsbereich auf **Ressourcen** und wählen Sie dann die **POST**-Methode aus.
1. Wählen Sie auf der Registerkarte **Methodenanfrage** unter **Methodenanfrage-Einstellungen** die Option **Bearbeiten** aus.
1. Für **Anforderungs-Validator** wählen Sie die Option **Text validieren** aus.
1. Klicken Sie unter **Anforderungstext** auf **Modell hinzufügen**.
1. Geben Sie für **Content type** (Inhaltstyp) **application/json** ein. Wenn kein passender Inhaltstyp gefunden wird, wird die Anforderungsvalidierung nicht durchgeführt. Geben Sie `$default` ein, um das gleiche Modell unabhängig vom Inhaltstyp zu verwenden.
Wählen Sie für **Modell die Option** aus. **PetStoreModel**
1. Wählen Sie **Speichern**.
**Testen der Anforderungsvalidierung für eine `POST`-Methode**
1. Wählen Sie die Registerkarte **Test**. Möglicherweise müssen Sie die rechte Pfeiltaste wählen, um die Registerkarte anzuzeigen.
1. Für **Anforderungstext** kopieren Sie Folgendes in den Code-Editor:
```
{
"id": 2,
"name": "Bella",
"type": "dog",
"price": 400
}
```
Wählen Sie **Test** aus.
1. Der Methodentest gibt `200 OK` und eine Erfolgsmeldung zurück.
1. Für **Anforderungstext** kopieren Sie Folgendes in den Code-Editor:
```
{
"id": 2,
"name": "Bella",
"type": "dog",
"price": 4000
}
```
Wählen Sie **Test** aus.
1. Der Methodentest gibt einen `400`-Fehler mit der folgenden Fehlermeldung zurück:
```
{
"message": "Invalid request body"
}
```
Der Grund für den ungültigen Anforderungstext wird ganz unten in den Testprotokollen angegeben. In diesem Fall lag der Preis des Haustiers außerhalb des im Modell angegebenen Höchstpreises.
**Um einen CloudFormation Stapel zu löschen**
1. Öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Wählen Sie Ihren CloudFormation Stack aus.
1. Wählen Sie **Löschen** und bestätigen Sie dann Ihre Auswahl.
### Nächste Schritte
+ Informationen zur Transformation von Ausgabedaten und zur Durchführung weiterer Datenzuordnungen finden Sie im [Tutorial zur Datenzuordnung](set-up-data-transformations-in-api-gateway.md#mapping-example-console).
+ Folgen Sie dem Abschnitt [Einrichtung einer einfachen Anforderungsvalidierung mithilfe der AWS CLI](#api-gateway-request-validation-setup-cli), um ähnliche Schritte mit der AWS CLI durchzuführen.
## Richten Sie die grundlegende Anforderungsvalidierung mit dem ein AWS CLI
Sie können einen Validator erstellen, um die Anforderungsvalidierung mithilfe der AWS CLI einzurichten. Um diesem Tutorial zu folgen, verwenden Sie eine CloudFormation Vorlage, um eine unvollständige API Gateway zu erstellen.
**Anmerkung**
Dies ist nicht dieselbe CloudFormation Vorlage wie das Konsolen-Tutorial.
Mithilfe einer vorab bereitgestellten `/validator`-Ressource erstellen Sie die Methoden `GET` und `POST`. Beide Methoden werden in den `http://petstore-demo-endpoint.execute-api.com/petstore/pets`-HTTP-Endpunkt integriert. Sie konfigurieren die folgenden zwei Anforderungsvalidierungen:
+ Für die `GET`-Methode erstellen Sie einen `params-only`-Validator zur Validierung von URL-Abfragezeichenfolgen-Parametern.
+ Für die `POST`-Methode erstellen Sie einen `body-only`-Validator, um den Anforderungstext zu validieren.
Dadurch können nur bestimmte API-Aufrufe an die API weitergeleitet werden.
**Um einen CloudFormation Stapel zu erstellen**
Laden Sie [die Vorlage zur App-Erstellung für CloudFormation](samples/request-validation-tutorial-cli.zip) herunter und entpacken Sie sie.
Um die folgenden Schritte durchzuführen, benötigen Sie die [AWS Command Line Interface (AWS CLI) Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Bei langen Befehlen wird ein Escape-Zeichen (`\`) verwendet, um einen Befehl auf mehrere Zeilen aufzuteilen.
**Anmerkung**
In Windows werden einige Bash-CLI-Befehle, die Sie häufig verwenden (z. B. `zip`), von den integrierten Terminals des Betriebssystems nicht unterstützt. Um eine in Windows integrierte Version von Ubuntu und Bash zu erhalten, [installieren Sie das Windows-Subsystem für Linux](https://learn.microsoft.com/en-us/windows/wsl/install). Die CLI-Beispielbefehle in diesem Handbuch verwenden die Linux-Formatierung. Befehle, die Inline-JSON-Dokumente enthalten, müssen neu formatiert werden, wenn Sie die Windows-CLI verwenden.
1. Verwenden Sie den folgenden Befehl, um den CloudFormation Stack zu erstellen.
```
aws cloudformation create-stack --stack-name request-validation-tutorial-cli --template-body file://request-validation-tutorial-cli.zip --capabilities CAPABILITY_NAMED_IAM
```
1. CloudFormation stellt die in der Vorlage angegebenen Ressourcen bereit. Die Bereitstellung der Ressourcen kann einige Minuten dauern. Verwenden Sie den folgenden Befehl, um den Status Ihres CloudFormation Stacks zu überprüfen.
```
aws cloudformation describe-stacks --stack-name request-validation-tutorial-cli
```
1. Wenn der Status Ihres CloudFormation Stacks lautet`StackStatus: "CREATE_COMPLETE"`, verwenden Sie den folgenden Befehl, um relevante Ausgabewerte für future Schritte abzurufen.
```
aws cloudformation describe-stacks --stack-name request-validation-tutorial-cli --query "Stacks[*].Outputs[*].{OutputKey: OutputKey, OutputValue: OutputValue, Description: Description}"
```
Die Ausgabewerte sind die folgenden:
+ ApiId, das ist die ID für die API. Für dieses Tutorial lautet die API-ID `abc123`.
+ ResourceId, das ist die ID für die Validator-Ressource, in der die `POST` Methoden `GET` und verfügbar gemacht werden. Für dieses Tutorial lautet die Ressourcen-ID `efg456`.
**So erstellen Sie die Anforderungsvalidierungen und importieren ein Modell**
1. Ein Validator ist erforderlich, um die Anforderungsvalidierung mit der AWS CLI zu verwenden. Verwenden Sie den folgenden Befehl, um einen Validator zu erstellen, der nur Anforderungsparameter validiert.
```
aws apigateway create-request-validator --rest-api-id abc123 \
--no-validate-request-body \
--validate-request-parameters \
--name params-only
```
Notieren Sie sich die ID des `params-only`-Validators.
1. Verwenden Sie den folgenden Befehl, um einen Validator zu erstellen, der nur den Anforderungstext validiert.
```
aws apigateway create-request-validator --rest-api-id abc123 \
--validate-request-body \
--no-validate-request-parameters \
--name body-only
```
Notieren Sie sich die ID des `body-only`-Validators.
1. Ein Modell ist erforderlich, um die Anforderungsvalidierung für den Text einer eingehenden Anfrage zu verwenden. Verwenden Sie den folgenden Befehl, um ein Modell zu importieren.
```
aws apigateway create-model --rest-api-id abc123 --name PetStoreModel --description 'My PetStore Model' --content-type 'application/json' --schema '{"type": "object", "required" : [ "name", "price", "type" ], "properties" : { "id" : {"type" : "integer"},"type" : {"type" : "string", "enum" : [ "dog", "cat", "fish" ]},"name" : { "type" : "string"},"price" : {"type" : "number","minimum" : 25.0, "maximum" : 500.0}}}}'
```
Wenn kein passender Inhaltstyp gefunden wird, wird die Anforderungsvalidierung nicht durchgeführt. Um das gleiche Modell unabhängig vom Inhaltstyp zu verwenden, geben Sie es `$default` als Schlüssel an.
**So erstellen Sie die Methoden `GET` und `POST`**
1. Rufen Sie den folgenden Befehl auf, um die `GET`-HTTP-Methode der `/validate`-Ressource hinzuzufügen. Dieser Befehl erstellt die `GET`-Methode, fügt den `params-only`-Validator hinzu und legt die Abfragezeichenfolge `petType` nach Bedarf fest.
```
aws apigateway put-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET \
--authorization-type "NONE" \
--request-validator-id aaa111 \
--request-parameters "method.request.querystring.petType=true"
```
Rufen Sie den folgenden Befehl auf, um die `POST`-HTTP-Methode der `/validate`-Ressource hinzuzufügen. Mit diesem Befehl wird die `POST`-Methode erstellt, der `body-only`-Validator hinzugefügt und das Modell an den Validator angehängt, der nur für den Text gilt.
```
aws apigateway put-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--authorization-type "NONE" \
--request-validator-id bbb222 \
--request-models 'application/json'=PetStoreModel
```
1. Führen Sie den folgenden Befehl aus, um die `200 OK`-Antwort der `GET /validate`-Methode einzurichten.
```
aws apigateway put-method-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET \
--status-code 200
```
Führen Sie den folgenden Befehl aus, um die `200 OK`-Antwort der `POST /validate`-Methode einzurichten.
```
aws apigateway put-method-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--status-code 200
```
1. Führen Sie den folgenden Befehl aus, um einen `Integration` mit einem angegebenen HTTP-Endpunkt für die `GET /validation`-Methode einzurichten.
```
aws apigateway put-integration --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET \
--type HTTP \
--integration-http-method GET \
--request-parameters '{"integration.request.querystring.type" : "method.request.querystring.petType"}' \
--uri 'http://petstore-demo-endpoint.execute-api.com/petstore/pets'
```
Führen Sie den folgenden Befehl aus, um einen `Integration` mit einem angegebenen HTTP-Endpunkt für die `POST /validation`-Methode einzurichten.
```
aws apigateway put-integration --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--type HTTP \
--integration-http-method GET \
--uri 'http://petstore-demo-endpoint.execute-api.com/petstore/pets'
```
1. Führen Sie den folgenden Befehl aus, um die Integration der `GET /validation`-Methode einzurichten.
```
aws apigateway put-integration-response --rest-api-id abc123 \
--resource-id efg456\
--http-method GET \
--status-code 200 \
--selection-pattern ""
```
Führen Sie den folgenden Befehl aus, um die Integration der `POST /validation`-Methode einzurichten.
```
aws apigateway put-integration-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--status-code 200 \
--selection-pattern ""
```
**So testen Sie die API-Daten**
1. Verwenden Sie den folgenden Befehl, um die `GET`-Methode zu testen, die eine Anforderungsvalidierung für die Abfragezeichenfolgen durchführt:
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET \
--path-with-query-string '/validate?petType=dog'
```
Das Ergebnis gibt `200 OK` und eine Liste von Hunden zurück.
1. Verwenden Sie den folgenden Befehl, um zu testen, ohne die Abfragezeichenfolge `petType` einzuschließen.
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET
```
Das Ergebnis gibt einen `400`-Fehler zurück.
1. Verwenden Sie den folgenden Befehl, um die `POST`-Methode zu testen, die eine Anforderungsvalidierung für den Anforderungstext durchführt:
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--body '{"id": 1, "name": "bella", "type": "dog", "price" : 400 }'
```
Das Ergebnis gibt `200 OK` und eine Erfolgsmeldung zurück.
1. Verwenden Sie den folgenden Befehl, um mit einem ungültigen Text zu testen.
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--body '{"id": 1, "name": "bella", "type": "dog", "price" : 1000 }'
```
Das Ergebnis gibt einen `400`-Fehler zurück, da der Preis des Hundes über dem vom Modell festgelegten Höchstpreis liegt.
**Um einen Stapel zu löschen CloudFormation**
+ Verwenden Sie den folgenden Befehl, um Ihre CloudFormation Ressourcen zu löschen.
```
aws cloudformation delete-stack --stack-name request-validation-tutorial-cli
```
## Einrichten der grundlegenden Anforderungsvalidierung mithilfe einer OpenAPI-Definition
Sie können eine Anforderungsvalidierung auf API-Ebene deklarieren, indem Sie eine Reihe von [x-amazon-apigateway-request-Validators.RequestValidator-Objekt](api-gateway-swagger-extensions-request-validators.requestValidator.md)-Objekten in der [x-amazon-apigateway-request-validators-Objekt](api-gateway-swagger-extensions-request-validators.md)-Zuordnung angeben, um auszuwählen, welcher Teil der Anfrage validiert werden soll. In der OpenAPI-Beispieldefinition gibt es zwei Validatoren:
+ `all`-Validator, der sowohl den Text anhand des `RequestBodyModel`-Datenmodells als auch die Parameter validiert.
Bei diesem `RequestBodyModel`-Modell muss das JSON-Eingabeobjekt die Eigenschaften `name`, `type` und `price` enthalten. Die Eigenschaft `name` kann eine beliebige Zeichenfolge sein, `type` muss einem der angegebenen Aufzählungsfelder (`["dog", "cat", "fish"]`) entsprechen und `price` muss zwischen 25 und 500 liegen. Der Parameter `id` ist nicht erforderlich.
+ `param-only`, der nur die Parameter validiert.
Zum Aktivieren einer Anforderungsvalidierung für alle Methoden einer API geben Sie eine [x-amazon-apigateway-request-validator-Eigenschaft](api-gateway-swagger-extensions-request-validator.md)-Eigenschaft auf API-Ebene in der OpenAPI-Definitionsdatei an. In der Beispiel-OpenAPI-Definition wird der `all` für alle API-Methoden verwendet (sofern nicht anderweitig außer Kraft gesetzt). Wenn ein Modell zur Validierung des Textes verwendet wird und kein übereinstimmender Inhaltstyp gefunden wird, wird die Anforderungsvalidierung nicht durchgeführt. Um das gleiche Modell unabhängig vom Inhaltstyp zu verwenden, geben Sie es `$default` als Schlüssel an.
Zum Aktivieren einer Anforderungsvalidierung für eine einzelne Methode geben Sie die `x-amazon-apigateway-request-validator`-Eigenschaft auf Methodenebene an. Im Beispiel mit OpenAPI-Definition überschreibt der `param-only`-Validator den `all`-Validator für die `GET`-Methode.
Um das OpenAPI-Beispiel in API Gateway zu importieren, lesen Sie die folgenden Anweisungen zu [Regionale API in API Gateway importieren](import-export-api-endpoints.md) oder zu [Edge-optimierte API in API Gateway importieren](import-edge-optimized-api.md).
------
#### [ OpenAPI 3.0 ]
```
{
"openapi" : "3.0.1",
"info" : {
"title" : "ReqValidators Sample",
"version" : "1.0.0"
},
"servers" : [ {
"url" : "/{basePath}",
"variables" : {
"basePath" : {
"default" : "/v1"
}
}
} ],
"paths" : {
"/validation" : {
"get" : {
"parameters" : [ {
"name" : "q1",
"in" : "query",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"200" : {
"description" : "200 response",
"headers" : {
"test-method-response-header" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/ArrayOfError"
}
}
}
}
},
"x-amazon-apigateway-request-validator" : "params-only",
"x-amazon-apigateway-integration" : {
"httpMethod" : "GET",
"uri" : "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"responses" : {
"default" : {
"statusCode" : "400",
"responseParameters" : {
"method.response.header.test-method-response-header" : "'static value'"
},
"responseTemplates" : {
"application/xml" : "xml 400 response template",
"application/json" : "json 400 response template"
}
},
"2\\d{2}" : {
"statusCode" : "200"
}
},
"requestParameters" : {
"integration.request.querystring.type" : "method.request.querystring.q1"
},
"passthroughBehavior" : "when_no_match",
"type" : "http"
}
},
"post" : {
"parameters" : [ {
"name" : "h1",
"in" : "header",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"requestBody" : {
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/RequestBodyModel"
}
}
},
"required" : true
},
"responses" : {
"200" : {
"description" : "200 response",
"headers" : {
"test-method-response-header" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/ArrayOfError"
}
}
}
}
},
"x-amazon-apigateway-request-validator" : "all",
"x-amazon-apigateway-integration" : {
"httpMethod" : "POST",
"uri" : "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"responses" : {
"default" : {
"statusCode" : "400",
"responseParameters" : {
"method.response.header.test-method-response-header" : "'static value'"
},
"responseTemplates" : {
"application/xml" : "xml 400 response template",
"application/json" : "json 400 response template"
}
},
"2\\d{2}" : {
"statusCode" : "200"
}
},
"requestParameters" : {
"integration.request.header.custom_h1" : "method.request.header.h1"
},
"passthroughBehavior" : "when_no_match",
"type" : "http"
}
}
}
},
"components" : {
"schemas" : {
"RequestBodyModel" : {
"required" : [ "name", "price", "type" ],
"type" : "object",
"properties" : {
"id" : {
"type" : "integer"
},
"type" : {
"type" : "string",
"enum" : [ "dog", "cat", "fish" ]
},
"name" : {
"type" : "string"
},
"price" : {
"maximum" : 500.0,
"minimum" : 25.0,
"type" : "number"
}
}
},
"ArrayOfError" : {
"type" : "array",
"items" : {
"$ref" : "#/components/schemas/Error"
}
},
"Error" : {
"type" : "object"
}
}
},
"x-amazon-apigateway-request-validators" : {
"all" : {
"validateRequestParameters" : true,
"validateRequestBody" : true
},
"params-only" : {
"validateRequestParameters" : true,
"validateRequestBody" : false
}
}
}
```
------
#### [ OpenAPI 2.0 ]
```
{
"swagger" : "2.0",
"info" : {
"version" : "1.0.0",
"title" : "ReqValidators Sample"
},
"basePath" : "/v1",
"schemes" : [ "https" ],
"paths" : {
"/validation" : {
"get" : {
"produces" : [ "application/json", "application/xml" ],
"parameters" : [ {
"name" : "q1",
"in" : "query",
"required" : true,
"type" : "string"
} ],
"responses" : {
"200" : {
"description" : "200 response",
"schema" : {
"$ref" : "#/definitions/ArrayOfError"
},
"headers" : {
"test-method-response-header" : {
"type" : "string"
}
}
}
},
"x-amazon-apigateway-request-validator" : "params-only",
"x-amazon-apigateway-integration" : {
"httpMethod" : "GET",
"uri" : "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"responses" : {
"default" : {
"statusCode" : "400",
"responseParameters" : {
"method.response.header.test-method-response-header" : "'static value'"
},
"responseTemplates" : {
"application/xml" : "xml 400 response template",
"application/json" : "json 400 response template"
}
},
"2\\d{2}" : {
"statusCode" : "200"
}
},
"requestParameters" : {
"integration.request.querystring.type" : "method.request.querystring.q1"
},
"passthroughBehavior" : "when_no_match",
"type" : "http"
}
},
"post" : {
"consumes" : [ "application/json" ],
"produces" : [ "application/json", "application/xml" ],
"parameters" : [ {
"name" : "h1",
"in" : "header",
"required" : true,
"type" : "string"
}, {
"in" : "body",
"name" : "RequestBodyModel",
"required" : true,
"schema" : {
"$ref" : "#/definitions/RequestBodyModel"
}
} ],
"responses" : {
"200" : {
"description" : "200 response",
"schema" : {
"$ref" : "#/definitions/ArrayOfError"
},
"headers" : {
"test-method-response-header" : {
"type" : "string"
}
}
}
},
"x-amazon-apigateway-request-validator" : "all",
"x-amazon-apigateway-integration" : {
"httpMethod" : "POST",
"uri" : "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"responses" : {
"default" : {
"statusCode" : "400",
"responseParameters" : {
"method.response.header.test-method-response-header" : "'static value'"
},
"responseTemplates" : {
"application/xml" : "xml 400 response template",
"application/json" : "json 400 response template"
}
},
"2\\d{2}" : {
"statusCode" : "200"
}
},
"requestParameters" : {
"integration.request.header.custom_h1" : "method.request.header.h1"
},
"passthroughBehavior" : "when_no_match",
"type" : "http"
}
}
}
},
"definitions" : {
"RequestBodyModel" : {
"type" : "object",
"required" : [ "name", "price", "type" ],
"properties" : {
"id" : {
"type" : "integer"
},
"type" : {
"type" : "string",
"enum" : [ "dog", "cat", "fish" ]
},
"name" : {
"type" : "string"
},
"price" : {
"type" : "number",
"minimum" : 25.0,
"maximum" : 500.0
}
}
},
"ArrayOfError" : {
"type" : "array",
"items" : {
"$ref" : "#/definitions/Error"
}
},
"Error" : {
"type" : "object"
}
},
"x-amazon-apigateway-request-validators" : {
"all" : {
"validateRequestParameters" : true,
"validateRequestBody" : true
},
"params-only" : {
"validateRequestParameters" : true,
"validateRequestBody" : false
}
}
}
```
------
# AWS CloudFormation Vorlage einer Beispiel-API mit grundlegender Anforderungsvalidierung
Die folgende CloudFormation Beispielvorlagendefinition definiert eine Beispiel-API mit aktivierter Anforderungsvalidierung. Die [PetStore-API ist eine Teilmenge der ](http://petstore-demo-endpoint.execute-api.com/petstore/pets)-API. Mithilfe einer `POST`-Methode wird ein Haustier zur Sammlung `pets` hinzugefügt und mit einer `GET`-Methode erfolgt die Abfrage der Haustiere nach Typ.
Es wurden zwei Anforderungsvalidatoren deklariert:
**`GETValidator`**
Dieser Validator ist für die `GET`-Methode aktiviert. Damit kann API Gateway überprüfen, ob der erforderliche Abfrageparameter (`q1`) in der eingehenden Anfrage enthalten und nicht leer ist.
**`POSTValidator`**
Dieser Validator ist für die `POST`-Methode aktiviert. Damit kann API Gateway prüfen, ob das Nutzlast-Anforderungsformat dem angegebenen `RequestBodyModel` entspricht. Wenn der Inhaltstyp `application/json` ist und kein passender Inhaltstyp gefunden wird, wird die Anforderungsüberprüfung nicht durchgeführt. Um das gleiche Modell unabhängig vom Inhaltstyp zu verwenden, geben Sie `$default` an. `RequestBodyModel` enthält ein zusätzliches Modell, `RequestBodyModelId`, um die Pet-ID zu definieren.
```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
StageName:
Type: String
Default: v1
Description: Name of API stage.
Resources:
Api:
Type: 'AWS::ApiGateway::RestApi'
Properties:
Name: ReqValidatorsSample
RequestBodyModelId:
Type: 'AWS::ApiGateway::Model'
Properties:
RestApiId: !Ref Api
ContentType: application/json
Description: Request body model for Pet ID.
Schema:
$schema: 'http://json-schema.org/draft-04/schema#'
title: RequestBodyModelId
properties:
id:
type: integer
RequestBodyModel:
Type: 'AWS::ApiGateway::Model'
Properties:
RestApiId: !Ref Api
ContentType: application/json
Description: Request body model for Pet type, name, price, and ID.
Schema:
$schema: 'http://json-schema.org/draft-04/schema#'
title: RequestBodyModel
required:
- price
- name
- type
type: object
properties:
id:
"$ref": !Sub
- 'https://apigateway.amazonaws.com/restapis/${Api}/models/${RequestBodyModelId}'
- Api: !Ref Api
RequestBodyModelId: !Ref RequestBodyModelId
price:
type: number
minimum: 25
maximum: 500
name:
type: string
type:
type: string
enum:
- "dog"
- "cat"
- "fish"
GETValidator:
Type: AWS::ApiGateway::RequestValidator
Properties:
Name: params-only
RestApiId: !Ref Api
ValidateRequestBody: False
ValidateRequestParameters: True
POSTValidator:
Type: AWS::ApiGateway::RequestValidator
Properties:
Name: body-only
RestApiId: !Ref Api
ValidateRequestBody: True
ValidateRequestParameters: False
ValidationResource:
Type: 'AWS::ApiGateway::Resource'
Properties:
RestApiId: !Ref Api
ParentId: !GetAtt Api.RootResourceId
PathPart: 'validation'
ValidationMethodGet:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref ValidationResource
HttpMethod: GET
AuthorizationType: NONE
RequestValidatorId: !Ref GETValidator
RequestParameters:
method.request.querystring.q1: true
Integration:
Type: HTTP_PROXY
IntegrationHttpMethod: GET
Uri: http://petstore-demo-endpoint.execute-api.com/petstore/pets/
ValidationMethodPost:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref ValidationResource
HttpMethod: POST
AuthorizationType: NONE
RequestValidatorId: !Ref POSTValidator
RequestModels:
application/json : !Ref RequestBodyModel
Integration:
Type: HTTP_PROXY
IntegrationHttpMethod: POST
Uri: http://petstore-demo-endpoint.execute-api.com/petstore/pets/
ApiDeployment:
Type: 'AWS::ApiGateway::Deployment'
DependsOn:
- ValidationMethodGet
- RequestBodyModel
Properties:
RestApiId: !Ref Api
StageName: !Sub '${StageName}'
Outputs:
ApiRootUrl:
Description: Root Url of the API
Value: !Sub 'https://${Api}.execute-api.${AWS::Region}.amazonaws.com/${StageName}'
```