Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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 operasi OpenSearch API. Klien Anda harus kompatibel dengan OpenSearch 2.x untuk berintegrasi dengan Tanpa OpenSearch Server.
**Topics**
+ [Izin minimum yang diperlukan](#serverless-ingestion-permissions)
+ [OpenSearch Tertelan](#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)
+ [Menandatangani permintaan HTTP dengan klien lain](#serverless-signing)
## 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:](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"
]
}
]
```
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* /\$1), atau subset indeks (index//). *target-collection* *logs\$1*
Untuk referensi semua operasi OpenSearch API yang tersedia dan izin terkait, lihat[Operasi dan plugin yang didukung di Amazon Tanpa Server OpenSearch](serverless-genref.md).
## 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 [Sekilas tentang Amazon OpenSearch Ingestion](ingestion.md).
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 permintaan HTTP ke dalamnya. Untuk petunjuk penggunaan OpenSearch Ingestion untuk menambahkan data ke koleksi, lihat. [Memberikan akses saluran pipa Amazon OpenSearch Ingestion ke koleksi](pipeline-collection-access.md)
Untuk memulai dengan OpenSearch Ingestion, lihat. [Tutorial: Menelan data ke dalam koleksi menggunakan Amazon OpenSearch Ingestion](osis-serverless-get-started.md)
## Fluent Bit
Anda dapat menggunakan [AWS gambar Fluent Bit](https://github.com/aws/aws-for-fluent-bit#public-images) dan [plugin OpenSearch output](https://docs.fluentbit.io/manual/pipeline/outputs/opensearch) untuk mencerna data ke dalam koleksi Tanpa OpenSearch Server.
**catatan**
Anda harus memiliki versi 2.30.0 atau yang lebih baru dari image AWS for Fluent Bit agar dapat diintegrasikan dengan Tanpa Server. OpenSearch
**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, yaitu`aoss`. `Host`adalah 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
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](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) [dan OpenSearch Pilih Tanpa Server untuk Tujuan](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-opensearch-serverless) Anda di Panduan Pengembang Amazon Data Firehose.*
Peran IAM yang Anda berikan kepada Firehose untuk pengiriman harus ditentukan dalam kebijakan akses data dengan `aoss:WriteDocument` izin minimum untuk pengumpulan target, dan Anda harus memiliki indeks yang sudah ada sebelumnya untuk mengirim data. Untuk informasi selengkapnya, lihat [Izin minimum yang diperlukan](#serverless-ingestion-permissions).
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](https://docs.aws.amazon.com/firehose/latest/dev/data-transformation.html) dalam panduan yang sama.
## Go
Kode contoh berikut menggunakan klien [opensearch-go untuk Go](https://github.com/opensearch-project/opensearch-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(""),
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
Kode contoh berikut menggunakan klien [opensearch-java](https://search.maven.org/artifact/org.opensearch.client/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 (`aoss`bukan`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();
```
Kode sampel berikut lagi membuat koneksi aman, dan kemudian mencari indeks.
```
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
Kode contoh berikut menggunakan klien [opensearch-js](https://www.npmjs.com/package/@opensearch-project/opensearch) 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 (`aoss`bukan`es`).
------
#### [ Version 3 ]
Contoh ini menggunakan SDK [versi 3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) untuk 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 SDK [versi 2](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/) untuk 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](https://github.com/opensearch-project/logstash-output-opensearch) untuk mempublikasikan log ke koleksi Tanpa OpenSearch Server.
**Untuk menggunakan Logstash untuk mengirim data ke Tanpa Server OpenSearch**
1. Instal [logstash-output-opensearch](https://github.com/opensearch-project/logstash-output-opensearch)plugin versi *2.0.0 atau yang lebih baru* menggunakan Docker atau Linux.
------
#### [ Docker ]
[Docker meng-host perangkat lunak Logstash OSS dengan plugin output yang sudah diinstal sebelumnya: opensearchproject/ OpenSearch -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) Anda dapat menarik gambar seperti gambar lainnya:
```
docker pull opensearchproject/logstash-oss-with-opensearch-output-plugin:latest
```
------
#### [ Linux ]
Pertama, [instal versi terbaru Logstash](https://www.elastic.co/guide/en/logstash/current/installing-logstash.html) jika Anda belum melakukannya. Kemudian, instal versi 2.0.0 dari plugin output:
```
cd logstash-8.5.0/
bin/logstash-plugin install --version 2.0.0 logstash-output-opensearch
```
Jika plugin sudah diinstal, perbarui ke versi terbaru:
```
bin/logstash-plugin update logstash-output-opensearch
```
Dimulai dengan versi 2.0.0 plugin, AWS SDK menggunakan versi 3. Jika Anda menggunakan versi Logstash lebih awal dari 8.4.0, Anda harus menghapus plugin pra-instal dan menginstal AWS plugin: `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. 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` bawah`auth_type`.
+ Tentukan titik akhir koleksi Anda untuk`hosts`.
+ Tambahkan parameter `default_server_major_version` dan`legacy_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
}
}
```
1. Kemudian, jalankan Logstash dengan konfigurasi baru untuk menguji plugin:
```
bin/logstash -f config/test-plugin.conf
```
## Python
Kode contoh berikut menggunakan klien [opensearch-py](https://pypi.org/project/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 (`aoss`bukan`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
`opensearch-aws-sigv4`Permata menyediakan akses ke OpenSearch Tanpa Server, bersama dengan OpenSearch Layanan, di luar kotak. Ini memiliki semua fitur klien [opensearch-ruby](https://rubygems.org/gems/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 permintaan HTTP dengan klien lain
Persyaratan berikut berlaku saat [menandatangani permintaan](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) ke koleksi OpenSearch Tanpa Server saat Anda membuat permintaan HTTP dengan klien lain.
+ Anda harus menentukan nama layanan sebagai`aoss`.
+ `x-amz-content-sha256`Header diperlukan untuk semua permintaan AWS Signature Version 4. Ini menyediakan hash dari payload permintaan. Jika ada payload permintaan, tetapkan nilainya ke hash kriptografi Secure Hash Algorithm (SHA). SHA256 Jika tidak ada payload permintaan, tetapkan nilainya`e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855`, yang merupakan hash dari string kosong.
**Topics**
+ [Pengindeksan dengan cURL](#serverless-signing-curl)
+ [Pengindeksan dengan Tukang Pos](#serverless-signing-postman)
### Pengindeksan dengan cURL
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 mengautentikasi, lihat Mengautentikasi [dengan alur kerja autentikasi AWS Tanda Tangan di Tukang](https://learning.postman.com/docs/sending-requests/authorization/aws-signature/) Pos.
![\[JSON response showing creation of a "movies-index" with successful result and no shards.\]](http://docs.aws.amazon.com/id_id/opensearch-service/latest/developerguide/images/ServerlessPostman.png)