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 interrogazioni 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)
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 oppure creare uno schema e connettere i resolver da una tabella esistente senza dover scrivere alcun codice.
Resolver AWS AppSync utilizzati 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) per](https://velocity.apache.org/engine/2.0/vtl-reference.html) 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, mentre le utilità di supporto disponibili per la programmazione sono disponibili nella guida al contesto del modello di mappatura Resolver](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide).](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference) AWS AppSync dispone anche di flussi di test e debug integrati che puoi usare quando modifichi o crei da zero. Per ulteriori informazioni, consulta [Test and debug](test-debug-resolvers.md#aws-appsync-test-debug-resolvers) 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 adatto al tuo tipo. `Query`
------
#### [ Console ]
1. [Accedi a Console di gestione AWS e apri la AppSync console.](https://console.aws.amazon.com/appsync/)
1. Nella **APIs dashboard**, 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. È possibile allegare resolver ai campi. Ad esempio, nella sezione 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 modelli di mappatura**, puoi scegliere sia il modello generico di mappatura di richiesta che quello di risposta utilizzando l'elenco a discesa a destra o scriverne uno personalizzato.
**Nota**
L'associazione di un modello di mappatura delle richieste a un modello di mappatura delle risposte viene chiamata risolutore di unità. I resolver di unità sono in genere pensati per eseguire operazioni di routine; si consiglia di utilizzarli solo per operazioni singolari con un numero limitato di fonti di dati. Per operazioni più complesse, consigliamo di utilizzare resolver a pipeline, che possono eseguire più operazioni con più fonti di 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)
[Per ulteriori informazioni sull'utilizzo dei resolver pipeline, vedete 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 è possibile utilizzare per recuperare elementi dalle fonti di dati (ad esempio, le query su tutti gli elementi, le ricerche individuali, ecc.). Ad esempio, nella versione semplice dello schema di [Designing your schema](designing-your-schema.md#aws-appsync-designing-your-schema) in cui `getTodos` non c'era l'impaginazione, il modello di mappatura delle richieste per elencare gli articoli è il seguente:
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. È sempre necessario un modello di mappatura delle risposte da allegare alla 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 il riferimento all'utilità del modello di [mappatura Resolver](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference).
1. **Scegli Save Resolver.**
------
#### [ API ]
1. Crea un oggetto resolver chiamando l'API. [https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html)
1. Puoi modificare i campi del tuo resolver chiamando l'API. [https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html)
------
#### [ CLI ]
1. Crea un resolver eseguendo il comando. [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)
Dovrai digitare 6 parametri per questo particolare comando:
1. La `api-id` 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 vuoi modificare nel tuo tipo. Nell'esempio della console, questo era`getTodos`.
1. La fonte `data-source-name` di 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. 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 al seguente:
```
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)"
```
Un output verrà restituito 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. [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)
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 passaggio successivo consiste nel creare un resolver adatto al tuo tipo. `Mutation`
------
#### [ Console ]
1. [Accedi a Console di gestione AWS e apri la AppSync console.](https://console.aws.amazon.com/appsync/)
1. Nella **APIs dashboard**, scegli la tua API GraphQL.
1. **Nella **barra laterale**, scegli Schema.**
1. Nella sezione Tipo di **mutazione**, scegli **Allega** accanto al `addTodo` campo.
1. Nella pagina **Create Resolver**, scegli l'origine dati che hai creato nella guida [Allegare una](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) fonte di dati.
1. Nella finestra **Configura modelli di mappatura**, è necessario modificare il modello di richiesta perché si tratta di una mutazione in cui si aggiunge 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 archivia i record in DynamoDB utilizzando una chiave `id` of, che viene passata dall'argomento di mutazione as. `$ctx.args.id` Tutti gli altri campi che passi attraverso vengono mappati automaticamente 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 e debug resolvers e Monitoraggio e](test-debug-resolvers.md#aws-appsync-test-debug-resolvers) registrazione.](monitoring.md#aws-appsync-monitoring)
1. **Scegli** Save Resolver.
------
#### [ API ]
Puoi farlo anche APIs utilizzando i comandi nella sezione [Crea il tuo primo resolver](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) e i dettagli dei parametri in questa sezione.
------
#### [ CLI ]
Puoi farlo anche nella CLI utilizzando i comandi nella sezione [Crea il tuo primo resolver](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) e i dettagli dei parametri in questa sezione.
------
[A questo punto, se non utilizzi i resolver avanzati, puoi iniziare a utilizzare l'API GraphQL come descritto in Utilizzo dell'API.](using-your-api.md#aws-appsync-using-your-api)
## Resolver avanzati
Se stai seguendo la sezione Avanzate 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, usa 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 si dispone di una `Comments` tabella e si sta risolvendo il campo dei commenti sul `Todo` tipo (che restituisce un tipo di`[Comment]`), è possibile 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 descritto in [Allegare](attaching-a-data-source.md#aws-appsync-getting-started-build-a-schema-from-scratch) un'origine dati.
**Nota**
Stiamo utilizzando un'operazione di interrogazione su una seconda tabella solo a scopo illustrativo. È possibile utilizzare invece un'altra operazione su DynamoDB. Inoltre, puoi estrarre i dati da un'altra fonte di dati, ad AWS Lambda esempio Amazon OpenSearch Service, perché la relazione è controllata dal tuo schema GraphQL.
------
#### [ Console ]
1. Accedi a Console di gestione AWS e apri la [AppSync console](https://console.aws.amazon.com/appsync/).
1. Nella **APIs dashboard**, scegli la tua API GraphQL.
1. **Nella **barra laterale**, scegli Schema.**
1. Nel tipo **Todo**, scegli **Allega** accanto al `comments` campo.
1. Nella pagina **Create Resolver**, scegli l'origine dati della tabella **Commenti**. Il nome predefinito per la tabella **Commenti** delle guide di avvio rapido è`AppSyncCommentTable`, ma può variare a seconda del nome 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 Save 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 APIs utilizzando i comandi nella sezione [Crea il tuo primo resolver](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) e i dettagli dei parametri in questa sezione.
------
#### [ CLI ]
Puoi farlo anche nella CLI utilizzando i comandi nella sezione [Crea il tuo primo resolver](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) e i dettagli dei parametri in questa sezione.
------