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.
# Création de requêtes de base (VTL)
**Note**
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)
Les résolveurs GraphQL connectent les champs d'un schéma de type à une source de données. Les résolveurs sont le mécanisme par lequel les demandes sont satisfaites. AWS AppSync peut créer et connecter automatiquement des résolveurs à partir d'un schéma ou créer un schéma et connecter des résolveurs à partir d'une table existante sans que vous ayez à écrire de code.
Résolveurs AWS AppSync utilisés JavaScript pour convertir une expression GraphQL dans un format utilisable par la source de données. Les modèles de mappage peuvent également être écrits dans le [langage VTL (Apache Velocity Template Language)](https://velocity.apache.org/engine/2.0/vtl-reference.html) pour convertir une expression GraphQL dans un format utilisable par la source de données.
Cette section explique comment configurer les résolveurs à l'aide de VTL. Un guide de programmation de type didacticiel d'introduction pour l'écriture de résolveurs se trouve dans le [guide de programmation du modèle de mappage Resolver](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide), et les utilitaires d'assistance disponibles pour la programmation se trouvent dans la référence contextuelle du modèle de mappage [Resolver](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference). AWS AppSync possède également des flux de test et de débogage intégrés que vous pouvez utiliser lorsque vous modifiez ou créez à partir de zéro. Pour plus d'informations, consultez la section [Tester et déboguer les résolveurs](test-debug-resolvers.md#aws-appsync-test-debug-resolvers).
Nous vous recommandons de suivre ce guide avant d'essayer d'utiliser l'un des didacticiels mentionnés ci-dessus.
Dans cette section, nous expliquerons comment créer un résolveur, ajouter un résolveur pour les mutations et utiliser des configurations avancées.
## Créez votre premier résolveur
En suivant les exemples des sections précédentes, la première étape consiste à créer un résolveur adapté à votre `Query` type.
------
#### [ Console ]
1. Connectez-vous à la [AppSync console AWS Management Console et ouvrez-la](https://console.aws.amazon.com/appsync/).
1. Dans le **APIs tableau de bord**, choisissez votre API GraphQL.
1. Dans la **barre latérale**, choisissez **Schema.**
1. Sur le côté droit de la page, il y a une fenêtre appelée **Resolvers**. Cette zone contient une liste des types et des champs tels que définis dans votre fenêtre de **schéma** sur le côté gauche de la page. Vous pouvez associer des résolveurs aux champs. Par exemple, sous le type de **requête**, choisissez **Joindre** à côté du `getTodos` champ.
1. Sur la page **Create Resolver**, choisissez la source de données que vous avez créée dans le guide [Joindre une source de données](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html). Dans la fenêtre **Configurer les modèles de mappage**, vous pouvez choisir à la fois les modèles de mappage de demande et de réponse génériques à l'aide de la liste déroulante de droite ou écrire le vôtre.
**Note**
L'appariement d'un modèle de mappage de demande à un modèle de mappage de réponse est appelé résolveur d'unités. Les résolveurs d'unités sont généralement conçus pour effectuer des opérations par cœur ; nous recommandons de les utiliser uniquement pour des opérations uniques avec un petit nombre de sources de données. Pour les opérations plus complexes, nous recommandons d'utiliser des résolveurs de pipeline, qui peuvent exécuter plusieurs opérations avec plusieurs sources de données de manière séquentielle.
Pour plus d'informations sur la différence entre les modèles de mappage de demandes et de réponses, consultez [Unit Resolvers](https://docs.aws.amazon.com//appsync/latest/devguide/resolver-mapping-template-reference-overview.html#unit-resolvers).
Pour plus d'informations sur l'utilisation des résolveurs de pipeline, consultez la section [Résolveurs de pipeline](pipeline-resolvers.md#aws-appsync-pipeline-resolvers).
1. Pour les cas d'utilisation courants, la AWS AppSync console possède des modèles intégrés que vous pouvez utiliser pour obtenir des éléments à partir de sources de données (par exemple, toutes les requêtes relatives aux articles, les recherches individuelles, etc.). Par exemple, dans la version simple du schéma de [Designing your schema](designing-your-schema.md#aws-appsync-designing-your-schema) where `getTodos` didn't have pagination, le modèle de mappage des demandes pour la liste des éléments est le suivant :
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. Vous avez toujours besoin d'un modèle de mappage des réponses pour accompagner la demande. La console fournit un modèle par défaut avec la valeur de transmission suivante pour les listes :
```
$util.toJson($ctx.result.items)
```
Dans cet exemple, l'objet `context` (dont l'alias est `$ctx`) pour les listes d'éléments se présente sous la forme `$context.result.items`. Si votre opération GraphQL renvoie un seul élément, ce serait `$context.result`. AWS AppSync fournit des fonctions d'assistant pour les opérations courantes, notamment la fonction `$util.toJson` répertoriée précédemment, pour mettre correctement en forme les réponses. Pour obtenir la liste complète des fonctions, consultez la [référence de l'utilitaire de modèle de mappage Resolver](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference).
1. Choisissez **Save Resolver.**
------
#### [ API ]
1. Créez un objet résolveur en appelant l'[https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html)API.
1. Vous pouvez modifier les champs de votre résolveur en appelant l'[https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html)API.
------
#### [ CLI ]
1. Créez un résolveur en exécutant la [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)commande.
Vous devez saisir 6 paramètres pour cette commande particulière :
1. Celui `api-id` de votre API.
1. Le `type-name` type que vous souhaitez modifier dans votre schéma. Dans l'exemple de console, c'était le cas`Query`.
1. Le `field-name` champ que vous souhaitez modifier dans votre type. Dans l'exemple de console, c'était le cas`getTodos`.
1. La source `data-source-name` de données que vous avez créée dans le guide [Joindre une source de données](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html).
1. Le`request-mapping-template`, qui est le corps de la demande. Dans l'exemple de console, c'était :
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. Le`response-mapping-template`, qui est le corps de la réponse. Dans l'exemple de console, c'était :
```
$util.toJson($ctx.result.items)
```
Voici un exemple de commande :
```
aws appsync create-resolver --api-id abcdefghijklmnopqrstuvwxyz --type-name Query --field-name getTodos --data-source-name TodoTable --request-mapping-template "{ "version" : "2017-02-28", "operation" : "Scan", }" --response-mapping-template ""$"util.toJson("$"ctx.result.items)"
```
Une sortie sera renvoyée dans la CLI. Voici un exemple :
```
{
"resolver": {
"kind": "UNIT",
"dataSourceName": "TodoTable",
"requestMappingTemplate": "{ version : 2017-02-28, operation : Scan, }",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Query/resolvers/getTodos",
"typeName": "Query",
"fieldName": "getTodos",
"responseMappingTemplate": "$util.toJson($ctx.result.items)"
}
}
```
1. Pour modifier les modèles de and/or mappage de champs d'un résolveur, exécutez la [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-resolver.html)commande.
À l'exception du `api-id` paramètre, les paramètres utilisés dans la `create-resolver` commande seront remplacés par les nouvelles valeurs de la `update-resolver` commande.
------
## Ajouter un résolveur pour les mutations
L'étape suivante consiste à créer un résolveur adapté à votre `Mutation` type.
------
#### [ Console ]
1. Connectez-vous à la [AppSync console AWS Management Console et ouvrez-la](https://console.aws.amazon.com/appsync/).
1. Dans le **APIs tableau de bord**, choisissez votre API GraphQL.
1. Dans la **barre latérale**, choisissez **Schema.**
1. Sous le type de **mutation**, choisissez **Attacher** à côté du `addTodo` champ.
1. Sur la page **Create Resolver**, choisissez la source de données que vous avez créée dans le guide [Joindre une source de données](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html).
1. Dans la fenêtre **Configurer les modèles de mappage**, vous devez modifier le modèle de demande car il s'agit d'une mutation dans laquelle vous ajoutez un nouvel élément à DynamoDB. Utilisez le modèle de mappage de demande suivant :
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
1. AWS AppSync convertit automatiquement les arguments définis dans le `addTodo` champ à partir de votre schéma GraphQL en opérations DynamoDB. L'exemple précédent stocke les enregistrements dans DynamoDB à l'aide d'une clé `id` de, qui est transmise par l'argument de mutation sous la forme. `$ctx.args.id` Tous les autres champs que vous traversez sont automatiquement mappés aux attributs DynamoDB avec. `$util.dynamodb.toMapValuesJson($ctx.args)`
Pour ce résolveur, utilisez ensuite le modèle de mappage de réponse suivant :
```
$util.toJson($ctx.result)
```
AWS AppSync prend également en charge les flux de travail de test et de débogage pour l'édition de résolveurs. Vous pouvez utiliser un objet `context` simulé pour afficher la valeur transformée du modèle avant l'appel. Le cas échéant, vous pouvez afficher l'intégralité de l'exécution de la requête sur une source de données de façon interactive lorsque vous exécutez une requête. Pour plus d'informations, consultez les sections [Tester et déboguer les résolveurs](test-debug-resolvers.md#aws-appsync-test-debug-resolvers) et [Surveillance et journalisation](monitoring.md#aws-appsync-monitoring).
1. Choisissez **Save Resolver.**
------
#### [ API ]
Vous pouvez également le faire APIs en utilisant les commandes de la section [Créez votre premier résolveur](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) et les détails des paramètres de cette section.
------
#### [ CLI ]
Vous pouvez également le faire dans la CLI en utilisant les commandes de la section [Créez votre premier résolveur](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) et les détails des paramètres de cette section.
------
À ce stade, si vous n'utilisez pas les résolveurs avancés, vous pouvez commencer à utiliser votre API GraphQL comme indiqué [dans Utilisation](using-your-api.md#aws-appsync-using-your-api) de votre API.
## Résolveurs avancés
Si vous suivez la section Avancé et que vous créez un exemple de schéma dans [Conception de votre schéma](designing-your-schema.md#aws-appsync-designing-your-schema) pour effectuer un scan paginé, utilisez plutôt le modèle de demande suivant pour le `getTodos` champ :
```
{
"version" : "2017-02-28",
"operation" : "Scan",
"limit": $util.defaultIfNull(${ctx.args.limit}, 20),
"nextToken": $util.toJson($util.defaultIfNullOrBlank($ctx.args.nextToken, null))
}
```
Pour ce scénario de pagination, le mappage de réponse est plus qu'une simple transmission, car il doit contenir à la fois le *curseur* (afin que le client sache quelle est la prochaine page à démarrer) et le jeu de résultats. Le modèle de mappage est ainsi :
```
{
"todos": $util.toJson($context.result.items),
"nextToken": $util.toJson($context.result.nextToken)
}
```
Les champs du précédent modèle de mappage de réponse doivent correspondre aux champs définis dans votre type `TodoConnection`.
Dans le cas de relations où vous avez une `Comments` table et que vous résolvez le champ de commentaires sur le `Todo` type (qui renvoie un type de`[Comment]`), vous pouvez utiliser un modèle de mappage qui exécute une requête sur la deuxième table. Pour ce faire, vous devez déjà avoir créé une source de données pour la `Comments` table, comme indiqué dans la section [Joindre une source de données](attaching-a-data-source.md#aws-appsync-getting-started-build-a-schema-from-scratch).
**Note**
Nous utilisons une opération de requête sur une deuxième table à des fins d'illustration uniquement. Vous pouvez utiliser une autre opération sur DynamoDB à la place. En outre, vous pouvez extraire les données d'une autre source de données, telle qu' AWS Lambda Amazon OpenSearch Service, car la relation est contrôlée par votre schéma GraphQL.
------
#### [ Console ]
1. Connectez-vous à la [AppSync console AWS Management Console et ouvrez-la](https://console.aws.amazon.com/appsync/).
1. Dans le **APIs tableau de bord**, choisissez votre API GraphQL.
1. Dans la **barre latérale**, choisissez **Schema.**
1. Sous le type **Todo**, choisissez **Joindre** à côté du `comments` champ.
1. Sur la page **Créer un résolveur**, choisissez la source de données de votre table de **commentaires**. Le nom par défaut du tableau des **commentaires** dans les guides de démarrage rapide est`AppSyncCommentTable`, mais il peut varier en fonction du nom que vous lui avez donné.
1. Ajoutez l'extrait suivant à votre modèle de mappage de demandes :
```
{
"version": "2017-02-28",
"operation": "Query",
"index": "todoid-index",
"query": {
"expression": "todoid = :todoid",
"expressionValues": {
":todoid": {
"S": $util.toJson($context.source.id)
}
}
}
}
```
1. Le `context.source` fait référence à l'objet parent du champ actif en cours de résolution. Dans cet exemple, `source.id` fait référence à l'objet `Todo` individuel, qui est ensuite utilisé pour l'expression de la requête.
Vous pouvez utiliser le modèle de mappage de réponse de transmission, comme suit :
```
$util.toJson($ctx.result.items)
```
1. Choisissez **Save Resolver.**
1. Enfin, revenez sur la page **Schéma** de la console, attachez un résolveur au `addComment` champ et spécifiez la source de données de la `Comments` table. Dans ce cas, le modèle de mappage de requête est un simple `PutItem` avec le `todoid` spécifique qui est commenté en tant qu'argument, mais vous utilisez l'utilitaire `$utils.autoId()` pour créer une clé de tri unique pour le commentaire de la façon suivante :
```
{
"version": "2017-02-28",
"operation": "PutItem",
"key": {
"todoid": { "S": $util.toJson($context.arguments.todoid) },
"commentid": { "S": "$util.autoId()" }
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
Utilisez un modèle de réponse de transmission comme suit :
```
$util.toJson($ctx.result)
```
------
#### [ API ]
Vous pouvez également le faire APIs en utilisant les commandes de la section [Créez votre premier résolveur](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) et les détails des paramètres de cette section.
------
#### [ CLI ]
Vous pouvez également le faire dans la CLI en utilisant les commandes de la section [Créez votre premier résolveur](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) et les détails des paramètres de cette section.
------
# Désactivation des modèles de mappage VTL avec des résolveurs Lambda directs (VTL)
**Note**
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)
Avec les résolveurs Lambda directs, vous pouvez contourner l'utilisation de modèles de mappage VTL lorsque vous utilisez des sources de données. AWS Lambda AWS AppSync peut fournir une charge utile par défaut à votre fonction Lambda ainsi qu'une traduction par défaut de la réponse d'une fonction Lambda en un type GraphQL. Vous pouvez choisir de fournir un modèle de demande, un modèle de réponse ou aucun des deux et AWS AppSync vous les traiterez en conséquence.
Pour en savoir plus sur la charge utile des demandes par défaut et la traduction des réponses AWS AppSync fournies, consultez la référence du [résolveur Direct Lambda](resolver-mapping-template-reference-lambda.md#direct-lambda-resolvers). Pour plus d'informations sur la configuration d'une source de AWS Lambda données et la configuration d'une politique de confiance IAM, voir [Joindre une source de données](attaching-a-data-source.md).
## Configurer des résolveurs Lambda directs
Les sections suivantes vous montrent comment associer des sources de données Lambda et ajouter des résolveurs Lambda à vos champs.
### Ajouter une source de données Lambda
Avant de pouvoir activer les résolveurs Lambda directs, vous devez ajouter une source de données Lambda.
------
#### [ Console ]
1. Connectez-vous à la [AppSyncconsole AWS Management Console et ouvrez-la](https://console.aws.amazon.com/appsync/).
1. Dans le **APIs tableau de bord**, choisissez votre API GraphQL.
1. Dans la **barre latérale**, sélectionnez **Sources de données.**
1. Choisissez **Create data source**.
1. Dans **Nom de la source de données**, entrez un nom pour votre source de données, tel que**myFunction**.
1. Pour **Type de source de données**, sélectionnez **AWS Lambda fonction**.
1. Pour **Région**, choisissez la région appropriée.
1. Pour **Function ARN**, choisissez la fonction Lambda dans la liste déroulante. Vous pouvez rechercher le nom de la fonction ou saisir manuellement l'ARN de la fonction que vous souhaitez utiliser.
1. Créez un nouveau rôle IAM (recommandé) ou choisissez un rôle existant disposant de l'autorisation `lambda:invokeFunction` IAM. Les rôles existants nécessitent une politique de confiance, comme expliqué dans la section [Joindre une source de données](attaching-a-data-source.md).
Voici un exemple de politique IAM disposant des autorisations requises pour effectuer des opérations sur la ressource :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [ "lambda:invokeFunction" ],
"Resource": [
"arn:aws:lambda:us-west-2:123456789012:function:myFunction",
"arn:aws:lambda:us-west-2:123456789012:function:myFunction:*"
]
}
]
}
```
------
1. Choisissez le bouton **Créer**.
------
#### [ CLI ]
1. Créez un objet de source de données en exécutant la [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-data-source.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-data-source.html)commande.
Vous devez saisir 4 paramètres pour cette commande particulière :
1. Celui `api-id` de votre API.
1. Le `name` de votre source de données. Dans l'exemple de console, il s'agit du **nom de la source de données**.
1. La source `type` de données. Dans l'exemple de console, il s'agit d'**AWS Lambda une fonction**.
1. Le`lambda-config`, qui est l'**ARN de la fonction** dans l'exemple de console.
**Note**
Il existe d'autres paramètres tels `Region` que ceux qui doivent être configurés, mais ils seront généralement définis par défaut sur les valeurs de configuration de votre CLI.
Voici un exemple de commande :
```
aws appsync create-data-source --api-id abcdefghijklmnopqrstuvwxyz --name myFunction --type AWS_LAMBDA --lambda-config lambdaFunctionArn=arn:aws:lambda:us-west-2:102847592837:function:appsync-lambda-example
```
Une sortie sera renvoyée dans la CLI. Voici un exemple :
```
{
"dataSource": {
"dataSourceArn": "arn:aws:appsync:us-west-2:102847592837:apis/abcdefghijklmnopqrstuvwxyz/datasources/myFunction",
"type": "AWS_LAMBDA",
"name": "myFunction",
"lambdaConfig": {
"lambdaFunctionArn": "arn:aws:lambda:us-west-2:102847592837:function:appsync-lambda-example"
}
}
}
```
1. Pour modifier les attributs d'une source de données, exécutez la [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-data-source.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-data-source.html)commande.
À l'exception du `api-id` paramètre, les paramètres utilisés dans la `create-data-source` commande seront remplacés par les nouvelles valeurs de la `update-data-source` commande.
------
### Activer les résolveurs Lambda directs
Après avoir créé une source de données Lambda et configuré le rôle IAM approprié pour permettre d'invoquer la fonction, vous pouvez la lier AWS AppSync à un résolveur ou à une fonction de pipeline.
------
#### [ Console ]
1. Connectez-vous à la [AppSyncconsole AWS Management Console et ouvrez-la](https://console.aws.amazon.com/appsync/).
1. Dans le **APIs tableau de bord**, choisissez votre API GraphQL.
1. Dans la **barre latérale**, choisissez **Schema.**
1. Dans la fenêtre **Resolvers**, choisissez un champ ou une opération, puis cliquez sur le bouton **Joindre**.
1. Sur la page **Créer un nouveau résolveur**, choisissez la fonction Lambda dans la liste déroulante.
1. Afin de tirer parti des résolveurs Lambda directs, vérifiez que les modèles de mappage de demandes et de réponses sont désactivés dans la section **Configurer les modèles de mappage**.
1. Cliquez sur le bouton **Enregistrer le résolveur**.
------
#### [ CLI ]
+ Créez un résolveur en exécutant la [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)commande.
Vous devez saisir 6 paramètres pour cette commande particulière :
1. Celui `api-id` de votre API.
1. Le `type-name` type de votre schéma.
1. Le champ `field-name` de votre schéma.
1. Le ou `data-source-name` le nom de votre fonction Lambda.
1. Le`request-mapping-template`, qui est le corps de la demande. Dans l'exemple de console, cela a été désactivé :
```
" "
```
1. Le`response-mapping-template`, qui est le corps de la réponse. Dans l'exemple de console, cela a également été désactivé :
```
" "
```
Voici un exemple de commande :
```
aws appsync create-resolver --api-id abcdefghijklmnopqrstuvwxyz --type-name Subscription --field-name onCreateTodo --data-source-name LambdaTest --request-mapping-template " " --response-mapping-template " "
```
Une sortie sera renvoyée dans la CLI. Voici un exemple :
```
{
"resolver": {
"resolverArn": "arn:aws:appsync:us-west-2:102847592837:apis/abcdefghijklmnopqrstuvwxyz/types/Subscription/resolvers/onCreateTodo",
"typeName": "Subscription",
"kind": "UNIT",
"fieldName": "onCreateTodo",
"dataSourceName": "LambdaTest"
}
}
```
------
Lorsque vous désactivez vos modèles de mappage, plusieurs comportements supplémentaires se produisent dans AWS AppSync :
+ En désactivant un modèle de mappage, vous indiquez AWS AppSync que vous acceptez les traductions de données par défaut spécifiées dans la référence du résolveur Direct [Lambda](resolver-mapping-template-reference-lambda.md#direct-lambda-resolvers).
+ [En désactivant le modèle de mappage des demandes, votre source de données Lambda recevra une charge utile composée de l'ensemble de l'objet Context.](resolver-context-reference.md)
+ En désactivant le modèle de mappage de réponse, le résultat de votre appel Lambda sera traduit en fonction de la version du modèle de mappage de demandes ou si le modèle de mappage de demandes est également désactivé.
# Tester et déboguer des résolveurs dans AWS AppSync (VTL)
**Note**
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)
AWS AppSync exécute des résolveurs sur un champ GraphQL par rapport à une source de données. Comme décrit dans la section [Présentation du modèle de mappage Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview), les résolveurs communiquent avec les sources de données à l'aide d'un langage de modélisation. Cela vous permet de personnaliser le comportement et d'appliquer une logique et des conditions avant et après la communication avec la source de données. Pour un guide de programmation de type didacticiel d'introduction à l'écriture de résolveurs, consultez le guide de programmation du modèle de [mappage Resolver](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide).
Pour aider les développeurs à écrire, tester et déboguer ces résolveurs, la AWS AppSync console fournit également des outils permettant de créer une requête et une réponse GraphQL avec des données fictives jusqu'au résolveur de champs individuel. En outre, vous pouvez effectuer des requêtes, des mutations et des abonnements dans la AWS AppSync console et consulter un journal détaillé de l'intégralité CloudWatch de la demande provenant d'Amazon. Cela inclut les résultats d'une source de données.
## Tester avec des données fictives
Lorsqu'un résolveur GraphQL est invoqué, il contient un `context` objet contenant des informations sur la demande. Ces informations incluent les arguments d'un client, les informations d'identité et les données du champ GraphQL parent. Il contient également les résultats de la source de données, qui peuvent être utilisés dans le modèle de réponse. Vous trouverez plus de détails sur cette structure et les utilitaires d'annotations disponibles à utiliser lors de la programmation dans le document [Référence du contexte du modèle de mappage des résolveurs](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference).
Lorsque vous écrivez ou modifiez un résolveur, vous pouvez transmettre un objet de *contexte *fictif* ou de test* dans l'éditeur de console. Cela vous permet de voir comment les deux modèles de la demande et de la réponse évaluent, sans réellement s'exécuter par rapport à une source de données. Par exemple, vous pouvez transmettre un argument de test `firstname: Shaggy` et voir comment il est analysé lors de l'utilisation de `$ctx.args.firstname` dans votre modèle de code. Vous pouvez également tester l'évaluation de n'importe quelle annotation d'utilitaire telle que `$util.autoId()` ou `util.time.nowISO8601()`.
### Tester les résolveurs
Cet exemple utilisera la AWS AppSync console pour tester les résolveurs.
1. Connectez-vous à la [AppSyncconsole AWS Management Console et ouvrez-la](https://console.aws.amazon.com/appsync/).
1. Dans le **APIs tableau de bord**, choisissez votre API GraphQL.
1. Dans la **barre latérale**, choisissez **Schema.**
1. Si ce n'est pas déjà fait, sous le type et à côté du champ, choisissez **Joindre** pour ajouter votre résolveur.
Pour plus d'informations sur la création d'un résolveur complet, voir [Configuration des](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html) résolveurs.
Sinon, sélectionnez le résolveur qui se trouve déjà dans le champ.
1. En haut de la page **Modifier le résolveur**, choisissez **Sélectionner le contexte de test**, puis **Créer un nouveau contexte**.
1. Sélectionnez un exemple d'objet de contexte ou renseignez le JSON manuellement dans la fenêtre de **contexte d'exécution** ci-dessous.
1. Entrez un **nom de contexte de texte**.
1. Choisissez le bouton **Enregistrer**.
1. En haut de la page **Modifier le résolveur**, sélectionnez **Exécuter le test**.
Pour un exemple plus pratique, supposons que vous disposiez d'une application stockant un type GraphQL `Dog` qui utilise la génération automatique d'identifiants pour les objets et les stocke dans Amazon DynamoDB. Il se peut aussi que vous souhaitiez écrire certaines valeurs des arguments d'une mutation GraphQL et permettre uniquement à des utilisateurs spécifiques de voir une réponse. Le schéma pourrait s'apparenter à ce qui suit :
```
type Dog {
breed: String
color: String
}
type Mutation {
addDog(firstname: String, age: Int): Dog
}
```
Lorsque vous ajoutez un résolveur pour la `addDog` mutation, vous pouvez renseigner un objet de contexte comme dans l'exemple suivant. Le suivant possède les arguments `name` et `age` du client, ainsi qu'un `username` renseigné dans l'objet `identity` :
```
{
"arguments" : {
"firstname": "Shaggy",
"age": 4
},
"source" : {},
"result" : {
"breed" : "Miniature Schnauzer",
"color" : "black_grey"
},
"identity": {
"sub" : "uuid",
"issuer" : " https://cognito-idp.{region}.amazonaws.com/{userPoolId}",
"username" : "Nadia",
"claims" : { },
"sourceIp" :[ "x.x.x.x" ],
"defaultAuthStrategy" : "ALLOW"
}
}
```
Vous pouvez effectuer le test en utilisant les modèles de mappage de demande et de réponse suivants :
**Modèle de demande**
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "$util.autoId()" }
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
**Modèle de réponse**
```
#if ($context.identity.username == "Nadia")
$util.toJson($ctx.result)
#else
$util.unauthorized()
#end
```
Le modèle évalué possède les données de votre objet de contexte du test et la valeur générée à partir de `$util.autoId()`. De plus, si vous deviez modifier `username` avec une valeur autre que `Nadia`, les résultats ne seront pas renvoyés, car le contrôle d'autorisation échouerait. Pour plus d'informations sur le contrôle d'accès détaillé, consultez la section [Cas d'utilisation des autorisations](security-authorization-use-cases.md#aws-appsync-security-authorization-use-cases).
### Tester des modèles de mappage avec AWS AppSync APIs
Vous pouvez utiliser la commande `EvaluateMappingTemplate` API pour tester à distance vos modèles de mappage avec des données simulées. Pour commencer à utiliser la commande, assurez-vous d'avoir ajouté l'`appsync:evaluateMappingTemplate`autorisation à votre politique. Par exemple :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateMappingTemplate",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
Vous pouvez utiliser la commande en utilisant le [AWS CLI](https://aws.amazon.com/cli/)ou [AWS SDKs](https://aws.amazon.com/tools/). Prenons par exemple le `Dog` schéma et ses modèles de request/response mappage de la section précédente. À l'aide de la CLI de votre station locale, enregistrez le modèle de demande dans un fichier nommé`request.vtl`, puis enregistrez l'`context`objet dans un fichier nommé`context.json`. Depuis votre shell, exécutez la commande suivante :
```
aws appsync evaluate-mapping-template --template file://request.vtl --context file://context.json
```
Cette commande renvoie la réponse suivante :
```
{
"evaluationResult": "{\n \"version\" : \"2017-02-28\",\n \"operation\" : \"PutItem\",\n \"key\" : {\n \"id\" : { \"S\" : \"afcb4c85-49f8-40de-8f2b-248949176456\" }\n },\n \"attributeValues\" : {\"firstname\":{\"S\":\"Shaggy\"},\"age\":{\"N\":4}}\n}\n"
}
```
`evaluationResult`Il contient les résultats du test de votre modèle fourni avec le modèle fourni`context`. Vous pouvez également tester vos modèles à l'aide du AWS SDKs. Voici un exemple d'utilisation du AWS SDK pour la JavaScript version 2 :
```
const AWS = require('aws-sdk')
const client = new AWS.AppSync({ region: 'us-east-2' })
const template = fs.readFileSync('./request.vtl', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
client
.evaluateMappingTemplate({ template, context })
.promise()
.then((data) => console.log(data))
```
À l'aide du SDK, vous pouvez facilement intégrer les tests de votre suite de tests préférée pour valider le comportement de votre modèle. Nous vous recommandons de créer des tests à l'aide du [Jest Testing Framework](https://jestjs.io/), mais toutes les suites de tests fonctionnent. L'extrait suivant montre une exécution de validation hypothétique. Notez que nous nous attendons à ce que la réponse d'évaluation soit un JSON valide. Nous utilisons donc `JSON.parse` pour récupérer le JSON à partir de la réponse sous forme de chaîne :
```
const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })
test('request correctly calls DynamoDB', async () => {
const template = fs.readFileSync('./request.vtl', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateMappingTemplate({ template, context }).promise()
const result = JSON.parse(response.evaluationResult)
expect(result.key.id.S).toBeDefined()
expect(result.attributeValues.firstname.S).toEqual(contextJSON.arguments.firstname)
})
```
Cela donne le résultat suivant :
```
Ran all test suites.
> jest
PASS ./index.test.js
✓ request correctly calls DynamoDB (543 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 total
Time: 1.511 s, estimated 2 s
```
## Débogage d'une requête en direct
Rien ne remplace un end-to-end test et une journalisation pour déboguer une application de production. AWS AppSync vous permet de consigner les erreurs et de fournir les détails complets des demandes à l'aide d'Amazon CloudWatch. En outre, vous pouvez utiliser la AWS AppSync console pour tester les requêtes GraphQL, les mutations et les abonnements, ainsi que pour diffuser en direct les données du journal de chaque requête dans l'éditeur de requêtes afin de les déboguer en temps réel. Pour les abonnements, les journaux affichent les informations de temps de connexion.
Pour ce faire, vous devez activer Amazon CloudWatch Logs à l'avance, comme décrit dans [Surveillance et journalisation](monitoring.md#aws-appsync-monitoring). Ensuite, dans la AWS AppSync console, choisissez l'onglet **Requêtes**, puis entrez une requête GraphQL valide. Dans la section inférieure droite, cliquez et faites glisser la fenêtre **Logs** pour ouvrir la vue des logs. À l'aide de la flèche « Play » en haut de la page, exécutez votre requête GraphQL. Dans quelques instants, vos journaux complets de demande et de réponse pour l'opération sont diffusés vers cette section et vous pouvez les voir dans la console.
# Configuration et utilisation de résolveurs de pipeline dans AWS AppSync (VTL)
**Note**
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)
AWS AppSync exécute des résolveurs sur un champ GraphQL. Dans certains cas, les applications nécessitent l'exécution de plusieurs opérations pour résoudre un seul champ GraphQL. Avec les résolveurs de pipeline, les développeurs peuvent désormais composer des opérations appelées fonctions et les exécuter en séquence. Les résolveurs de pipeline sont utiles pour les applications qui, par exemple, doivent effectuer un contrôle d'autorisation avant d'extraire des données pour un champ.
Un résolveur de pipeline est composé d'un modèle de mappage **Avant**, d'un modèle de mappage **Après** et d'une liste de Fonctions. Chaque fonction possède un modèle de mappage de **requêtes** et de **réponses** qu'elle exécute par rapport à une source de données. Comme un résolveur de pipeline délègue l'exécution à une liste de fonctions, il n'est lié à aucune source de données. Les résolveurs d'unités et les fonctions sont des primitives qui exécutent des opérations sur des sources de données. Consultez la [présentation du modèle de mappage Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview) pour plus d'informations.
## Étape 1 : Création d'un résolveur de pipeline
Dans la AWS AppSync console, accédez à la page **Schéma**.
Enregistrez le schéma suivant :
```
schema {
query: Query
mutation: Mutation
}
type Mutation {
signUp(input: Signup): User
}
type Query {
getUser(id: ID!): User
}
input Signup {
username: String!
email: String!
}
type User {
id: ID!
username: String
email: AWSEmail
}
```
Nous allons raccorder un résolveur de pipeline au champ **signUp** sur le type **Mutation**. Dans le champ Type de **mutation** sur le côté droit, choisissez **Attacher** à côté du champ de `signUp` mutation. Sur la page de création d'un résolveur, cliquez sur **Actions**, puis sur **Mettre à jour le moteur d'exécution**. Choisissez`Pipeline Resolver`, puis choisissez`VTL`, puis choisissez **Mettre à jour**. La page doit désormais afficher trois sections : une zone de texte **avant le mappage du modèle**, une section **Fonctions** et une zone de texte **après le mappage du modèle**.
Notre résolveur de pipeline inscrit un utilisateur en validant tout d'abord l'adresse e-mail saisie, puis en enregistrant l'utilisateur dans le système. Nous allons encapsuler la validation d'e-mail dans une fonction **validateEmail** et l'enregistrement de l'utilisateur dans une fonction **saveUser**. La fonction **validateEmail** s'exécute d'abord, puis si l'e-mail est valide, alors la fonction **saveUser** s'exécute.
Le flux d'exécution sera comme suit :
1. Modèle de mappage de demande de résolveur Mutation.signUp
1. Fonction validateEmail
1. Fonction saveUser
1. Modèle de mappage de réponse de résolveur Mutation.signUp
Comme nous réutiliserons probablement la fonction **ValidateEmail** dans d'autres résolveurs de notre API, nous voulons éviter d'`$ctx.args`y accéder car ceux-ci changeront d'un champ GraphQL à l'autre. Au lieu de cela, nous pouvons utiliser le `$ctx.stash` pour stocker l'attribut e-mail depuis l'argument de champ de saisie `signUp(input: Signup)`.
Modèle **de** mappage BEFORE :
```
## store email input field into a generic email key
$util.qr($ctx.stash.put("email", $ctx.args.input.email))
{}
```
La console fournit un modèle de mappage **AFTER** passthrough par défaut que nous utiliserons :
```
$util.toJson($ctx.result)
```
Choisissez **Créer** ou **Enregistrer** pour mettre à jour le résolveur.
## Étape 2 : Création d'une fonction
Sur la page du résolveur de pipeline, dans la section **Fonctions**, cliquez sur **Ajouter une fonction**, puis sur **Créer une nouvelle fonction**. Il est également possible de créer des fonctions sans passer par la page du résolveur ; pour cela, dans la AWS AppSync console, rendez-vous sur la page **Fonctions**. Choisissez le bouton **Créer une fonction**. Créons une fonction permettant de vérifier si un e-mail est valide et provient d'un domaine spécifique. Si l'e-mail n'est pas valide, la fonction renvoie une erreur. Dans le cas contraire, elle transmet les données saisies.
Sur la page des nouvelles fonctions, choisissez **Actions**, puis **Mettre à jour le moteur d'exécution**. Choisissez`VTL`, puis **Mettre à jour**. Assurez-vous d'avoir créé une source de données de type **NONE**. Choisissez cette source de données dans la liste des **noms des sources de données**. Pour le **nom de la fonction**, entrez`validateEmail`. Dans la zone du **code de fonction**, remplacez tout par cet extrait de code :
```
#set($valid = $util.matches("^[a-zA-Z0-9_.+-]+@(?:(?:[a-zA-Z0-9-]+\.)?[a-zA-Z]+\.)?(myvaliddomain)\.com", $ctx.stash.email))
#if (!$valid)
$util.error("$ctx.stash.email is not a valid email.")
#end
{
"payload": { "email": $util.toJson(${ctx.stash.email}) }
}
```
Collez ceci dans le modèle de mappage des réponses :
```
$util.toJson($ctx.result)
```
Passez en revue vos modifications, puis choisissez **Créer**. Nous venons de créer notre fonction **validateEmail**. Répétez ces étapes pour créer la fonction **SaveUser** avec les modèles de mappage de demandes et de réponses suivants (par souci de simplicité, nous utilisons **une** source de données NONE et prétendons que l'utilisateur a été enregistré dans le système après l'exécution de la fonction. ) :
Modèle de mappage de demande :
```
## $ctx.prev.result contains the signup input values. We could have also
## used $ctx.args.input.
{
"payload": $util.toJson($ctx.prev.result)
}
```
Modèle de mappage de réponse :
```
## an id is required so let's add a unique random identifier to the output
$util.qr($ctx.result.put("id", $util.autoId()))
$util.toJson($ctx.result)
```
Nous venons de créer notre fonction **SaveUser**.
## Étape 3 : Ajouter une fonction à un résolveur de pipeline
Nos fonctions auraient dû être ajoutées automatiquement au résolveur de pipeline que nous venons de créer. Si ce n'était pas le cas, ou si vous avez créé les fonctions via la page **Fonctions**, vous pouvez cliquer sur **Ajouter une fonction** sur la page du résolveur pour les joindre. Ajoutez les fonctions **ValidateEmail** **et** SaveUser au résolveur. La fonction **validateEmail** doit être placée avant la fonction **saveUser**. Au fur et à mesure que vous ajoutez des fonctions, vous pouvez utiliser les options de **déplacement vers le haut** **et de déplacement vers le bas** pour réorganiser l'ordre d'exécution de vos fonctions. Passez en revue vos modifications, puis choisissez **Enregistrer**.
## Étape 4 : Exécution d'une requête
Dans la AWS AppSync console, accédez à la page **Requêtes**. Dans l'explorateur, assurez-vous d'utiliser votre mutation. Si ce n'est pas le cas, choisissez `Mutation` dans la liste déroulante, puis choisissez`+`. Entrez la requête suivante :
```
mutation {
signUp(input: {
email: "nadia@myvaliddomain.com"
username: "nadia"
}) {
id
email
}
}
```
Cela devrait renvoyer quelque chose comme :
```
{
"data": {
"signUp": {
"id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
"email": "nadia@myvaliddomain.com"
}
}
}
```
Nous avons inscrit notre utilisateur et validé l'e-mail saisi à l'aide d'un résolveur de pipeline. Pour suivre un didacticiel plus complet sur les résolveurs de pipeline, vous pouvez consulter le [Didacticiel : Résolveurs de Pipeline](tutorial-pipeline-resolvers.md#aws-appsync-tutorial-pipeline-resolvers)