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 locali in AWS AppSync
<a name="tutorial-local-resolvers-js"></a>

AWS AppSync consente di utilizzare fonti di dati supportate (AWS Lambda Amazon DynamoDB o OpenSearch Amazon Service) per eseguire varie operazioni. In alcuni scenari, tuttavia, una chiamata a un'origine dati supportata può non essere necessaria.

È in queste situazioni che il resolver locale risulta utile. Invece di chiamare una fonte di dati remota, il resolver locale **inoltrerà** semplicemente il risultato del gestore della richiesta al gestore della risposta. La risoluzione del campo rimarrà in AWS AppSync.

I resolver locali sono utili in una miriade di situazioni. Quello più comune è la pubblicazione di notifiche senza attivare una chiamata a un'origine dati. Per dimostrare questo caso d'uso, creiamo un'applicazione pub/sub in cui gli utenti possano pubblicare e iscriversi ai messaggi. In questo esempio vengono usate le *sottoscrizioni*. Quindi, se non hai familiarità con le *sottoscrizioni*, puoi seguire il tutorial [Dati in tempo reale](aws-appsync-real-time-data.md).

## Creazione dell'app pub/sub
<a name="create-the-pub-sub-application-js"></a>

Innanzitutto, crea un'API GraphQL vuota scegliendo l'opzione **Design from scratch** e configurando i dettagli opzionali durante la creazione dell'API GraphQL.

Nella nostra applicazione pub/sub, i clienti possono iscriversi e pubblicare messaggi. Ogni messaggio pubblicato include un nome e dei dati. Aggiungi questo allo schema:

```
type Channel {
	name: String!
	data: AWSJSON!
}

type Mutation {
	publish(name: String!, data: AWSJSON!): Channel
}

type Query {
	getChannel: Channel
}

type Subscription {
	subscribe(name: String!): Channel
		@aws_subscribe(mutations: ["publish"])
}
```

Quindi, colleghiamo un resolver al `Mutation.publish` campo. **Nel **riquadro Resolver** accanto al riquadro **Schema**, trova il `Mutation` tipo, quindi il `publish(...): Channel` campo, quindi fai clic su Allega.**

Crea una fonte di dati *Nessuno* e assegnale un nome. *PageDataSource* Collegalo al tuo resolver.

Aggiungi l'implementazione del tuo resolver utilizzando il seguente frammento:

```
export function request(ctx) {
  return { payload: ctx.args };
}

export function response(ctx) {
  return ctx.result;
}
```

Assicurati di creare il resolver e di salvare le modifiche apportate.

## Invia e sottoscrivi messaggi
<a name="send-and-subscribe-to-messages-js"></a>

Affinché i clienti possano ricevere messaggi, devono prima essere iscritti a una casella di posta.

Nel riquadro **Query**, esegui l'abbonamento: `SubscribeToData`

```
subscription SubscribeToData {
    subscribe(name:"channel") {
        name
        data
    }
}
```

 Il sottoscrittore riceverà messaggi ogni volta che viene richiamata la `publish` mutazione, ma solo quando il messaggio viene inviato all'abbonamento. `channel` **Proviamo a farlo nel riquadro Query.** Mentre l'abbonamento è ancora in esecuzione nella console, apri un'altra console ed esegui la seguente richiesta nel riquadro **Query**:

**Nota**  
In questo esempio utilizziamo stringhe JSON valide.

```
mutation PublishData {
    publish(data: "{\"msg\": \"hello world!\"}", name: "channel") {
        data
        name
    }
}
```

Il risultato sarà simile al seguente:

```
{
  "data": {
    "publish": {
      "data": "{\"msg\":\"hello world!\"}",
      "name": "channel"
    }
  }
}
```

Abbiamo appena dimostrato l'uso dei resolver locali, pubblicando un messaggio e ricevendolo senza uscire dal servizio. AWS AppSync