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 resolver HTTP in AWS AppSync
AWS AppSync consente di utilizzare fonti di dati supportate (ad esempio Amazon DynamoDB AWS Lambda, Amazon Service o OpenSearch Amazon Aurora) per eseguire varie operazioni, oltre a qualsiasi endpoint HTTP arbitrario per risolvere i campi GraphQL. Quando gli endpoint HTTP sono disponibili, è possibile connettersi a questi utilizzando un'origine dati. Quindi, è possibile configurare un resolver nello schema per eseguire operazioni GraphQL, ad esempio query, mutazioni e sottoscrizioni. Questo tutorial fornirà una guida di alcuni esempi comuni.
In questo tutorial utilizzi un'API REST (creata utilizzando Amazon API Gateway e Lambda) con un endpoint GraphQL AWS AppSync .
## Creazione di un'API REST
Puoi utilizzare il seguente AWS CloudFormation modello per configurare un endpoint REST adatto a questo tutorial:
[https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/http/http-api-gw.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/http/http-api-gw.yaml)
Lo AWS CloudFormation stack esegue i seguenti passaggi:
1. Imposta una funzione Lambda che contiene la logica di business per il tuo microservizio.
1. Imposta un'API REST API Gateway con la seguente combinazione endpoint/method/content di tipi:
****
| Percorso risorsa API | Metodo HTTP | Tipo di contenuto supportato |
| --- | --- | --- |
| /v1/utenti | POST | application/json |
| /v1/utenti | GET | application/json |
| /v1/utenti/1 | GET | application/json |
| /v1/utenti/1 | PUT | application/json |
| /v1/utenti/1 | DELETE | application/json |
## Creazione dell'API GraphQL
Per creare l'API GraphQL in: AWS AppSync
1. Apri la AWS AppSync console e scegli **Crea API**.
1. Scegli **GraphQL APIs** e poi scegli **Design da zero**. Scegli **Next (Successivo)**.
1. Per il nome API, digita `UserData`. Scegli **Next (Successivo)**.
1. Scegli `Create GraphQL resources later`. Scegli **Next (Successivo)**.
1. Controlla i tuoi input e scegli **Crea** API.
La AWS AppSync console crea una nuova API GraphQL utilizzando la modalità di autenticazione della chiave API. Puoi utilizzare la console per configurare ulteriormente l'API GraphQL ed eseguire le richieste.
## Creazione di uno schema GraphQL
Ora che hai un'API GraphQL, è possibile creare uno schema GraphQL. Nell'editor di **schema** della AWS AppSync console, usa lo snippet seguente:
```
type Mutation {
addUser(userInput: UserInput!): User
deleteUser(id: ID!): User
}
type Query {
getUser(id: ID): User
listUser: [User!]!
}
type User {
id: ID!
username: String!
firstname: String
lastname: String
phone: String
email: String
}
input UserInput {
id: ID!
username: String!
firstname: String
lastname: String
phone: String
email: String
}
```
## Configura la tua fonte di dati HTTP
Per configurare l'origine dati HTTP, effettua le seguenti operazioni:
1. Nella pagina **Sorgenti dati** dell'API AWS AppSync GraphQL, scegli **Crea origine dati**.
1. Inserisci un nome per la fonte di dati, ad esempio`HTTP_Example`.
1. In **Tipo di origine dati**, scegli **Endpoint HTTP**.
1. Imposta l'endpoint sull'endpoint API Gateway creato all'inizio del tutorial. **Puoi trovare l'endpoint generato dallo stack accedendo alla console Lambda e trovando l'applicazione in Applicazioni.** All'interno delle impostazioni dell'applicazione, dovresti vedere un endpoint **API che fungerà da endpoint**. AWS AppSync Assicurati di non includere il nome dello stage come parte dell'endpoint. Ad esempio, se il tuo endpoint lo fosse`https://aaabbbcccd.execute-api.us-east-1.amazonaws.com/v1`, dovresti digitare. `https://aaabbbcccd.execute-api.us-east-1.amazonaws.com`
**Nota**
Al momento, solo gli endpoint pubblici sono supportati da. AWS AppSync
Per ulteriori informazioni sulle autorità di certificazione riconosciute dal AWS AppSync servizio, consulta [Autorità di certificazione (CA) riconosciute da AWS AppSync per gli endpoint HTTPS](http-cert-authorities.md#aws-appsync-http-certificate-authorities).
## Configurazione dei resolver
In questo passaggio, collegherai l'origine dati HTTP alle query `getUser` and`addUser`.
Per configurare il `getUser` resolver:
1. Nella tua API AWS AppSync GraphQL, scegli la scheda **Schema**.
1. **A destra dell'editor dello **schema**, nel riquadro **Resolvers** e sotto il tipo di **query**, trova il `getUser` campo e scegli Allega.**
1. Mantieni invariato il tipo di resolver e il runtime inalterato`Unit`. `APPSYNC_JS`
1. Nel **Nome dell'origine dati**, scegli l'endpoint HTTP creato in precedenza.
1. Scegli **Create** (Crea).
1. Nell'editor di codice **Resolver**, aggiungi il seguente frammento come gestore delle richieste:
```
import { util } from '@aws-appsync/utils'
export function request(ctx) {
return {
version: '2018-05-29',
method: 'GET',
params: {
headers: {
'Content-Type': 'application/json',
},
},
resourcePath: `/v1/users/${ctx.args.id}`,
}
}
```
1. Aggiungi il seguente frammento come gestore delle risposte:
```
export function response(ctx) {
const { statusCode, body } = ctx.result
// if response is 200, return the response
if (statusCode === 200) {
return JSON.parse(body)
}
// if response is not 200, append the response to error block.
util.appendError(body, statusCode)
}
```
1. Scegliere la scheda **Query** quindi eseguire la seguente query:
```
query GetUser{
getUser(id:1){
id
username
}
}
```
Viene restituita la risposta seguente:
```
{
"data": {
"getUser": {
"id": "1",
"username": "nadia"
}
}
}
```
Per configurare il resolver: `addUser`
1. Scegli la scheda **Schema**.
1. **A destra dell'editor dello **schema**, nel riquadro **Resolver** e sotto il tipo di **query, trova il `addUser` campo** e scegli Allega.**
1. Mantieni invariato il tipo di resolver e il runtime inalterato`Unit`. `APPSYNC_JS`
1. Nel **Nome dell'origine dati**, scegli l'endpoint HTTP creato in precedenza.
1. Scegli **Create** (Crea).
1. Nell'editor di codice **Resolver**, aggiungi il seguente frammento come gestore delle richieste:
```
export function request(ctx) {
return {
"version": "2018-05-29",
"method": "POST",
"resourcePath": "/v1/users",
"params":{
"headers":{
"Content-Type": "application/json"
},
"body": ctx.args.userInput
}
}
}
```
1. Aggiungi il seguente frammento come gestore delle risposte:
```
export function response(ctx) {
if(ctx.error) {
return util.error(ctx.error.message, ctx.error.type)
}
if (ctx.result.statusCode == 200) {
return ctx.result.body
} else {
return util.appendError(ctx.result.body, "ctx.result.statusCode")
}
}
```
1. Scegliere la scheda **Query** quindi eseguire la seguente query:
```
mutation addUser{
addUser(userInput:{
id:"2",
username:"shaggy"
}){
id
username
}
}
```
Se esegui nuovamente la `getUser` query, dovrebbe restituire la seguente risposta:
```
{
"data": {
"getUser": {
"id": "2",
"username": "shaggy"
}
}
}
```
## Richiamo dei servizi AWS
È possibile utilizzare i resolver HTTP per configurare un'interfaccia API GraphQL per i servizi. AWS Le richieste HTTP AWS devono essere firmate con il [processo Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) in modo da AWS poter identificare chi le ha inviate. AWS AppSync calcola la firma per tuo conto quando associ un ruolo IAM all'origine dati HTTP.
Fornisci due componenti aggiuntivi per richiamare i AWS servizi con resolver HTTP:
+ Un ruolo IAM con autorizzazioni per chiamare il servizio AWS APIs
+ Configurazione della firma nell'origine dati
Ad esempio, se desideri chiamare l'[ListGraphqlApis operazione](https://docs.aws.amazon.com/appsync/latest/APIReference/API_ListGraphqlApis.html) con resolver HTTP, devi prima [creare un ruolo IAM](attaching-a-data-source.md#aws-appsync-getting-started-build-a-schema-from-scratch) che AWS AppSync presuppone la seguente policy allegata:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"appsync:ListGraphqlApis"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
Quindi, crea l'origine dati HTTP per. AWS AppSync In questo esempio, chiami AWS AppSync nella regione Stati Uniti occidentali (Oregon). Imposta la seguente configurazione HTTP in un file denominato `http.json`, che include la regione di firma e il nome del servizio:
```
{
"endpoint": "https://appsync.us-west-2.amazonaws.com/",
"authorizationConfig": {
"authorizationType": "AWS_IAM",
"awsIamConfig": {
"signingRegion": "us-west-2",
"signingServiceName": "appsync"
}
}
}
```
Quindi, utilizzate il AWS CLI per creare l'origine dati con un ruolo associato come segue:
```
aws appsync create-data-source --api-id \
--name AWSAppSync \
--type HTTP \
--http-config file:///http.json \
--service-role-arn
```
Quando colleghi un resolver al campo dello schema, usa il seguente modello di mappatura delle richieste per chiamare: AWS AppSync
```
{
"version": "2018-05-29",
"method": "GET",
"resourcePath": "/v1/apis"
}
```
Quando esegui una query GraphQL per questa fonte di dati, AWS AppSync firma la richiesta utilizzando il ruolo che hai fornito e include la firma nella richiesta. La query restituisce un elenco di AWS AppSync GraphQL APIs nel tuo account in quella AWS regione.