# Solicitar validação para APIs REST no API Gateway
Você pode configurar o API Gateway para realizar a validação básica de uma solicitação de API antes de prosseguir com a solicitação de integração. Quando a validação falha, o API Gateway marca a solicitação como falha imediatamente, retorna uma resposta de erro 400 para o autor da chamada e publica os resultados da validação em CloudWatch Logs. Isso reduz as chamadas desnecessárias para o backend. O mais importante, isso permite concentrar-se nos esforços de validação específicos para o seu aplicativo. É possível validar um corpo de solicitação verificando se os parâmetros de solicitação necessários são válidos e não nulos especificando um esquema de modelo para uma validação de dados mais complicada.
**Topics**
+ [Visão geral da validação básica de solicitações no API Gateway](#api-gateway-request-validation-basic-definitions)
+ [Modelos de dados para APIs REST](models-mappings-models.md)
+ [Configurar a validação básica de solicitações no API Gateway](api-gateway-request-validation-set-up.md)
+ [Modelo do AWS CloudFormation de uma API de amostra com validação de solicitação básica](api-gateway-request-validation-sample-cloudformation.md)
## Visão geral da validação básica de solicitações no API Gateway
O API Gateway pode realizar a validação básica da solicitação, para que você possa enfocar a validação específica do aplicativo no back-end. Para a validação, o API Gateway verifica uma das seguintes condições ou ambas:
+ Se os parâmetros de solicitação necessários no URI, a string de consulta e os cabeçalhos de uma solicitação de entrada estão incluídos e não estão vazios. O API Gateway verifica apenas a existência de um parâmetro e não verifica o tipo ou o formato.
+ Se a carga útil da solicitação aplicável atende à solicitação do [esquema JSON](https://datatracker.ietf.org/doc/html/draft-zyp-json-schema-04) do método para determinado tipo de conteúdo. Se nenhum tipo de conteúdo correspondente for encontrado, a validação da solicitação não será executada. Para usar o mesmo modelo, independentemente do tipo de conteúdo, defina o tipo de conteúdo do modelo de dados como `$default`.
Para ativar a validação, você deve especificar regras de validação em um [validador de solicitação](https://docs.aws.amazon.com/apigateway/latest/api/API_RequestValidator.html), adicionar o validador ao [mapa de validadores de solicitação](https://docs.aws.amazon.com/apigateway/latest/api/API_RequestValidator.html) da API e atribuir o validador a métodos de API individuais.
**nota**
Solicite a validação do corpo e os [Comportamento de solicitação de método para cargas úteis sem modelos de mapeamento para APIs REST no API Gateway](integration-passthrough-behaviors.md) são dois tópicos distintos. Quando uma carga útil de solicitação não tem nenhum esquema de modelo correspondente, você pode optar por transmitir ou bloquear a carga útil original. Para obter mais informações, consulte [Comportamento de solicitação de método para cargas úteis sem modelos de mapeamento para APIs REST no API Gateway](integration-passthrough-behaviors.md).
# Modelos de dados para APIs REST
No API Gateway, um modelo define a estrutura de dados de uma carga. No API Gateway, modelos são definidos usando o [esquema JSON rascunho 4](https://tools.ietf.org/html/draft-zyp-json-schema-04). O objeto JSON a seguir é uma amostra de dados no exemplo da Pet Store.
```
{
"id": 1,
"type": "dog",
"price": 249.99
}
```
Os dados contêm o `id`, o `type` e o `price` do animal de estimação. Um modelo desses dados possibilita que você:
+ Use a validação básica da solicitação.
+ Crie modelos de mapeamento para transformação de dados.
+ Crie um tipo de dados definido pelo usuário (UDT) ao gerar um SDK.
![\[Exemplo de modelo de dados JSON para a API PetStore.\]](http://docs.aws.amazon.com/pt_br/apigateway/latest/developerguide/images/how-to-validate-requests.png)
Neste modelo:
1. O objeto `$schema` representa um identificador de versão do Esquema JSON válido. Esse esquema é o rascunho do JSON Schema v4.
1. O objeto `title` é um identificador humanamente legível para o modelo. Esse título é `PetStoreModel`.
1. A palavra-chave de validação `required` exige o `type` e o `price` para validação básica da solicitação.
1. As `properties` do modelo são `id`, `type` e `price`. Cada objeto tem propriedades que são descritas no modelo.
1. O objeto `type` pode ter somente os valores `dog`, `cat` ou `fish`.
1. O objeto `price` é um número e está limitado ao `minimum` de 25 e ao `maximum` de 500.
## Modelo PetStore
```
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 }
```
Neste modelo:
1. Na linha 2, o objeto `$schema` representa um identificador de versão do JSON Schema válido. Esse esquema é o rascunho do JSON Schema v4.
1. Na linha 3, o objeto `title` é um identificador legível para o modelo. Esse título é `PetStoreModel`.
1. Na linha 5, a palavra-chave de validação `required` exige o `type` e o `price` para validação básica da solicitação.
1. Nas linhas 6 a 17, as `properties` do modelo são `id`, `type` e `price`. Cada objeto tem propriedades que são descritas no modelo.
1. Na linha 12, o objeto `type` pode ter somente os valores `dog`, `cat` ou `fish`.
1. Nas linhas 14 a 17, o objeto `price` é um número e está limitado ao `minimum` de 25 e ao `maximum` de 500.
## Criar modelos mais complexos
É possível usar o `$ref` primitivo para criar definições reutilizáveis para modelos mais longos. Por exemplo, você pode criar uma definição chamada `Price` na seção `definitions` que descreve o objeto `price`. O valor de `$ref` é a definição `Price`.
```
{
"$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
}
}
}
```
Você também pode referenciar outro esquema de modelo definido em um arquivo de modelo externo. Defina o valor da propriedade `$ref` para a localização do modelo. No exemplo a seguir, o modelo `Price` é definido no modelo `PetStorePrice` na API `a1234`.
```
{
"$schema" : "http://json-schema.org/draft-04/schema#",
"title" : "PetStorePrice",
"type": "number",
"minimum": 25,
"maximum": 500
}
```
O modelo mais longo pode referenciar o modelo `PetStorePrice`.
```
{
"$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"
}
}
}
```
## Usar modelos de dados de saída
Se você transformar seus dados, poderá definir um modelo de carga útil na resposta de integração. Um modelo de carga útil pode ser usado quando você gera um SDK. Para linguagens de tipo forte, como Java, Objective-C ou Swift, o objeto corresponde a um tipo de dados definido pelo usuário (UDT). O API Gateway cria um UDT se você fornecê-lo com um modelo de dados ao gerar um SDK. Para ter mais informações sobre transformações de dados, consulte [Transformações de modelo de mapeamento para APIs REST no API Gateway](models-mappings.md).
O exemplo a seguir são dados de saída de uma resposta de integração.
```
{
[
{
"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
}
]
}
```
O exemplo a seguir é um modelo de payload que descreve os dados de saída.
```
{
"$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
}
}
}
```
Com esse modelo, você pode chamar um SDK para recuperar os valores de propriedades `description` e `askingPrice`, lendo as propriedades `PetStoreOutputModel[i].description` e `PetStoreOutputModel[i].askingPrice`. Se nenhum modelo for fornecido, o API Gateway usará o modelo vazio para criar um UDT padrão.
## Próximas etapas
+ Esta seção fornece recursos que você pode usar para ter mais conhecimento sobre os conceitos apresentados neste tópico.
É possível seguir os tutoriais de validação da solicitação:
+ [Configurar a validação de solicitação usando o console do API Gateway](api-gateway-request-validation-set-up.md#api-gateway-request-validation-setup-in-console)
+ [Configurar a validação básica de solicitações usando a AWS CLI](api-gateway-request-validation-set-up.md#api-gateway-request-validation-setup-cli)
+ [Configurar a validação básica de solicitações importando a definição de OpenAPI](api-gateway-request-validation-set-up.md#api-gateway-request-validation-setup-importing-swagger)
+ Consulte mais informações sobre modelos de mapeamento e transformação de dados em [Transformações de modelo de mapeamento para APIs REST no API Gateway](models-mappings.md).
# Configurar a validação básica de solicitações no API Gateway
Esta seção mostra como configurar a validação de solicitações para o API Gateway usando o console, a AWS CLI e uma definição de OpenAPI.
**Topics**
+ [Configurar a validação de solicitação usando o console do API Gateway](#api-gateway-request-validation-setup-in-console)
+ [Configurar a validação básica de solicitações usando a AWS CLI](#api-gateway-request-validation-setup-cli)
+ [Configurar a validação básica de solicitações importando a definição de OpenAPI](#api-gateway-request-validation-setup-importing-swagger)
## Configurar a validação de solicitação usando o console do API Gateway
Você pode usar o console do API Gateway para validar uma solicitação selecionando um dos três validadores para uma solicitação de API:
+ **Validar o corpo**.
+ **Valide parâmetros e cabeçalhos da string de consulta**.
+ **Validar o corpo, parâmetros da string de consulta e cabeçalhos**.
Ao aplicar um dos validadores em um método de API, o console do API Gateway adiciona o validador ao mapa [RequestValidators](https://docs.aws.amazon.com/apigateway/latest/api/API_RequestValidator.html) da API.
Para seguir esse tutorial, você usará um modelo CloudFormation para criar uma API incompleta do API Gateway. Essa API tem um recurso `/validator` com os métodos `GET` e `POST`. Os dois métodos são integrados ao endpoint HTTP `http://petstore-demo-endpoint.execute-api.com/petstore/pets`. Você vai configurar dois tipos de validação de solicitação:
+ No método `GET`, você vai configurar a validação da solicitação para os parâmetros da string de consulta de URL.
+ No método `POST`, você vai configurar a validação da solicitação para o corpo da solicitação.
Isso vai possibilitar que somente determinadas chamadas de API sejam transmitidas à API.
Baixe e descompacte [o modelo de criação de aplicativos para CloudFormation](samples/request-validation-tutorial-console.zip). Você usará esse modelo para criar uma API incompleta. Você concluirá o restante das etapas no console do API Gateway.
**Como criar uma pilha do CloudFormation**
1. Abra o console do CloudFormation em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Selecione **Create stack (Criar pilha)** e **With new resources (standard) (Com novos recursos (padrão))**.
1. Em **Specify template (Especificar modelo)**, escolha **Upload a template file (Fazer upload de um arquivo de modelo)**.
1. Selecione o modelo que você baixou.
1. Escolha **Next (Próximo)**.
1. Em **Nome da pilha**, insira **request-validation-tutorial-console** e escolha **Avançar**.
1. Para **Configurar opções de pilha**, escolha **Avançar**.
1. Para **Capabilities** (Recursos), reconheça que CloudFormation pode criar recursos do IAM em sua conta.
1. Escolha **Próximo** e, depois, **Enviar**.
CloudFormationO fornece os recursos especificados no modelo. Pode demorar alguns minutos para concluir o provisionamento de seus recursos. Quando o status da sua pilha do CloudFormation for **CREATE\$1COMPLETE**, você estará pronto para passar para a próxima etapa.
**Como selecionar sua API recém-criada**
1. Selecione a pilha **request-validation-tutorial-console** recém-criada.
1. Escolha **atributos**.
1. Em **ID físico**, escolha sua API. Esse link direcionará você para o console do API Gateway.
Antes de modificar os métodos `GET` e `POST`, é necessário criar um modelo.
**Como criar um modelo**
1. É necessário um modelo para usar a validação da solicitação no corpo de uma solicitação recebida. Para criar um modelo, no painel de navegação principal, selecione **Modelos**.
1. Escolha **Criar modelo**.
1. Em **Name (Nome)**, insira **PetStoreModel**.
1. Em **Tipo de conteúdo**, insira **application/json**. Se nenhum tipo de conteúdo correspondente for encontrado, a validação da solicitação não será executada. Para usar o mesmo modelo, independentemente do tipo de conteúdo, insira **\$1default**.
1. Em **Descrição**, insira **My PetStore Model** como descrição do modelo.
1. Em **Esquema do modelo**, cole o modelo a seguir no editor de código e escolha **Criar**.
```
{
"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
}
}
}
```
Para obter mais informações sobre o modelo, consulte [Modelos de dados para APIs REST](models-mappings-models.md).
**Como configurar a validação da solicitação para um método `GET`**
1. No painel de navegação, selecione **Recursos** e, depois, selecione o método **GET**.
1. Na guia **Solicitação de método**, em **Configurações de solicitação de método**, escolha **Editar**.
1. Em **Validador de solicitação**, selecione **Validar parâmetros de string de consulta e cabeçalhos**.
1. Em **Parâmetros de string de consulta de URL**, faça o seguinte:
1. Escolha **Add query string** (Adicionar string de consulta).
1. Em **Name (Nome)**, insira **petType**.
1. Ative a opção **Obrigatório**.
1. Mantenha **Armazenamento em cache** desativado.
1. Escolha **Salvar**.
1. Na guia **Solicitação de integração**, em **Configurações de solicitação de integração**, selecione **Editar**.
1. Em **Parâmetros de string de consulta de URL**, faça o seguinte:
1. Escolha **Add query string** (Adicionar string de consulta).
1. Em **Name (Nome)**, insira **petType**.
1. Em **Mapeado de**, insira **method.request.querystring.petType**. Isso associa o **petType** ao tipo do animal de estimação.
Para ter mais informações sobre mapeamento de dados, consulte [ o tutorial de mapeamento de dados](set-up-data-transformations-in-api-gateway.md#mapping-example-console).
1. Mantenha **Armazenamento em cache** desativado.
1. Escolha **Salvar**.
**Como testar a validação da solicitação para o método `GET`**
1. Selecione a guia **Testar**. Talvez seja necessário selecionar o botão de seta para a direita para mostrar a guia.
1. Em **Strings de consulta**, insira **petType=dog** e escolha **Testar**.
1. O teste de método vai gerar `200 OK` e uma lista de cães.
Para ter informações sobre como transformar esses dados de saída, consulte o [tutorial de mapeamento de dados](set-up-data-transformations-in-api-gateway.md#mapping-example-console).
1. Remova **petType=dog** e escolha **Testar**.
1. O teste de método vai gerar um erro `400` com a seguinte mensagem de erro:
```
{
"message": "Missing required request parameters: [petType]"
}
```
**Como configurar a validação da solicitação para o método `POST`**
1. No painel de navegação principal, selecione **Recursos** e, depois, selecione o método **POST**.
1. Na guia **Solicitação de método**, em **Configurações de solicitação de método**, escolha **Editar**.
1. Em **Validador de solicitação**, selecione **Validar corpo.**
1. Em **Corpo da solicitação**, escolha **Adicionar modelo**.
1. Em **Tipo de conteúdo**, insira **application/json**. Se nenhum tipo de conteúdo correspondente for encontrado, a validação da solicitação não será executada. Para usar o mesmo modelo, independentemente do tipo de conteúdo, insira `$default`.
Em **Modelo**, selecione **PetStoreModel**.
1. Escolha **Salvar**.
**Como testar a validação da solicitação para um método `POST`**
1. Selecione a guia **Testar**. Talvez seja necessário selecionar o botão de seta para a direita para mostrar a guia.
1. Em **Corpo da solicitação**, cole o seguinte no editor de código:
```
{
"id": 2,
"name": "Bella",
"type": "dog",
"price": 400
}
```
Escolha **Testar**.
1. O teste de método vai gerar `200 OK` e uma mensagem de êxito.
1. Em **Corpo da solicitação**, cole o seguinte no editor de código:
```
{
"id": 2,
"name": "Bella",
"type": "dog",
"price": 4000
}
```
Escolha **Testar**.
1. O teste de método vai gerar um erro `400` com a seguinte mensagem de erro:
```
{
"message": "Invalid request body"
}
```
Na parte inferior dos logs de teste, o motivo do corpo de solicitação inválido será exibido. Nesse caso, o preço do animal de estimação estava fora do máximo especificado no modelo.
**Para excluir uma pilha do CloudFormation**
1. Abra o console do CloudFormation em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Selecione sua pilha do CloudFormation.
1. Escolha **Excluir** e, em seguida, confirme sua escolha.
### Próximas etapas
+ Para ter informações sobre como transformar os dados de saída e realizar o mapeamento de mais dados, consulte o [tutorial de mapeamento de dados](set-up-data-transformations-in-api-gateway.md#mapping-example-console).
+ Siga o tutorial [Configurar a validação básica da solicitação usando o AWS CLI](#api-gateway-request-validation-setup-cli), para realizar etapas semelhantes usando a AWS CLI.
## Configurar a validação básica de solicitações usando a AWS CLI
Você pode criar um validador para configurar a validação da solicitação usando a AWS CLI. Para seguir esse tutorial, você usará um modelo CloudFormation para criar uma API incompleta do API Gateway.
**nota**
Esse não é o mesmo modelo CloudFormation do tutorial do console.
Usando um recurso `/validator` pré-exposto, você criará os métodos `GET` e `POST`. Os dois métodos serão integrados ao endpoint HTTP `http://petstore-demo-endpoint.execute-api.com/petstore/pets`. Você vai configurar as duas validações de solicitação a seguir:
+ No método `GET`, você criará um validador `params-only` para validar os parâmetros da string de consulta de URL.
+ No método `POST`, você criará um validador `body-only` para validar o corpo da solicitação.
Isso vai possibilitar que somente determinadas chamadas de API sejam transmitidas à API.
**Como criar uma pilha do CloudFormation**
Baixe e descompacte [o modelo de criação de aplicativos para CloudFormation](samples/request-validation-tutorial-cli.zip).
Para concluir o tutorial a seguir, é necessária a [AWS Command Line Interface (AWS CLI) versão 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Para comandos longos, um caractere de escape (`\`) é usado para dividir um comando em várias linhas.
**nota**
No Windows, alguns comandos da CLI do Bash que você costuma usar (como `zip`) não são compatíveis com os terminais integrados do sistema operacional. Para obter uma versão do Ubuntu com o Bash integrada no Windows, [instale o Subsistema do Windows para Linux](https://learn.microsoft.com/en-us/windows/wsl/install). Os exemplos de comandos da CLI neste guia usam a formatação Linux. Os comandos que incluem documentos JSON em linha deverão ser reformatados se você estiver usando a CLI do Windows.
1. Use o comando a seguir para criar a pilha de CloudFormation.
```
aws cloudformation create-stack --stack-name request-validation-tutorial-cli --template-body file://request-validation-tutorial-cli.zip --capabilities CAPABILITY_NAMED_IAM
```
1. CloudFormationO fornece os recursos especificados no modelo. Pode demorar alguns minutos para concluir o provisionamento de seus recursos. Use o comando a seguir para ver o status de sua pilha de CloudFormation.
```
aws cloudformation describe-stacks --stack-name request-validation-tutorial-cli
```
1. Quando o status da sua pilha de CloudFormation for `StackStatus: "CREATE_COMPLETE"`, use o comando a seguir para recuperar valores de saída relevantes para etapas futuras.
```
aws cloudformation describe-stacks --stack-name request-validation-tutorial-cli --query "Stacks[*].Outputs[*].{OutputKey: OutputKey, OutputValue: OutputValue, Description: Description}"
```
Os valores de saída são os seguintes:
+ ApiId, que é o ID da API. Para este tutorial, o ID da API é `abc123`.
+ ResourceId, que é a ID do recurso validador em que os métodos `GET` e `POST` são expostos. Para este tutorial, o ID do recurso é `efg456`.
**Como criar os validadores de solicitação e importar um modelo**
1. É necessário um validador para usar a validação da solicitação com o AWS CLI. Use o comando a seguir para criar um validador que valide somente os parâmetros da solicitação.
```
aws apigateway create-request-validator --rest-api-id abc123 \
--no-validate-request-body \
--validate-request-parameters \
--name params-only
```
Anote o ID do validador `params-only`.
1. Use o comando a seguir para criar um validador que valide somente o corpo da solicitação.
```
aws apigateway create-request-validator --rest-api-id abc123 \
--validate-request-body \
--no-validate-request-parameters \
--name body-only
```
Anote o ID do validador `body-only`.
1. É necessário um modelo para usar a validação da solicitação no corpo de uma solicitação recebida. Use o comando a seguir para importar um modelo.
```
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}}}}'
```
Se nenhum tipo de conteúdo correspondente for encontrado, a validação da solicitação não será executada. Para usar o mesmo modelo, independentemente do tipo de conteúdo, especifique `$default` como a chave.
**Como criar os métodos `GET` e `POST`**
1. Use o comando a seguir para adicionar o método HTTP `GET` ao recurso `/validate`. Esse comando cria o método `GET`, adiciona o validador `params-only` e define a string de consulta `petType` conforme necessário.
```
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"
```
Use o comando a seguir para adicionar o método HTTP `POST` ao recurso `/validate`. Esse comando cria o método `POST`, adiciona o validador `body-only` e anexa o modelo ao validador exclusivo do corpo.
```
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. Use o comando a seguir para configurar a reposta `200 OK` do método como `GET /validate`.
```
aws apigateway put-method-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET \
--status-code 200
```
Use o comando a seguir para configurar a reposta `200 OK` do método como `POST /validate`.
```
aws apigateway put-method-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--status-code 200
```
1. Use o comando a seguir para configurar uma `Integration` com um endpoint HTTP especificado para o método `GET /validation`.
```
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'
```
Use o comando a seguir para configurar uma `Integration` com um endpoint HTTP especificado para o método `POST /validation`.
```
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. Use o comando a seguir para configurar a resposta de integração do método `GET /validation`.
```
aws apigateway put-integration-response --rest-api-id abc123 \
--resource-id efg456\
--http-method GET \
--status-code 200 \
--selection-pattern ""
```
Use o comando a seguir para configurar a resposta de integração do método `POST /validation`.
```
aws apigateway put-integration-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--status-code 200 \
--selection-pattern ""
```
**Como testar a API**
1. Para testar o método `GET`, que executará a validação da solicitação para as strings de consulta, use o seguinte comando:
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET \
--path-with-query-string '/validate?petType=dog'
```
O resultado retornará `200 OK` e uma lista de cães.
1. Use o comando a seguir para testar sem incluir a string de consulta `petType`.
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET
```
O resultado retornará um erro `400`.
1. Para testar o método `POST`, que executará a validação da solicitação para o corpo da string, use o seguinte comando:
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--body '{"id": 1, "name": "bella", "type": "dog", "price" : 400 }'
```
O resultado retornará `200 OK` e uma mensagem de êxito.
1. Use o comando a seguir para testar usando um corpo inválido.
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--body '{"id": 1, "name": "bella", "type": "dog", "price" : 1000 }'
```
O resultado retornará um erro `400`, pois o preço do cachorro está acima do preço máximo definido pelo modelo.
**Para excluir uma pilha do CloudFormation**
+ Use o comando a seguir para excluir seus recursos de CloudFormation.
```
aws cloudformation delete-stack --stack-name request-validation-tutorial-cli
```
## Configurar a validação básica de solicitações importando a definição de OpenAPI
Você pode declarar um validador de solicitação no nível da API especificando um conjunto de objetos [Objeto x-amazon-apigateway-request-validators.requestValidator](api-gateway-swagger-extensions-request-validators.requestValidator.md) no mapa [Objeto x-amazon-apigateway-request-validators](api-gateway-swagger-extensions-request-validators.md) para selecionar qual parte da solicitação será validada. No exemplo de definição de OpenAPI, há dois validadores:
+ O validador `all` que valida o corpo, usando o modelo de dados `RequestBodyModel`, e os parâmetros.
O modelo de dados `RequestBodyModel` requer que o objeto JSON de entrada contenha as propriedades `name`, `type` e `price`. A propriedade `name` pode ser qualquer string, `type` deve ser um dos campos de enumeração especificados (`["dog", "cat", "fish"]`) e `price` deve variar entre 25 e 500. O parâmetro `id` não é necessário.
+ `param-only` que valida somente os parâmetros.
Para ativar um validador de solicitação em todos os métodos de uma API, especifique uma propriedade [Propriedade x-amazon-apigateway-request-validator](api-gateway-swagger-extensions-request-validator.md) em nível de API da definição de OpenAPI. Na definição de OpenAPI de exemplo, o validador `all` é usado em todos os métodos de API, a menos que ele seja substituído de outra forma. Ao usar um modelo para validar o corpo, se nenhum tipo de conteúdo correspondente for encontrado, a validação da solicitação não será executada. Para usar o mesmo modelo, independentemente do tipo de conteúdo, especifique `$default` como a chave.
Para ativar um validador de solicitação em um método individual, especifique a propriedade `x-amazon-apigateway-request-validator` no nível do método. No exemplo, definição de OpenAPI, o validador `param-only` sobrescreve o validador `all` no método `GET`.
Para importar o exemplo de OpenAPI para o API Gateway, consulte as instruções a seguir para [Importar uma API regional para o API Gateway](import-export-api-endpoints.md) ou [Importar uma API otimizada para bordas para o API Gateway](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
}
}
}
```
------
# Modelo do AWS CloudFormation de uma API de amostra com validação de solicitação básica
A definição a seguir do modelo de exemplo do CloudFormation especifica uma API de amostra com a validação de solicitações habilitada. A API é um subconjunto da [API PetStore](http://petstore-demo-endpoint.execute-api.com/petstore/pets). Ela expõe um método `POST` para adicionar um animal de estimação à coleção `pets` e um método `GET` para consulta animais de estimação por um tipo especificado.
Há dois validadores de solicitações declarados:
**`GETValidator`**
Esse validador está habilitado no método `GET`. Ele permite que o API Gateway verifique se o parâmetro de consulta necessário (`q1`) está incluído e não está em branco na solicitação de entrada.
**`POSTValidator`**
Esse validador está habilitado no método `POST`. Isso permite que o API Gateway verifique se o formato da solicitação de carga está de acordo com o `RequestBodyModel` especificado quando o tipo de conteúdo é `application/json`. Caso nenhum tipo de conteúdo correspondente seja encontrado, a validação da solicitação não será realizada. Para usar o mesmo modelo, independentemente do tipo de conteúdo, especifique `$default`. `RequestBodyModel` contém um modelo adicional, `RequestBodyModelId`, para definir a identificação do animal de estimação.
```
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}'
```