# Solicitud de la validación de las API de REST en API Gateway
Puede configurar API Gateway para que realice una validación básica de una solicitud de API antes de continuar con la solicitud de integración. Cuando no se supera la validación, API Gateway invalida inmediatamente la solicitud, devuelve una respuesta de error 400 al intermediario y publica los resultados de la validación en logs de CloudWatch Logs. Esto reduce las llamadas innecesarias al backend. Y lo que es más importante, le permite centrarse en el trabajo de validación específico de su aplicación. Para validar el cuerpo de una solicitud, debe verificar que los parámetros obligatorios de la solicitud sean válidos y no nulos o especificar un esquema de modelo para una validación de datos más complicada.
**Topics**
+ [Información general de la validación básica de solicitudes en API Gateway](#api-gateway-request-validation-basic-definitions)
+ [Modelos de datos para las API de REST](models-mappings-models.md)
+ [Configuración de la validación básica de solicitudes en API Gateway](api-gateway-request-validation-set-up.md)
+ [Plantilla de AWS CloudFormation de una API de ejemplo con validación de solicitudes básica](api-gateway-request-validation-sample-cloudformation.md)
## Información general de la validación básica de solicitudes en API Gateway
API Gateway puede realizar la validación básica de las solicitudes, de modo que pueda centrarse en la validación específica de la aplicación en el backend. Para la validación, API Gateway verifica una o ambas de las condiciones siguientes:
+ Los parámetros de la solicitud necesarios en el URI, la cadena de consulta y los encabezados de una solicitud de entrada están presentes y no están vacíos. API Gateway solo comprueba la existencia de un parámetro y no verifica el tipo ni el formato.
+ La carga útil de solicitud aplicable se adhiere a la solicitud de [esquema JSON](https://datatracker.ietf.org/doc/html/draft-zyp-json-schema-04) configurada del método para un tipo de contenido determinado. Si no se encuentra ningún tipo de contenido coincidente, no se realiza la validación de la solicitud. Para utilizar el mismo modelo independientemente del tipo de contenido, establezca el tipo de contenido para el modelo de datos en `$default`.
Para habilitar la validación, debe especificar reglas de validación en un [validador de solicitudes](https://docs.aws.amazon.com/apigateway/latest/api/API_RequestValidator.html), agregar el validador al [mapa de validadores de solicitudes](https://docs.aws.amazon.com/apigateway/latest/api/API_RequestValidator.html) de la API y asignar el validador a métodos de la API individuales.
**nota**
La validación del cuerpo de la solicitud y [Comportamiento de solicitud de método para cargas útiles sin plantillas de asignación para las API de REST en API Gateway](integration-passthrough-behaviors.md) son dos temas distintos. Cuando una carga de solicitud no tiene ningún esquema de modelo coincidente, tiene la opción de elegir acceder directamente a ella o bloquear la carga original. Para obtener más información, consulte [Comportamiento de solicitud de método para cargas útiles sin plantillas de asignación para las API de REST en API Gateway](integration-passthrough-behaviors.md).
# Modelos de datos para las API de REST
En API Gateway, un modelo define la estructura de datos de una carga. En API Gateway, los modelos se definen mediante el [borrador 4 del esquema JSON](https://tools.ietf.org/html/draft-zyp-json-schema-04). El siguiente objeto JSON incluye datos de muestra del ejemplo de la tienda de mascotas (Pet Store).
```
{
"id": 1,
"type": "dog",
"price": 249.99
}
```
Los datos contienen el `id`, `type` y `price` de la mascota. Un modelo de estos datos le permite:
+ Utilizar la validación básica de solicitudes.
+ Crear plantillas de mapeo para la transformación de datos.
+ Crear un tipo de datos definido por el usuario (UDT) al generar un SDK.
![\[Ejemplo de modelo de datos JSON para la API de PetStore.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/how-to-validate-requests.png)
En este modelo:
1. El objeto `$schema` representa un identificador de versión válido del esquema JSON. Este esquema es la versión 4 del borrador del esquema JSON.
1. El objeto `title` es un identificador descriptivo del modelo. Este título es `PetStoreModel`.
1. La palabra clave de validación `required` requiere `type` y `price` para la validación básica de solicitudes.
1. Las `properties` del modelo son `id`, `type` y `price`. Cada objeto tiene propiedades que se describen en el modelo.
1. El objeto `type` solo puede tener los valores `dog`, `cat` o `fish`.
1. El objeto `price` es un número y está restringido con un valor `minimum` de 25 y un valor `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 }
```
En este modelo:
1. En la línea 2, el objeto `$schema` representa un identificador de versión válido del esquema JSON. Este esquema es la versión 4 del borrador del esquema JSON.
1. En la línea 3, el objeto `title` es un identificador descriptivo del modelo. Este título es `PetStoreModel`.
1. En la línea 5, la palabra clave de validación `required` requiere `type` y `price` para la validación básica de solicitudes.
1. En las líneas 6 a 17, las `properties` del modelo son `id`, `type` y `price`. Cada objeto tiene propiedades que se describen en el modelo.
1. En la línea 12, el objeto `type` solo puede tener los valores `dog`, `cat` o `fish`.
1. En las líneas 14 a 17, el objeto `price` es un número y está restringido con un valor `minimum` de 25 y un valor `maximum` de 500.
## Creación de modelos más complejos
Puede utilizar la primitiva `$ref` para crear definiciones reutilizables para modelos más largos. Por ejemplo, puede crear una definición llamada `Price` en la sección `definitions` que describa el objeto `price`. El valor de `$ref` es la definición de `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
}
}
}
```
También puede hacer referencia a otro esquema de modelo definido en un archivo de modelo externo. Defina el valor de la propiedad `$ref` en la ubicación del modelo. En el siguiente ejemplo, el modelo `Price` se define en el modelo `PetStorePrice` de la API `a1234`.
```
{
"$schema" : "http://json-schema.org/draft-04/schema#",
"title" : "PetStorePrice",
"type": "number",
"minimum": 25,
"maximum": 500
}
```
El modelo más largo puede hacer referencia al 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"
}
}
}
```
## Uso de modelos de datos de salida
Si transforma sus datos, puede definir un modelo de carga en la respuesta de integración. Se puede utilizar un modelo de carga al generar un SDK. Para lenguajes con establecimiento inflexible de tipos, como Java, Objective-C o Swift, el objeto se corresponde con un tipo de datos definido por el usuario (UDT). API Gateway crea un UDT si le facilita un modelo de datos al generar un SDK. Para obtener más información sobre las transformaciones de datos, consulte [Asignación de las transformaciones de plantillas de asignación para las API de REST en API Gateway](models-mappings.md).
En el siguiente ejemplo se muestran datos de salida de una respuesta de integración.
```
{
[
{
"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
}
]
}
```
En el siguiente ejemplo se muestra un modelo de carga que describe los datos de salida.
```
{
"$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
}
}
}
```
Con este modelo, puede llamar a un SDK para recuperar los valores de las propiedades `description` y `askingPrice` al leer las propiedades `PetStoreOutputModel[i].description` y `PetStoreOutputModel[i].askingPrice`. Si no se proporciona un modelo, API Gateway utiliza el modelo vacío para crear un UDT predeterminado.
## Pasos a seguir a continuación
+ En esta sección se proporcionan recursos que puede utilizar para obtener más información sobre los conceptos presentados en este tema.
Puede seguir los tutoriales de validación de solicitudes:
+ [Configuración de la validación de solicitudes mediante la consola de API Gateway](api-gateway-request-validation-set-up.md#api-gateway-request-validation-setup-in-console)
+ [Configuración de la validación básica de solicitudes mediante la AWS CLI](api-gateway-request-validation-set-up.md#api-gateway-request-validation-setup-cli)
+ [Configuración de la validación básica de solicitudes con una definición de OpenAPI](api-gateway-request-validation-set-up.md#api-gateway-request-validation-setup-importing-swagger)
+ Para obtener más información sobre la transformación de datos y las plantillas de asignación, [Asignación de las transformaciones de plantillas de asignación para las API de REST en API Gateway](models-mappings.md).
# Configuración de la validación básica de solicitudes en API Gateway
En esta sección se muestra cómo configurar la validación de solicitudes para API Gateway mediante la consola, la AWS CLI y una definición de OpenAPI.
**Topics**
+ [Configuración de la validación de solicitudes mediante la consola de API Gateway](#api-gateway-request-validation-setup-in-console)
+ [Configuración de la validación básica de solicitudes mediante la AWS CLI](#api-gateway-request-validation-setup-cli)
+ [Configuración de la validación básica de solicitudes con una definición de OpenAPI](#api-gateway-request-validation-setup-importing-swagger)
## Configuración de la validación de solicitudes mediante la consola de API Gateway
Para utilizar la consola de API Gateway para validar una solicitud, seleccione uno de los tres validadores para una solicitud de API:
+ **Validar el cuerpo**.
+ **Validar los parámetros de la cadena de consulta y los encabezados**.
+ **Validar el cuerpo, los parámetros de la cadena de consulta y los encabezados**.
Al aplicar uno de los validadores en un método de la API, la consola de API Gateway lo agrega al mapa [RequestValidators](https://docs.aws.amazon.com/apigateway/latest/api/API_RequestValidator.html) de la API.
Para seguir este tutorial, utilizará una plantilla CloudFormation para crear una API de API Gateway incompleta. Esta API incompleta tiene un recurso `/validator` con los métodos `GET` y `POST`. Ambos métodos están integrados con el punto de conexión HTTP `http://petstore-demo-endpoint.execute-api.com/petstore/pets`. Configurará dos tipos de validación de solicitudes:
+ En el método `GET`, configurará la validación de solicitudes para los parámetros de la cadena de consulta URL.
+ En el método `POST`, configurará la validación de solicitudes para el cuerpo de la solicitud.
Esto permitirá que solo ciertas llamadas a la API pasen a la API.
Descargue y descomprima [la plantilla de creación de aplicaciones para CloudFormation](samples/request-validation-tutorial-console.zip). Usará esta plantilla para crear una API incompleta. Finalizará el resto de los pasos en la consola de API Gateway.
**Para crear una pila de CloudFormation**
1. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Seleccione **Create stack (Crear pila)** y, a continuación, seleccione **With new resources (standard) (Con nuevos recursos [estándar])**.
1. En **Specify template (Especificar plantilla)**, elija **Upload a template file (Cargar un archivo de plantilla)**.
1. Seleccione la plantilla que ha descargado.
1. Elija **Next (Siguiente)**.
1. En **Stack name (Nombre de pila)**, escriba **request-validation-tutorial-console** y, a continuación, elija **Next (Siguiente)**.
1. En **Configure stack options (Configurar opciones de pila)**, elija **Next (Siguiente)**.
1. Para **Capabilities** (Capacidades), sepa que CloudFormation puede crear recursos de IAM en su cuenta.
1. Elija **Siguiente** y, a continuación, elija **Enviar**.
CloudFormation aprovisiona los recursos especificados en la plantilla. Puede tardar varios minutos en finalizar el aprovisionamiento de los recursos. Cuando el estado de la pila de CloudFormation sea **CREATE\$1COMPLETE**, estará listo para continuar con el paso siguiente.
**Para seleccionar la API recién creada**
1. Seleccione la pila **request-validation-tutorial-console** recién creada.
1. Seleccione **Recursos**.
1. En **ID físico**, seleccione la API. Este enlace lo dirigirá a la consola de API Gateway.
Antes de modificar los métodos `GET` y `POST`, debe crear un modelo.
**Para crear un modelo**
1. Se requiere un modelo para usar la validación de solicitudes en el cuerpo de una solicitud entrante. Para crear un modelo, en el panel de navegación principal, elija **Modelos**.
1. Seleccione **Crear modelo**.
1. En **Nombre**, escriba **PetStoreModel**.
1. En **Tipo de contenido**, indique **application/json**. Si no se encuentra ningún tipo de contenido coincidente, no se realiza la validación de la solicitud. Para utilizar el mismo modelo independientemente del tipo de contenido, introduzca **\$1default**.
1. En **Descripción**, indique **My PetStore Model** como descripción del modelo.
1. En **Esquema del modelo**, pegue el siguiente modelo en el editor de código y seleccione **Crear**.
```
{
"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 obtener más información acerca del modelo, consulte [Modelos de datos para las API de REST](models-mappings-models.md).
**Para configurar la validación de solicitudes para un método `GET`**
1. En el panel de navegación principal, seleccione **Recursos** y, a continuación, seleccione el método **GET**.
1. En la pestaña **Solicitud de método**, en **Configuración de solicitud de método**, elija **Editar**.
1. En **Validador de solicitud**, seleccione **Validar parámetros de cadena de consulta y encabezados**.
1. En **Parámetros de cadenas de consulta de URL**, haga lo siguiente:
1. Elija **Añadir cadena de consulta**.
1. En **Nombre**, escriba **petType**.
1. Active la opción **Obligatorio**.
1. Mantenga **Almacenamiento en caché** desactivado.
1. Seleccione **Save**.
1. En la pestaña **Solicitud de integración**, en **Configuración de la solicitud de integración**, seleccione **Editar**.
1. En **Parámetros de cadenas de consulta de URL**, haga lo siguiente:
1. Elija **Añadir cadena de consulta**.
1. En **Nombre**, escriba **petType**.
1. En **Asignado desde**, introduzca **method.request.querystring.petType**. Esto mapea el **petType** con el tipo de mascota.
Para obtener más información sobre el mapeo de datos, consulte [el tutorial de mapeo de datos](set-up-data-transformations-in-api-gateway.md#mapping-example-console).
1. Mantenga **Almacenamiento en caché** desactivado.
1. Seleccione **Save**.
**Para probar la validación de solicitudes para el método `GET`**
1. Elija la pestaña **Prueba**. Puede que tenga que elegir el botón de flecha hacia la derecha para mostrar la pestaña.
1. En **Cadenas de consulta**, introduzca **petType=dog** y seleccione **Prueba**.
1. La prueba del método dará como resultado `200 OK` y mostrará una lista de perros.
Para obtener información sobre cómo transformar estos datos de salida, consulte el [tutorial de mapeo de datos.](set-up-data-transformations-in-api-gateway.md#mapping-example-console)
1. Elimine **petType=dog** y seleccione **Pruebas**.
1. La prueba del método devolverá un error `400` con el siguiente mensaje de error:
```
{
"message": "Missing required request parameters: [petType]"
}
```
**Para configurar la validación de solicitudes para el método `POST`**
1. En el panel de navegación principal, seleccione **Recursos** y, a continuación, seleccione el método **POST**.
1. En la pestaña **Solicitud de método**, en **Configuración de solicitud de método**, elija **Editar**.
1. En **Validador de solicitudes**, seleccione **Validar cuerpo**.
1. En **Cuerpo de la solicitud**, seleccione **Agregar modelo**.
1. En **Tipo de contenido**, ingrese **application/json**. Si no se encuentra ningún tipo de contenido coincidente, no se realiza la validación de la solicitud. Para utilizar el mismo modelo independientemente del tipo de contenido, introduzca `$default`.
En **Modelo**, seleccione **PetStoreModel**.
1. Seleccione **Save**.
**Para probar la validación de solicitudes para un método `POST`**
1. Elija la pestaña **Prueba**. Puede que tenga que elegir el botón de flecha hacia la derecha para mostrar la pestaña.
1. En **Cuerpo de la solicitud**, pegue lo siguiente en el editor de código:
```
{
"id": 2,
"name": "Bella",
"type": "dog",
"price": 400
}
```
Seleccione **Probar**
1. La prueba del método devolverá `200 OK` y un mensaje de éxito.
1. En **Cuerpo de la solicitud**, pegue lo siguiente en el editor de código:
```
{
"id": 2,
"name": "Bella",
"type": "dog",
"price": 4000
}
```
Seleccione **Probar**
1. La prueba del método devolverá un error `400` con el siguiente mensaje de error:
```
{
"message": "Invalid request body"
}
```
En la parte inferior de los registros de pruebas, se mostrará el motivo por el que el cuerpo de la solicitud no es válido. En este caso, el precio de la mascota estaba fuera del máximo especificado en el modelo.
**Para eliminar una pila de CloudFormation**
1. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Seleccione su pila de CloudFormation.
1. Elija **Delete (Eliminar)** y, a continuación, confirme su elección.
### Pasos a seguir a continuación
+ Para obtener información sobre cómo transformar estos datos de salida y realizar más mapeos de datos, consulte el [tutorial de mapeo de datos.](set-up-data-transformations-in-api-gateway.md#mapping-example-console)
+ Siga el tutorial [Configuración de la validación básica de solicitudes mediante la AWS CLI](#api-gateway-request-validation-setup-cli) para realizar pasos similares con la AWS CLI.
## Configuración de la validación básica de solicitudes mediante la AWS CLI
Puede crear un validador para configurar la validación de solicitudes mediante la AWS CLI Para seguir este tutorial, utilizará una plantilla CloudFormation para crear una API de API Gateway incompleta.
**nota**
Esta no es la misma plantilla de CloudFormation que la del tutorial de la consola.
Con un recurso `/validator` preexpuesto, creará los métodos `GET` y `POST`. Ambos métodos están integrados con el punto de conexión HTTP `http://petstore-demo-endpoint.execute-api.com/petstore/pets`. Configurará las dos validaciones de solicitudes siguientes:
+ En el método `GET`, creará un validador `params-only` para validar los parámetros de la cadena de consulta de URL.
+ En el método `POST`, creará un validador `body-only` para validar el cuerpo de la solicitud.
Esto permitirá que solo ciertas llamadas a la API pasen a la API.
**Para crear una pila de CloudFormation**
Descargue y descomprima [la plantilla de creación de aplicaciones para CloudFormation](samples/request-validation-tutorial-cli.zip).
Para completar el siguiente tutorial, necesita la [versión 2 de la AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Para comandos largos, se utiliza un carácter de escape (`\`) para dividir un comando en varias líneas.
**nota**
En Windows, algunos comandos de la CLI de Bash que utiliza habitualmente (por ejemplo, `zip`) no son compatibles con los terminales integrados del sistema operativo. Para obtener una versión de Ubuntu y Bash integrada con Windows, [instale el subsistema de Windows para Linux](https://learn.microsoft.com/en-us/windows/wsl/install). Los comandos de la CLI de ejemplo de esta guía utilizan el formato Linux. Los comandos que incluyen documentos JSON en línea deben reformatearse si utiliza la CLI de Windows.
1. Utilice el siguiente comando para crear la pila CloudFormation.
```
aws cloudformation create-stack --stack-name request-validation-tutorial-cli --template-body file://request-validation-tutorial-cli.zip --capabilities CAPABILITY_NAMED_IAM
```
1. CloudFormation aprovisiona los recursos especificados en la plantilla. Puede tardar varios minutos en finalizar el aprovisionamiento de los recursos. Use el siguiente comando para ver el estado de su pila CloudFormation.
```
aws cloudformation describe-stacks --stack-name request-validation-tutorial-cli
```
1. Cuando el estado de su pila CloudFormation sea `StackStatus: "CREATE_COMPLETE"`, utilice el siguiente comando para recuperar los valores de salida relevantes para los pasos futuros.
```
aws cloudformation describe-stacks --stack-name request-validation-tutorial-cli --query "Stacks[*].Outputs[*].{OutputKey: OutputKey, OutputValue: OutputValue, Description: Description}"
```
A continuación se muestran los valores de salida:
+ ApiID, que es el identificador de la API. Para este tutorial, el ID de la API es `abc123`.
+ ResourceId, que es el identificador del recurso del validador donde están expuestos los métodos `GET` y `POST`. Para este tutorial, el ID del recurso es `efg456`.
**Para crear los validadores de solicitudes e importar un modelo**
1. Se requiere un validador para utilizar la validación de solicitudes con la AWS CLI. Utilice el siguiente comando para crear un validador que valide únicamente los parámetros de la solicitud.
```
aws apigateway create-request-validator --rest-api-id abc123 \
--no-validate-request-body \
--validate-request-parameters \
--name params-only
```
Anote el ID del validador `params-only`.
1. Utilice el siguiente comando para crear un validador que valide únicamente el cuerpo de la solicitud.
```
aws apigateway create-request-validator --rest-api-id abc123 \
--validate-request-body \
--no-validate-request-parameters \
--name body-only
```
Anote el ID del validador `body-only`.
1. Se requiere un modelo para usar la validación de solicitudes en el cuerpo de una solicitud entrante. Utilice el siguiente comando para importar un 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}}}}'
```
Si no se encuentra ningún tipo de contenido coincidente, no se realiza la validación de la solicitud. Para utilizar el mismo modelo independientemente del tipo de contenido, especifique `$default` como la clave.
**Para crear los métodos `GET` y `POST`**
1. Use el siguiente comando para añadir el método HTTP `GET` en el recurso `/validate`. Este comando crea el método `GET`, agrega el validador `params-only` y establece la cadena de consulta `petType` según sea necesario.
```
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 el siguiente comando para añadir el método HTTP `POST` en el recurso `/validate`. Este comando crea el método `POST`, agrega el validador `body-only` y adjunta el modelo al validador exclusivo para el cuerpo.
```
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 el siguiente comando para configurar la respuesta `200 OK` del método `GET /validate`.
```
aws apigateway put-method-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET \
--status-code 200
```
Use el siguiente comando para configurar la respuesta `200 OK` del método `POST /validate`.
```
aws apigateway put-method-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--status-code 200
```
1. Use el siguiente comando para configurar una `Integration` con un punto de conexión HTTP especificado para el 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 el siguiente comando para configurar una `Integration` con un punto de conexión HTTP especificado para el 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 el siguiente comando para configurar la respuesta de integración para el 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 el siguiente comando para configurar la respuesta de integración para el método `POST /validation`.
```
aws apigateway put-integration-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--status-code 200 \
--selection-pattern ""
```
**Para probar el API**
1. Para probar el método `GET`, que realizará la validación de la solicitud para las cadenas de consulta, utilice el siguiente comando:
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET \
--path-with-query-string '/validate?petType=dog'
```
El resultado devolverá `200 OK` y una lista de perros.
1. Use el siguiente comando para probar sin incluir la cadena de consulta `petType`.
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET
```
El resultado devolverá un error `400`.
1. Para probar el método `POST`, que realizará la validación de la solicitud para el cuerpo de la solicitud, utilice el siguiente 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 }'
```
El resultado devolverá `200 OK` y un mensaje de éxito.
1. Use el siguiente comando para probar el uso de un cuerpo no vá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 }'
```
El resultado devolverá un error `400`, ya que el precio del perro supera el precio máximo definido por el modelo.
**Para eliminar una pila de CloudFormation**
+ Use el siguiente comando para eliminar los recursos CloudFormation.
```
aws cloudformation delete-stack --stack-name request-validation-tutorial-cli
```
## Configuración de la validación básica de solicitudes con una definición de OpenAPI
Puede declarar un validador de solicitudes en el nivel de la API especificando un conjunto de objetos [Objeto x-amazon-apigateway-request-validators.requestValidator](api-gateway-swagger-extensions-request-validators.requestValidator.md) en el mapa [Objeto x-amazon-apigateway-request-validators](api-gateway-swagger-extensions-request-validators.md) para seleccionar qué parte de la solicitud se validará. En la definición de OpenAPI de ejemplo hay dos validadores:
+ El validador `all`, que valida tanto el cuerpo, utilizando el modelo de datos `RequestBodyModel`, como los parámetros.
El modelo de datos `RequestBodyModel` exige que el objeto JSON de entrada contenga las propiedades `name`, `type` y `price`. La propiedad `name` puede ser cualquier cadena, `type` debe ser uno de los campos de la enumeración especificada (`["dog", "cat", "fish"]`) y `price` debe estar comprendido entre 25 y 500. El parámetro `id` no es obligatorio.
+ `param-only`, que valida solo los parámetros.
Para habilitar un validador de solicitudes en todos los métodos de una API, especifique una propiedad [Propiedad x-amazon-apigateway-request-validator](api-gateway-swagger-extensions-request-validator.md) en el nivel de la API de la definición de OpenAPI. En el ejemplo de definición de OpenAPI, el validador `all` se usa en todos los métodos de la API, a menos que se invalide de otro modo. Cuando se utiliza un modelo para validar el cuerpo, si no se encuentra ningún tipo de contenido coincidente, no se realiza la validación de la solicitud. Para utilizar el mismo modelo independientemente del tipo de contenido, especifique `$default` como la clave.
Para habilitar un validador de solicitudes para un método individual, especifique la propiedad `x-amazon-apigateway-request-validator` en el nivel de método. En el ejemplo de definición de OpenAPI, el validador `param-only` anula el validador `all` del método `GET`.
Para importar el ejemplo de OpenAPI a API Gateway, consulte las siguientes instrucciones para [Importación de una API regional en API Gateway](import-export-api-endpoints.md) o para [Importación de una API optimizada para bordes en 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
}
}
}
```
------
# Plantilla de AWS CloudFormation de una API de ejemplo con validación de solicitudes básica
La siguiente definición de plantilla de ejemplo de CloudFormation define una API de ejemplo con la validación de solicitudes habilitada. La API es un subconjunto de la [API PetStore](http://petstore-demo-endpoint.execute-api.com/petstore/pets). Expone un método `POST` para añadir una mascota a la colección `pets` y un método `GET` para consultar las mascotas de un tipo especificado.
Hay dos validadores de solicitudes declarados:
**`GETValidator`**
Este validador está habilitado en el método `GET`. Permite a API Gateway verificar que el parámetro de consulta obligatorio (`q1`) está incluido y no está en blanco en la solicitud de entrada.
**`POSTValidator`**
Este validador está habilitado en el método `POST`. Permite a API Gateway verificar que el formato de la solicitud de carga se adhiere al `RequestBodyModel` especificado cuando el tipo de contenido es `application/json` si no se encuentra un tipo de contenido coincidente, no se realiza la validación de la solicitud. Para utilizar el mismo modelo independientemente del tipo de contenido, especifique `$default`. `RequestBodyModel` contiene un modelo adicional, `RequestBodyModelId`, para definir el ID de mascota.
```
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}'
```