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à. # Utilizzo di risolutori di pipeline in 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/tutorials-js.html) AWS AppSync fornisce un modo semplice per collegare un campo GraphQL a una singola fonte di dati tramite resolver di unità. Tuttavia, un'unica operazione potrebbe non essere sufficiente. I resolver della pipeline offrono la possibilità di eseguire operazioni seriali sulle origini dati. Creazione di funzioni nell'API e collegamento a un resolver della pipeline. Il risultato di ogni funzione eseguita viene reindirizzato alla funzione successiva finché non rimangono altre funzioni da eseguire. Con i resolver della pipeline, è ora possibile creare flussi di lavoro più complessi direttamente in AWS AppSync. In questo tutorial, verrà creata una semplice applicazione per la visualizzazione di immagini, in cui gli utenti possono pubblicare immagini e visualizzare quelle pubblicate dai loro amici. ## Impostazione One-Click Se desideri configurare automaticamente l'endpoint GraphQL AWS AppSync con tutti i resolver configurati e le AWS risorse necessarie, puoi utilizzare il seguente modello: AWS CloudFormation [https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/pipeline/pipeline-resolvers-full.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/pipeline/pipeline-resolvers-full.yaml) Con questo stack. nell'account vengono create le seguenti risorse: + IAM Role per accedere AWS AppSync alle risorse del tuo account + 2 tabelle DynamoDB + 1 pool di utenti di Amazon Cognito + 2 gruppi di pool di utenti di Amazon Cognito + 3 utenti di pool di utenti di Amazon Cognito + 1 API AWS AppSync Al termine del processo di creazione dello AWS CloudFormation stack, riceverai un'e-mail per ciascuno dei tre utenti Amazon Cognito creati. Ogni e-mail contiene una password temporanea che usi per accedere come utente Amazon Cognito alla AWS AppSync console. Salvare le password per la parte restante del tutorial. ## Configurazione manuale Se preferisci eseguire manualmente una step-by-step procedura tramite la AWS AppSync console, segui la procedura di configurazione riportata di seguito. ### Configurazione AWS AppSync delle risorse non aziendali L'API comunica con due tabelle DynamoDB: **una tabella di immagini che memorizza le immagini e **una**** tabella di amici che memorizza le relazioni tra gli utenti. L'API è configurata per utilizzare un pool di utenti di Amazon Cognito come tipo di autenticazione. Lo CloudFormation stack seguente configura queste risorse nell'account. [https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/pipeline/pipeline-resolvers-resources-only.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/pipeline/pipeline-resolvers-resources-only.yaml) Al termine del processo di creazione dello AWS CloudFormation stack, riceverai un'e-mail per ciascuno dei tre utenti Amazon Cognito creati. Ogni e-mail conterrà una password temporanea utilizzabile per effettuare l'accesso come utente Amazon Cognito alla console di AWS AppSync. Salvare le password per la parte restante del tutorial. ### Creazione dell'API GraphQL Per creare l'API GraphQL in: AWS AppSync 1. Apri la AWS AppSync console e scegli **Build From Scratch** e scegli **Start**. 1. Impostare il nome dell'API su `AppSyncTutorial-PicturesViewer`. 1. Scegli **Create** (Crea). La AWS AppSync console crea una nuova API GraphQL utilizzando la modalità di autenticazione della chiave API. Puoi usare la console per configurare ulteriormente l'API GraphQL ed eseguire query sull'API per le parti restanti di questo tutorial. ### Configurazione dell'API per GraphQL Devi configurare l' AWS AppSync API con il pool di utenti Amazon Cognito che hai appena creato. 1. Seleziona la scheda **Impostazioni**. 1. Nella sezione **Authorization Type (Tipo di autorizzazione)**, scegliere *Amazon Cognito User Pool (Pool di utenti di Amazon Cognito)*. 1. *In **Configurazione del pool di utenti**, scegli **US-WEST-2 per la regione**.AWS * 1. Scegli il pool di UserPool utenti **AppSyncTutorial-**. 1. Scegliere **DENY (NEGA)** come *Default Action (Operazione predefinita)*. 1. Lascia vuoto il campo **regex del AppId client**. 1. Scegli **Save** (Salva). L'API è ora configurata per utilizzare un pool di utenti di Amazon Cognito come tipo di autorizzazione. ### Configurazione delle sorgenti dati per le tabelle DynamoDB **Dopo aver creato le tabelle DynamoDB, accedi all'API AWS AppSync GraphQL nella console e scegli la scheda Data Sources.** Ora creerai un'origine dati AWS AppSync per ciascuna delle tabelle DynamoDB che hai appena creato. 1. Passa alla scheda **Data source (Origine dati)**. 1. Scegli **New (Nuovo)** per creare una nuova origine dati. 1. Per il nome dell'origine dati, immetti `PicturesDynamoDBTable`. 1. Scegli **Amazon DynamoDB table (Tabella Amazon DynamoDB)** come tipo di origine dati. 1. Scegli **US-WEST-2** per la regione. 1. Dall'elenco delle tabelle, scegli la tabella **AppSyncTutorial-Pictures** DynamoDB. 1. Scegliere **Existing role (Ruolo esistente)** nella sezione **Create or use an existing role (Crea o usa un ruolo esistente)**. 1. Scegli il ruolo appena creato dal modello. CloudFormation Se non hai cambiato il *ResourceNamePrefix*, il nome del ruolo dovrebbe essere **AppSyncTutorial-Dynamo DBRole**. 1. Scegli **Create** (Crea). Ripeti la stessa procedura per la tabella degli **amici**, il nome della tabella DynamoDB dovrebbe **AppSyncTutorialessere** -Friends se non hai modificato *ResourceNamePrefix*il parametro al momento della creazione dello stack. CloudFormation ### Creazione dello schema GraphQL Ora che le sorgenti dati sono collegate alle tabelle DynamoDB, creiamo uno schema GraphQL. Dall'editor di schemi nella AWS AppSync console, assicurati che lo schema corrisponda al seguente schema: ``` schema { query: Query mutation: Mutation } type Mutation { createPicture(input: CreatePictureInput!): Picture! @aws_auth(cognito_groups: ["Admins"]) createFriendship(id: ID!, target: ID!): Boolean @aws_auth(cognito_groups: ["Admins"]) } type Query { getPicturesByOwner(id: ID!): [Picture] @aws_auth(cognito_groups: ["Admins", "Viewers"]) } type Picture { id: ID! owner: ID! src: String } input CreatePictureInput { owner: ID! src: String! } ``` Scegliere **Save Schema (Salva schema)** per salvare lo schema. Alcuni campi dello schema sono stati annotati con la direttiva *@aws\$1auth*. Poiché l'operazione predefinita dell'API è impostata su *DENY (NEGA)*, l'API rifiuta tutti gli utenti che non sono membri dei gruppi inclusi nella direttiva *@aws\$1auth*. Per ulteriori informazioni su come proteggere l'API, è possibile leggere la pagina sulla [sicurezza](security-authz.md#aws-appsync-security). **In questo caso, solo gli utenti amministratori hanno accesso ai campi *Mutation.createPicture e *Mutation.createFriendship**, mentre gli utenti membri dei gruppi Admins o Viewers possono accedere alla Query.** * getPicturesByCampo Proprietario.* Tutti gli altri utenti non hanno accesso. ### Configurazione dei resolver Ora che si dispone di un valido schema GraphQL e di due origini dati, è possibile collegare i resolver ai campi GraphQL dello schema. L'API offre le seguenti funzionalità: + Creazione di un'immagine tramite il campo *Mutation.createPicture* + Creazione di una richiesta di amicizia tramite il campo *Mutation.createFriendship* + Recupero di un'immagine tramite il campo *Query.getPicture* #### Mutation.createPicture Dall'editor dello schema nella AWS AppSync console, sul lato destro scegli **Attach Resolver for**. `createPicture(input: CreatePictureInput!): Picture!` Scegli l'origine dati *PicturesDynamoDBTable*DynamoDB. Aggiungere il modello seguente nella sezione **request mapping template (modello di mappatura della richiesta)**: ``` #set($id = $util.autoId()) { "version" : "2018-05-29", "operation" : "PutItem", "key" : { "id" : $util.dynamodb.toDynamoDBJson($id), "owner": $util.dynamodb.toDynamoDBJson($ctx.args.input.owner) }, "attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args.input) } ``` Aggiungere il modello seguente nella sezione **response mapping template (modello di mappatura della risposta)**: ``` #if($ctx.error) $util.error($ctx.error.message, $ctx.error.type) #end $util.toJson($ctx.result) ``` La funzionalità per la creazione di immagini è stata creata. Verrà salvata un'immagine nella tabella **pictures** con un UUID casuale come id dell'immagine e il nome utente di Cognito come proprietario dell'immagine. #### Mutation.createFriendship Dall'editor dello schema nella AWS AppSync console, sul lato destro scegli **Attach Resolver** for. `createFriendship(id: ID!, target: ID!): Boolean` Scegli l'origine dati **FriendsDynamoDBTable**DynamoDB. Aggiungere il modello seguente nella sezione **request mapping template (modello di mappatura della richiesta)**: ``` #set($userToFriendFriendship = { "userId" : "$ctx.args.id", "friendId": "$ctx.args.target" }) #set($friendToUserFriendship = { "userId" : "$ctx.args.target", "friendId": "$ctx.args.id" }) #set($friendsItems = [$util.dynamodb.toMapValues($userToFriendFriendship), $util.dynamodb.toMapValues($friendToUserFriendship)]) { "version" : "2018-05-29", "operation" : "BatchPutItem", "tables" : { ## Replace 'AppSyncTutorial-' default below with the ResourceNamePrefix you provided in the CloudFormation template "AppSyncTutorial-Friends": $util.toJson($friendsItems) } } ``` Importante: nel modello di **BatchPutItem**richiesta, deve essere presente il nome esatto della tabella DynamoDB. *Il nome di tabella predefinito è AppSyncTutorial -Friends.* Se si utilizza il nome di tabella sbagliato, viene visualizzato un errore quando si AppSync tenta di assumere il ruolo fornito. Per semplicità, in questo tutorial, procedi come se la richiesta di amicizia fosse stata approvata e salva la voce della relazione direttamente nella **AppSyncTutorialFriends**tabella. Di fatto, si stanno memorizzando due voci per ogni richiesta di amicizia dato che la relazione è bidirezionale. Per ulteriori dettagli sulle best practice di Amazon DynamoDB per many-to-many rappresentare le relazioni, consulta [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-adjacency-graphs.html) Best Practices. Aggiungere il modello seguente nella sezione **response mapping template (modello di mappatura della risposta)**: ``` #if($ctx.error) $util.error($ctx.error.message, $ctx.error.type) #end true ``` Nota: verificare che il proprio modello di richiesta contenga il nome corretto della tabella. Il nome predefinito è *AppSyncTutorial-Friends*, ma il nome della tabella potrebbe essere diverso se modifichi il parametro. CloudFormation **ResourceNamePrefix** #### Interrogazione. getPicturesByProprietario Ora che si dispone di richieste di amicizia e immagini, è necessario fornire la possibilità agli utenti di visualizzare le immagini dei loro amici. Per soddisfare questo requisito, occorre prima verificare che il richiedente sia amico del proprietario, quindi è necessario eseguire una query per ottenere l'immagine. Poiché questa funzionalità richiede due operazioni sull'origine dati, si creano due funzioni. La prima funzione, **isFriend**, verifica se il richiedente e il proprietario sono amici. La seconda funzione, **getPicturesByOwner**, recupera le immagini richieste con un ID proprietario. *Diamo un'occhiata al flusso di esecuzione riportato di seguito per il resolver proposto sulla Query. getPicturesByCampo proprietario*: 1. Modello di mappatura Before: prepara il contesto e gli argomenti di input per il campo. 1. Funzione isFriend: verifica se il richiedente è il proprietario dell'immagine. In caso contrario, verifica se gli utenti richiedenti e proprietari sono amici eseguendo un'operazione GetItem DynamoDB sulla tabella degli amici. 1. getPicturesBy*Funzione Owner: recupera le immagini dalla tabella Pictures utilizzando un'operazione di interrogazione DynamoDB sull'indice secondario globale owner-index.* 1. Modello di mappatura After: mappa le immagini risultanti in modo che gli attributi di DynamoDB siano mappati correttamente con i campi dei tipi GraphQL previsti. Innanzitutto, verranno create le funzioni. ##### Funzione isFriend 1. Selezionare la scheda **Functions (Funzioni)**. 1. Scegliere **Create Function (Crea funzione)** per creare una funzione. 1. Per il nome dell'origine dati, immetti `FriendsDynamoDBTable`. 1. Come nome della funzione, immettere *isFriend*. 1. Nell'area di testo del modello di mappatura della richiesta, incollare il seguente modello: ``` #set($ownerId = $ctx.prev.result.owner) #set($callerId = $ctx.prev.result.callerId) ## if the owner is the caller, no need to make the check #if($ownerId == $callerId) #return($ctx.prev.result) #end { "version" : "2018-05-29", "operation" : "GetItem", "key" : { "userId" : $util.dynamodb.toDynamoDBJson($callerId), "friendId" : $util.dynamodb.toDynamoDBJson($ownerId) } } ``` 1. Nell'area di testo del modello di mappatura della risposta, incollare il seguente modello: ``` #if($ctx.error) $util.error("Unable to retrieve friend mapping message: ${ctx.error.message}", $ctx.error.type) #end ## if the users aren't friends #if(!$ctx.result) $util.unauthorized() #end $util.toJson($ctx.prev.result) ``` 1. Selezionare **Create function (Crea funzione)**. Risultato: è stata creata la funzione **isFriend**. ##### getPicturesByFunzione del proprietario 1. Selezionare la scheda **Functions (Funzioni)**. 1. Scegliere **Create Function (Crea funzione)** per creare una funzione. 1. Per il nome dell'origine dati, immetti `PicturesDynamoDBTable`. 1. Come nome della funzione, immettere `getPicturesByOwner`. 1. Nell'area di testo del modello di mappatura della richiesta, incollare il seguente modello: ``` { "version" : "2018-05-29", "operation" : "Query", "query" : { "expression": "#owner = :owner", "expressionNames": { "#owner" : "owner" }, "expressionValues" : { ":owner" : $util.dynamodb.toDynamoDBJson($ctx.prev.result.owner) } }, "index": "owner-index" } ``` 1. Nell'area di testo del modello di mappatura della risposta, incollare il seguente modello: ``` #if($ctx.error) $util.error($ctx.error.message, $ctx.error.type) #end $util.toJson($ctx.result) ``` 1. Selezionare **Create function (Crea funzione)**. Risultato: hai creato la funzione **getPicturesByOwner**. *Ora che le funzioni sono state create, collegate un resolver di pipeline alla Query. getPicturesByCampo Proprietario.* Dall'editor dello schema nella AWS AppSync console, sul lato destro scegli **Attach Resolver for**. `Query.getPicturesByOwner(id: ID!): [Picture]` Nella pagina seguente, selezionare il collegamento **Convert to pipeline resolver (Converti in resolver della pipeline)** che viene visualizzato sotto l'origine dati nell'elenco a discesa. Utilizzare la procedura seguente per il modello di mappatura Before: ``` #set($result = { "owner": $ctx.args.id, "callerId": $ctx.identity.username }) $util.toJson($result) ``` Nella sezione **after mapping template (modello di mappatura After)**, utilizzare la procedura seguente: ``` #foreach($picture in $ctx.result.items) ## prepend "src://" to picture.src property #set($picture['src'] = "src://${picture['src']}") #end $util.toJson($ctx.result.items) ``` Scegliere **Create Resolver (Crea resolver)**. Il primo resolver della pipeline è stato ora collegato. Nella stessa pagina, aggiungere le due funzioni create in precedenza. Nella sezione delle funzioni, scegliere **Add A Function (Aggiungi funzione)**, quindi scegliere o digitare il nome della prima funzione, **isFriend**. Aggiungi la seconda funzione seguendo la stessa procedura per la funzione **getPicturesByOwner**. Assicuratevi che la funzione **isFriend** compaia per prima nell'elenco seguita dalla funzione **getPicturesByOwner**. È possibile utilizzare le frecce Su è Giù per riorganizzare le funzioni per ordinarne l'esecuzione nella pipeline. Una volta creato il resolver della pipeline e collegate le funzioni, è opportuno testare la nuova API GraphQL. ## Test dell'API GraphQL Innanzitutto, occorre inserire immagini e richieste di amicizia eseguendo alcune mutazioni con l'utente con privilegi di amministratore creato. Sul lato sinistro della AWS AppSync console, scegli la scheda **Interrogazioni**. ### Mutazione createPicture 1. Nella AWS AppSync console, scegli la scheda **Interrogazioni.** 1. Scegliere **Login With User Pools (Accedi con pool di utenti)**. 1. Nella modalità modale, inserisci l'ID client Cognito Sample creato dallo stack (ad esempio CloudFormation 37solo6mmhh7k4v63cqdfgdg5d). 1. Immettete il nome utente CloudFormation che avete passato come parametro allo stack. L'impostazione predefinita è **nadia**. 1. Utilizza la password temporanea che è stata inviata all'e-mail che hai fornito come parametro per lo CloudFormation stack (ad esempio, *UserPoolUserEmail*). 1. Selezionare **Login (Accesso)**. Ora dovresti vedere il pulsante rinominato **Logout nadia**, o qualunque nome utente tu abbia scelto durante la creazione dello CloudFormation stack (ovvero,). *UserPoolUsername* A questo punto trasmetteremo alcune mutazioni *createPicture* per popolare la tabella delle immagini. Eseguire la seguente query GraphQL nella console: ``` mutation { createPicture(input:{ owner: "nadia" src: "nadia.jpg" }) { id owner src } } ``` La risposta dovrebbe essere simile alla seguente: ``` { "data": { "createPicture": { "id": "c6fedbbe-57ad-4da3-860a-ffe8d039882a", "owner": "nadia", "src": "nadia.jpg" } } } ``` Aggiungiamo alcune altre immagini: ``` mutation { createPicture(input:{ owner: "shaggy" src: "shaggy.jpg" }) { id owner src } } ``` ``` mutation { createPicture(input:{ owner: "rex" src: "rex.jpg" }) { id owner src } } ``` Sono state aggiunte tre immagini utilizzando **nadia** come utente con privilegi di amministratore. ### Mutazione createFriendship Ora aggiungiamo una richiesta di amicizia. Eseguire le seguenti mutazioni nella console. Nota: è necessario essere connessi con l'utente con privilegi di amministratore (l'utente predefinito è **nadia**). ``` mutation { createFriendship(id: "nadia", target: "shaggy") } ``` La risposta dovrebbe essere simile alla seguente: ``` { "data": { "createFriendship": true } } ``` **nadia** e **shaggy** sono amici. **rex** non è amico di altri utenti. ### getPicturesByRichiesta del proprietario Per questa fase, effettuare l'accesso con l'utente **nadia**, utilizzando pool di utenti di Cognito e le credenziali impostate all'inizio di questo tutorial. Come utente **nadia**, recuperare le immagini di proprietà di **shaggy**. ``` query { getPicturesByOwner(id: "shaggy") { id owner src } } ``` Poiché **nadia** e **shaggy** sono amici, la query dovrebbe restituire l'immagine corrispondente. ``` { "data": { "getPicturesByOwner": [ { "id": "05a16fba-cc29-41ee-a8d5-4e791f4f1079", "owner": "shaggy", "src": "src://shaggy.jpg" } ] } } ``` Analogamente, anche un eventuale tentativo di **nadia** di recuperare proprie immagini andrebbe a buon fine. Il pipeline resolver è stato ottimizzato per evitare l'esecuzione dell'operazione ** GetItem isFriend** in questo caso. Provare la seguente query: ``` query { getPicturesByOwner(id: "nadia") { id owner src } } ``` Se si attiva la registrazione per le API (nel riquadro **Settings (Impostazioni))**, impostare il livello di debug a **ALL** ed eseguire di nuovo la stessa query; verranno restituiti i log per l'esecuzione effettiva. Esaminando i log, è possibile stabilire se la funzione **isFriend** ha restituito un output nelle prime fasi del **modello di mappatura della richiesta**: ``` { "errors": [], "mappingTemplateType": "Request Mapping", "path": "[getPicturesByOwner]", "resolverArn": "arn:aws:appsync:us-west-2:XXXX:apis/XXXX/types/Query/fields/getPicturesByOwner", "functionArn": "arn:aws:appsync:us-west-2:XXXX:apis/XXXX/functions/o2f42p2jrfdl3dw7s6xub2csdfs", "functionName": "isFriend", "earlyReturnedValue": { "owner": "nadia", "callerId": "nadia" }, "context": { "arguments": { "id": "nadia" }, "prev": { "result": { "owner": "nadia", "callerId": "nadia" } }, "stash": {}, "outErrors": [] }, "fieldInError": false } ``` *La *earlyReturnedValue*chiave rappresenta i dati restituiti dalla direttiva \$1return.* ****Infine, anche se **rex** è membro del **Viewers Cognito** UserPool Group e poiché **rex** non è amico di nessuno, non potrà accedere a nessuna delle immagini di proprietà di Shaggy o Nadia.**** Se si effettua l'accesso come **rex** nella console e si esegue la query seguente: ``` query { getPicturesByOwner(id: "nadia") { id owner src } } ``` Si otterrà il seguente errore per mancanza di autorizzazioni: ``` { "data": { "getPicturesByOwner": null }, "errors": [ { "path": [ "getPicturesByOwner" ], "data": null, "errorType": "Unauthorized", "errorInfo": null, "locations": [ { "line": 2, "column": 9, "sourceName": null } ], "message": "Not Authorized to access getPicturesByOwner on type Query" } ] } ``` L'autorizzazione complessa è stata correttamente implementata utilizzando i resolver della pipeline.