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"></a>

**Anmerkung**  
Wir unterstützen jetzt hauptsächlich die APPSYNC\$1JS-Laufzeit und ihre Dokumentation. [Bitte erwägen Sie, die APPSYNC\$1JS-Laufzeit und ihre Anleitungen hier zu verwenden.](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html)

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 auf einem Resolver unabhängig vom Schema konfiguriert wird, haben Sie die Möglichkeit, GraphQL-Typen über verschiedene Datenquellen aufzulösen oder zu manipulieren. Dabei spielt die Kombination des Schemas keine Rolle und kann sich ganz nach Ihren Anforderungen richten.

Die folgenden Beispielszenarien zeigen, wie Sie Datenquellen in Ihrem Schema kombinieren und abgleichen können. Bevor Sie beginnen, empfehlen wir, dass Sie mit der Einrichtung von Datenquellen und Resolvern für AWS Lambda Amazon DynamoDB und Amazon OpenSearch Service vertraut sind, wie in den vorherigen Tutorials beschrieben.

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

Das folgende Schema hat einen Typ `Post` mit 3 `Query` Operationen und 3 definierten `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 müssten Sie insgesamt 6 Resolver anfügen. Eine Möglichkeit wäre, all diese Daten aus einer Amazon DynamoDB-Tabelle mit dem Namen`Posts`, zu beziehen, in der ein Scan und `searchPosts` eine Abfrage `AllPosts` ausgeführt werden, wie in der [DynamoDB Resolver](resolver-mapping-template-reference-dynamodb.md#aws-appsync-resolver-mapping-template-reference-dynamodb) Mapping Template Reference beschrieben. Es gibt jedoch Alternativen, um Ihre Geschäftsanforderungen zu erfüllen, z. B. die Auflösung dieser GraphQL-Abfragen von Lambda oder OpenSearch Service.

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

Möglicherweise müssen Sie Ergebnisse aus einer Datenbank wie DynamoDB (oder Amazon Aurora) an Clients zurückgeben, wobei einige der Attribute geändert wurden. Dies kann mit der Formatierung der Datentypen (z. B. Zeitstempeldifferenzen der Clients) oder mit Problemen bei der Handhabung der Rückwärtskompatibilität in Zusammenhang stehen. Zur Veranschaulichung manipuliert im folgenden Beispiel eine AWS Lambda Funktion die positiven und negativen Stimmen für Blogbeiträge, indem sie ihnen bei jedem Aufruf des GraphQL-Resolvers Zufallszahlen zuweist:

```
'use strict';
const doc = require('dynamodb-doc');
const dynamo = new doc.DynamoDB();

exports.handler = (event, context, callback) => {
    const payload = {
        TableName: 'Posts',
        Limit: 50,
        Select: 'ALL_ATTRIBUTES',
    };

    dynamo.scan(payload, (err, data) => {
        const result = { data: data.Items.map(item =>{
            item.ups = parseInt(Math.random() * (50 - 10) + 10, 10);
            item.downs = parseInt(Math.random() * (20 - 0) + 0, 10);
            return item;
        }) };
        callback(err, result.data);
    });
};
```

Hierbei handelt es sich um eine absolut gültige Lambda-Funktion, die dem `AllPosts`-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"></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. Anschließend können Sie 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 hilfreich sein, wenn Sie Ihren Anwendungen erweiterte Suchfunktionen hinzufügen, beispielsweise Schlüsselwort-, Fuzzy- oder sogar raumbezogene Suchen. Die Übertragung von Daten aus DynamoDB kann über einen ETL-Prozess erfolgen, oder Sie können alternativ mithilfe von Lambda aus DynamoDB streamen. Sie können ein vollständiges Beispiel dafür starten, indem Sie den folgenden AWS CloudFormation Stack in der Region USA West 2 (Oregon) in Ihrem Konto verwenden: AWS 

[https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/multipledatasource/appsyncesdbstream.yml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/multipledatasource/appsyncesdbstream.yml) 

Mit dem Schema in diesem Beispiel können Sie Beiträge mithilfe eines DynamoDB-Resolvers wie folgt hinzufügen:

```
mutation add {
    putPost(author:"Nadia"
        title:"My first post"
        content:"This is some test content"
        url:"https://aws.amazon.com/appsync/"
    ){
        id
        title
    }
}
```

Dadurch werden Daten in DynamoDB geschrieben, das dann Daten über Lambda an Amazon OpenSearch Service streamt, wo Sie nach allen Beiträgen anhand verschiedener Felder suchen können. 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
    }
}

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

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

 **Hinweis:** Dieser Code dient nur der Veranschaulichung.

```
var AWS = require('aws-sdk');
var path = require('path');
var stream = require('stream');

var esDomain = {
    endpoint: 'https://opensearch-domain-name.REGION.es.amazonaws.com',
    region: 'REGION',
    index: 'id',
    doctype: 'post'
};

var endpoint = new AWS.Endpoint(esDomain.endpoint)
var creds = new AWS.EnvironmentCredentials('AWS');

function postDocumentToES(doc, context) {
    var req = new AWS.HttpRequest(endpoint);

    req.method = 'POST';
    req.path = '/_bulk';
    req.region = esDomain.region;
    req.body = doc;
    req.headers['presigned-expires'] = false;
    req.headers['Host'] = endpoint.host;

    // Sign the request (Sigv4)
    var signer = new AWS.Signers.V4(req, 'es');
    signer.addAuthorization(creds, new Date());

    // Post document to ES
    var send = new AWS.NodeHttpClient();
    send.handleRequest(req, null, function (httpResp) {
        var body = '';
        httpResp.on('data', function (chunk) {
            body += chunk;
        });
        httpResp.on('end', function (chunk) {
            console.log('Successful', body);
            context.succeed();
        });
    }, function (err) {
        console.log('Error: ' + err);
        context.fail();
    });
}

exports.handler = (event, context, callback) => {
    console.log("event => " + JSON.stringify(event));
    var posts = '';

    for (var i = 0; i < event.Records.length; i++) {
        var eventName = event.Records[i].eventName;
        var actionType = '';
        var image;
        var noDoc = false;
        switch (eventName) {
            case 'INSERT':
                actionType = 'create';
                image = event.Records[i].dynamodb.NewImage;
                break;
            case 'MODIFY':
                actionType = 'update';
                image = event.Records[i].dynamodb.NewImage;
                break;
            case 'REMOVE':
            actionType = 'delete';
                image = event.Records[i].dynamodb.OldImage;
                noDoc = true;
                break;
        }

        if (typeof image !== "undefined") {
            var postData = {};
            for (var key in image) {
                if (image.hasOwnProperty(key)) {
                    if (key === 'postId') {
                        postData['id'] = image[key].S;
                    } else {
                        var val = image[key];
                        if (val.hasOwnProperty('S')) {
                            postData[key] = val.S;
                        } else if (val.hasOwnProperty('N')) {
                            postData[key] = val.N;
                        }
                    }
                }
            }

            var action = {};
            action[actionType] = {};
            action[actionType]._index = 'id';
            action[actionType]._type = 'post';
            action[actionType]._id = postData['id'];
            posts += [
                JSON.stringify(action),
            ].concat(noDoc?[]:[JSON.stringify(postData)]).join('\n') + '\n';
        }
    }
    console.log('posts:',posts);
    postDocumentToES(posts, context);
};
```

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).