Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Demande de validation pour REST APIs dans API Gateway
Vous pouvez configurer API Gateway afin d’exécuter la validation de base d’une demande d’API avant de procéder à la demande d’intégration. Lorsque la validation échoue, API Gateway échoue immédiatement à la demande, renvoie une réponse d'erreur 400 à l'appelant et publie les résultats de la validation dans CloudWatch Logs. Cela permet de réduire les appels non nécessaires au backend. Qui plus est, il vous permet de vous concentrer sur les efforts de validation spécifiques à votre application. Vous pouvez valider un corps de demande en vérifiant que les paramètres de demande obligatoires sont valides et autres que null ou en indiquant un schéma de modèle pour la validation de données plus compliquées.
**Topics**
+ [Présentation de la validation de demande de base dans API Gateway](#api-gateway-request-validation-basic-definitions)
+ [Modèles de données pour REST APIs](models-mappings-models.md)
+ [Configuration de la validation de demande de base dans API Gateway](api-gateway-request-validation-set-up.md)
+ [AWS CloudFormation modèle d'un exemple d'API avec validation de demande de base](api-gateway-request-validation-sample-cloudformation.md)
## Présentation de la validation de demande de base dans API Gateway
API Gateway peut effectuer la validation de base des demandes, afin que vous puissiez vous concentrer sur la validation spécifique à l’application dans le backend. Pour la validation, API Gateway vérifie l’une ou l’ensemble des conditions suivantes :
+ Les paramètres de demande obligatoires dans l’URI, la chaîne de requête et les en-têtes d’une demande entrante sont inclus et non vides. API Gateway vérifie uniquement si un paramètre existe. Il ne vérifie ni son type ni son format.
+ Les données utiles de la demande adhère à la demande de [schéma JSON](https://datatracker.ietf.org/doc/html/draft-zyp-json-schema-04) configurée de la méthode pour un type de contenu donné. Si aucun type de contenu correspondant n’est trouvé, la validation de demande n’est pas effectuée. Pour utiliser le même modèle quel que soit le type de contenu, définissez le type de contenu de votre modèle de données sur `$default`.
Pour activer la validation, vous indiquez des règles de validation dans un [validateur de demande](https://docs.aws.amazon.com/apigateway/latest/api/API_RequestValidator.html), vous ajoutez le validateur au [mappage des validateurs de demande](https://docs.aws.amazon.com/apigateway/latest/api/API_RequestValidator.html) de l’API, puis vous affectez le validateur à des méthodes d’API individuelles.
**Note**
La validation du corps de la demande et les [Comportement des demandes de méthode pour les charges utiles sans modèles de mappage pour REST APIs dans API Gateway](integration-passthrough-behaviors.md) sont deux sujets distincts. Quand la charge utile d’une demande n’a pas de schéma de modèle correspondant, vous pouvez choisir de transmettre ou de bloquer la charge utile d’origine. Pour de plus amples informations, veuillez consulter [Comportement des demandes de méthode pour les charges utiles sans modèles de mappage pour REST APIs dans API Gateway](integration-passthrough-behaviors.md).
# Modèles de données pour REST APIs
Dans API Gateway, un modèle définit la structure de données d’une charge utile. Dans API Gateway, les modèles sont définis à l’aide du [schéma JSON version 4](https://tools.ietf.org/html/draft-zyp-json-schema-04). L’objet JSON suivant est un exemple de données figurant dans l’exemple d’animalerie.
```
{
"id": 1,
"type": "dog",
"price": 249.99
}
```
Les données contiennent les éléments `id`, `type` et `price` de l’animal de compagnie. Un modèle de ces données vous permet de :
+ Utiliser la validation de base des demandes.
+ Créer des modèles de mappage pour la transformation des données.
+ Créer un type de données défini par l’utilisateur (UDT) lorsque vous générez un kit SDK.
![\[Exemple de modèle de données JSON pour PetStore l'API.\]](http://docs.aws.amazon.com/fr_fr/apigateway/latest/developerguide/images/how-to-validate-requests.png)
Dans ce modèle :
1. L’objet `$schema` représente un identifiant de version de schéma JSON valide. Ce schéma est le brouillon de schéma JSON version 4.
1. L’objet `title` est un identifiant du modèle lisible à l’œil. Ce titre est `PetStoreModel`.
1. Le mot clé de validation `required` requiert `type` et `price` pour la validation de base des demandes.
1. Les propriétés (`properties`) du modèle sont `id`, `type` et `price`. Chaque objet possède des propriétés qui sont décrites dans le modèle.
1. L’objet `type` ne peut avoir que les valeurs `dog`, `cat` ou `fish`.
1. L’objet `price` est un nombre limité entre un `minimum` de 25 et un `maximum` de 500.
## PetStore modèle
```
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 }
```
Dans ce modèle :
1. Ligne 2, l’objet `$schema` représente un identifiant de version de schéma JSON valide. Ce schéma est le brouillon de schéma JSON version 4.
1. Ligne 3, l’objet `title` est un identifiant lisible du modèle. Ce titre est `PetStoreModel`.
1. Ligne 5, le mot clé de validation `required` requiert `type` et `price` pour la validation de base des demandes.
1. Lignes 6 à 17, les propriétés (`properties`) du modèle sont `id`, `type` et `price`. Chaque objet possède des propriétés qui sont décrites dans le modèle.
1. Ligne 12, l’objet `type` ne peut avoir que les valeurs `dog`, `cat` ou `fish`.
1. Lignes 14 à 17, l’objet `price` est un nombre limité entre un `minimum` de 25 et un `maximum` de 500.
## Création de modèles plus complexes
Vous pouvez utiliser la primitive `$ref` pour créer des définitions réutilisables pour des modèles plus longs. Par exemple, vous pouvez créer une définition appelée `Price` dans la section `definitions` décrivant l’objet `price`. La valeur de `$ref` est la définition `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
}
}
}
```
Vous pouvez également référencer un autre schéma de modèle défini dans un fichier de modèle externe. Définissez la valeur de la propriété `$ref` en fonction de l’emplacement du modèle. Dans l’exemple suivant, le modèle `Price` est défini dans le modèle `PetStorePrice` dans l’API `a1234`.
```
{
"$schema" : "http://json-schema.org/draft-04/schema#",
"title" : "PetStorePrice",
"type": "number",
"minimum": 25,
"maximum": 500
}
```
Le modèle le plus long peut référencer le modèle `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"
}
}
}
```
## Utilisation de modèles de données de sortie
Si vous transformez vos données, vous pouvez définir un modèle de charge utile dans la réponse d’intégration. Un modèle de charge utile peut être utilisé lorsque vous générez un kit SDK. Pour les langages fortement typés, comme Java, Objective-C ou Swift, l’objet correspond à un type de données défini par l’utilisateur (UDT). API Gateway crée un type UDT si vous lui fournissez un modèle de données lorsque vous générez un kit SDK. Pour plus d’informations sur les transformations de données, consultez [Transformations de modèles de mappage pour REST APIs dans API Gateway](models-mappings.md).
L’exemple suivant présente les données de sortie d’une réponse d’intégration.
```
{
[
{
"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
}
]
}
```
L’exemple suivant est un modèle de données utiles qui décrit les données de sortie.
```
{
"$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
}
}
}
```
Avec ce modèle, vous pouvez appeler un kit SDK pour récupérer les valeurs des propriétés `description` et `askingPrice` en lisant les propriétés `PetStoreOutputModel[i].description` et `PetStoreOutputModel[i].askingPrice`. Si aucun modèle n’est fourni, API Gateway utilise le modèle vide pour créer un type UDT par défaut.
## Étapes suivantes
+ Cette section fournit des ressources que vous pouvez utiliser pour en apprendre davantage sur les concepts présentés dans cette rubrique.
Vous pouvez suivre les didacticiels de validation des demandes :
+ [Configuration la validation des demandes à l’aide de la console API Gateway](api-gateway-request-validation-set-up.md#api-gateway-request-validation-setup-in-console)
+ [Configurez la validation de base des demandes à l'aide du AWS CLI](api-gateway-request-validation-set-up.md#api-gateway-request-validation-setup-cli)
+ [Configuration de la validation de base des demandes à l’aide d’une définition OpenAPI](api-gateway-request-validation-set-up.md#api-gateway-request-validation-setup-importing-swagger)
+ Pour plus d’informations sur la transformation des données et les modèles de mappage, consultez [Transformations de modèles de mappage pour REST APIs dans API Gateway](models-mappings.md).
# Configuration de la validation de demande de base dans API Gateway
Cette section explique comment configurer la validation des demandes pour API Gateway à l'aide de la console et d'une définition OpenAPI. AWS CLI
**Topics**
+ [Configuration la validation des demandes à l’aide de la console API Gateway](#api-gateway-request-validation-setup-in-console)
+ [Configurez la validation de base des demandes à l'aide du AWS CLI](#api-gateway-request-validation-setup-cli)
+ [Configuration de la validation de base des demandes à l’aide d’une définition OpenAPI](#api-gateway-request-validation-setup-importing-swagger)
## Configuration la validation des demandes à l’aide de la console API Gateway
Vous pouvez utiliser la console API Gateway pour valider une demande en sélectionnant l’un des trois validateurs suivants pour une demande d’API :
+ **Valider le corps**.
+ **Valider les paramètres de chaîne de requête et les en-têtes**.
+ **Valider le corps et les paramètres et en-têtes des chaînes de requête**.
Lorsque vous appliquez l'un des validateurs à une méthode d'API, la console API Gateway ajoute le validateur à la carte de [RequestValidators](https://docs.aws.amazon.com/apigateway/latest/api/API_RequestValidator.html)l'API.
Pour suivre ce didacticiel, vous allez utiliser un CloudFormation modèle pour créer une API API Gateway incomplète. Cette API possède une ressource `/validator` avec les méthodes `GET` et `POST`. Ces deux méthodes sont intégrées avec le point de terminaison HTTP `http://petstore-demo-endpoint.execute-api.com/petstore/pets`. Vous allez configurer deux types de validation des demandes :
+ Dans la méthode `GET`, vous allez configurer la validation des demandes pour les paramètres de chaîne de requête d’URL.
+ Dans la méthode `POST`, vous allez configurer la validation des demandes pour le corps de la demande.
Cela permettra uniquement à certains appels d'API d'être transmis à l'API.
Téléchargez et décompressez [le modèle de création d'application pour CloudFormation](samples/request-validation-tutorial-console.zip). Vous allez utiliser ce modèle pour créer une API incomplète. Vous terminerez les étapes restantes dans la console API Gateway.
**Pour créer une CloudFormation pile**
1. Ouvrez la CloudFormation console à l'adresse [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Choisissez **Créer une pile**, puis choisissez **Avec de nouvelles ressources (standard).**
1. Dans **Spécifier le modèle**, choisissez **Charger un modèle de fichier**.
1. Sélectionnez le modèle que vous avez téléchargé.
1. Choisissez **Suivant**.
1. Pour **Nom de la pile**, saisissez **request-validation-tutorial-console**, puis choisissez **Suivant**.
1. Pour **Configurer les options de pile**, choisissez **Suivant**.
1. Pour les **fonctionnalités**, reconnaissez que CloudFormation vous pouvez créer des ressources IAM dans votre compte.
1. Choisissez **Suivant**, puis **Soumettre**.
CloudFormation fournit les ressources spécifiées dans le modèle. La fin du provisionnement de vos ressources peut prendre quelques minutes. Lorsque le statut de votre CloudFormation pile est **CREATE\$1COMPLETE**, vous êtes prêt à passer à l'étape suivante.
**Pour sélectionner l’API que vous venez de créer**
1. Sélectionnez la pile **request-validation-tutorial-console** nouvellement créée.
1. Sélectionnez **Ressources**.
1. Sous **ID physique**, choisissez votre API. Ce lien vous dirigera vers la console API Gateway.
Avant de modifier les méthodes `GET` et `POST`, vous devez créer un modèle.
**Pour créer un modèle**
1. Un modèle est requis pour utiliser la validation des demandes sur le corps d'une demande entrante. Pour créer un modèle, dans le volet de navigation principal, choisissez **Modèles**.
1. Sélectionnez **Créer un modèle**.
1. Pour **Nom**, saisissez **PetStoreModel**.
1. Pour **Type de contenu**, entrez **application/json**. Si aucun type de contenu correspondant n’est trouvé, la validation de demande n’est pas effectuée. Pour utiliser le même modèle quel que soit le type de contenu, saisissez **\$1default**.
1. Pour **Description**, saisissez **My PetStore Model** comme description du modèle.
1. Pour **Schéma du modèle**, collez le modèle suivant dans l’éditeur de code, puis choisissez **Créer**.
```
{
"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
}
}
}
```
Pour plus d’informations sur le modèle, consultez [Modèles de données pour REST APIs](models-mappings-models.md).
**Pour configurer la validation de requête pour une méthode `GET`**
1. Dans le volet de navigation principal, choisissez **Ressources**, puis sélectionnez la méthode **GET**.
1. Dans l’onglet **Demande de méthode**, sous **Paramètres de requête de méthode**, choisissez **Modifier**.
1. Pour **Validateur de requête**, sélectionnez **Valider les paramètres de chaîne de requête et les en-têtes**.
1. Sous **Paramètres de chaîne de requête d’URL**, procédez comme suit :
1. Sélectionnez **Add query string** (Ajouter une chaîne de requêtes).
1. Pour **Nom**, saisissez **petType**.
1. Activez **Obligatoire**.
1. Maintenez **Mise en cache** désactivée.
1. Choisissez **Enregistrer**.
1. Dans l’onglet **Requête d’intégration**, sous **Paramètres de requête d’intégration**, choisissez **Modifier**.
1. Sous **Paramètres de chaîne de requête d’URL**, procédez comme suit :
1. Sélectionnez **Add query string** (Ajouter une chaîne de requêtes).
1. Pour **Nom**, saisissez **petType**.
1. Pour **Mappage à partir de**, entrez **method.request.querystring.petType**. Cela mappe **petType** au type d’animal de compagnie.
Pour plus d’informations sur le mappage des données, consultez [le didacticiel sur le mappage des données](set-up-data-transformations-in-api-gateway.md#mapping-example-console).
1. Maintenez **Mise en cache** désactivée.
1. Choisissez **Enregistrer**.
**Pour tester la validation des requêtes pour la méthode `GET`**
1. Choisissez l’onglet **Test**. Vous devrez peut-être choisir la flèche droite pour afficher l’onglet.
1. Pour **Chaînes de requête**, saisissez **petType=dog**, puis choisissez **Tester**.
1. Le test de méthode renverra `200 OK` et une liste de chiens.
Pour obtenir des informations sur la façon de transformer ces données de sortie, consultez le [didacticiel sur le mappage des données](set-up-data-transformations-in-api-gateway.md#mapping-example-console).
1. Supprimez **petType=dog** et choisissez **Tester**.
1. Le test de méthode renverra une erreur `400` avec le message d’erreur suivant :
```
{
"message": "Missing required request parameters: [petType]"
}
```
**Pour configurer la validation de requête pour la méthode `POST`**
1. Dans le volet de navigation principal, sélectionnez **Ressources**, puis sélectionnez la méthode **POST**.
1. Dans l’onglet **Demande de méthode**, sous **Paramètres de requête de méthode**, choisissez **Modifier**.
1. Pour **Validateur de requête**, sélectionnez **Valider le corps**.
1. Sous **Corps de la requête**, choisissez **Ajouter un modèle**.
1. Pour **Type de contenu**, entrez **application/json**. Si aucun type de contenu correspondant n’est trouvé, la validation de demande n’est pas effectuée. Pour utiliser le même modèle quel que soit le type de contenu, saisissez `$default`.
Pour **Modèle**, sélectionnez **PetStoreModel**.
1. Choisissez **Enregistrer**.
**Pour tester la validation de requête pour une méthode `POST`**
1. Choisissez l’onglet **Test**. Vous devrez peut-être choisir la flèche droite pour afficher l’onglet.
1. Sous **Corps de la requête**, collez ce qui suit dans l’éditeur de code :
```
{
"id": 2,
"name": "Bella",
"type": "dog",
"price": 400
}
```
Sélectionnez **Tester)**.
1. Le test de méthode renverra `200 OK` et un message de réussite.
1. Sous **Corps de la requête**, collez ce qui suit dans l’éditeur de code :
```
{
"id": 2,
"name": "Bella",
"type": "dog",
"price": 4000
}
```
Sélectionnez **Tester)**.
1. Le test de méthode renverra une erreur `400` avec le message d’erreur suivant :
```
{
"message": "Invalid request body"
}
```
Au bas des journaux de test, la raison pour laquelle le corps de la requête est non valide est renvoyée. Dans ce cas, le prix de l’animal de compagnie était supérieur au maximum spécifié dans le modèle.
**Pour supprimer une CloudFormation pile**
1. Ouvrez la CloudFormation console à l'adresse [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Sélectionnez votre CloudFormation pile.
1. Choisissez **Supprimer**, puis confirmez votre choix.
### Étapes suivantes
+ Pour obtenir des informations sur la façon de transformer les données de sortie et d’effectuer plus de mappage des données, consultez le [didacticiel sur le mappage des données](set-up-data-transformations-in-api-gateway.md#mapping-example-console).
+ Suivez le didacticiel [Configuration d’une validation de base des demandes à l’aide de l’interface AWS CLI](#api-gateway-request-validation-setup-cli), pour effectuer des étapes similaires à l’aide de l’interface AWS CLI.
## Configurez la validation de base des demandes à l'aide du AWS CLI
Vous pouvez créer un validateur pour configurer la validation des demandes à l’aide de l’interface AWS CLI. Pour suivre ce didacticiel, vous allez utiliser un CloudFormation modèle pour créer une API API Gateway incomplète.
**Note**
Il ne s'agit pas du même CloudFormation modèle que le didacticiel de la console.
À l’aide d’une ressource `/validator` pré-exposée, vous allez créer les méthodes `GET` et `POST`. Ces deux méthodes seront intégrées avec le point de terminaison HTTP `http://petstore-demo-endpoint.execute-api.com/petstore/pets`. Vous allez configurer les deux validations de demandes suivantes :
+ Sur la méthode `GET`, vous allez créer un validateur `params-only` pour valider les paramètres de chaîne de requête d’URL.
+ Sur la méthode `POST`, vous allez créer un validateur `body-only` pour valider le corps de la demande.
Cela permettra uniquement à certains appels d'API d'être transmis à l'API.
**Pour créer une CloudFormation pile**
Téléchargez et décompressez [le modèle de création d'application pour CloudFormation](samples/request-validation-tutorial-cli.zip).
Pour effectuer le didacticiel suivant, vous avez besoin de l’[AWS Command Line Interface (AWS CLI) version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Pour les commandes longues, un caractère d’échappement (`\`) est utilisé pour les fractionner en plusieurs lignes.
**Note**
Dans Windows, certaines commandes CLI Bash que vous utilisez couramment (par exemple `zip`) ne sont pas prises en charge par les terminaux intégrés du système d’exploitation. [Installez le sous-système Windows pour Linux](https://learn.microsoft.com/en-us/windows/wsl/install) afin d’obtenir une version intégrée avec Windows d’Ubuntu et Bash. Les exemples de commandes CLI de ce guide utilisent le formatage Linux. Les commandes qui incluent des documents JSON en ligne doivent être reformatées si vous utilisez la CLI Windows.
1. Utilisez la commande suivante pour créer la CloudFormation pile.
```
aws cloudformation create-stack --stack-name request-validation-tutorial-cli --template-body file://request-validation-tutorial-cli.zip --capabilities CAPABILITY_NAMED_IAM
```
1. CloudFormation fournit les ressources spécifiées dans le modèle. La fin du provisionnement de vos ressources peut prendre quelques minutes. Utilisez la commande suivante pour voir l'état de votre CloudFormation pile.
```
aws cloudformation describe-stacks --stack-name request-validation-tutorial-cli
```
1. Lorsque le statut de votre CloudFormation pile est défini`StackStatus: "CREATE_COMPLETE"`, utilisez la commande suivante pour récupérer les valeurs de sortie pertinentes pour les étapes futures.
```
aws cloudformation describe-stacks --stack-name request-validation-tutorial-cli --query "Stacks[*].Outputs[*].{OutputKey: OutputKey, OutputValue: OutputValue, Description: Description}"
```
Les valeurs de sortie sont les suivantes :
+ ApiId, qui est l'ID de l'API. Pour ce didacticiel, l’ID d’API est `abc123`.
+ ResourceId, qui est l'ID de la ressource de validation dans laquelle les `POST` méthodes `GET` et sont exposées. Pour ce didacticiel, l’ID de ressource est `efg456`.
**Pour créer les validateurs de demandes et importer un modèle**
1. Un validateur est requis pour utiliser la validation des demandes avec l’interface AWS CLI. Utilisez la commande suivante pour créer un validateur qui valide uniquement les paramètres de demande.
```
aws apigateway create-request-validator --rest-api-id abc123 \
--no-validate-request-body \
--validate-request-parameters \
--name params-only
```
Notez l'ID du validateur `params-only`.
1. Utilisez la commande suivante pour créer un validateur qui valide uniquement le corps de la demande.
```
aws apigateway create-request-validator --rest-api-id abc123 \
--validate-request-body \
--no-validate-request-parameters \
--name body-only
```
Notez l'ID du validateur `body-only`.
1. Un modèle est requis pour utiliser la validation des demandes sur le corps d'une demande entrante. Utilisez la commande suivante pour importer un modèle.
```
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 aucun type de contenu correspondant n'est trouvé, la validation de demande n'est pas effectuée. Pour utiliser le même modèle quel que soit le type de contenu, spécifiez `$default` comme clé.
**Pour créer les méthodes `GET` et `POST`**
1. Utilisez la commande suivante pour ajouter la méthode HTTP `GET` sur la ressource `/validate`. Cette commande crée la méthode `GET`, ajoute le validateur `params-only` et définit la chaîne de requête `petType` selon les besoins.
```
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"
```
Utilisez la commande suivante pour ajouter la méthode HTTP `POST` sur la ressource `/validate`. Cette commande crée la méthode `POST`, ajoute le validateur `body-only` et attache le modèle au validateur de corps uniquement.
```
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. Utilisez la commande suivante pour configurer la réponse `200 OK` de la méthode `GET /validate`.
```
aws apigateway put-method-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET \
--status-code 200
```
Utilisez la commande suivante pour configurer la réponse `200 OK` de la méthode `POST /validate`.
```
aws apigateway put-method-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--status-code 200
```
1. Utilisez la commande suivante pour configurer une `Integration` avec un point de terminaison HTTP spécifié pour la méthode `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'
```
Utilisez la commande suivante pour configurer une `Integration` avec un point de terminaison HTTP spécifié pour la méthode `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. Utilisez la commande suivante pour configurer une réponse d'intégration pour la méthode `GET /validation`.
```
aws apigateway put-integration-response --rest-api-id abc123 \
--resource-id efg456\
--http-method GET \
--status-code 200 \
--selection-pattern ""
```
Utilisez la commande suivante pour configurer une réponse d'intégration pour la méthode `POST /validation`.
```
aws apigateway put-integration-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--status-code 200 \
--selection-pattern ""
```
**Pour tester l’API**
1. Pour tester la méthode `GET` qui effectuera la validation des demandes pour les chaînes de requête, utilisez la commande suivante :
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET \
--path-with-query-string '/validate?petType=dog'
```
Le résultat sera `200 OK` et une liste de chiens.
1. Utilisez la commande suivante pour tester sans inclure la chaîne de requête `petType`.
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET
```
Le résultat sera une erreur `400`.
1. Pour tester la méthode `POST` qui effectuera la validation des demandes pour le corps de la demande, utilisez la commande suivante :
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--body '{"id": 1, "name": "bella", "type": "dog", "price" : 400 }'
```
Le résultat sera `200 OK` et un message de réussite.
1. Utilisez la commande suivante pour tester en utilisant un corps non valide.
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--body '{"id": 1, "name": "bella", "type": "dog", "price" : 1000 }'
```
Le résultat sera une erreur `400`, car le prix du chien est supérieur au prix maximum défini par le modèle.
**Pour supprimer une CloudFormation pile**
+ Utilisez la commande suivante pour supprimer vos CloudFormation ressources.
```
aws cloudformation delete-stack --stack-name request-validation-tutorial-cli
```
## Configuration de la validation de base des demandes à l’aide d’une définition OpenAPI
Vous pouvez déclarer un validateur de demande au niveau de l’API en spécifiant un ensemble d’objets [x-amazon-apigateway-request-Validators.RequestValidator objet](api-gateway-swagger-extensions-request-validators.requestValidator.md) dans le mappage d’[x-amazon-apigateway-requestobjet -validators](api-gateway-swagger-extensions-request-validators.md) afin de sélectionner la partie de la demande qui sera validée. Dans l’exemple de définition OpenAPI, il existe deux validateurs :
+ Le validateur `all` qui valide à la fois le corps, à l’aide du modèle de données `RequestBodyModel`, et les paramètres.
Le modèle de données `RequestBodyModel` exige que l’objet JSON en entrée contienne les propriétés `name`, `type` et `price`. La propriété `name` peut être une chaîne, `type` doit être l’un de champs d’énumération spécifiés (`["dog", "cat", "fish"]`) et `price` doit être compris entre 25 et 500. Le paramètre `id` n’est pas obligatoire.
+ Le validateur `param-only` qui valide uniquement les paramètres.
Pour activer un validateur de demande sur toutes les méthodes d’une API, spécifiez une propriété [x-amazon-apigateway-requestpropriété -validator](api-gateway-swagger-extensions-request-validator.md) au niveau de l’API de la définition OpenAPI. Dans l’exemple de définition OpenAPI, le validateur `all` est utilisé sur toutes les méthodes d’API, sauf s’il est remplacé. Lorsque vous utilisez un modèle pour valider le corps et qu’aucun type de contenu correspondant n’est trouvé, la validation de demande n’est pas effectuée. Pour utiliser le même modèle quel que soit le type de contenu, spécifiez `$default` comme clé.
Pour activer un validateur de demande sur une méthode individuelle, spécifiez la propriété `x-amazon-apigateway-request-validator` au niveau de la méthode. Dans cet exemple de définition OpenAPI, le validateur `param-only` remplace le validateur `all` sur la méthode `GET`.
Pour importer l’exemple OpenAPI dans API Gateway, consultez les instructions suivantes pour réaliser l’[Importation d’une API régionale dans API Gateway](import-export-api-endpoints.md) ou l’[Importation d’une API optimisée pour la périphérie dans 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
}
}
}
```
------
# AWS CloudFormation modèle d'un exemple d'API avec validation de demande de base
L' CloudFormation exemple de définition de modèle suivant définit un exemple d'API avec la validation des demandes activée. L'API [PetStore est un sous-ensemble de l'API ](http://petstore-demo-endpoint.execute-api.com/petstore/pets). Elle expose une méthode `POST` pour l’ajout d’un animal de compagnie à la collection `pets` et d’une méthode `GET` pour interroger les animaux de compagnie par un type spécifié.
Deux valideurs de demandes sont déclarés :
**`GETValidator`**
Ce valideur est activé sur la méthode `GET`. Il autorise API Gateway à vérifier que le paramètre de requête obligatoire (`q1`) est inclus et non vide dans la demande entrante.
**`POSTValidator`**
Ce valideur est activé sur la méthode `POST`. Il autorise API Gateway à vérifier que le format de demande de charge utile est conforme au `RequestBodyModel` spécifié quand le type de contenu est `application/json`. Si aucun type de contenu correspondant n’est trouvé, la validation de demande n’est pas effectuée. Pour utiliser le même modèle quel que soit le type de contenu, spécifiez `$default`. `RequestBodyModel` contient un modèle supplémentaire, `RequestBodyModelId`, permettant de définir l’identifiant d’animal de compagnie.
```
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}'
```