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\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS 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.
------
# Disabilitazione dei modelli di mappatura VTL con resolver Lambda diretti (VTL)
**Nota**
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)
Con i resolver diretti Lambda, puoi aggirare l'uso di modelli di mappatura VTL quando utilizzi fonti di dati. AWS Lambda AWS AppSync può fornire un payload predefinito alla funzione Lambda e una traduzione predefinita dalla risposta di una funzione Lambda a un tipo GraphQL. Puoi scegliere di fornire un modello di richiesta, un modello di risposta o nessuno dei due e lo AWS AppSync gestirai di conseguenza.
Per ulteriori informazioni sul payload predefinito della richiesta e sulla traduzione delle risposte che AWS AppSync fornisce, consulta il riferimento al [resolver Direct Lambda](resolver-mapping-template-reference-lambda.md#direct-lambda-resolvers). Per ulteriori informazioni sulla configurazione di un'origine AWS Lambda dati e sulla configurazione di una IAM Trust Policy, consulta [Allegare](attaching-a-data-source.md) un'origine dati.
## Configurazione di resolver Lambda diretti
Le seguenti sezioni ti mostreranno come collegare sorgenti dati Lambda e aggiungere resolver Lambda ai tuoi campi.
### Aggiungere un'origine dati Lambda
Prima di poter attivare i resolver Lambda diretti, devi aggiungere un'origine dati Lambda.
------
#### [ Console ]
1. [Accedi e apri la console. Console di gestione AWS AppSync](https://console.aws.amazon.com/appsync/)
1. Nella **APIs dashboard**, scegli la tua API GraphQL.
1. Nella **barra laterale**, scegli Origini **dati**.
1. Seleziona **Create data source (Crea origine dati)**.
1. Per **Nome dell'origine dati**, inserisci un nome per la tua origine dati, ad esempio**myFunction**.
1. Per **Tipo di origine dati**, scegli **AWS Lambda funzione**.
1. Per **Regione**, scegli la regione appropriata.
1. Per **Funzione ARN**, scegli la funzione Lambda dall'elenco a discesa. È possibile cercare il nome della funzione o inserire manualmente l'ARN della funzione che si desidera utilizzare.
1. Crea un nuovo ruolo IAM (consigliato) o scegli un ruolo esistente con l'autorizzazione `lambda:invokeFunction` IAM. I ruoli esistenti richiedono una policy di fiducia, come spiegato nella sezione [Allegare una fonte di dati](attaching-a-data-source.md).
Di seguito è riportato un esempio di policy IAM che dispone delle autorizzazioni necessarie per eseguire operazioni sulla risorsa:
------
#### [ 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. Scegli il pulsante **Crea**.
------
#### [ CLI ]
1. Crea un oggetto sorgente dati eseguendo il [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)comando.
Dovrai digitare 4 parametri per questo particolare comando:
1. La `api-id` della tua API.
1. La tua fonte `name` di dati. Nell'esempio della console, questo è il **nome dell'origine dati**.
1. La fonte `type` dei dati. Nell'esempio della console, questa è **AWS Lambda la funzione**.
1. Il`lambda-config`, che è l'**ARN della funzione nell'esempio** della console.
**Nota**
Esistono altri parametri come questi `Region` che devono essere configurati, ma di solito vengono utilizzati per impostazione predefinita i valori di configurazione CLI.
Un comando di esempio può avere il seguente aspetto:
```
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
```
Un output verrà restituito nella CLI. Ecco un esempio:
```
{
"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. Per modificare gli attributi di un'origine dati, esegui il [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)comando.
Ad eccezione del `api-id` parametro, i parametri utilizzati nel `create-data-source` comando verranno sovrascritti dai nuovi valori del `update-data-source` comando.
------
### Attiva i resolver Lambda diretti
Dopo aver creato un'origine dati Lambda e impostato il ruolo IAM appropriato per consentire di AWS AppSync richiamare la funzione, puoi collegarla a una funzione resolver o pipeline.
------
#### [ Console ]
1. [Accedi a e apri la console. Console di gestione AWS AppSync](https://console.aws.amazon.com/appsync/)
1. Nella **APIs dashboard**, scegli la tua API GraphQL.
1. **Nella **barra laterale**, scegli Schema.**
1. **Nella finestra **Resolver**, scegli un campo o un'operazione, quindi seleziona il pulsante Allega.**
1. Nella pagina **Crea nuovo resolver**, scegli la funzione Lambda dall'elenco a discesa.
1. **Per sfruttare i resolver diretti Lambda, verifica che i modelli di mappatura di richiesta e risposta siano disabilitati nella sezione Configura modelli di mappatura.**
1. **Scegli il pulsante Save** Resolver.
------
#### [ CLI ]
+ 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 nel tuo schema.
1. Il campo `field-name` del tuo schema.
1. Il`data-source-name`, o il nome della tua funzione Lambda.
1. Il`request-mapping-template`, che è il corpo della richiesta. Nell'esempio della console, questo era disabilitato:
```
" "
```
1. Il`response-mapping-template`, che è il corpo della risposta. Nell'esempio della console, anche questo era disabilitato:
```
" "
```
Un comando di esempio può avere il seguente aspetto:
```
aws appsync create-resolver --api-id abcdefghijklmnopqrstuvwxyz --type-name Subscription --field-name onCreateTodo --data-source-name LambdaTest --request-mapping-template " " --response-mapping-template " "
```
Un output verrà restituito nella CLI. Ecco un esempio:
```
{
"resolver": {
"resolverArn": "arn:aws:appsync:us-west-2:102847592837:apis/abcdefghijklmnopqrstuvwxyz/types/Subscription/resolvers/onCreateTodo",
"typeName": "Subscription",
"kind": "UNIT",
"fieldName": "onCreateTodo",
"dataSourceName": "LambdaTest"
}
}
```
------
Quando disabiliti i modelli di mappatura, si verificheranno diversi comportamenti aggiuntivi in: AWS AppSync
+ Disabilitando un modello di mappatura, stai segnalando AWS AppSync che accetti le traduzioni dei dati predefinite specificate nel riferimento del resolver Direct [Lambda](resolver-mapping-template-reference-lambda.md#direct-lambda-resolvers).
+ [Disabilitando il modello di mappatura della richiesta, l'origine dati Lambda riceverà un payload costituito dall'intero oggetto Context.](resolver-context-reference.md)
+ Disabilitando il modello di mappatura delle risposte, il risultato della chiamata Lambda verrà tradotto a seconda della versione del modello di mappatura della richiesta o se anche il modello di mappatura della richiesta è disabilitato.
# Test e debug dei resolver in (VTL) AWS AppSync
**Nota**
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)
AWS AppSync esegue resolver su un campo GraphQL su un'origine dati. Come descritto nella [panoramica dei modelli di mappatura Resolver, i resolver comunicano con le fonti di dati utilizzando un linguaggio di template](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview). Ciò consente di personalizzare il comportamento e applicare logica e condizioni prima e dopo la comunicazione con l'origine dati. [Per una guida introduttiva alla programmazione in stile tutorial per la scrittura di resolver, consulta la guida alla programmazione dei modelli di mappatura Resolver.](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide)
Per aiutare gli sviluppatori a scrivere, testare ed eseguire il debug di questi resolver, la AWS AppSync console fornisce anche strumenti per creare una richiesta e una risposta GraphQL con dati fittizi fino al singolo resolver di campo. Inoltre, puoi eseguire query, mutazioni e sottoscrizioni nella AWS AppSync console e visualizzare un flusso di log dettagliato da Amazon CloudWatch dell'intera richiesta. Ciò include i risultati di un'origine dati.
## Test con dati fittizi
Quando viene richiamato un resolver GraphQL, contiene un `context` oggetto che contiene informazioni sulla richiesta. Tali informazioni includono gli argomenti provenienti da un client, le informazioni sull'identità e i dati del campo GraphQL padre. Contiene anche i risultati della fonte di dati, che possono essere utilizzati nel modello di risposta. Per ulteriori informazioni su questa struttura e sulle utilità helper disponibili per la programmazione, consulta le [informazioni di riferimento contestuali sui modelli di mappatura dei resolver](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference).
Quando si scrive o si modifica un resolver, è possibile passare un oggetto di *contesto *fittizio* o di test* all'editor della console. In questo modo è possibile vedere in che modo i modelli di richiesta e di risposta eseguono la valutazione senza effettivamente eseguire un'origine dati. Puoi ad esempio passare un argomento `firstname: Shaggy` di test e vedere i relativi risultati quando usi `$ctx.args.firstname` nel codice del modello. Puoi anche testare la valutazione di utilità helper, ad esempio `$util.autoId()` o `util.time.nowISO8601()`.
### Test dei resolver
Questo esempio utilizzerà la AWS AppSync console per testare i resolver.
1. [Accedi a Console di gestione AWS e apri la console. AppSync](https://console.aws.amazon.com/appsync/)
1. Nella **APIs dashboard**, scegli la tua API GraphQL.
1. **Nella **barra laterale**, scegli Schema.**
1. Se non l'hai già fatto, sotto il tipo e accanto al campo, scegli **Allega** per aggiungere il tuo resolver.
[Per ulteriori informazioni su come creare un resolver completo, consulta Configurazione dei resolver.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html)
Altrimenti, seleziona il resolver già presente nel campo.
1. **Nella parte superiore della pagina **Modifica resolver**, scegli **Seleziona contesto di test, scegli Crea nuovo contesto**.**
1. Seleziona un oggetto contestuale di esempio o compila il JSON manualmente nella finestra del contesto di **esecuzione** sottostante.
1. Immettete un nome di **contesto di testo**.
1. Seleziona il pulsante **Save** (Salva).
1. Nella parte superiore della pagina **Edit Resolver**, scegli **Esegui** test.
Per un esempio più pratico, supponiamo di avere un'app che memorizza un tipo GraphQL che utilizza la generazione automatica `Dog` di ID per gli oggetti e li archivia in Amazon DynamoDB. Devi inoltre scrivere alcuni valori dagli argomenti di una mutazione GraphQL e permettere la visualizzazione di una risposta solo a determinati utenti. Di seguito viene mostrato come potrebbe apparire lo schema:
```
type Dog {
breed: String
color: String
}
type Mutation {
addDog(firstname: String, age: Int): Dog
}
```
Quando aggiungi un resolver per la `addDog` mutazione, puoi popolare un oggetto di contesto come nell'esempio seguente. Il seguente include gli argomenti `name` e `age` del client, oltre che un elemento `username` popolato nell'oggetto `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"
}
}
```
Puoi eseguire un test usando i modelli di mappatura della richiesta e della risposta seguenti:
**Modello di richiesta**
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "$util.autoId()" }
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
**Modello di risposta**
```
#if ($context.identity.username == "Nadia")
$util.toJson($ctx.result)
#else
$util.unauthorized()
#end
```
Il modello valutato contiene i dati dell'oggetto context di test e il valore generato da `$util.autoId()`. Inoltre, se decidi di modificare `username` in un valore diverso da `Nadia`, i risultati non verranno restituiti perché il controllo di autorizzazione avrebbe esito negativo. [Per ulteriori informazioni sul controllo granulare degli accessi, consulta Casi d'uso delle autorizzazioni.](security-authorization-use-cases.md#aws-appsync-security-authorization-use-cases)
### Test dei modelli di mappatura con's AWS AppSync APIs
Puoi utilizzare il comando `EvaluateMappingTemplate` API per testare in remoto i tuoi modelli di mappatura con dati simulati. Per iniziare con il comando, assicurati di aver aggiunto l'`appsync:evaluateMappingTemplate`autorizzazione alla tua politica. Esempio:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateMappingTemplate",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
È possibile sfruttare il comando utilizzando [AWS CLI](https://aws.amazon.com/cli/)o [AWS SDKs](https://aws.amazon.com/tools/). Ad esempio, prendiamo lo `Dog` schema e i relativi modelli di request/response mappatura della sezione precedente. Utilizzando la CLI sulla stazione locale, salvate il modello di richiesta in un file denominato`request.vtl`, quindi salvate l'`context`oggetto in un file denominato. `context.json` Dalla tua shell, esegui il seguente comando:
```
aws appsync evaluate-mapping-template --template file://request.vtl --context file://context.json
```
Il comando restituisce la seguente risposta:
```
{
"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`Contiene i risultati del test del modello fornito con quello fornito`context`. Puoi anche testare i tuoi modelli utilizzando il AWS SDKs. Ecco un esempio di utilizzo dell' AWS SDK per la versione 2 JavaScript :
```
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))
```
Utilizzando l'SDK, puoi incorporare facilmente i test della tua suite di test preferita per convalidare il comportamento del tuo modello. Ti consigliamo di creare test utilizzando [Jest Testing Framework](https://jestjs.io/), ma qualsiasi suite di test funziona. Il seguente frammento mostra un'ipotetica esecuzione di convalida. Nota che ci aspettiamo che la risposta di valutazione sia un codice JSON valido, quindi lo utilizziamo `JSON.parse` per recuperare JSON dalla stringa di risposta:
```
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)
})
```
Ciò produce il seguente risultato:
```
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
```
## Eseguire il debug di una query live
Non c'è nulla che possa sostituire un end-to-end test e una registrazione per eseguire il debug di un'applicazione di produzione. AWS AppSync consente di registrare gli errori e i dettagli completi delle richieste utilizzando Amazon CloudWatch. Inoltre, puoi utilizzare la AWS AppSync console per testare le query, le mutazioni e gli abbonamenti GraphQL e trasmettere in live streaming i dati di registro per ogni richiesta nell'editor di query per il debug in tempo reale. Per le sottoscrizioni, i log visualizzano le informazioni relative al tempo della connessione.
A tale scopo, è necessario che Amazon CloudWatch logs sia abilitato in anticipo, come descritto in [Monitoraggio e registrazione](monitoring.md#aws-appsync-monitoring). Successivamente, nella AWS AppSync console, scegli la scheda **Queries** e inserisci una query GraphQL valida. Nella sezione in basso a destra, fai clic e trascina la finestra **Logs per aprire** la visualizzazione dei log. Sulla parte superiore della pagina, scegliere l'icona con la freccia per la riproduzione per eseguire la query GraphQL. Dopo alcuni istati, i log completi per la richiesta e la risposta per l'operazione verranno trasmessi in questa sezione della console, dove potrai visualizzarli.
# Configurazione e utilizzo dei resolver di pipeline in (VTL) AWS AppSync
**Nota**
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)
AWS AppSync esegue i resolver su un campo GraphQL. In alcuni casi, le applicazioni prevedono il compimento di più operazioni per la risoluzione di un singolo campo GraphQL. Con i resolver a pipeline, gli sviluppatori possono ora comporre operazioni chiamate Funzioni ed eseguirle in sequenza. Questo tipo di resolver torna utile, ad esempio, con applicazioni che prevedono un controllo delle autorizzazioni antecedente al recupero dei dati per un campo.
Un resolver di pipeline è composto da due modelli di mappatura, della fase **antecedente** e **successiva**, e un elenco di funzioni. Ogni funzione dispone di un modello di mappatura delle **richieste** e delle **risposte** che esegue su un'origine dati. Dal momento che delega l'esecuzione a un elenco di funzioni, il resolver di pipeline non prevede il collegamento a un'origine dati. I resolver e le funzioni di unità sono primitive che eseguono operazioni su fonti di dati. Per ulteriori informazioni, consulta la panoramica del [modello di mappatura Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
## Fase 1: Creazione di un risolutore di pipeline
**Nella AWS AppSync console, vai alla pagina Schema.**
Salva lo schema seguente:
```
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
}
```
Bisogna implementare un resolver di pipeline per il campo **signUp (registrazione)** del tipo di **Mutation (Mutazione)**. Nel tipo di **mutazione** sul lato destro, scegli **Allega** accanto al campo di `signUp` mutazione. **Nella pagina di creazione del resolver, fai clic su **Azioni, quindi su Aggiorna runtime**.** **Scegli`Pipeline Resolver`, quindi scegli`VTL`, quindi scegli Aggiorna.** La pagina dovrebbe ora mostrare tre sezioni: un'area di testo **Prima della mappatura del modello**, una sezione **Funzioni** e un'area di testo **Dopo la mappatura del modello**.
Il nostra resolver di pipeline registra un utente convalidandone l'indirizzo e-mail e, successivamente, salvandolo nel sistema. Dobbiamo quindi incapsulare la convalida dell'e-mail in una funzione **validateEmail** e il salvataggio dell'utente in una funzione **saveUser**. Per prima, viene eseguita la funzione **validateEmail**, al termine della quale e solo se appurata la validità dell'e-mail, si può procedere con la **saveUser**.
Il flusso di esecuzione corrisponderà al seguente:
1. Modello di mappatura della richiesta del resolver Mutation.signUp
1. Funzione validateEmail
1. Funzione saveUser
1. Modello di mappatura della risposta del resolver Mutation.signUp
Poiché probabilmente riutilizzeremo la funzione **ValidateEmail** in altri resolver sulla nostra API, vogliamo evitare l'accesso `$ctx.args` perché questi cambieranno da un campo GraphQL all'altro. In alternativa, è possibile avvalersi di `$ctx.stash` per memorizzare l'attributo e-mail dall'argomento del campo di input `signUp(input: Signup)`.
**PRIMA di mappare il modello:**
```
## store email input field into a generic email key
$util.qr($ctx.stash.put("email", $ctx.args.input.email))
{}
```
La console fornisce un modello di mappatura **AFTER** passthrough predefinito che utilizzeremo:
```
$util.toJson($ctx.result)
```
Scegli **Crea** o **Salva** per aggiornare il resolver.
## Fase 2: Creazione di una funzione
Dalla pagina Pipeline Resolver, nella sezione **Funzioni**, fai clic su **Aggiungi funzione, quindi su **Crea** nuova funzione**. **È anche possibile creare funzioni senza passare dalla pagina del resolver; per farlo, nella AWS AppSync console, vai alla pagina Funzioni.** Selezionare il pulsante **Create function (Crea funzione)**. Creiamo quindi una funzione che verifichi la validità e la provenienza da un determinato dominio di un indirizzo e-mail. In caso di e-mail non valida, la funzione restituisce un errore. Altrimenti, inoltra qualsiasi input immesso.
Nella pagina della nuova funzione, scegli **Azioni**, quindi **Aggiorna** runtime. Scegli`VTL`, quindi **Aggiorna**. Assicurati di aver creato un'origine dati del tipo **NONE**. Scegli questa fonte di **dati nell'elenco Nome origine dati**. Per **il nome della funzione**, inserisci`validateEmail`. Nell'area del **codice della funzione**, sovrascrivi tutto con questo frammento:
```
#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}) }
}
```
Incollalo nel modello di mappatura delle risposte:
```
$util.toJson($ctx.result)
```
Controlla le modifiche, quindi scegli **Crea**. A questo punto, la funzione **validateEmail** è stata creata. Ripeti questi passaggi per creare la funzione **SaveUser** con i seguenti modelli di mappatura di richieste e risposte (per semplicità, utilizziamo **una** fonte di dati NONE e facciamo finta che l'utente sia stato salvato nel sistema dopo l'esecuzione della funzione. ):
Modello di mappatura della richiesta:
```
## $ctx.prev.result contains the signup input values. We could have also
## used $ctx.args.input.
{
"payload": $util.toJson($ctx.prev.result)
}
```
Modello di mappatura della risposta:
```
## 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)
```
Abbiamo appena creato la nostra funzione **SaveUser**.
## Fase 3: Aggiungere una funzione a un risolutore di pipeline
Le nostre funzioni avrebbero dovuto essere aggiunte automaticamente al risolutore di pipeline che abbiamo appena creato. Se così non fosse, o se hai creato le funzioni tramite la pagina **Funzioni**, puoi fare clic su **Aggiungi funzione** nella pagina del resolver per allegarle. Aggiungi entrambe le funzioni **ValidateEmail** **e** SaveUser al resolver. la funzione **validateEmail** deve precedere quella **saveUser**. Man mano che aggiungi altre funzioni, puoi utilizzare le opzioni di **spostamento su** e **sposta giù** per riorganizzare l'ordine di esecuzione delle funzioni. Controlla le modifiche, quindi scegli **Salva**.
## Fase 4: Esecuzione di una query
Nella AWS AppSync console, vai alla pagina **Query**. Nell'explorer, assicurati di usare la tua mutazione. Se non lo sei, scegli `Mutation` nell'elenco a discesa, quindi scegli. `+` Inserire la query seguente:
```
mutation {
signUp(input: {
email: "nadia@myvaliddomain.com"
username: "nadia"
}) {
id
email
}
}
```
Questo dovrebbe restituire qualcosa del tipo:
```
{
"data": {
"signUp": {
"id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
"email": "nadia@myvaliddomain.com"
}
}
}
```
Abbiamo quindi registrato il nostro utente convalidandone, al contempo, l'e-mail di input tramite un resolver di pipeline. Un tutorial più articolato sui resolver di pipeline è disponibile alla pagina [Tutorial: resolver di pipeline](tutorial-pipeline-resolvers.md#aws-appsync-tutorial-pipeline-resolvers).