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. # Ingerir datos en colecciones de Amazon OpenSearch Serverless En estas secciones se proporcionan detalles sobre las canalizaciones de ingesta compatibles para la ingesta de datos en las colecciones de Amazon OpenSearch Serverless. También incluyen algunos de los clientes que puede utilizar para interactuar con las operaciones de la API. OpenSearch Sus clientes deben ser compatibles con la versión OpenSearch 2.x para poder integrarse con OpenSearch Serverless. **Topics** + [Permisos mínimos necesarios](#serverless-ingestion-permissions) + [OpenSearch Ingestión](#serverless-osis-ingestion) + [Fluent Bit](#serverless-fluentbit) + [Amazon Data Firehose](#serverless-kdf) + [Go](#serverless-go) + [Java](#serverless-java) + [JavaScript](#serverless-javascript) + [Logstash](#serverless-logstash) + [Python](#serverless-python) + [Ruby](#serverless-ruby) + [Firma de solicitudes HTTP con otros clientes](#serverless-signing) ## Permisos mínimos necesarios [Para incorporar datos a una colección OpenSearch sin servidor, el director que escribe los datos debe tener los siguientes permisos mínimos asignados en una política de acceso a los datos:](serverless-data-access.md) ``` [ { "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 índice objetivo único, puede conceder permisos a todos los índices (index/ *target-collection* /\$1) o a un subconjunto de índices (index//). *target-collection* *logs\$1* Para obtener una referencia de todas las operaciones de OpenSearch API disponibles y sus permisos asociados, consulte. [Operaciones y complementos compatibles en Amazon OpenSearch Serverless](serverless-genref.md) ## OpenSearch Ingestión En lugar de utilizar un cliente de terceros para enviar datos directamente a una colección OpenSearch sin servidor, puede utilizar Amazon OpenSearch Ingestion. Usted configura sus generadores de datos para que envíen datos a OpenSearch Ingestion y esta entrega automáticamente los datos a la colección que usted especifique. También puede configurar OpenSearch Ingestion para transformar los datos antes de entregarlos. Para obtener más información, consulte [Información general sobre Amazon OpenSearch Ingestion](ingestion.md). Una canalización de OpenSearch ingestión necesita permiso para escribir en una colección OpenSearch sin servidor que esté configurada como sumidero. Estos permisos incluyen la capacidad de describir la colección y enviarle solicitudes HTTP. Para obtener instrucciones sobre cómo usar OpenSearch Ingestión para añadir datos a una colección, consulte. [Otorgar a Amazon OpenSearch Ingestion pipelines acceso a las colecciones](pipeline-collection-access.md) Para empezar a usar OpenSearch Ingestion, consulte. [Tutorial: Ingerir datos en una colección mediante Amazon OpenSearch Ingestion](osis-serverless-get-started.md) ## Fluent Bit Puede utilizar la [imagen AWS de Fluent Bit](https://github.com/aws/aws-for-fluent-bit#public-images) y el [complemento OpenSearch de salida](https://docs.fluentbit.io/manual/pipeline/outputs/opensearch) para introducir datos en colecciones OpenSearch sin servidor. **nota** Debe tener la versión 2.30.0 o posterior de la imagen de Fluent Bit AWS para poder integrarla con Serverless. OpenSearch **Ejemplo de configuración**: Este ejemplo de sección de resultados del archivo de configuración muestra cómo utilizar una colección OpenSearch Serverless 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 AWS_Service_Name aoss tls On Suppress_Type_Name On ``` ## Amazon Data Firehose Firehose admite OpenSearch Serverless como destino de entrega. Para obtener instrucciones sobre cómo enviar datos a OpenSearch Serverless, consulte [Crear una transmisión de entrega de Kinesis Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) [y OpenSearch elegir Serverless para su destino](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-opensearch-serverless) 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](#serverless-ingestion-permissions). Antes de enviar datos a OpenSearch Serverless, es posible que deba realizar transformaciones en los datos. 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](https://docs.aws.amazon.com/firehose/latest/dev/data-transformation.html) en la misma guía. ## Go El siguiente código de ejemplo utiliza el cliente [opensearch-go para Go](https://github.com/opensearch-project/opensearch-go) a fin de establecer una conexión segura con la colección OpenSearch Serverless 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(""), config.WithCredentialsProvider( getCredentialProvider("", "", ""), ), ) 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 código de ejemplo, se utiliza el cliente [opensearch-java para Java](https://search.maven.org/artifact/org.opensearch.client/opensearch-java) a fin de establecer una conexión segura con la colección OpenSearch Serverless especificada y crear un índice único. Debe proporcionar valores para `region` y `host`. La diferencia importante en comparación con los *dominios* de OpenSearch servicio 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; 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 El siguiente código de ejemplo utiliza el cliente [opensearch-js](https://www.npmjs.com/package/@opensearch-project/opensearch) JavaScript para establecer una conexión segura con la colección OpenSearch Serverless especificada, crear un índice único, agregar un documento y eliminar el índice. Debe proporcionar valores para `node` y `region`. La diferencia importante en comparación con los *dominios* de OpenSearch servicio es el nombre del servicio (`aoss`en lugar de). `es` ------ #### [ Version 3 ] En este ejemplo, se utiliza la [versión 3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) del SDK para JavaScript 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 usa la [versión 2](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/) del SDK para JavaScript 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 [ OpenSearch complemento Logstash](https://github.com/opensearch-project/logstash-output-opensearch) para publicar registros en colecciones OpenSearch sin servidor. **Para usar Logstash para enviar datos a Serverless OpenSearch** 1. Instale la versión *2.0.0 o posterior* del [logstash-output-opensearch](https://github.com/opensearch-project/logstash-output-opensearch)complemento mediante Docker o Linux. ------ #### [ Docker ] [Docker aloja el software Logstash OSS con el complemento de OpenSearch salida preinstalado: opensearchproject/ -output-plugin. logstash-oss-with-opensearch](https://hub.docker.com/r/opensearchproject/logstash-oss-with-opensearch-output-plugin/tags?page=1&ordering=last_updated&name=8.4.0) Puede extraer la imagen como cualquier otra: ``` docker pull opensearchproject/logstash-oss-with-opensearch-output-plugin:latest ``` ------ #### [ Linux ] En primer lugar, [instale la última versión de Logstash](https://www.elastic.co/guide/en/logstash/current/installing-logstash.html) si aún no lo hizo. A continuación, instale la versión 2.0.0 del complemento de salida: ``` cd logstash-8.5.0/ bin/logstash-plugin install --version 2.0.0 logstash-output-opensearch ``` Si el complemento ya está instalado, actualícelo a la versión más reciente: ``` bin/logstash-plugin update logstash-output-opensearch ``` A partir de la versión 2.0.0 del complemento, el SDK usa la versión 3. AWS Si utilizas una versión de Logstash anterior a la 8.4.0, debes eliminar todos los AWS complementos preinstalados e instalar el complemento: `logstash-integration-aws` ``` /usr/share/logstash/bin/logstash-plugin remove logstash-input-s3 /usr/share/logstash/bin/logstash-plugin remove logstash-input-sqs /usr/share/logstash/bin/logstash-plugin remove logstash-output-s3 /usr/share/logstash/bin/logstash-plugin remove logstash-output-sns /usr/share/logstash/bin/logstash-plugin remove logstash-output-sqs /usr/share/logstash/bin/logstash-plugin remove logstash-output-cloudwatch /usr/share/logstash/bin/logstash-plugin install --version 0.1.0.pre logstash-integration-aws ``` ------ 1. Para que el complemento de OpenSearch salida funcione con OpenSearch Serverless, debes realizar las siguientes modificaciones en la sección de salida de logstash.conf: `opensearch` + Especifique `aoss` como el `service_name` en `auth_type`. + Especifique el punto de conexión de la colección para `hosts`. + Agregue los parámetros `default_server_major_version` y `legacy_template`. Estos parámetros son necesarios para que el complemento funcione con Serverless. OpenSearch ``` output { opensearch { hosts => "collection-endpoint:443" auth_type => { ... service_name => 'aoss' } default_server_major_version => 2 legacy_template => false } } ``` Este ejemplo de archivo de configuración toma las entradas de los archivos de un bucket de S3 y las envía a una colección OpenSearch Serverless: ``` input { s3 { bucket => "my-s3-bucket" region => "us-east-1" } } output { opensearch { ecs_compatibility => disabled hosts => "https://my-collection-endpoint.us-east-1.aoss.amazonaws.com:443" index => my-index auth_type => { type => 'aws_iam' aws_access_key_id => 'your-access-key' aws_secret_access_key => 'your-secret-key' region => 'us-east-1' service_name => 'aoss' } default_server_major_version => 2 legacy_template => false } } ``` 1. A continuación, ejecute Logstash con la nueva configuración para probar el complemento: ``` bin/logstash -f config/test-plugin.conf ``` ## Python El siguiente código de ejemplo usa el [cliente opensearch-py](https://pypi.org/project/opensearch-py/) para Python para establecer una conexión segura con la colección OpenSearch Serverless especificada, crear un índice único y buscar en ese índice. Debe proporcionar valores para `region` y `host`. La diferencia importante en comparación con los *dominios* de OpenSearch servicio 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 `opensearch-aws-sigv4` gema proporciona acceso a OpenSearch Serverless, junto con OpenSearch Service, de forma inmediata. Dispone de todas las funciones del cliente [opensearch-ruby](https://rubygems.org/gems/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 Los siguientes requisitos se aplican a la hora de [firmar solicitudes](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) en colecciones OpenSearch sin servidor cuando se crean solicitudes HTTP con otros clientes. + Debe especificar el nombre del servicio como `aoss`. + El encabezado `x-amz-content-sha256` es obligatorio para todas las solicitudes de Signature Version 4 de AWS . Proporciona un hash de la carga de solicitud. Si hay una carga útil de solicitud, defina el valor en su hash criptográfico () del algoritmo de hash seguro (SHA). SHA256 Si no hay ninguna carga de solicitud, establezca el valor en `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855`, que es el hash de una cadena vacía. **Topics** + [Indexación con cURL](#serverless-signing-curl) + [Indexación con Postman](#serverless-signing-postman) ### 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 el flujo de trabajo de [autenticación con AWS firma](https://learning.postman.com/docs/sending-requests/authorization/aws-signature/) en Postman. ![\[JSON response showing creation of a "movies-index" with successful result and no shards.\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/ServerlessPostman.png)