Verwendung von Amazon OpenSearch Service-Resolvern in AWS AppSync

AWS AppSync unterstützt die Nutzung von Amazon OpenSearch Service von Domains aus, die Sie in Ihrem eigenen AWS Konto bereitgestellt haben, sofern sie nicht in einem VPC vorhanden sind. Nachdem Ihre Domänen bereitgestellt wurden, können Sie sich über eine Datenquelle mit ihnen verbinden. Zu diesem Zeitpunkt können Sie auch einen Resolver im Schema konfigurieren, um GraphQL-Operationen, wie z. B. Abfragen, Mutationen und Abonnements, auszuführen. Diese Anleitung führt Sie durch einige häufig auftretende Beispiele.

Weitere Informationen finden Sie in unserer Referenz zu JavaScript Resolver-Funktionen für. OpenSearch

Erstellen Sie eine neue OpenSearch Dienstdomäne

Um mit diesem Tutorial beginnen zu können, benötigen Sie eine bestehende OpenSearch Service-Domain. Wenn Sie noch keine haben, können Sie das folgende Bespiel verwenden. Beachten Sie, dass es bis zu 15 Minuten dauern kann, bis eine OpenSearch Dienstdomäne erstellt ist, bevor Sie mit der Integration in eine AWS AppSync Datenquelle fortfahren können.

aws cloudformation create-stack --stack-name AppSyncOpenSearch \
--template-url https://s3.us-west-2.amazonaws.com/awsappsync/resources/elasticsearch/ESResolverCFTemplate.yaml \
--parameters ParameterKey=OSDomainName,ParameterValue=ddtestdomain ParameterKey=Tier,ParameterValue=development \
--capabilities CAPABILITY_NAMED_IAM

Sie können den folgenden AWS CloudFormation Stack in der Region US-West-2 (Oregon) in Ihrem AWS Konto starten:

Konfigurieren Sie eine Datenquelle für Service OpenSearch

Nachdem die OpenSearch Dienstdomäne erstellt wurde, navigieren Sie zu Ihrem AWS AppSync GraphQL API und wählen Sie die Registerkarte Datenquellen. Wählen Sie Datenquelle erstellen und geben Sie einen benutzerfreundlichen Namen für die Datenquelle ein, z. B.“oss“. Wählen Sie dann OpenSearch Amazon-Domain als Datenquellentyp und wählen Sie die entsprechende Region aus, und Ihre OpenSearch Service-Domain sollte aufgeführt sein. Nachdem Sie sie ausgewählt haben, können Sie entweder eine neue Rolle erstellen und AWS AppSync ihnen die entsprechenden Berechtigungen zuweisen, oder Sie können eine bestehende Rolle auswählen, für die die folgende Inline-Richtlinie gilt:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "Stmt1234234",
            "Effect": "Allow",
            "Action": [
                "es:ESHttpDelete",
                "es:ESHttpHead",
                "es:ESHttpGet",
                "es:ESHttpPost",
                "es:ESHttpPut"
            ],
            "Resource": [
                "arn:aws:es:REGION:ACCOUNTNUMBER:domain/democluster/*"
            ]
        }
    ]
}

Sie müssen außerdem eine Vertrauensbeziehung AWS AppSync für diese Rolle einrichten mit:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "appsync.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

Darüber hinaus verfügt die OpenSearch Service-Domain über eine eigene Zugriffsrichtlinie, die Sie über die Amazon OpenSearch Service-Konsole ändern können. Sie müssen eine Richtlinie hinzufügen, die der folgenden ähnelt und die entsprechenden Aktionen und Ressourcen für die OpenSearch Service-Domain enthält. Beachten Sie, dass der Principal die AWS AppSync Datenquellenrolle sein wird, die Sie in der IAM Konsole finden, wenn Sie sie von dieser Konsole erstellen lassen.

{
    "Version": "2012-10-17",
    "Statement": [
        {
        "Effect": "Allow",
        "Principal": {
            "AWS": "arn:aws:iam::ACCOUNTNUMBER:role/service-role/APPSYNC_DATASOURCE_ROLE"
        },
        "Action": [
            "es:ESHttpDelete",
            "es:ESHttpHead",
            "es:ESHttpGet",
            "es:ESHttpPost",
            "es:ESHttpPut"
        ],
        "Resource": "arn:aws:es:REGION:ACCOUNTNUMBER:domain/DOMAIN_NAME/*"
        }
    ]
}

Einen Resolver anschließen

Nachdem die Datenquelle nun mit Ihrer OpenSearch Service-Domain verbunden ist, können Sie sie mit einem Resolver mit Ihrem GraphQL-Schema verbinden, wie im folgenden Beispiel gezeigt:

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

 type Mutation {
   addPost(id: ID!, author: String, title: String, url: String, ups: Int, downs: Int, content: String): AWSJSON
 }

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

Beachten Sie, dass es einen benutzerdefinierten Post-Typ mit einem id-Feld gibt. In den folgenden Beispielen gehen wir davon aus, dass es einen Prozess gibt (der automatisiert werden kann), um diesen Typ in Ihre OpenSearch Service-Domain einzufügen, der einer Pfadwurzel zugeordnet würde, /post/_doc wo sich der Index post befindet. Von diesem Stammpfad aus können Sie einzelne Dokumente, Platzhaltersuchen mit /id/post* oder Suchen in mehreren Dokumenten mit dem Pfad von durchführen. /post/_search Wenn Sie beispielsweise einen anderen Typ habenUser, können Sie Dokumente unter einem neuen Index namens user indexieren und dann Suchen mit dem Pfad von durchführen. /user/_search

Ändern Sie im Schema-Editor in der AWS AppSync Konsole das vorherige Posts Schema, sodass es eine searchPosts Abfrage enthält:

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

Speichern Sie das Schema. Suchen Sie im Bereich Resolver nach Attach searchPosts und wählen Sie es aus. Wählen Sie Ihre OpenSearch Service-Datenquelle aus und speichern Sie den Resolver. Aktualisieren Sie den Code Ihres Resolvers mithilfe des folgenden Snippets:

import { util } from '@aws-appsync/utils'

/**
 * Searches for documents by using an input term
 * @param {import('@aws-appsync/utils').Context} ctx the context
 * @returns {*} the request
 */
export function request(ctx) {
	return {
		operation: 'GET',
		path: `/post/_search`,
		params: { body: { from: 0, size: 50 } },
	}
}

/**
 * Returns the fetched items
 * @param {import('@aws-appsync/utils').Context} ctx the context
 * @returns {*} the result
 */
export function response(ctx) {
	if (ctx.error) {
		util.error(ctx.error.message, ctx.error.type)
	}
	return ctx.result.hits.hits.map((hit) => hit._source)
}

Dabei wird davon ausgegangen, dass das vorherige Schema Dokumente enthält, die in OpenSearch Service indexiert wurden, unter dem Feld. post Wenn Sie Ihre Daten anders strukturieren, müssen Sie sie entsprechend aktualisieren.

Ihre Suchanfragen ändern

Der vorherige Resolver-Request-Handler führt eine einfache Abfrage für alle Datensätze durch. Angenommen, Sie möchten nach einem bestimmten Autor suchen. Nehmen wir außerdem an, Sie möchten, dass dieser Autor ein in Ihrer GraphQL-Abfrage definiertes Argument ist. Fügen Sie im Schema-Editor der AWS AppSync Konsole eine allPostsByAuthor Abfrage hinzu:

type Query {
  getPost(id: ID!): Post
  allPosts: [Post]
  allPostsByAuthor(author: String!): [Post]
  searchPosts: [Post]
}

Suchen Sie im Bereich Resolver nach Attach allPostsByAuthor und wählen Sie es aus. Wählen Sie die OpenSearch Service-Datenquelle aus und verwenden Sie den folgenden Code:

import { util } from '@aws-appsync/utils'

/**
 * Searches for documents by `author`
 * @param {import('@aws-appsync/utils').Context} ctx the context
 * @returns {*} the request
 */
export function request(ctx) {
	return {
		operation: 'GET',
		path: '/post/_search',
		params: {
			body: {
				from: 0,
				size: 50,
				query: { match: { author: ctx.args.author } },
			},
		},
	}
}

/**
 * Returns the fetched items
 * @param {import('@aws-appsync/utils').Context} ctx the context
 * @returns {*} the result
 */
export function response(ctx) {
	if (ctx.error) {
		util.error(ctx.error.message, ctx.error.type)
	}
	return ctx.result.hits.hits.map((hit) => hit._source)
}

Beachten Sie, dass der body mit einer Begriffsabfrage für das author-Feld ausgefüllt wurde und vom Client als Argument übergeben wurde. Optional können Sie vorab ausgefüllte Informationen verwenden, z. B. Standardtext.

Daten zum OpenSearch Service hinzufügen

Möglicherweise möchten Sie Ihrer OpenSearch Service-Domain aufgrund einer GraphQL-Mutation Daten hinzufügen. Hierbei handelt es sich um einen äußerst effektiven Mechanismus für Suchvorgänge und andere Zwecke. Da Sie GraphQL-Abonnements verwenden können, um Ihre Daten in Echtzeit zu erstellen, kann dies als Mechanismus dienen, um Clients über Aktualisierungen von Daten in Ihrer OpenSearch Service-Domain zu informieren.

Kehren Sie zur Schemaseite in der AWS AppSync Konsole zurück und wählen Sie Attach für die addPost() Mutation aus. Wählen Sie erneut die OpenSearch Service-Datenquelle aus und verwenden Sie den folgenden Code:

import { util } from '@aws-appsync/utils'

/**
 * Searches for documents by `author`
 * @param {import('@aws-appsync/utils').Context} ctx the context
 * @returns {*} the request
 */
export function request(ctx) {
	return {
		operation: 'PUT',
		path: `/post/_doc/${ctx.args.id}`,
		params: { body: ctx.args },
	}
}

/**
 * Returns the inserted post
 * @param {import('@aws-appsync/utils').Context} ctx the context
 * @returns {*} the result
 */
export function response(ctx) {
	if (ctx.error) {
		util.error(ctx.error.message, ctx.error.type)
	}
	return ctx.result
}

Wie zuvor ist dies ein Beispiel dafür, wie Ihre Daten strukturiert sein könnten. Wenn Sie unterschiedliche Feldnamen oder Indizes haben, müssen Sie path und aktualisierenbody. Dieses Beispiel zeigt auch, wie Sie dascontext.arguments, was auch als geschrieben werden kannctx.args, in Ihrem Request-Handler verwenden.

Ein einzelnes Dokument wird abgerufen

Wenn Sie schließlich die getPost(id:ID) Abfrage in Ihrem Schema verwenden möchten, um ein einzelnes Dokument zurückzugeben, suchen Sie diese Abfrage im Schema-Editor der AWS AppSync Konsole und wählen Sie Anhängen aus. Wählen Sie erneut die OpenSearch Service-Datenquelle aus und verwenden Sie den folgenden Code:

import { util } from '@aws-appsync/utils'

/**
 * Searches for documents by `author`
 * @param {import('@aws-appsync/utils').Context} ctx the context
 * @returns {*} the request
 */
export function request(ctx) {
	return {
		operation: 'GET',
		path: `/post/_doc/${ctx.args.id}`,
	}
}

/**
 * Returns the post
 * @param {import('@aws-appsync/utils').Context} ctx the context
 * @returns {*} the result
 */
export function response(ctx) {
	if (ctx.error) {
		util.error(ctx.error.message, ctx.error.type)
	}
	return ctx.result._source
}

Führen Sie Abfragen und Mutationen durch

Sie sollten jetzt in der Lage sein, GraphQL-Operationen für Ihre OpenSearch Service-Domain durchzuführen. Navigieren Sie zur Registerkarte Abfragen der AWS AppSync Konsole und fügen Sie einen neuen Datensatz hinzu:

mutation AddPost {
    addPost (
        id:"12345"
        author: "Fred"
        title: "My first book"
        content: "This will be fun to write!"
        url: "publisher website",
        ups: 100,
        downs:20 
       )
}

Sie werden das Ergebnis der Mutation auf der rechten Seite sehen. In ähnlicher Weise können Sie jetzt eine searchPosts Abfrage für Ihre OpenSearch Service-Domain ausführen:

query search {
    searchPosts {
        id
        title
        author
        content
    }
}

Bewährte Methoden

• OpenSearch Der Dienst sollte zum Abfragen von Daten dienen, nicht als primäre Datenbank. Möglicherweise möchten Sie OpenSearch Service in Verbindung mit Amazon DynamoDB verwenden, wie unter Kombinieren von GraphQL-Resolvern beschrieben.

• Gewähren Sie nur Zugriff auf Ihre Domain, indem Sie der AWS AppSync Servicerolle den Zugriff auf den Cluster gestatten.

• Sie können mit dieser Entwicklung klein anfangen, indem Sie zunächst nur den preisgünstigsten Cluster verwenden, und später während der Produktion zu einem größeren Cluster überwechseln, der über eine hohe Verfügbarkeit verfügt.