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.

Ingesta de datos en las colecciones de Amazon OpenSearch sin servidor

Estas secciones proporcionan detalles sobre las canalizaciones de ingesta compatibles para la ingesta de datos en las colecciones de Amazon OpenSearch sin servidor. También describen algunos de los clientes que puede utilizar para interactuar con las operaciones de la API de OpenSearch. Sus clientes deben ser compatibles con OpenSearch 2.x para poder integrarse con OpenSearch sin servidor.

Permisos mínimos necesarios

Para poder incorporar datos a una colección de OpenSearch sin servidor, la entidad principal que escribe los datos debe tener los siguientes permisos mínimos asignados en una política de acceso a los datos:

[
   {
      "Rules":[
         {
            "ResourceType":"index",
            "Resource":[
               "index/target-collection/logs"
            ],
            "Permission":[
               "aoss:CreateIndex",
               "aoss:WriteDocument",
               "aoss:UpdateIndex"
            ]
         }
      ],
      "Principal":[
         "arn:aws:iam::123456789012:user/my-user"
      ]
   }
]

Los permisos pueden ser más amplios si planea escribir en índices adicionales. Por ejemplo, en lugar de especificar un único índice de destino, puede conceder permisos a todos los índices (index/target-collection/*) o a un subconjunto de índices (index/target-collection/logs*).

Para obtener una referencia de todas las operaciones de la API de OpenSearch disponibles y sus permisos asociados, consulte Operaciones y complementos compatibles en Amazon OpenSearch sin servidor.

OpenSearch Ingestion

En lugar de utilizar un cliente de terceros para enviar datos directamente a una colección de OpenSearch sin servidor, puede utilizar Amazon OpenSearch Ingestion. Puede configurar los productores de datos para que envíen datos a OpenSearch Ingestion, que a su vez los envían automáticamente a la colección que especifique. También puede configurar OpenSearch Ingestion para transformar los datos antes de entregarlos. Para más información, consulte Amazon OpenSearch Ingestion.

Una canalización de OpenSearch Ingestion necesita permiso para escribir en una colección de OpenSearch sin servidor que esté configurada como su receptor. Estos permisos incluyen la capacidad de describir la colección y enviarle solicitudes HTTP. Para obtener instrucciones sobre cómo usar OpenSearch Ingestion para agregar datos a una colección, consulte Concesión de acceso a colecciones para canalizaciones de Amazon OpenSearch Ingestion.

Para comenzar con OpenSearch Ingestion, consulte Tutorial: incorporar datos en una colección mediante Amazon OpenSearch Ingestion.

Fluent Bit

Puede utilizar la imagen de AWS for Fluent Bit y el complemento de salida de OpenSearch para realizar la ingesta de datos en colecciones de OpenSearch sin servidor.

Ejemplo de configuración:

En este ejemplo de sección de resultados del archivo de configuración se muestra cómo utilizar una colección de OpenSearch sin servidor como destino. La adición importante es el parámetro AWS_Service_Name, que es aoss. Host es el punto de conexión de la colección.

[OUTPUT]
    Name  opensearch
    Match *
    Host  collection-endpoint.us-west-2.aoss.amazonaws.com
    Port  443
    Index  my_index
    Trace_Error On
    Trace_Output On
    AWS_Auth On
    AWS_Region <region>
    AWS_Service_Name aoss
    tls     On
    Suppress_Type_Name On

Amazon Data Firehose

Firehose es compatible con OpenSearch sin servidor como destino de entrega. Para obtener instrucciones para enviar los datos a OpenSearch sin servidor, consulte Creating a Kinesis Data Firehose Delivery Stream y Choose OpenSearch Serverless for Your Destination en la Guía para desarrolladores de Amazon Data Firehose.

El rol de IAM que proporcione a Firehose para la entrega se debe especificar dentro de una política de acceso a datos con el permiso mínimo aoss:WriteDocument para la colección de destino y debe tener un índice preexistente al que enviar datos. Para obtener más información, consulte Permisos mínimos necesarios.

Es posible que necesite realizar transformaciones en los datos antes de enviarlos a OpenSearch sin servidor. Para obtener más información acerca de cómo utilizar las funciones de Lambda para realizar esta tarea, consulte Amazon Kinesis Data Firehose Data Transformation en la misma guía.

Go

En el siguiente ejemplo de código se utiliza el cliente opensearch-go para Go con el fin de establecer una conexión segura con la colección de OpenSearch sin servidor especificada y crear un índice único. Debe proporcionar valores para region y host.

package main

import (
  "context"
  "log"
  "strings"
  "github.com/aws/aws-sdk-go-v2/aws"
  "github.com/aws/aws-sdk-go-v2/config"
  opensearch "github.com/opensearch-project/opensearch-go/v2"
  opensearchapi "github.com/opensearch-project/opensearch-go/v2/opensearchapi"
  requestsigner "github.com/opensearch-project/opensearch-go/v2/signer/awsv2"
)

const endpoint = "" // serverless collection endpoint

func main() {
	ctx := context.Background()

	awsCfg, err := config.LoadDefaultConfig(ctx,
		config.WithRegion("<AWS_REGION>"),
		config.WithCredentialsProvider(
			getCredentialProvider("<AWS_ACCESS_KEY>", "<AWS_SECRET_ACCESS_KEY>", "<AWS_SESSION_TOKEN>"),
		),
	)
	if err != nil {
		log.Fatal(err) // don't log.fatal in a production-ready app
	}

	// create an AWS request Signer and load AWS configuration using default config folder or env vars.
	signer, err := requestsigner.NewSignerWithService(awsCfg, "aoss") // "aoss" for Amazon OpenSearch Serverless
	if err != nil {
		log.Fatal(err) // don't log.fatal in a production-ready app
	}

	// create an opensearch client and use the request-signer
	client, err := opensearch.NewClient(opensearch.Config{
		Addresses: []string{endpoint},
		Signer:    signer,
	})
	if err != nil {
		log.Fatal("client creation err", err)
	}

	indexName := "go-test-index"

  // define index mapping
	mapping := strings.NewReader(`{
	 "settings": {
	   "index": {
	        "number_of_shards": 4
	        }
	      }
	 }`)

	// create an index
	createIndex := opensearchapi.IndicesCreateRequest{
		Index: indexName,
    Body: mapping,
	}
	createIndexResponse, err := createIndex.Do(context.Background(), client)
	if err != nil {
		log.Println("Error ", err.Error())
		log.Println("failed to create index ", err)
		log.Fatal("create response body read err", err)
	}
	log.Println(createIndexResponse)

	// delete the index
	deleteIndex := opensearchapi.IndicesDeleteRequest{
		Index: []string{indexName},
	}

	deleteIndexResponse, err := deleteIndex.Do(context.Background(), client)
	if err != nil {
		log.Println("failed to delete index ", err)
		log.Fatal("delete index response body read err", err)
	}
	log.Println("deleting index", deleteIndexResponse)
}

func getCredentialProvider(accessKey, secretAccessKey, token string) aws.CredentialsProviderFunc {
	return func(ctx context.Context) (aws.Credentials, error) {
		c := &aws.Credentials{
			AccessKeyID:     accessKey,
			SecretAccessKey: secretAccessKey,
			SessionToken:    token,
		}
		return *c, nil
	}
}

Java

En el siguiente ejemplo de código se utiliza el cliente opensearch-java para Java con el fin de establecer una conexión segura con la colección de OpenSearch sin servidor especificada y crear un índice único. Debe proporcionar valores para region y host.

La diferencia importante con respecto a los dominios de OpenSearch Service es el nombre del servicio (aoss en lugar de es).

// import OpenSearchClient to establish connection to OpenSearch Serverless collection
import org.opensearch.client.opensearch.OpenSearchClient;

SdkHttpClient httpClient = ApacheHttpClient.builder().build();
// create an opensearch client and use the request-signer
OpenSearchClient client = new OpenSearchClient(
    new AwsSdk2Transport(
        httpClient,
        "...us-west-2.aoss.amazonaws.com", // serverless collection endpoint
        "aoss" // signing service name
        Region.US_WEST_2, // signing service region
        AwsSdk2TransportOptions.builder().build()
    )
);

String index = "sample-index";

// create an index
CreateIndexRequest createIndexRequest = new CreateIndexRequest.Builder().index(index).build();
CreateIndexResponse createIndexResponse = client.indices().create(createIndexRequest);
System.out.println("Create index reponse: " + createIndexResponse);

// delete the index
DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest.Builder().index(index).build();
DeleteIndexResponse deleteIndexResponse = client.indices().delete(deleteIndexRequest);
System.out.println("Delete index reponse: " + deleteIndexResponse);

httpClient.close();   

El siguiente código de ejemplo vuelve a establecer una conexión segura y, a continuación, busca en un índice.

import org.opensearch.client.opensearch.OpenSearchClient;
>>>>>>> aoss-slr-update

SdkHttpClient httpClient = ApacheHttpClient.builder().build();

OpenSearchClient client = new OpenSearchClient(
    new AwsSdk2Transport(
        httpClient,
        "...us-west-2.aoss.amazonaws.com", // serverless collection endpoint
        "aoss" // signing service name
        Region.US_WEST_2, // signing service region
        AwsSdk2TransportOptions.builder().build()
    )
);

Response response = client.generic()
    .execute(
        Requests.builder()
            .endpoint("/" + "users" + "/_search?typed_keys=true")
            .method("GET")
            .json("{"
                + "    \"query\": {"
                + "        \"match_all\": {}"
                + "    }"
                + "}")
            .build());

httpClient.close();  

JavaScript

En el siguiente ejemplo de código se utiliza el cliente opensearch-js para JavaScript con el fin de establecer una conexión segura con la colección de OpenSearch sin servidor especificada, crear un índice único, agregar un documento y eliminar el índice. Debe proporcionar valores para node y region.

La diferencia importante con respecto a los dominios de OpenSearch Service es el nombre del servicio (aoss en lugar de es).

Version 3

En este ejemplo, se utiliza la versión 3 del SDK para JavaScript en Node.js.

const { defaultProvider } = require('@aws-sdk/credential-provider-node');
const { Client } = require('@opensearch-project/opensearch');
const { AwsSigv4Signer } = require('@opensearch-project/opensearch/aws');

async function main() {
    // create an opensearch client and use the request-signer
    const client = new Client({
        ...AwsSigv4Signer({
            region: 'us-west-2',
            service: 'aoss',
            getCredentials: () => {
                const credentialsProvider = defaultProvider();
                return credentialsProvider();
            },
        }),
        node: '' # // serverless collection endpoint
    });

    const index = 'movies';

    // create index if it doesn't already exist
    if (!(await client.indices.exists({ index })).body) {
        console.log((await client.indices.create({ index })).body);
    }

    // add a document to the index
    const document = { foo: 'bar' };
    const response = await client.index({
        id: '1',
        index: index,
        body: document,
    });
    console.log(response.body);

    // delete the index
    console.log((await client.indices.delete({ index })).body);
}

main();

Version 2

En este ejemplo, se utiliza la versión 2 del SDK para JavaScript en Node.js.

const AWS = require('aws-sdk');
const { Client } = require('@opensearch-project/opensearch');
const { AwsSigv4Signer } = require('@opensearch-project/opensearch/aws');

async function main() {
    // create an opensearch client and use the request-signer
    const client = new Client({
        ...AwsSigv4Signer({
            region: 'us-west-2',
            service: 'aoss',
            getCredentials: () =>
                new Promise((resolve, reject) => {
                    AWS.config.getCredentials((err, credentials) => {
                        if (err) {
                            reject(err);
                        } else {
                            resolve(credentials);
                        }
                    });
                }),
        }),
        node: '' # // serverless collection endpoint
    });

    const index = 'movies';

    // create index if it doesn't already exist
    if (!(await client.indices.exists({ index })).body) {
        console.log((await client.indices.create({
            index
        })).body);
    }

    // add a document to the index
    const document = {
        foo: 'bar'
    };
    const response = await client.index({
        id: '1',
        index: index,
        body: document,
    });
    console.log(response.body);

    // delete the index
    console.log((await client.indices.delete({ index })).body);
}

main();

Logstash

Puede usar el complemento Logstash OpenSearch para publicar registros en las colecciones de OpenSearch sin servidor.

Python

En el siguiente ejemplo de código se utiliza el cliente opensearch-py para Python con el fin de establecer una conexión segura con la colección de OpenSearch sin servidor especificada, crear un índice único y buscar en él. Debe proporcionar valores para region y host.

La diferencia importante con respecto a los dominios de OpenSearch Service es el nombre del servicio (aoss en lugar de es).

from opensearchpy import OpenSearch, RequestsHttpConnection, AWSV4SignerAuth
import boto3

host = ''  # serverless collection endpoint, without https://
region = ''  # e.g. us-east-1

service = 'aoss'
credentials = boto3.Session().get_credentials()
auth = AWSV4SignerAuth(credentials, region, service)

# create an opensearch client and use the request-signer
client = OpenSearch(
    hosts=[{'host': host, 'port': 443}],
    http_auth=auth,
    use_ssl=True,
    verify_certs=True,
    connection_class=RequestsHttpConnection,
    pool_maxsize=20,
)

# create an index
index_name = 'books-index'
create_response = client.indices.create(
    index_name
)

print('\nCreating index:')
print(create_response)

# index a document
document = {
  'title': 'The Green Mile',
  'director': 'Stephen King',
  'year': '1996'
}

response = client.index(
    index = 'books-index',
    body = document,
    id = '1'
)


# delete the index
delete_response = client.indices.delete(
    index_name
)

print('\nDeleting index:')
print(delete_response)

Ruby

La gema opensearch-aws-sigv4 proporciona acceso a OpenSearch sin servidor y OpenSearch Service directamente. Dispone de todas las funciones del cliente opensearch-ruby, ya que es una dependencia de esta gema.

Cuando cree una instancia del firmante de Sigv4, especifique aoss como nombre del servicio:

require 'opensearch-aws-sigv4'
require 'aws-sigv4'

signer = Aws::Sigv4::Signer.new(service: 'aoss',
                                region: 'us-west-2',
                                access_key_id: 'key_id',
                                secret_access_key: 'secret')

# create an opensearch client and use the request-signer
client = OpenSearch::Aws::Sigv4Client.new(
  { host: 'https://your.amz-opensearch-serverless.endpoint',
    log: true },
  signer)

# create an index
index = 'prime'
client.indices.create(index: index)

# insert data
client.index(index: index, id: '1', body: { name: 'Amazon Echo', 
                                            msrp: '5999', 
                                            year: 2011 })

# query the index
client.search(body: { query: { match: { name: 'Echo' } } })

# delete index entry
client.delete(index: index, id: '1')

# delete the index
client.indices.delete(index: index)

Firma de solicitudes HTTP con otros clientes

Se aplican los siguientes requisitos para firmar solicitudes de colecciones de OpenSearch sin servidor cuando se crean solicitudes HTTP con otros clientes.

Indexación con cURL

La siguiente solicitud de ejemplo utiliza la biblioteca de solicitudes de URL de cliente (cURL) para enviar un único documento a un índice denominado movies-index dentro de una colección:

curl -XPOST \
    --user "$AWS_ACCESS_KEY_ID":"$AWS_SECRET_ACCESS_KEY" \
    --aws-sigv4 "aws:amz:us-east-1:aoss" \
    --header "x-amz-content-sha256: $REQUEST_PAYLOAD_SHA_HASH" \
    --header "x-amz-security-token: $AWS_SESSION_TOKEN" \
    "https://my-collection-endpoint.us-east-1.aoss.amazonaws.com/movies-index/_doc" \
    -H "Content-Type: application/json" -d '{"title": "Shawshank Redemption"}'

Indexación con Postman

La siguiente imagen muestra cómo enviar solicitudes a una colección con Postman. Para obtener instrucciones sobre cómo autenticarse, consulte Authenticate with AWS Signature authentication workflow in Postman.