As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Ingestão de dados em coleções Amazon OpenSearch Serverless Essas seções fornecem detalhes sobre os pipelines de ingestão compatíveis para ingestão de dados em coleções Amazon OpenSearch Serverless. Eles também abrangem alguns dos clientes que você pode usar para interagir com as operações da OpenSearch API. Seus clientes devem ser compatíveis com OpenSearch 2.x para se integrarem ao OpenSearch Serverless. **Topics** + [Permissões mínimas necessárias](#serverless-ingestion-permissions) + [OpenSearch Ingestão](#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) + [Assinar solicitações HTTP com outros clientes](#serverless-signing) ## Permissões mínimas necessárias Para ingerir dados em uma coleção OpenSearch sem servidor, o diretor que está gravando os dados deve ter as seguintes permissões mínimas atribuídas em uma política de acesso a [dados](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" ] } ] ``` As permissões podem ser mais amplas se você planejar gravar em índices adicionais. Por exemplo, em vez de especificar um único índice de destino, você pode conceder permissão para todos os índices (índice/ *target-collection* /\$1) ou para um subconjunto de índices (índice//). *target-collection* *logs\$1* Para obter uma referência de todas as operações de OpenSearch API disponíveis e suas permissões associadas, consulte[Operações e plug-ins compatíveis no Amazon OpenSearch Serverless](serverless-genref.md). ## OpenSearch Ingestão Em vez de usar um cliente terceirizado para enviar dados diretamente para uma coleção OpenSearch sem servidor, você pode usar o Amazon OpenSearch Ingestion. Você configura seus produtores de dados para enviar dados para OpenSearch Ingestão, e ele entrega automaticamente os dados para a coleção que você especificar. Você também pode configurar a OpenSearch ingestão para transformar seus dados antes de entregá-los. Para obter mais informações, consulte [Visão geral da OpenSearch ingestão da Amazon](ingestion.md). Um pipeline OpenSearch de ingestão precisa de permissão para gravar em uma coleção OpenSearch Serverless configurada como coletor. Essas permissões incluem a capacidade de descrever a coleção e enviar solicitações HTTP para ela. Para obter instruções sobre como usar a OpenSearch ingestão para adicionar dados a uma coleção, consulte[Concedendo aos pipelines do Amazon OpenSearch Ingestion acesso às coleções](pipeline-collection-access.md). Para começar a usar o OpenSearch Ingestion, consulte[Tutorial: Ingestão de dados em uma coleção usando o Amazon OpenSearch Ingestion](osis-serverless-get-started.md). ## Fluent Bit Você pode usar AWS a [imagem Fluent Bit](https://github.com/aws/aws-for-fluent-bit#public-images) e o [plug-in OpenSearch de saída](https://docs.fluentbit.io/manual/pipeline/outputs/opensearch) para ingerir dados em coleções sem OpenSearch servidor. **nota** Você deve ter a versão 2.30.0 ou posterior da imagem AWS for Fluent Bit para fazer a integração com o Serverless. OpenSearch **Exemplo de configuração**: Este exemplo de seção de saída do arquivo de configuração mostra como usar uma coleção OpenSearch Serverless como destino. A adição importante é o parâmetro `AWS_Service_Name`, que é `aoss`. `Host` é o endpoint da coleção. ``` [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 O Firehose oferece suporte ao OpenSearch Serverless como destino de entrega. *Para obter instruções sobre como enviar dados para o OpenSearch Serverless, consulte [Criação de um stream de entrega do Kinesis Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) [e OpenSearch Escolha sem servidor para seu destino](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-opensearch-serverless) no Guia do desenvolvedor do Amazon Data Firehose.* O perfil do IAM que você fornece ao Firehose para entrega deve ser especificado em uma política de acesso a dados com a permissão mínima de `aoss:WriteDocument` para a coleção de destino, e você deve ter um índice preexistente para o qual enviar os dados. Para obter mais informações, consulte [Permissões mínimas necessárias](#serverless-ingestion-permissions). Antes de enviar dados para o OpenSearch Serverless, talvez seja necessário realizar transformações nos dados. Para saber mais sobre como usar funções do Lambda para executar essa tarefa, consulte [Transformação de dados do Amazon Kinesis Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/data-transformation.html) no mesmo guia. ## Go O código de exemplo a seguir usa o cliente [opensearch-go](https://github.com/opensearch-project/opensearch-go) para Go para estabelecer uma conexão segura com a coleção OpenSearch Serverless especificada e criar um único índice. Você deve fornecer valores para `region` e `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 O código de exemplo a seguir usa o cliente [opensearch-java](https://search.maven.org/artifact/org.opensearch.client/opensearch-java) para Java para estabelecer uma conexão segura com a coleção OpenSearch Serverless especificada e criar um único índice. Você deve fornecer valores para `region` e `host`. A diferença importante em relação aos *domínios OpenSearch * de serviço é o nome do serviço (`aoss`em vez 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(); ``` O exemplo de código a seguir estabelece novamente uma conexão segura e depois pesquisa um í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 O código de exemplo a seguir usa o cliente [opensearch-js](https://www.npmjs.com/package/@opensearch-project/opensearch) JavaScript para estabelecer uma conexão segura com a coleção OpenSearch Serverless especificada, criar um único índice, adicionar um documento e excluir o índice. Você deve fornecer valores para `node` e `region`. A diferença importante em relação aos *domínios OpenSearch * de serviço é o nome do serviço (`aoss`em vez de`es`). ------ #### [ Version 3 ] Este exemplo usa a [versão 3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) do 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 ] Este exemplo usa a [versão 2](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/) do 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 Você pode usar o [ OpenSearch plug-in Logstash](https://github.com/opensearch-project/logstash-output-opensearch) para publicar registros em coleções sem OpenSearch servidor. **Para usar o Logstash para enviar dados para o Serverless OpenSearch** 1. Instale a versão *2.0.0 ou posterior* do [logstash-output-opensearch](https://github.com/opensearch-project/logstash-output-opensearch)plug-in usando Docker ou Linux. ------ #### [ Docker ] [O Docker hospeda o software Logstash OSS com o plug-in de OpenSearch saída pré-instalado: 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) É possível puxar a imagem como qualquer outra imagem: ``` docker pull opensearchproject/logstash-oss-with-opensearch-output-plugin:latest ``` ------ #### [ Linux ] Primeiro, [instale a versão mais recente do Logstash](https://www.elastic.co/guide/en/logstash/current/installing-logstash.html), caso ainda não a tenha. Em seguida, instale a versão 2.0.0 do plug-in de saída: ``` cd logstash-8.5.0/ bin/logstash-plugin install --version 2.0.0 logstash-output-opensearch ``` Se o plug-in já estiver instalado, atualize-o para a versão mais recente: ``` bin/logstash-plugin update logstash-output-opensearch ``` A partir da versão 2.0.0 do plug-in, o AWS SDK usa a versão 3. Se você estiver usando uma versão do Logstash anterior à 8.4.0, deverá remover todos os plug-ins pré-instalados e instalar o AWS plug-in: `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 o plug-in OpenSearch de saída funcione com o OpenSearch Serverless, você deve fazer as seguintes modificações na seção de `opensearch` saída do logstash.conf: + Especifique `aoss` como o `service_name` em `auth_type`. + Especifique seu endpoint de coleção para `hosts`. + Adicione os parâmetros `default_server_major_version` e `legacy_template`. Esses parâmetros são necessários para que o plug-in funcione com o OpenSearch Serverless. ``` output { opensearch { hosts => "collection-endpoint:443" auth_type => { ... service_name => 'aoss' } default_server_major_version => 2 legacy_template => false } } ``` Esse exemplo de arquivo de configuração obtém sua entrada de arquivos em um bucket do S3 e os envia para uma coleção 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. Em seguida, execute o Logstash com a nova configuração para testar o plug-in: ``` bin/logstash -f config/test-plugin.conf ``` ## Python O código de exemplo a seguir usa o [cliente opensearch-py](https://pypi.org/project/opensearch-py/) para Python para estabelecer uma conexão segura com a coleção OpenSearch Serverless especificada, criar um único índice e pesquisar esse índice. Você deve fornecer valores para `region` e `host`. A diferença importante em relação aos *domínios OpenSearch * de serviço é o nome do serviço (`aoss`em vez 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 A `opensearch-aws-sigv4` gema fornece acesso ao OpenSearch Serverless, junto com o OpenSearch Service, pronto para uso. Ele tem todos os recursos do cliente [opensearch-ruby](https://rubygems.org/gems/opensearch-ruby) porque é uma dependência desse gem. Ao instanciar o signatário do Sigv4, especifique `aoss` como nome do serviço: ``` 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) ``` ## Assinar solicitações HTTP com outros clientes Os requisitos a seguir se aplicam ao [assinar solicitações](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) em coleções OpenSearch sem servidor quando você cria solicitações HTTP com outros clientes. + O nome do serviço deve ser especificado como `aoss`. + O cabeçalho `x-amz-content-sha256` é obrigatório para todas as solicitações do AWS Signature Version 4. Ele fornece um hash da carga da solicitação. Se houver uma carga útil de solicitação, defina o valor como seu hash criptográfico () do Secure Hash Algorithm (SHA). SHA256 Se não houver carga de solicitação, defina o valor como `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855`, que é o hash de uma string vazia. **Topics** + [Indexar com cURL](#serverless-signing-curl) + [Indexar com o Postman](#serverless-signing-postman) ### Indexar com cURL O exemplo de solicitação a seguir usa a Client URL Request Library (cURL) para enviar um único documento para um índice denominado `movies-index` em uma coleção: ``` 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"}' ``` ### Indexar com o Postman A imagem a seguir mostra como enviar solicitações para uma coleção usando o Postman. Para obter instruções sobre como autenticar, consulte [Fluxo de trabalho de autenticação com AWS assinatura no Postman](https://learning.postman.com/docs/sending-requests/authorization/aws-signature/). ![\[JSON response showing creation of a "movies-index" with successful result and no shards.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/ServerlessPostman.png)