Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Erfassung von Daten in OpenSearch Amazon-Serverless-Sammlungen

Diese Abschnitte enthalten Details zu den unterstützten Erfassungspipelines für die Datenerfassung in Amazon-Serverless-Sammlungen. OpenSearch Sie behandeln auch einige der Clients, die Sie zur Interaktion mit den OpenSearch API-Operationen verwenden können. Ihre Clients sollten mit OpenSearch 2.x kompatibel sein, um eine Integration mit OpenSearch Serverless zu ermöglichen.

Erforderliche Mindestberechtigungen

Um Daten in eine OpenSearch Serverless-Sammlung aufzunehmen, müssen dem Prinzipal, der die Daten schreibt, die folgenden Mindestberechtigungen in einer Datenzugriffsrichtlinie zugewiesen werden:

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

Die Berechtigungen können umfassender sein, wenn Sie in zusätzliche Indizes schreiben möchten. Anstatt beispielsweise einen einzelnen Zielindex anzugeben, können Sie die Berechtigung für alle Indizes (index/ target-collection /*) oder eine Teilmenge von Indizes (index//) erteilen. target-collection logs*

Eine Referenz aller verfügbaren OpenSearch API-Operationen und der zugehörigen Berechtigungen finden Sie unterUnterstützte Vorgänge und Plugins OpenSearch .

OpenSearch Verschlucken

Anstatt einen Drittanbieter-Client zu verwenden, um Daten direkt an eine OpenSearch serverlose Sammlung zu senden, können Sie Amazon OpenSearch Ingestion verwenden. Sie konfigurieren Ihre Datenproduzenten zum Senden von Daten an OpenSearch Ingestion. Die Daten werden dann automatisch an die angegebene Sammlung geliefert. Sie können OpenSearch Ingestion auch so konfigurieren, dass die Daten vor der Bereitstellung transformiert werden. Weitere Informationen finden Sie unter Überblick über Amazon OpenSearch Ingestion.

Eine OpenSearch Ingestion-Pipeline benötigt die Berechtigung, in eine OpenSearch serverlose Sammlung zu schreiben, die als Senke konfiguriert ist. Diese Berechtigungen umfassen die Möglichkeit, die Sammlung zu beschreiben und HTTP-Anforderungen an sie zu senden. Anweisungen zur Verwendung von OpenSearch Ingestion zum Hinzufügen von Daten zu einer Sammlung finden Sie unter. Amazon OpenSearch Ingestion-Pipelines Zugriff auf Sammlungen gewähren

Informationen zu den ersten Schritten mit OpenSearch Ingestion finden Sie unter. Tutorial: Daten mit Amazon OpenSearch Ingestion in eine Sammlung aufnehmen

Fluent Bit

Sie können AWS für Fluent-Bit-Image und das OpenSearch Ausgabe-Plugin verwenden, um Daten in OpenSearch Serverless-Sammlungen aufzunehmen.

Beispielkonfiguration:

Dieser Beispielausgabeabschnitt der Konfigurationsdatei zeigt, wie eine OpenSearch Serverless-Sammlung als Ziel verwendet wird. Die wichtige Ergänzung ist der AWS_Service_Name-Parameter, der aoss ist. Host ist der Sammlungsendpunkt.

[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 unterstützt OpenSearch Serverless als Zustellziel. Anweisungen zum Senden von Daten an OpenSearch Serverless finden Sie unter Erstellen eines Kinesis-Data-Firehose-Bereitstellungsstreams und Auswahl von OpenSearch Serverless als Ihr Ziel im Entwicklerhandbuch fürAmazon Data Firehose.

Die IAM-Rolle, die Sie Firehose für die Bereitstellung zur Verfügung stellen, muss in einer Datenzugriffsrichtlinie mit der aoss:WriteDocument Mindestberechtigung für die Zielsammlung angegeben werden, und Sie benötigen ein zuvor vorhandenes Index, an das Sie Daten senden. Weitere Informationen finden Sie unter Erforderliche Mindestberechtigungen.

Bevor Sie Daten an OpenSearch Serverless senden, müssen Sie möglicherweise Transformationen an den Daten durchführen. Weitere Informationen über die Verwendung von Lambda-Funktionen zur Ausführung dieser Aufgabe finden Sie unter Amazon Kinesis Data Firehose Datentransformation im selben Handbuch.

Go

Der folgende Beispielcode verwendet den opensearch-go -Client für Go, um eine sichere Verbindung zur angegebenen OpenSearch Serverless-Sammlung herzustellen und einen einzelnen Index zu erstellen. Sie müssen Werte für region und host angeben.

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

Der folgende Beispielcode verwendet den opensearch-java -Client für Java, um eine sichere Verbindung zur angegebenen OpenSearch Serverless-Sammlung herzustellen und einen einzelnen Index zu erstellen. Sie müssen Werte für region und host angeben.

Der wichtige Unterschied zu OpenSearch Service- Domains ist der Service-Name (aossanstelle vones).

// 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();   

Der folgende Beispielcode stellt erneut eine sichere Verbindung her und durchsucht dann einen Index.

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

Der folgende Beispielcode verwendet den opensearch-js -Client, JavaScript um eine sichere Verbindung zur angegebenen OpenSearch Serverless-Sammlung herzustellen, einen einzelnen Index zu erstellen, ein Dokument hinzuzufügen und den Index zu löschen. Sie müssen Werte für node und region angeben.

Der wichtige Unterschied zu OpenSearch Service- Domains ist der Service-Name (aossanstelle vones).

Version 3

In diesem Beispiel wird die Version 3 des SDK für JavaScript in Node.js verwendet.

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

In diesem Beispiel wird Version 2 des SDK für JavaScript in Node.js verwendet.

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

Sie können das OpenSearch Logstash-Plugin verwenden, um Logs in OpenSearch serverlosen Sammlungen zu veröffentlichen.

Python

Der folgende Beispielcode verwendet den opensearch-py -Client für Python, um eine sichere Verbindung zur angegebenen OpenSearch Serverless-Sammlung herzustellen, einen einzelnen Index zu erstellen und diesen Index zu durchsuchen. Sie müssen Werte für region und host angeben.

Der wichtige Unterschied zu OpenSearch Service- Domains ist der Service-Name (aossanstelle vones).

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

Das opensearch-aws-sigv4 Gem bietet OpenSearch standardmäßig Zugriff auf Serverless zusammen mit OpenSearch Service. Es hat alle Funktionen des opensearch-ruby-Clients, da es von diesem Gem abhängig ist.

Geben Sie bei der Instanziierung des Sigv4-Signers aoss als Servicenamen an:

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)

Signieren von HTTP-Anforderungen mit anderen Clients

Beim Signieren von Anforderungen an OpenSearch Serverless-Sammlungen gelten die folgenden Anforderungen, wenn Sie HTTP-Anforderungen mit anderen Clients erstellen:

Indizierung mit cURL

Die folgende Beispielanforderung verwendet die Client URL Request Library (cURL), um ein einzelnes Dokument an einen Index zu senden, der movies-index innerhalb einer Sammlung benannt ist:

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"}'

Indexierung mit Postman

In der folgenden Abbildung sehen Sie, wie eine Anfrage an eine Sammlung mithilfe von Postman gesendet wird. Anweisungen zur Authentifizierung finden Sie unter Workflow zur Authentifizierung mit AWS Signatur in Postman.