Izin minimum yang diperlukan OpenSearch Tertelan Fluent Bit Amazon Data Firehose Go Java JavaScript Logstash Python Ruby Klien lainnya

Menyerap data ke dalam koleksi Amazon Tanpa OpenSearch Server

Bagian ini memberikan detail tentang saluran pipa konsumsi yang didukung untuk konsumsi data ke dalam koleksi Amazon OpenSearch Tanpa Server. Mereka juga mencakup beberapa klien yang dapat Anda gunakan untuk berinteraksi dengan OpenSearch API operasi. Klien Anda harus kompatibel dengan OpenSearch 2.x untuk berintegrasi dengan Tanpa OpenSearch Server.

Topik

Izin minimum yang diperlukan
OpenSearch Tertelan
Fluent Bit
Amazon Data Firehose
Go
Java
JavaScript
Logstash
Python
Ruby
Menandatangani HTTP permintaan dengan klien lain

Izin minimum yang diperlukan

Untuk memasukkan data ke dalam koleksi OpenSearch Tanpa Server, prinsipal yang menulis data harus memiliki izin minimum berikut yang ditetapkan dalam kebijakan akses data:


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

Izin bisa lebih luas jika Anda berencana untuk menulis ke indeks tambahan. Misalnya, daripada menentukan indeks target tunggal, Anda dapat mengizinkan izin untuk semua indeks (index/target-collection/*), atau subset dari indeks (index/target-collection/logs*).

Untuk referensi semua OpenSearch API operasi yang tersedia dan izin terkait, lihatOperasi dan plugin yang didukung di Amazon Tanpa Server OpenSearch .

OpenSearch Tertelan

Daripada menggunakan klien pihak ketiga untuk mengirim data langsung ke koleksi OpenSearch Tanpa Server, Anda dapat menggunakan Amazon OpenSearch Ingestion. Anda mengonfigurasi produsen data Anda untuk mengirim data ke OpenSearch Ingestion, dan secara otomatis mengirimkan data ke koleksi yang Anda tentukan. Anda juga dapat mengonfigurasi OpenSearch Ingestion untuk mengubah data Anda sebelum mengirimkannya. Untuk informasi selengkapnya, lihat OpenSearch Tertelan Amazon.

Pipeline OpenSearch Ingestion memerlukan izin untuk menulis ke koleksi OpenSearch Tanpa Server yang dikonfigurasi sebagai wastafelnya. Izin ini mencakup kemampuan untuk mendeskripsikan koleksi dan mengirim HTTP permintaan ke sana. Untuk petunjuk penggunaan OpenSearch Ingestion untuk menambahkan data ke koleksi, lihat. Memberikan akses saluran pipa Amazon OpenSearch Ingestion ke koleksi

Untuk memulai dengan OpenSearch Ingestion, lihat. Tutorial: Menelan data ke dalam koleksi menggunakan Amazon OpenSearch Ingestion

Fluent Bit

Anda dapat menggunakan AWS untuk gambar Fluent Bit dan plugin OpenSearch output untuk menyerap data ke dalam koleksi Tanpa OpenSearch Server.

catatan

Anda harus memiliki versi 2.30.0 atau yang lebih baru AWS untuk image Fluent Bit agar dapat diintegrasikan dengan OpenSearch Serverless.

Contoh konfigurasi:

Bagian keluaran sampel dari file konfigurasi ini menunjukkan cara menggunakan koleksi OpenSearch Tanpa Server sebagai tujuan. Penambahan penting adalah AWS_Service_Name parameter, yaituaoss. Hostadalah titik akhir koleksi.


[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 mendukung OpenSearch Tanpa Server sebagai tujuan pengiriman. Untuk petunjuk pengiriman data ke OpenSearch Tanpa Server, lihat Membuat Aliran Pengiriman Firehose Data Kinesis dan OpenSearch Pilih Tanpa Server untuk Tujuan Anda di Panduan Pengembang Amazon Data Firehose.

IAMPeran yang Anda berikan kepada Firehose untuk pengiriman harus ditentukan dalam kebijakan akses data dengan izin aoss:WriteDocument minimum untuk pengumpulan target, dan Anda harus memiliki indeks yang sudah ada sebelumnya untuk mengirim data. Untuk informasi selengkapnya, lihat Izin minimum yang diperlukan.

Sebelum mengirim data ke OpenSearch Tanpa Server, Anda mungkin perlu melakukan transformasi pada data. Untuk mempelajari selengkapnya tentang penggunaan fungsi Lambda untuk menjalankan tugas ini, lihat Transformasi Data Amazon Kinesis Data Firehose dalam panduan yang sama.

Go

Kode contoh berikut menggunakan klien opensearch-go untuk Go untuk membuat koneksi aman ke koleksi OpenSearch Tanpa Server yang ditentukan dan membuat indeks tunggal. Anda harus memberikan nilai untuk region dan 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

Kode contoh berikut menggunakan klien opensearch-java untuk Java untuk membuat koneksi aman ke koleksi OpenSearch Serverless tertentu dan membuat indeks tunggal. Anda harus memberikan nilai untuk region dan host.

Perbedaan penting dibandingkan dengan domain OpenSearch Layanan adalah nama layanan (aossbukanes).


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

Kode sampel berikut lagi membuat koneksi aman, dan kemudian mencari indeks.


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

Kode contoh berikut menggunakan klien opensearch-js untuk membuat koneksi aman JavaScript ke koleksi OpenSearch Tanpa Server yang ditentukan, membuat indeks tunggal, menambahkan dokumen, dan menghapus indeks. Anda harus memberikan nilai untuk node dan region.

Perbedaan penting dibandingkan dengan domain OpenSearch Layanan adalah nama layanan (aossbukanes).

Version 3

Contoh ini menggunakan versi 3 dari SDK for JavaScript di 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

Contoh ini menggunakan versi 2 dari SDK for JavaScript di 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

Anda dapat menggunakan OpenSearch plugin Logstash untuk mempublikasikan log ke koleksi Tanpa OpenSearch Server.

Untuk menggunakan Logstash untuk mengirim data ke Tanpa Server OpenSearch

Instal logstash-output-opensearchplugin versi 2.0.0 atau yang lebih baru menggunakan Docker atau Linux.

Agar plugin OpenSearch output berfungsi dengan OpenSearch Tanpa Server, Anda harus membuat modifikasi berikut pada bagian opensearch output logstash.conf:

Tentukan aoss sebagai di service_name bawahauth_type.
Tentukan titik akhir koleksi Anda untukhosts.
Tambahkan parameter default_server_major_version danlegacy_template. Parameter ini diperlukan agar plugin dapat bekerja dengan Tanpa OpenSearch Server.


output {
  opensearch {
    hosts => "collection-endpoint:443"
    auth_type => {
      ...
      service_name => 'aoss'
    }
    default_server_major_version => 2
    legacy_template => false
  }
}

Contoh file konfigurasi ini mengambil inputnya dari file dalam bucket S3 dan mengirimkannya ke koleksi Tanpa OpenSearch Server:


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

Kemudian, jalankan Logstash dengan konfigurasi baru untuk menguji plugin:
```
bin/logstash -f config/test-plugin.conf
```

Python

Kode contoh berikut menggunakan klien opensearch-py untuk Python untuk membuat koneksi aman ke koleksi OpenSearch Tanpa Server yang ditentukan, membuat indeks tunggal, dan mencari indeks itu. Anda harus memberikan nilai untuk region dan host.

Perbedaan penting dibandingkan dengan domain OpenSearch Layanan adalah nama layanan (aossbukanes).


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

opensearch-aws-sigv4Permata menyediakan akses ke OpenSearch Tanpa Server, bersama dengan OpenSearch Layanan, di luar kotak. Ini memiliki semua fitur klien opensearch-ruby karena merupakan ketergantungan permata ini.

Saat membuat instance Sigv4 signer, tentukan aoss sebagai nama layanan:


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)

Menandatangani HTTP permintaan dengan klien lain

Persyaratan berikut berlaku saat menandatangani permintaan ke koleksi OpenSearch Tanpa Server saat Anda membuat HTTP permintaan dengan klien lain.

Anda harus menentukan nama layanan sebagaiaoss.
x-amz-content-sha256Header diperlukan untuk semua AWS Permintaan Versi Tanda Tangan 4. Ini menyediakan hash dari payload permintaan. Jika ada payload permintaan, tetapkan nilainya ke Secure Hash Algorithm (SHA) kriptografi hash (). SHA256 Jika tidak ada payload permintaan, tetapkan nilainyae3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855, yang merupakan hash dari string kosong.

Pengindeksan dengan c URL

Contoh permintaan berikut menggunakan Client URL Request Library (cURL) untuk mengirim satu dokumen ke indeks bernama movies-index dalam koleksi:


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

Pengindeksan dengan Tukang Pos

Gambar berikut menunjukkan cara mengirim permintaan ke koleksi menggunakan Postman. Untuk petunjuk untuk mengautentikasi, lihat Mengautentikasi dengan AWS Alur kerja otentikasi tanda tangan di Postman.

JSON response showing creation of a "movies-index" with successful result and no shards.

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Mengelola batas kapasitas

Keamanan di Tanpa OpenSearch Server