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.

# Kombinieren von GraphQL-Resolvern in AWS AppSync
<a name="tutorial-combining-graphql-resolvers-js"></a>

Resolver und Felder in einem GraphQL-Schema zeichnen sich durch 1-zu-1-Beziehungen mit einem hohen Maß an Flexibilität aus. Da eine Datenquelle unabhängig von einem Schema auf einem Resolver konfiguriert wird, haben Sie die Möglichkeit, Ihre GraphQL-Typen über verschiedene Datenquellen aufzulösen oder zu manipulieren, sodass Sie ein Schema kombinieren und anpassen können, um Ihren Anforderungen am besten gerecht zu werden.

Die folgenden Szenarien zeigen, wie Sie Datenquellen in Ihrem Schema mischen und abgleichen können. Bevor Sie beginnen, sollten Sie mit der Konfiguration von Datenquellen und Resolvern für AWS Lambda Amazon DynamoDB und Amazon Service vertraut sein. OpenSearch 

## Beispielschema
<a name="example-schema-js"></a>

Das folgende Schema hat den Typ `Post` mit jeweils drei `Query` `Mutation` Operationen:

```
type Post {
    id: ID!
    author: String!
    title: String
    content: String
    url: String
    ups: Int
    downs: Int
    version: Int!
}

type Query {
    allPost: [Post]
    getPost(id: ID!): Post
    searchPosts: [Post]
}

type Mutation {
    addPost(
        id: ID!,
        author: String!,
        title: String,
        content: String,
        url: String
    ): Post
    updatePost(
        id: ID!,
        author: String!,
        title: String,
        content: String,
        url: String,
        ups: Int!,
        downs: Int!,
        expectedVersion: Int!
    ): Post
    deletePost(id: ID!): Post
}
```

In diesem Beispiel hätten Sie insgesamt sechs Resolver, von denen jeder eine Datenquelle benötigt. Eine Möglichkeit, dieses Problem zu lösen, besteht darin, diese mit einer einzigen Amazon DynamoDB-Tabelle namens, zu verbinden`Posts`, in der das `AllPost` Feld einen Scan und das `searchPosts` Feld eine Abfrage ausführt (siehe [JavaScriptResolver-Funktionsreferenz für](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html) DynamoDB). Sie sind jedoch nicht auf Amazon DynamoDB beschränkt; es gibt verschiedene Datenquellen wie Lambda oder OpenSearch Service, um Ihre Geschäftsanforderungen zu erfüllen. 

## Änderung von Daten mithilfe von Resolvern
<a name="alter-data-through-resolvers-js"></a>

Möglicherweise müssen Sie Ergebnisse aus einer Drittanbieter-Datenbank zurückgeben, die nicht direkt von AWS AppSync Datenquellen unterstützt wird. Möglicherweise müssen Sie auch komplexe Änderungen an den Daten vornehmen, bevor sie an die API-Clients zurückgegeben werden. Dies kann durch eine falsche Formatierung der Datentypen verursacht werden, z. B. durch Zeitstempelunterschiede auf Clients oder durch den Umgang mit Abwärtskompatibilitätsproblemen. In diesem Fall ist es die geeignete Lösung, AWS Lambda Funktionen als Datenquelle mit Ihrer AWS AppSync API zu verbinden. Zur Veranschaulichung: Im folgenden Beispiel manipuliert eine AWS Lambda Funktion Daten, die aus einem Datenspeicher eines Drittanbieters abgerufen wurden:

```
export const handler = (event, context, callback) => {
    // fetch data
    const result = fetcher()

    // apply complex business logic
    const data = transform(result)	

    // return to AppSync
    return data
};
```

Hierbei handelt es sich um eine absolut gültige Lambda-Funktion, die dem `AllPost`-Feld im GraphQL-Schema zugewiesen werden könnte. Auf diese Weise würde jeder Abfrage, die alle Ergebnisse zurückgibt, Zufallszahlen für die positiven und negativen Stimmen vergeben.

## DynamoDB und Service OpenSearch
<a name="ddb-and-es-js"></a>

Bei einigen Anwendungen führen Sie möglicherweise Mutationen oder einfache Suchabfragen für DynamoDB durch und lassen einen Hintergrundprozess Dokumente an OpenSearch Service übertragen. Sie könnten den `searchPosts` Resolver einfach an die OpenSearch Service-Datenquelle anhängen und Suchergebnisse (aus Daten, die ihren Ursprung in DynamoDB haben) mithilfe einer GraphQL-Abfrage zurückgeben. Dies kann äußerst leistungsfähig sein, wenn Sie Ihren Anwendungen erweiterte Suchoperationen wie Stichwörter, unscharfe Wortübereinstimmungen oder sogar Geodatensuchen hinzufügen. Die Übertragung von Daten aus DynamoDB könnte über einen ETL-Prozess erfolgen, oder Sie könnten alternativ mithilfe von Lambda aus DynamoDB streamen.

Informationen zu den ersten Schritten mit diesen speziellen Datenquellen finden Sie in unseren [DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/tutorial-dynamodb-resolvers-js.html) - und [Lambda-Tutorials](https://docs.aws.amazon.com/appsync/latest/devguide/tutorial-lambda-resolvers-js.html).

Wenn Sie beispielsweise das Schema aus unserem vorherigen Tutorial verwenden, fügt die folgende Mutation DynamoDB ein Element hinzu:

```
mutation addPost {
  addPost(
    id: 123
    author: "Nadia"
    title: "Our first post!"
    content: "This is our first post."
    url: "https://aws.amazon.com/appsync/"
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}
```

Dadurch werden Daten in DynamoDB geschrieben, das dann Daten über Lambda an Amazon OpenSearch Service streamt, mit dem Sie dann anhand verschiedener Felder nach Beiträgen suchen. Da sich die Daten beispielsweise in Amazon OpenSearch Service befinden, können Sie entweder die Autoren- oder Inhaltsfelder mit Freiformtext, auch mit Leerzeichen, wie folgt durchsuchen:

```
query searchName{
    searchAuthor(name:"   Nadia   "){
        id
        title
        content
    }
}

---------- or ----------

query searchContent{
    searchContent(text:"test"){
        id
        title
        content
    }
}
```

Da die Daten direkt in DynamoDB geschrieben werden, können Sie mit den Abfragen `allPost{...}` und `getPost{...}` dennoch effiziente Listen- oder Element-Suchvorgänge für die Tabelle durchführen. Dieser Stack verwendet den folgenden Beispielcode für DynamoDB-Streams:

**Anmerkung**  
Dieser Python-Code ist ein Beispiel und sollte nicht im Produktionscode verwendet werden.

```
import boto3
import requests
from requests_aws4auth import AWS4Auth

region = '' # e.g. us-east-1
service = 'es'
credentials = boto3.Session().get_credentials()
awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token)

host = '' # the OpenSearch Service domain, e.g. https://search-mydomain.us-west-1.es.amazonaws.com
index = 'lambda-index'
datatype = '_doc'
url = host + '/' + index + '/' + datatype + '/'

headers = { "Content-Type": "application/json" }

def handler(event, context):
    count = 0
    for record in event['Records']:
        # Get the primary key for use as the OpenSearch ID
        id = record['dynamodb']['Keys']['id']['S']

        if record['eventName'] == 'REMOVE':
            r = requests.delete(url + id, auth=awsauth)
        else:
            document = record['dynamodb']['NewImage']
            r = requests.put(url + id, auth=awsauth, json=document, headers=headers)
        count += 1
    return str(count) + ' records processed.'
```

Sie können dies dann mithilfe von DynamoDB-Streams an eine DynamoDB-Tabelle mit dem Primärschlüssel von anhängen`id`, und alle Änderungen an der DynamoDB-Quelle würden in Ihre Service-Domain gestreamt. OpenSearch Weitere Informationen zum Konfigurieren dieser Einstellung finden Sie in der [Dokumentation zu DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.Lambda.html).