Uso de resolutores OpenSearch de Amazon Service en AWS AppSync

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

AWS AppSync admite el uso de Amazon OpenSearch Service desde dominios que hayas aprovisionado en tu propia AWS cuenta, siempre que no existan dentro de una VPC. Después de aprovisionar los dominios, puede conectarse a ellos con un origen de datos. En ese momento, puede configurar un solucionador en el esquema para que realice operaciones de GraphQL como consultas, mutaciones y suscripciones. Este tutorial le guiará a lo largo de algunos ejemplos comunes.

Para obtener más información, consulte nuestra referencia de funciones JavaScript de resolución para. OpenSearch

Cree un nuevo dominio OpenSearch de servicio

Para empezar con este tutorial, necesitas un dominio de OpenSearch servicio existente. Si todavía no tiene uno, puede utilizar la siguiente muestra. Tenga en cuenta que la creación de un dominio de OpenSearch servicio puede tardar hasta 15 minutos antes de que pueda pasar a integrarlo con una fuente de AWS AppSync datos.

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

Puedes lanzar la siguiente AWS CloudFormation pila en la región US-West-2 (Oregón) de tu AWS cuenta:

Configure una fuente de datos para el servicio OpenSearch

Una vez creado el dominio de OpenSearch servicio, dirígete a tu API de AWS AppSync GraphQL y selecciona la pestaña Fuentes de datos. Selecciona Crear fuente de datos e introduce un nombre descriptivo para la fuente de datos, como «oss». A continuación, elige el OpenSearch dominio de Amazon como tipo de fuente de datos, elige la región correspondiente y verás tu dominio de OpenSearch servicio en la lista. Después de seleccionarlo, puede crear un nuevo rol y AWS AppSync asignarle los permisos correspondientes, o puede elegir un rol existente, que tenga la siguiente política en línea:

{
    "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/*"
            ]
        }
    ]
}

También tendrás que establecer una relación de confianza AWS AppSync para ese rol:

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

Además, el dominio del OpenSearch servicio tiene su propia política de acceso que puedes modificar a través de la consola de Amazon OpenSearch Service. Debe añadir una política similar a la siguiente con las acciones y los recursos adecuados para el dominio del OpenSearch servicio. Tenga en cuenta que la función principal será la de fuente de AWS AppSync datos, que podrá encontrar en la consola de IAM si deja que dicha consola la cree.

{
    "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/*"
        }
    ]
}

Conexión de un solucionador

Ahora que la fuente de datos está conectada a tu dominio de OpenSearch servicio, puedes conectarla a tu esquema de GraphQL con un solucionador, como se muestra en el siguiente ejemplo:

 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
}

Observe que hay un tipo Post definido por el usuario con un campo id. En los siguientes ejemplos, suponemos que hay un proceso (que se puede automatizar) para colocar este tipo en tu dominio de OpenSearch servicio, que se asignaría a la raíz de la ruta /post/_doc donde post se encuentra el índice. A partir de esta ruta raíz, puede realizar búsquedas de documentos individuales, búsquedas de comodín con /id/post* o búsquedas en varios documentos con la ruta /post/_search. Por ejemplo, si tiene otro tipo llamado User, puede indexar documentos bajo un nuevo índice llamado user, y luego realizar búsquedas con una ruta de /user/_search.

En el editor de esquemas de la AWS AppSync consola, modifique el Posts esquema anterior para incluir una searchPosts consulta:

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

Guarde el esquema. En el panel Solucionadores, busque searchPosts y seleccione Asociar. Elija la fuente OpenSearch de datos del servicio y guarde la resolución. Actualice el código del solucionador mediante el siguiente fragmento:

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

Esto supone que el esquema anterior contiene documentos que se han indexado en OpenSearch Service en el post campo. Si estructura los datos de manera diferente, tendrá que realizar una actualización como corresponda.

Modificación de las búsquedas

El controlador de solicitudes del solucionador anterior realiza una consulta sencilla para todos los registros. Supongamos que desea buscar por un autor específico. Además, supongamos que desea que ese autor sea un argumento definido en la consulta de GraphQL. En el editor de esquemas de la AWS AppSync consola, añada una allPostsByAuthor consulta:

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

En el panel Solucionadores, busque allPostsByAuthor y seleccione Asociar. Elija la fuente OpenSearch de datos del servicio y utilice el siguiente código:

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

Observe que body se llena con una consulta de término para el campo author, que se pasa desde el cliente como un argumento. Si lo desea, puede usar información previamente rellenada, como texto estándar.

Añadir datos al OpenSearch servicio

Es posible que desee añadir datos a su dominio de OpenSearch servicio como resultado de una mutación de GraphQL. Se trata de un eficaz mecanismo para realizar búsquedas y para otros fines. Como puedes usar las suscripciones de GraphQL para crear tus datos en tiempo real, puede servir como un mecanismo para notificar a los clientes las actualizaciones de los datos en tu OpenSearch dominio de servicio.

Vuelve a la página del esquema de la AWS AppSync consola y selecciona Adjuntar para ver la addPost() mutación. Vuelva a seleccionar la fuente de datos del OpenSearch servicio y utilice el siguiente código:

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
}

Como antes, este es un ejemplo de cómo pueden estar estructurados los datos. Si los nombres de campos o índices son distintos, debe actualizar la path y body. En este ejemplo, también se muestra cómo utilizar context.arguments, que también se puede escribir como ctx.args, en el controlador de solicitudes.

Recuperación de un solo documento

Por último, si desea utilizar la getPost(id:ID) consulta en su esquema para obtener un documento individual, busque esta consulta en el editor de esquemas de la AWS AppSync consola y seleccione Adjuntar. Vuelva a seleccionar la fuente de datos del OpenSearch servicio y utilice el siguiente código:

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
}

Ejecución de consultas y mutaciones

Ahora deberías poder realizar operaciones de GraphQL en tu dominio de OpenSearch servicio. Ve a la pestaña Consultas de la AWS AppSync consola y agrega un registro nuevo:

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

Verá el resultado de la mutación a la derecha. Del mismo modo, ahora puedes ejecutar una searchPosts consulta en tu dominio OpenSearch de servicio:

query search {
    searchPosts {
        id
        title
        author
        content
    }
}

Prácticas recomendadas