Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verwendung lokaler Resolver in AWS AppSync
<a name="tutorial-local-resolvers-js"></a>

AWS AppSync ermöglicht es Ihnen AWS Lambda, unterstützte Datenquellen (Amazon DynamoDB oder Amazon OpenSearch Service) zu verwenden, um verschiedene Operationen durchzuführen. Doch in bestimmten Szenarien ist ein Aufruf an eine unterstützte Datenquelle möglicherweise nicht erforderlich.

Hier ist der lokale Resolver nützlich. Anstatt eine Remote-Datenquelle aufzurufen, leitet der lokale Resolver einfach das Ergebnis des Request-Handlers an den Response-Handler **weiter**. Das Feldauflösung verlässt AWS AppSync nicht.

Lokale Resolver sind in einer Vielzahl von Situationen nützlich. Der beliebtest Anwendungsfall ist das Veröffentlichen von Benachrichtigungen ohne Auslösen eines Datenquellenaufrufs. Um diesen Anwendungsfall zu demonstrieren, erstellen wir eine Pub/Sub-Anwendung, in der Benutzer Nachrichten veröffentlichen und abonnieren können. In diesem Beispiel werden *Abonnements* verwendet. Wenn Sie noch nicht mit *Abonnements* vertraut sind, sehen Sie sich das Tutorial [Echtzeitdaten](aws-appsync-real-time-data.md) an.

## Die Pub/Sub-App erstellen
<a name="create-the-pub-sub-application-js"></a>

Erstellen Sie zunächst eine leere GraphQL-API, indem Sie die Option **Von Grund auf neu entwerfen** wählen und die optionalen Details konfigurieren, wenn Sie Ihre GraphQL-API erstellen.

In unserer Pub/Sub-Anwendung können Kunden Nachrichten abonnieren und veröffentlichen. Jede veröffentlichte Nachricht enthält einen Namen und Daten. Fügen Sie dies dem Schema hinzu:

```
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"])
}
```

Als Nächstes fügen wir dem `Mutation.publish` Feld einen Resolver hinzu. **Suchen Sie im Bereich **Resolver** neben dem **Schemabereich** den `Mutation` Typ und dann das `publish(...): Channel` Feld und klicken Sie dann auf Anhängen.**

Erstellen Sie eine *None-Datenquelle* und geben Sie ihr *PageDataSource*einen Namen. Hängen Sie sie an Ihren Resolver an.

Fügen Sie Ihre Resolver-Implementierung mithilfe des folgenden Snippets hinzu:

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

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

Stellen Sie sicher, dass Sie den Resolver erstellen und die von Ihnen vorgenommenen Änderungen speichern.

## Nachrichten senden und abonnieren
<a name="send-and-subscribe-to-messages-js"></a>

Damit Kunden Nachrichten empfangen können, müssen sie zunächst einen Posteingang abonniert haben.

Führen Sie im Bereich **Abfragen** das `SubscribeToData` Abonnement aus:

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

 Der Abonnent erhält Nachrichten, wann immer die `publish` Mutation aufgerufen wird, aber nur, wenn die Nachricht an das `channel` Abonnement gesendet wird. Lassen Sie uns das im Bereich **Abfragen** versuchen. Während Ihr Abonnement noch in der Konsole läuft, öffnen Sie eine andere Konsole und führen Sie im Bereich **Abfragen** die folgende Anfrage aus:

**Anmerkung**  
In diesem Beispiel verwenden wir gültige JSON-Zeichenketten.

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

Das Ergebnis sieht etwa wie folgt aus:

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

Wir haben gerade die Verwendung lokaler Resolver demonstriert, indem wir eine Nachricht veröffentlicht und empfangen haben, ohne den AWS AppSync Dienst zu verlassen.