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 nas coleções do Amazon Sem OpenSearch Servidor

Estas seções fornecem detalhes sobre os pipelines de ingestão com suporte para ingestão de dados nas coleções do Amazon OpenSearch Sem Servidor. Elas também abrangem alguns dos clientes possíveis de serem usados para interagir com as operações da OpenSearch API. Seus clientes devem ser compatíveis com a OpenSearch versão 2.x para se integrarem ao Sem OpenSearch Servidor.

Permissões mínimas necessárias

Para ingerir dados em uma coleção de tecnologia OpenSearch sem servidor, a entidade principal que estiver gravando os dados deverá ter as seguintes permissões mínimas atribuídas em uma política de acesso a dados:

[
   {
      "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, é possível atribuir permissão a todos os índices (índice/ target-collection /*) ou a um subconjunto de índices (índice/). target-collection logs*

Para obter uma referência de todas as operações disponíveis na OpenSearch API e suas permissões associadas, consulteOperações e plug-ins com suporte no Amazon Amazon Sem OpenSearch Servidor.

OpenSearch Ingestão

Em vez de usar um cliente terceirizado para enviar dados diretamente para uma coleção de tecnologia OpenSearch sem servidor, você pode usar a Ingestão da Amazon OpenSearch . Configure seus produtores de dados para enviar dados para OpenSearch Ingestão e ele os entrega automaticamente à coleção especificada. Você também pode configurar a OpenSearch Ingestão para transformar os dados antes de entregá-los. Para obter mais informações, consulte Visão geral da OpenSearch ingestão da Amazon.

Um pipeline OpenSearch de Ingestão precisa de permissão para gravar em uma coleção de tecnologia OpenSearch sem servidor que esteja configurada como seu 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, consulteConcedendo aos pipelines do Amazon OpenSearch Ingestion acesso às coleções.

Para começar a usar o OpenSearch Ingestion, consulteTutorial: Ingestão de dados em uma coleção usando o Amazon OpenSearch Ingestion.

Fluent Bit

Você pode usar AWS a imagem Fluent Bit e o plug-in OpenSearch de saída para ingerir dados em coleções sem OpenSearch servidor.

Exemplo de configuração:

Esta seção de saída de exemplo do arquivo de configuração mostra como usar uma coleção de OpenSearch tecnologia sem servidor 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 <region>
    AWS_Service_Name aoss
    tls     On
    Suppress_Type_Name On

Amazon Data Firehose

O Firehose oferece suporte ao OpenSearch Sem Servidor como um 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 e OpenSearch Escolha sem servidor para seu destino no Guia do desenvolvedor do Amazon Data Firehose.

O perfil do IAM que você fornece ao Firehose para entrega deve ser especificada em uma política de acesso a dados com a permissão aoss:WriteDocument mínima para a coleção de destino, e você deve ter um índice preexistente para o qual enviar dados. Para obter mais informações, consulte Permissões mínimas necessárias.

Antes de enviar os dados para a OpenSearch tecnologia sem servidor, talvez você precise 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 no mesmo guia.

Go

O código de exemplo a seguir usa o cliente opensearch-go para estabelecer uma conexão segura com a coleção especificada do OpenSearch Sem Servidor e cria 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("<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

O código de exemplo a seguir usa o cliente opensearch-java para estabelecer uma conexão segura com a coleção especificada do OpenSearch Sem Servidor e cria 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 (aossem vez dees).

// 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 código de exemplo a seguir estabelece novamente uma conexão segura e, em seguida, pesquisa um í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

O código de exemplo a seguir usa o cliente opensearch-js JavaScript para estabelecer uma conexão segura com a coleção especificada OpenSearch , 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 (aossem vez dees).

Version 3

Este exemplo usa a versão 3 do SDK para JavaScript in 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 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

É necessário usar o OpenSearch plug-in do Logstash para publicar logs nas coleções do Sem OpenSearch Servidor.

Python

O código de exemplo a seguir usa o cliente opensearch-py para Python para estabelecer uma conexão segura com a coleção especificada, criar um único índice e OpenSearch 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 (aossem vez dees).

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

O opensearch-aws-sigv4 gem fornece acesso ao OpenSearch Sem Servidor, junto com o OpenSearch Service, pronto para uso. Ele tem todos os recursos do cliente 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 na assinatura de solicitações para coleções de OpenSearch tecnologia sem servidor quando você cria solicitações HTTP com outros clientes.

Indexar com cURL

O exemplo de solicitação a seguir usa a Biblioteca de Solicitações de URL do Cliente (cURL) para enviar um único documento para um índice chamado movies-index dentro de 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"}'

Indexação com do do do do do Postman

A imagem a seguir mostra como enviar solicitações para uma coleção usando o do do do do do do do do do do do do do do do do do do do do Para obter instruções sobre como autenticar, consulte Fluxo de trabalho de autenticação com AWS assinatura no Postman.