Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Creazione di domande di base (VTL)
**Nota**
Ora supportiamo principalmente il runtime APPSYNC\_JS e la relativa documentazione. Prendi in considerazione l'utilizzo del runtime APPSYNC\_JS e delle relative guide qui. [https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)
I resolver GraphQL connettono i campi nello schema di un tipo a un'origine dati. I resolver sono il meccanismo mediante il quale le richieste vengono soddisfatte. AWS AppSync possono creare e connettere automaticamente i resolver da uno schema o creare uno schema e connettere i resolver da una tabella esistente senza dover scrivere alcun codice.
Risolutori in AWS AppSync uso JavaScript per convertire un'espressione GraphQL in un formato utilizzabile dall'origine dati. In alternativa, i modelli di mappatura possono essere scritti in [ Apache Velocity Template Language (VTL) ](https://velocity.apache.org/engine/2.0/vtl-reference.html) per convertire un'espressione GraphQL in un formato utilizzabile dall'origine dati.
Questa sezione ti mostrerà come configurare i resolver usando VTL. Una guida introduttiva alla programmazione in stile tutorial per la scrittura di resolver è disponibile nella guida alla programmazione dei modelli di mappatura [ Resolver e le utilità di supporto disponibili per la programmazione sono disponibili nel riferimento ](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide) al contesto del modello di mappatura Resolver. [Resolver Mapping Template Context Reference](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference) AWS AppSync dispone anche di flussi di test e debug integrati che puoi utilizzare quando modifichi o crei da zero. Per ulteriori informazioni, consulta [ Test and debug resolvers. ](test-debug-resolvers.md#aws-appsync-test-debug-resolvers)
Ti consigliamo di seguire questa guida prima di provare a utilizzare uno dei tutorial sopra menzionati.
In questa sezione, spiegheremo come creare un resolver, aggiungere un resolver per le mutazioni e utilizzare configurazioni avanzate.
## Crea il tuo primo resolver
Seguendo gli esempi delle sezioni precedenti, il primo passo è creare un resolver per il tuo tipo. `Query`
------
#### [ Console ]
1. Accedi Console di gestione AWS e apri la [ AppSync console. ](https://console.aws.amazon.com/appsync/)
1. Nella dashboard delle ** API**, scegli la tua API GraphQL.
1. Nella ** barra laterale, scegli Schema. ** ** **
1. Sul lato destro della pagina, c'è una finestra chiamata Resolvers. ** ** Questa casella contiene un elenco dei tipi e dei campi definiti nella ** finestra ** Schema sul lato sinistro della pagina. Puoi allegare risolutori ai campi. Ad esempio, nel ** tipo di ** query, scegli ** Allega ** accanto al campo. `getTodos`
1. Nella ** pagina ** Create Resolver, scegli l'origine dati che hai creato nella guida [ Allegare una fonte di dati. ](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) Nella ** finestra ** Configura i modelli di mappatura, puoi scegliere sia i modelli generici di mappatura delle richieste che quelli delle risposte utilizzando l'elenco a discesa a destra o scriverne uno personalizzato.
**Nota**
L'abbinamento di un modello di mappatura delle richieste a un modello di mappatura delle risposte è chiamato Unit Resolver. Gli unit resolver sono in genere destinati a eseguire operazioni meccaniche; si consiglia di utilizzarli solo per operazioni singole con un numero limitato di origini dati. Per operazioni più complesse, consigliamo di utilizzare risolutori di pipeline, in grado di eseguire più operazioni con più origini dati in sequenza.
Per ulteriori informazioni sulla differenza tra i modelli di mappatura delle richieste e delle risposte, consulta Unit resolvers. [https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-overview.html#unit-resolvers](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-overview.html#unit-resolvers)
Per ulteriori informazioni sull'utilizzo dei risolutori di pipeline, consulta Pipeline resolvers. [Pipeline Resolvers](pipeline-resolvers.md#aws-appsync-pipeline-resolvers)
1. Per i casi d'uso più comuni, la AWS AppSync console dispone di modelli integrati che puoi utilizzare per ottenere elementi da origini dati (ad esempio, tutte le query sugli elementi, ricerche individuali, ecc.). Ad esempio, nella versione semplice dello schema di [ Designing your schema ](designing-your-schema.md#aws-appsync-designing-your-schema) where `getTodos` didn't have pagination, il modello di mappatura delle richieste per elencare gli elementi è il seguente:
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. È sempre necessario un modello di mappatura delle risposte per accompagnare la richiesta. La console ne fornisce uno predefinito con il valore di passthrough seguente per elenchi:
```
$util.toJson($ctx.result.items)
```
In questo esempio, l'oggetto `context` (con alias `$ctx`) per gli elenchi di elementi presenta la forma `$context.result.items`. Se l'operazione GraphQL restituisce un singolo elemento, sarebbe `$context.result`. AWS AppSync fornisce funzioni di helper per operazioni comuni, ad esempio la funzione `$util.toJson` elencata in precedenza, per formattare le risposte correttamente. Per un elenco completo delle funzioni, consulta [ Resolver Mapping Template Utility Reference. ](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference)
1. Scegli Salva Resolver**. **
------
#### [ API ]
1. Crea un oggetto resolver chiamando l'API. [`CreateResolver`](https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html)
1. Puoi modificare i campi del tuo resolver chiamando l'API. [`UpdateResolver`](https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html)
------
#### [ CLI ]
1. Crea un resolver eseguendo il comando. [`create-resolver`](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)
Dovrai digitare 6 parametri per questo particolare comando:
1. L'`api-id`indirizzo della tua API.
1. Il `type-name` tipo che desideri modificare nel tuo schema. Nell'esempio della console, questo era`Query`.
1. Il `field-name` campo che desideri modificare nel tuo tipo. Nell'esempio della console, questo era`getTodos`.
1. L'`data-source-name`origine dati che hai creato nella [ guida ](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) Allegare una fonte di dati.
1. Il`request-mapping-template`, che è il corpo della richiesta. Nell'esempio della console, questo era:
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. Il`response-mapping-template`, che è il corpo della risposta. Nell'esempio della console, questo era:
```
$util.toJson($ctx.result.items)
```
Un comando di esempio può essere simile a questo:
```
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)"
```
Verrà restituito un output nella CLI. Ecco un esempio:
```
{
"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. Per modificare i modelli di and/or mappatura dei campi di un resolver, esegui il comando. [`update-resolver`](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-resolver.html)
Ad eccezione del `api-id` parametro, i parametri utilizzati nel `create-resolver` comando verranno sovrascritti dai nuovi valori del comando. `update-resolver`
------
## Aggiungere un resolver per le mutazioni
Il passo successivo è creare un resolver per il tuo tipo. `Mutation`
------
#### [ Console ]
1. Accedi Console di gestione AWS e apri la [ AppSync console. ](https://console.aws.amazon.com/appsync/)
1. Nella dashboard delle ** API**, scegli la tua API GraphQL.
1. Nella ** barra laterale, scegli Schema. ** ** **
1. Sotto il ** tipo di ** mutazione, scegli ** Allega ** accanto al campo. `addTodo`
1. Nella ** pagina ** Create Resolver, scegli l'origine dati che hai creato nella guida [ Allegare una fonte di dati. ](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html)
1. Nella ** finestra ** Configura i modelli di mappatura, dovrai modificare il modello di richiesta perché si tratta di una mutazione in cui aggiungi un nuovo elemento a DynamoDB. Usa modello di mappatura della richiesta seguente:
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
1. AWS AppSync converte automaticamente gli argomenti definiti nel `addTodo` campo dallo schema GraphQL in operazioni DynamoDB. L'esempio precedente memorizza i record in DynamoDB utilizzando una chiave di`id`, che viene trasmessa dall'argomento di mutazione as. `$ctx.args.id` Tutti gli altri campi che passi vengono automaticamente mappati agli attributi DynamoDB con. `$util.dynamodb.toMapValuesJson($ctx.args)`
Per questo resolver, usare il seguente modello di mappatura della risposta:
```
$util.toJson($ctx.result)
```
AWS AppSync supporta anche flussi di lavoro di test e debug per la modifica dei resolver. È possibile utilizzare un oggetto `context` fittizio per visualizzare il valore trasformato del modello prima di effettuare la chiamata. Eventualmente, è possibile visualizzare l'esecuzione di richiesta completa a un'origine dati in modo interattivo quando si esegue una query. Per ulteriori informazioni, consulta [ Test and debug resolver e Monitoraggio e registrazione. ](test-debug-resolvers.md#aws-appsync-test-debug-resolvers) [Monitoring and Logging](monitoring.md#aws-appsync-monitoring)
1. Scegli ** Salva Resolver. **
------
#### [ API ]
Puoi farlo anche con le API utilizzando i comandi nella sezione [ Crea il tuo primo resolver e i dettagli dei parametri di ](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) questa sezione.
------
#### [ CLI ]
Puoi farlo anche nella CLI utilizzando i comandi nella sezione [ Crea il tuo primo resolver e i dettagli dei parametri di ](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) questa sezione.
------
A questo punto, se non stai utilizzando i resolver avanzati, puoi iniziare a utilizzare la tua API GraphQL come descritto in Utilizzo della tua API. [Using Your API](using-your-api.md#aws-appsync-using-your-api)
## Resolver avanzati
Se stai seguendo la sezione Avanzata e stai creando uno schema di esempio in [ Progettazione dello schema ](designing-your-schema.md#aws-appsync-designing-your-schema) per eseguire una scansione impaginata, utilizza invece il seguente modello di richiesta per il campo: `getTodos`
```
{
"version" : "2017-02-28",
"operation" : "Scan",
"limit": $util.defaultIfNull(${ctx.args.limit}, 20),
"nextToken": $util.toJson($util.defaultIfNullOrBlank($ctx.args.nextToken, null))
}
```
Per questo caso d'uso della paginazione, la mappatura della risposta è più di un semplice passthrough perché deve contenere sia il *cursore* (in modo che il client sappia a quale pagina passare) che il set di risultati. Il modello di mappatura è come segue:
```
{
"todos": $util.toJson($context.result.items),
"nextToken": $util.toJson($context.result.nextToken)
}
```
I campi nel modello di mappatura della risposta precedente devono corrispondere ai campi definiti nel tipo `TodoConnection`.
Nel caso di relazioni in cui hai una `Comments` tabella e stai risolvendo il campo dei commenti sul `Todo` tipo (che restituisce un tipo di`[Comment]`), puoi utilizzare un modello di mappatura che esegue una query sulla seconda tabella. A tale scopo, è necessario aver già creato un'origine dati per la `Comments` tabella, come indicato in [ Allegare un'origine dati. ](attaching-a-data-source.md#aws-appsync-getting-started-build-a-schema-from-scratch)
**Nota**
Stiamo utilizzando un'operazione di interrogazione su una seconda tabella solo a scopo illustrativo. È invece possibile utilizzare un'altra operazione su DynamoDB. Inoltre, puoi estrarre i dati da un'altra fonte di dati, come AWS Lambda Amazon OpenSearch Service, perché la relazione è controllata dal tuo schema GraphQL.
------
#### [ Console ]
1. Accedi Console di gestione AWS e apri la [ AppSync console](https://console.aws.amazon.com/appsync/).
1. Nella dashboard delle ** API**, scegli la tua API GraphQL.
1. Nella ** barra laterale, scegli Schema. ** ** **
1. Sotto il ** tipo ** Todo, scegli ** Allega ** accanto al campo. `comments`
1. Nella ** pagina ** Create Resolver, scegli l'origine dati della ** tabella ** Commenti. Il nome predefinito per la ** tabella ** Commenti nelle guide di avvio rapido è`AppSyncCommentTable`, ma può variare a seconda del nome che le hai assegnato.
1. Aggiungi il seguente frammento al modello di mappatura della richiesta:
```
{
"version": "2017-02-28",
"operation": "Query",
"index": "todoid-index",
"query": {
"expression": "todoid = :todoid",
"expressionValues": {
":todoid": {
"S": $util.toJson($context.source.id)
}
}
}
}
```
1. `context.source` fa riferimento all'oggetto padre del campo corrente che viene risolto. In questo esempio, `source.id` si riferisce al singolo oggetto `Todo`, che viene quindi utilizzato per l'espressione di query.
Puoi usare il modello di mappatura della risposta passthrough come segue:
```
$util.toJson($ctx.result.items)
```
1. Scegli Salva Resolver**. **
1. Infine, torna alla ** pagina ** Schema della console, collega un resolver al `addComment` campo e specifica l'origine dati per la tabella. `Comments` Il modello di mappatura della richiesta in questo caso è un semplice oggetto `PutItem` con il `todoid` specifico commentato su un argomento, ma puoi utilizzare l'utilità `$utils.autoId()` per creare una chiave di ordinamento per il commento, come segue:
```
{
"version": "2017-02-28",
"operation": "PutItem",
"key": {
"todoid": { "S": $util.toJson($context.arguments.todoid) },
"commentid": { "S": "$util.autoId()" }
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
Usa un modello di risposta passthrough come segue:
```
$util.toJson($ctx.result)
```
------
#### [ API ]
Puoi farlo anche con le API utilizzando i comandi nella sezione [ Crea il tuo primo resolver e i dettagli dei parametri di ](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) questa sezione.
------
#### [ CLI ]
Puoi farlo anche nella CLI utilizzando i comandi nella sezione [ Crea il tuo primo resolver e i dettagli dei parametri di ](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) questa sezione.
------