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.
# Tutoriel : Modifier la demande et la réponse d'intégration pour les intégrations aux services AWS
Le didacticiel suivant explique comment utiliser les transformations de modèles de mappage pour configurer des modèles de mappage afin de transformer les demandes et réponses d'intégration à l'aide de la console et de la AWS CLI.
**Topics**
+ [Configuration d’une transformation de données à l’aide de la console API Gateway](#mapping-example-console)
+ [Configuration de la transformation des données à l'aide de la AWS CLI](#mapping-example-cli)
+ [CloudFormation Modèle de transformation de données terminé](#api-gateway-data-transformations-full-cfn-stack)
## Configuration d’une transformation de données à l’aide de la console API Gateway
[Dans ce didacticiel, vous allez créer une API et une table DynamoDB incomplètes à l'aide du fichier .zip .zip suivant. data-transformation-tutorial-console](samples/data-transformation-tutorial-console.zip) Cette API incomplète possède une ressource `/pets` avec les méthodes `GET` et `POST`.
+ La méthode `GET` obtiendra des données à partir du point de terminaison HTTP `http://petstore-demo-endpoint.execute-api.com/petstore/pets`. Les données de sortie seront transformées conformément au modèle de mappage figurant dans [Transformations de modèles de mappage pour REST APIs dans API Gateway](models-mappings.md).
+ La méthode `POST` permettra à l’utilisateur de publier (`POST`) les informations sur les animaux dans une table Amazon DynamoDB à l’aide d’un modèle de mappage.
Téléchargez et décompressez [le modèle de création d'application pour CloudFormation](samples/data-transformation-tutorial-console.zip). Vous allez utiliser ce modèle pour créer une table DynamoDB afin de publier les informations sur les animaux et 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 **data-transformation-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 tester la réponse d’intégration `GET`**
1. Dans l'onglet **Ressources** de la CloudFormation pile pour**data-transformation-tutorial-console**, sélectionnez l'ID physique de votre API.
1. Dans le volet de navigation principal, choisissez **Ressources**, puis sélectionnez la méthode **GET**.
1. Choisissez l’onglet **Test**. Vous devrez peut-être choisir la flèche droite pour afficher l’onglet.
La sortie du test affichera les informations suivantes :
```
[
{
"id": 1,
"type": "dog",
"price": 249.99
},
{
"id": 2,
"type": "cat",
"price": 124.99
},
{
"id": 3,
"type": "fish",
"price": 0.99
}
]
```
Vous allez transformer cette sortie conformément au modèle de mappage figurant dans [Transformations de modèles de mappage pour REST APIs dans API Gateway](models-mappings.md).
**Pour transformer la réponse d’intégration `GET`**
1. Choisissez l’onglet **Réponse d’intégration**.
Aucun modèle de mappage n’est actuellement défini, de sorte que la réponse d’intégration ne sera pas transformée.
1. Pour **Par défaut - Réponse**, choisissez **Modifier**.
1. Choisissez **Modèles de mappage**, puis procédez comme suit :
1. Sélectionnez **Add mapping template**.
1. Pour **Type de contenu**, entrez **application/json**.
1. Pour **Corps du modèle**, saisissez ce qui suit :
```
#set($inputRoot = $input.path('$'))
[
#foreach($elem in $inputRoot)
{
"description" : "Item $elem.id is a $elem.type.",
"askingPrice" : $elem.price
}#if($foreach.hasNext),#end
#end
]
```
Choisissez **Enregistrer**.
**Pour tester la réponse d’intégration `GET`**
+ Choisissez l’onglet **Tester**, puis choisissez **Tester**.
La sortie du test affichera la réponse transformée.
```
[
{
"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
}
]
```
**Pour transformer les données d’entrée issues de la méthode `POST`**
1. Choisissez la méthode **POST**.
1. Choisissez l’onglet **Requête d’intégration**, puis dans la section **Paramètres de requête d’intégration**, choisissez **Modifier**.
Le CloudFormation modèle a rempli certains champs de demande d'intégration.
+ Le type d'intégration est Service AWS.
+ Service AWS Il s'agit de DynamoDB.
+ La méthode HTTP est `POST`.
+ L’action est `PutItem`.
+ Le rôle d'exécution permettant à API Gateway de placer un élément dans la table DynamoDB est. `data-transformation-tutorial-console-APIGatewayRole` CloudFormation a créé ce rôle pour permettre à API Gateway de disposer des autorisations minimales nécessaires pour interagir avec DynamoDB.
Le nom de la table DynamoDB n’a pas été spécifié. Vous allez spécifier ce nom dans les étapes suivantes.
1. Pour **Transmission du corps de requête**, sélectionnez **Jamais**.
Cela signifie que l’API rejettera les données avec des types de contenu qui ne disposent pas d’un modèle de mappage.
1. Choisissez **Modèles de mappage**.
1. **Type de contenu** est défini sur `application/json`. Cela signifie que les types de contenu qui ne le sont pas application/json seront rejetés par l'API. Pour plus d’informations sur les comportements de transmission d’intégration, consultez [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).
1. Saisissez le code suivant dans l’éditeur de texte.
```
{
"TableName":"data-transformation-tutorial-console-ddb",
"Item": {
"id": {
"N": $input.json("$.id")
},
"type": {
"S": $input.json("$.type")
},
"price": {
"N": $input.json("$.price")
}
}
}
```
Ce modèle spécifie la table en tant que `data-transformation-tutorial-console-ddb` et définit les éléments en tant que `id`, `type` et `price`. Ces éléments proviennent du corps de la méthode `POST`. Vous pouvez également utiliser un modèle de données pour favoriser la création d’un modèle de mappage. Pour de plus amples informations, veuillez consulter [Demande de validation pour REST APIs dans API Gateway](api-gateway-method-request-validation.md).
1. Choisissez **Enregistrer** pour enregistrer votre modèle de mappage.
**Pour ajouter une réponse de méthode et d’intégration à partir de la méthode `POST`**
Ils CloudFormation ont créé une méthode vide et une réponse d'intégration. Vous allez modifier cette réponse pour fournir plus d’informations. Pour plus d’informations sur la façon de modifier des réponses, consultez [Exemples de mappage de paramètres pour REST APIs dans API Gateway](request-response-data-mappings.md).
1. Dans l’onglet **Réponse d’intégration**, pour **Par défaut - Réponse**, choisissez **Modifier**.
1. Choisissez **Modèles de mappage**, puis choisissez **Ajouter un modèle de mappage**.
1. Pour **Type de contenu**, saisissez **application/json**.
1. Dans l’éditeur de code, entrez le modèle de mappage de sortie suivant pour envoyer un message de sortie :
```
{ "message" : "Your response was recorded at $context.requestTime" }
```
Pour plus d’informations sur les variables de contexte, consultez [Variables context pour les transformations de données](api-gateway-mapping-template-reference.md#context-variable-reference).
1. Choisissez **Enregistrer** pour enregistrer votre modèle de mappage.
**Test de la méthode `POST`**
Choisissez l’onglet **Test**. Vous devrez peut-être choisir la flèche droite pour afficher l’onglet.
1. Dans le corps de la demande, entrez l’exemple suivant.
```
{
"id": "4",
"type" : "dog",
"price": "321"
}
```
1. Sélectionnez **Tester)**.
La sortie doit afficher votre message de réussite.
Vous pouvez ouvrir la console DynamoDB [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)à l'adresse pour vérifier que l'exemple d'élément figure dans votre tableau.
**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.
## Configuration de la transformation des données à l'aide de la AWS CLI
[Dans ce didacticiel, vous allez créer une API et une table DynamoDB incomplètes à l'aide du fichier .zip .zip suivant. data-transformation-tutorial-cli](samples/data-transformation-tutorial-cli.zip) Cette API incomplète possède une ressource `/pets` avec une méthode `GET` intégrée au point de terminaison HTTP `http://petstore-demo-endpoint.execute-api.com/petstore/pets`. Vous allez créer une méthode `POST` pour vous connecter à une table DynamoDB et utiliser des modèles de mappage pour entrer des données dans une table DynamoDB.
+ Vous allez transformer les données de sortie conformément au modèle de mappage figurant dans [Transformations de modèles de mappage pour REST APIs dans API Gateway](models-mappings.md).
+ Vous allez créer une méthode `POST` pour permettre à l’utilisateur de publier (`POST`) les informations sur les animaux dans une table Amazon DynamoDB à l’aide d’un modèle de mappage.
**Pour créer une CloudFormation pile**
Téléchargez et décompressez [le modèle de création d'application pour CloudFormation](samples/data-transformation-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 data-transformation-tutorial-cli --template-body file://data-transformation-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 data-transformation-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 data-transformation-tutorial-cli --query "Stacks[*].Outputs[*].{OutputKey: OutputKey, OutputValue: OutputValue, Description: Description}"
```
Les valeurs de sortie sont les suivantes :
+ ApiRole, qui est le nom du rôle qui permet à API Gateway de placer des éléments dans la table DynamoDB. Pour ce didacticiel, le nom du rôle est `data-transformation-tutorial-cli-APIGatewayRole-ABCDEFG`.
+ DDBTableNom, qui est le nom de la table DynamoDB. Pour ce didacticiel, le nom de la table est `data-transformation-tutorial-cli-ddb`.
+ ResourceId, qui est l'identifiant de la ressource pour animaux de compagnie dans laquelle les `POST` méthodes `GET` et sont exposées. Pour ce didacticiel, l’ID de ressource est `efg456`.
+ ApiId, qui est l'ID de l'API. Pour ce didacticiel, l’ID d’API est `abc123`.
**Pour tester la méthode `GET` avant la transformation des données**
+ Utilisez la commande suivante pour tester la méthode `GET`.
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET
```
La sortie du test affichera les informations suivantes.
```
[
{
"id": 1,
"type": "dog",
"price": 249.99
},
{
"id": 2,
"type": "cat",
"price": 124.99
},
{
"id": 3,
"type": "fish",
"price": 0.99
}
]
```
Vous allez transformer cette sortie conformément au modèle de mappage figurant dans [Transformations de modèles de mappage pour REST APIs dans API Gateway](models-mappings.md).
**Pour transformer la réponse d’intégration `GET`**
+ Utilisez la commande suivante pour mettre à jour la réponse d’intégration de la méthode `GET`. Remplacez le *rest-api-id* et *resource-id* par vos valeurs.
Utilisez la commande suivante pour créer la réponse d’intégration.
```
aws apigateway put-integration-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET \
--status-code 200 \
--selection-pattern "" \
--response-templates '{"application/json": "#set($inputRoot = $input.path(\"$\"))\n[\n#foreach($elem in $inputRoot)\n {\n \"description\": \"Item $elem.id is a $elem.type\",\n \"askingPrice\": \"$elem.price\"\n }#if($foreach.hasNext),#end\n\n#end\n]"}'
```
**Pour tester la méthode `GET`**
+ Utilisez la commande suivante pour tester la méthode `GET`.
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET \
```
La sortie du test affichera la réponse transformée.
```
[
{
"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
}
]
```
**Pour créer une méthode `POST`**
1. Utilisez la commande suivante pour créer une nouvelle méthode sur la ressource `/pets`.
```
aws apigateway put-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--authorization-type "NONE" \
```
Cette méthode vous permettra d'envoyer des informations relatives aux animaux de compagnie à la table DynamoDB que vous avez créée dans la pile. CloudFormation
1. Utilisez la commande suivante pour créer une Service AWS intégration sur la `POST` méthode.
```
aws apigateway put-integration --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--type AWS \
--integration-http-method POST \
--uri "arn:aws:apigateway:us-east-2:dynamodb:action/PutItem" \
--credentials arn:aws:iam::111122223333:role/data-transformation-tutorial-cli-APIGatewayRole-ABCDEFG \
--request-templates '{"application/json":"{\"TableName\":\"data-transformation-tutorial-cli-ddb\",\"Item\":{\"id\":{\"N\":$input.json(\"$.id\")},\"type\":{\"S\":$input.json(\"$.type\")},\"price\":{\"N\":$input.json(\"$.price\")} }}"}'
```
1. Utilisez la commande suivante pour créer une réponse de méthode pour un appel réussi de la méthode `POST`.
```
aws apigateway put-method-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--status-code 200
```
1. Utilisez la commande suivante pour créer une réponse d’intégration pour l’appel réussi de la méthode `POST`.
```
aws apigateway put-integration-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--status-code 200 \
--selection-pattern "" \
--response-templates '{"application/json": "{\"message\": \"Your response was recorded at $context.requestTime\"}"}'
```
**Pour tester la méthode `POST`**
+ Utilisez la commande suivante pour tester la méthode `POST`.
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--body '{\"id\": \"4\", \"type\": \"dog\", \"price\": \"321\"}'
```
La sortie affichera le message de réussite.
**Pour supprimer une CloudFormation pile**
+ Utilisez la commande suivante pour supprimer vos CloudFormation ressources.
```
aws cloudformation delete-stack --stack-name data-transformation-tutorial-cli
```
## CloudFormation Modèle de transformation de données terminé
L'exemple suivant est un CloudFormation modèle complet, qui crée une API et une table DynamoDB avec `/pets` une ressource `GET` avec des méthodes et. `POST`
+ La méthode `GET` obtiendra des données à partir du point de terminaison HTTP `http://petstore-demo-endpoint.execute-api.com/petstore/pets`. Les données de sortie seront transformées conformément au modèle de mappage figurant dans [Transformations de modèles de mappage pour REST APIs dans API Gateway](models-mappings.md).
+ La méthode `POST` permettra à l’utilisateur de publier (`POST`) les informations sur les animaux de compagnie dans une table DynamoDB à l’aide d’un modèle de mappage.
### Exemple de CloudFormation modèle
```
AWSTemplateFormatVersion: 2010-09-09
Description: A completed Amazon API Gateway REST API that uses non-proxy integration to POST to an Amazon DynamoDB table and non-proxy integration to GET transformed pets data.
Parameters:
StageName:
Type: String
Default: v1
Description: Name of API stage.
Resources:
DynamoDBTable:
Type: 'AWS::DynamoDB::Table'
Properties:
TableName: !Sub data-transformation-tutorial-complete
AttributeDefinitions:
- AttributeName: id
AttributeType: N
KeySchema:
- AttributeName: id
KeyType: HASH
ProvisionedThroughput:
ReadCapacityUnits: 5
WriteCapacityUnits: 5
APIGatewayRole:
Type: 'AWS::IAM::Role'
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
- Action:
- 'sts:AssumeRole'
Effect: Allow
Principal:
Service:
- apigateway.amazonaws.com
Policies:
- PolicyName: APIGatewayDynamoDBPolicy
PolicyDocument:
Version: 2012-10-17
Statement:
- Effect: Allow
Action:
- 'dynamodb:PutItem'
Resource: !GetAtt DynamoDBTable.Arn
Api:
Type: 'AWS::ApiGateway::RestApi'
Properties:
Name: data-transformation-complete-api
ApiKeySourceType: HEADER
PetsResource:
Type: 'AWS::ApiGateway::Resource'
Properties:
RestApiId: !Ref Api
ParentId: !GetAtt Api.RootResourceId
PathPart: 'pets'
PetsMethodGet:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref PetsResource
HttpMethod: GET
ApiKeyRequired: false
AuthorizationType: NONE
Integration:
Type: HTTP
Credentials: !GetAtt APIGatewayRole.Arn
IntegrationHttpMethod: GET
Uri: http://petstore-demo-endpoint.execute-api.com/petstore/pets/
PassthroughBehavior: WHEN_NO_TEMPLATES
IntegrationResponses:
- StatusCode: '200'
ResponseTemplates:
application/json: "#set($inputRoot = $input.path(\"$\"))\n[\n#foreach($elem in $inputRoot)\n {\n \"description\": \"Item $elem.id is a $elem.type\",\n \"askingPrice\": \"$elem.price\"\n }#if($foreach.hasNext),#end\n\n#end\n]"
MethodResponses:
- StatusCode: '200'
PetsMethodPost:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref PetsResource
HttpMethod: POST
ApiKeyRequired: false
AuthorizationType: NONE
Integration:
Type: AWS
Credentials: !GetAtt APIGatewayRole.Arn
IntegrationHttpMethod: POST
Uri: arn:aws:apigateway:us-west-1:dynamodb:action/PutItem
PassthroughBehavior: NEVER
RequestTemplates:
application/json: "{\"TableName\":\"data-transformation-tutorial-complete\",\"Item\":{\"id\":{\"N\":$input.json(\"$.id\")},\"type\":{\"S\":$input.json(\"$.type\")},\"price\":{\"N\":$input.json(\"$.price\")} }}"
IntegrationResponses:
- StatusCode: 200
ResponseTemplates:
application/json: "{\"message\": \"Your response was recorded at $context.requestTime\"}"
MethodResponses:
- StatusCode: '200'
ApiDeployment:
Type: 'AWS::ApiGateway::Deployment'
DependsOn:
- PetsMethodGet
Properties:
RestApiId: !Ref Api
StageName: !Sub '${StageName}'
Outputs:
ApiId:
Description: API ID for CLI commands
Value: !Ref Api
ResourceId:
Description: /pets resource ID for CLI commands
Value: !Ref PetsResource
ApiRole:
Description: Role ID to allow API Gateway to put and scan items in DynamoDB table
Value: !Ref APIGatewayRole
DDBTableName:
Description: DynamoDB table name
Value: !Ref DynamoDBTable
```