Richten Sie die grundlegende Anforderungsvalidierung in API Gateway ein

In diesem Abschnitt wird gezeigt, wie die Anforderungsvalidierung für API Gateway mithilfe der Konsole und einer API Open-Definition eingerichtet wird. AWS CLI

Richten Sie die Anforderungsvalidierung mit der API Gateway-Konsole ein

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 der s-Map hinzu. API RequestValidators

Um diesem Tutorial zu folgen, verwenden Sie eine AWS CloudFormation Vorlage, um ein unvollständiges Gateway zu erstellen. API API Dies API hat eine /validator Ressource mit GET und POST Methoden. 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 Abfragezeichenfolgenparameter.

• In der POST-Methode konfigurieren Sie die Anforderungsvalidierung für den Anforderungstext.

Dadurch können nur bestimmte API Aufrufe an den weitergeleitet API werden.

Laden Sie die Vorlage zur App-Erstellung für AWS CloudFormation herunter und entpacken Sie sie. Sie verwenden diese Vorlage, um eine unvollständige API Vorlage zu erstellen. Sie werden die restlichen Schritte in der API Gateway-Konsole abschließen.

Um einen AWS CloudFormation Stapel zu erstellen

1. Öffnen Sie die AWS CloudFormation Konsole unter https://console.aws.amazon.com/cloudformation.

2. Wählen Sie Stack erstellen und dann Mit neuen Ressourcen (Standard) aus.

3. Wählen Sie unter Vorlage angeben die Option Vorlagendatei hochladen aus.

4. Wählen Sie die Vorlage aus, die Sie heruntergeladen haben.

5. Wählen Sie Weiter aus.

6. Geben Sie für Stack-Name die Zeichenfolge request-validation-tutorial-console ein und klicken Sie auf Weiter.

7. Wählen Sie in Stack-Optionen konfigurieren die Option Weiter aus.

8. Bestätigen Sie bei Funktionen, dass IAM Ressourcen in Ihrem Konto erstellt werden AWS CloudFormation können.

9. Wählen Sie Absenden aus.

AWS CloudFormation stellt die in der Vorlage angegebenen Ressourcen bereit. Die Bereitstellung der Ressourcen kann einige Minuten dauern. Wenn der Status Ihres AWS CloudFormation Stacks CREATE_ istCOMPLETE, können Sie mit dem nächsten Schritt fortfahren.

Um dein neu erstelltes auszuwählen API

1. Wählen Sie den neu erstellten request-validation-tutorial-console-Stack aus.

2. Wählen Sie Resources aus.

3. Wählen Sie unter Physische ID Ihre ausAPI. 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.

2. Wählen Sie Modell erstellen aus.

3. Geben Sie unter Name PetStoreModel ein.

4. Geben Sie für 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.

5. Geben Sie für Beschreibung My PetStore Model als die Modellbeschreibung ein.

6. 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.

Konfigurieren einer Anforderungsvalidierung für eine GET-Methode

1. Wählen Sie im Hauptnavigationsbereich Ressourcen und dann die GETMethode aus.

2. Wählen Sie auf der Registerkarte Methodenanfrage unter Methodenanfrage-Einstellungen die Option Bearbeiten aus.

3. Wählen Sie für Anforderungs-Validierer die Option Abfragezeichenfolgeparameter und -Header validieren aus.

4. Gehen Sie unter Parameter für die URL Abfragezeichenfolge wie folgt vor:

   1. Wählen Sie Abfragezeichenfolge hinzufügen aus.

   2. Geben Sie unter Name petType ein.

   3. Aktivieren Sie die Option Erforderlich.

   4. Caching bleibt ausgeschaltet.

5. Wählen Sie Speichern.

6. Klicken Sie auf der Registerkarte Integrationsanfrage unter Einstellungen für Integrationsanfragen auf Bearbeiten.

7. Gehen Sie unter Parameter für URL Abfragezeichenfolgen wie folgt vor:

   1. Wählen Sie Abfragezeichenfolge hinzufügen aus.

   2. Geben Sie unter Name petType ein.

   3. 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.

   4. Caching bleibt ausgeschaltet.

8. 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.

2. Für Abfragezeichenfolgen geben Sie petType=dog ein und klicken dann auf Test.

3. Der Methodentest gibt 200 OK und eine Liste von Hunden zurück.

   Informationen zur Umwandlung dieser Ausgabedaten finden Sie im Tutorial zur Datenzuordnung.

4. Entfernen Sie petType=dog und wählen Sie Test aus.

5. 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. Wählen Sie im Hauptnavigationsbereich Resources und dann die POSTMethode aus.

2. Wählen Sie auf der Registerkarte Methodenanfrage unter Methodenanfrage-Einstellungen die Option Bearbeiten aus.

3. Für Anforderungs-Validator wählen Sie die Option Text validieren aus.

4. Klicken Sie unter Anforderungstext auf Modell hinzufügen.

5. Geben Sie als Inhaltstyp den application/json Text ein, und wählen Sie dann für Modell aus PetStoreModel.

6. 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.

2. Für Anforderungstext kopieren Sie Folgendes in den Code-Editor:

   {
     "id": 2,
     "name": "Bella",
     "type": "dog",
     "price": 400
   }

   Wählen Sie Test aus.

3. Der Methodentest gibt 200 OK und eine Erfolgsmeldung zurück.

4. Für Anforderungstext kopieren Sie Folgendes in den Code-Editor:

   {
     "id": 2,
     "name": "Bella",
     "type": "dog",
     "price": 4000
   }

   Wählen Sie Test aus.

5. 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 AWS CloudFormation Stapel zu löschen

1. Öffnen Sie die AWS CloudFormation Konsole unter https://console.aws.amazon.com/cloudformation.

2. Wählen Sie Ihren AWS CloudFormation Stack aus.

3. 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.

• Folgen Sie dem Abschnitt Einrichtung einer einfachen Anforderungsvalidierung mithilfe der  AWS 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 AWS CloudFormation Vorlage, um ein unvollständiges API Gateway zu erstellenAPI.

Anmerkung

Dies ist nicht dieselbe AWS 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 Abfragezeichenfolgenparametern.

• Für die POST-Methode erstellen Sie einen body-only-Validator, um den Anforderungstext zu validieren.

Dadurch können nur bestimmte API Aufrufe an den weitergeleitet werden. API

Um einen AWS CloudFormation Stapel zu erstellen

Laden Sie die Vorlage zur App-Erstellung für AWS CloudFormation herunter und entpacken Sie sie.

Um die folgenden Schritte durchzuführen, benötigen Sie die AWS Command Line Interface (AWS CLI) Version 2.

Bei langen Befehlen wird ein Escape-Zeichen (\) verwendet, um einen Befehl auf mehrere Zeilen aufzuteilen.

Anmerkung

In Windows werden einige CLI Bash-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. Die CLI Beispielbefehle in diesem Handbuch verwenden die Linux-Formatierung. Befehle, die JSON Inline-Dokumente enthalten, müssen neu formatiert werden, wenn Sie Windows verwenden. CLI

1. Verwenden Sie den folgenden Befehl, um den Stapel zu erstellen. AWS CloudFormation

   aws cloudformation create-stack --stack-name request-validation-tutorial-cli --template-body file://request-validation-tutorial-cli.zip --capabilities CAPABILITY_NAMED_IAM 

2. AWS 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 AWS CloudFormation Stacks zu überprüfen.

   aws cloudformation describe-stacks --stack-name request-validation-tutorial-cli

3. Wenn der Status Ihres AWS CloudFormation Stacks lautetStackStatus: "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ürAPI. Für dieses Tutorial lautet die API IDabc123.

   • 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.

2. 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.

3. 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. Verwenden Sie den folgenden Befehl, um die GET HTTP Methode zur Ressource hinzuzufügen. /validate 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"

   Verwenden Sie den folgenden Befehl, um die POST HTTP Methode zur /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

2. 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

3. Verwenden Sie den folgenden Befehl, um eine Integration mit einem bestimmten 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'

   Verwenden Sie den folgenden Befehl, um eine Integration mit einem bestimmten 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'

4. 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 ""

Um das zu testen API

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.

2. 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.

3. 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.

4. 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 AWS CloudFormation Stapel zu löschen

• Verwenden Sie den folgenden Befehl, um Ihre AWS CloudFormation Ressourcen zu löschen.

  aws cloudformation delete-stack  --stack-name request-validation-tutorial-cli

Richten Sie die grundlegende Anforderungsvalidierung mithilfe einer API Open-Definition ein

Sie können einen Anforderungsvalidator auf der API Ebene deklarieren, indem Sie eine Reihe von x-amazon-apigateway-request-Validatoren. requestValidator Objekt Objekten in der x-amazon-apigateway-requestObjekt -validators Map angeben, um auszuwählen, welcher Teil der Anforderung validiert werden soll. In der API Open-Beispieldefinition gibt es zwei Validatoren:

• all-Validator, der sowohl den Text anhand des RequestBodyModel-Datenmodells als auch die Parameter validiert.

  Das RequestBodyModel Datenmodell erfordert, dass das JSON Eingabeobjekt die Eigenschaften nametype, und price enthält. 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.

Um einen Anforderungsvalidator für alle Methoden von zu aktivierenAPI, geben Sie eine x-amazon-apigateway-request-validator-Eigenschaft Eigenschaft auf der API Ebene der API Open-Definition an. In der API Open-Beispieldefinition wird der all Validator für alle API Methoden verwendet, sofern nicht anders überschrieben. 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 Open API definition überschreibt der param-only Validator den Validator der Methode. all GET

Um das API Open-Beispiel in API Gateway zu importieren, lesen Sie die folgenden Anweisungen zu oder zu. Importieren Sie eine regionale API in API Gateway Edge-optimierte API in API Gateway importieren

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
    }
  }
}