Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Kembangkan produsen menggunakan Amazon Kinesis Producer Library (KPL)
*Produsen Amazon Kinesis Data Streams adalah aplikasi yang menempatkan catatan data pengguna ke dalam aliran data Kinesis (juga disebut konsumsi data).* Amazon Kinesis Producer Library (KPL) menyederhanakan pengembangan aplikasi produser, memungkinkan pengembang mencapai throughput penulisan yang tinggi ke aliran data Kinesis.
Anda dapat memantau KPL dengan Amazon CloudWatch. Untuk informasi selengkapnya, lihat [Pantau Perpustakaan Produser Kinesis dengan Amazon CloudWatch](monitoring-with-kpl.md).
**Topics**
+ [Tinjau peran KPL](#developing-producers-with-kpl-role)
+ [Sadarilah keuntungan menggunakan KPL](#developing-producers-with-kpl-advantage)
+ [Memahami kapan tidak menggunakan KPL](#developing-producers-with-kpl-when)
+ [Instal KPL](kinesis-kpl-dl-install.md)
+ [Migrasi dari KPL 0.x ke KPL 1.x](kpl-migration-1x.md)
+ [Transisi ke sertifikat Amazon Trust Services (ATS) untuk KPL](kinesis-kpl-upgrades.md)
+ [Platform yang didukung KPL](kinesis-kpl-supported-plats.md)
+ [Konsep kunci KPL](kinesis-kpl-concepts.md)
+ [Integrasikan KPL dengan kode produsen](kinesis-kpl-integration.md)
+ [Menulis ke aliran data Kinesis Anda menggunakan KPL](kinesis-kpl-writing.md)
+ [Konfigurasikan Perpustakaan Produsen Amazon Kinesis](kinesis-kpl-config.md)
+ [Menerapkan de-agregasi konsumen](kinesis-kpl-consumer-deaggregation.md)
+ [Gunakan KPL dengan Amazon Data Firehose](kpl-with-firehose.md)
+ [Gunakan KPL dengan AWS Glue Schema Registry](kpl-with-schemaregistry.md)
+ [Konfigurasikan konfigurasi proxy KPL](kpl-proxy-configuration.md)
+ [Kebijakan siklus hidup versi KPL](kpl-version-lifecycle-policy.md)
**catatan**
Disarankan agar Anda meningkatkan ke versi KPL terbaru. KPL diperbarui secara berkala dengan rilis yang lebih baru yang mencakup patch dependensi dan keamanan terbaru, perbaikan bug, dan fitur baru yang kompatibel ke belakang. Untuk informasi selengkapnya, lihat [https://github.com/awslabs/amazon-kinesis-producer/releases/](https://github.com/awslabs/amazon-kinesis-producer/releases/).
## Tinjau peran KPL
KPL adalah pustaka yang easy-to-use sangat dapat dikonfigurasi yang membantu Anda menulis ke aliran data Kinesis. Ini bertindak sebagai perantara antara kode aplikasi produser Anda dan tindakan API Kinesis Data Streams. KPL melakukan tugas-tugas utama berikut:
+ Menulis ke satu atau lebih aliran data Kinesis dengan mekanisme coba ulang otomatis dan dapat dikonfigurasi
+ Mengumpulkan catatan dan menggunakan `PutRecords` untuk menulis beberapa catatan ke beberapa pecahan per permintaan
+ Mengagregat catatan pengguna untuk meningkatkan ukuran payload dan meningkatkan throughput
+ Terintegrasi secara mulus dengan [Kinesis Client Library](https://docs.aws.amazon.com/kinesis/latest/dev/developing-consumers-with-kcl.html) (KCL) untuk melakukan de-agregasi batch record pada konsumen
+ Mengirimkan CloudWatch metrik Amazon atas nama Anda untuk memberikan visibilitas ke kinerja produsen
Perhatikan bahwa KPL berbeda dari Kinesis Data Streams API yang tersedia di. [AWS SDKs](https://aws.amazon.com/tools/) Kinesis Data Streams API membantu Anda mengelola banyak aspek Kinesis Data Streams (termasuk membuat stream, resharding, dan menempatkan dan mendapatkan record), sementara KPL menyediakan lapisan abstraksi khusus untuk menyerap data. Untuk informasi tentang Kinesis Data Streams API, lihat Referensi API [Amazon Kinesis](https://docs.aws.amazon.com/kinesis/latest/APIReference/).
## Sadarilah keuntungan menggunakan KPL
Daftar berikut merupakan beberapa keuntungan utama menggunakan KPL untuk mengembangkan produsen Kinesis Data Streams.
KPL dapat digunakan dalam kasus penggunaan sinkron atau asinkron. Kami menyarankan untuk menggunakan kinerja antarmuka asinkron yang lebih tinggi kecuali ada alasan khusus untuk menggunakan perilaku sinkron. Untuk informasi selengkapnya tentang dua kasus penggunaan dan kode contoh ini, lihat[Menulis ke aliran data Kinesis Anda menggunakan KPL](kinesis-kpl-writing.md).
**Manfaat Kinerja**
KPL dapat membantu membangun produsen berkinerja tinggi. Pertimbangkan situasi di mana instans Amazon EC2 Anda berfungsi sebagai proxy untuk mengumpulkan peristiwa 100 byte dari ratusan atau ribuan perangkat berdaya rendah dan menulis catatan ke dalam aliran data Kinesis. Instans EC2 ini masing-masing harus menulis ribuan peristiwa per detik ke aliran data Anda. Untuk mencapai throughput yang dibutuhkan, produsen harus menerapkan logika yang rumit, seperti batching atau multithreading, selain logika coba ulang dan de-agregasi rekaman di sisi konsumen. KPL melakukan semua tugas ini untuk Anda.
**Kemudahan Penggunaan Sisi Konsumen**
Untuk pengembang sisi konsumen yang menggunakan KCL di Jawa, KPL terintegrasi tanpa usaha tambahan. Ketika KCL mengambil rekaman Kinesis Data Streams agregat yang terdiri dari beberapa catatan pengguna KPL, secara otomatis memanggil KPL untuk mengekstrak catatan pengguna individu sebelum mengembalikannya ke pengguna.
Untuk pengembang sisi konsumen yang tidak menggunakan KCL tetapi menggunakan operasi API `GetRecords` secara langsung, perpustakaan Java KPL tersedia untuk mengekstrak catatan pengguna individu sebelum mengembalikannya ke pengguna.
**Pemantauan Produsen**
Anda dapat mengumpulkan, memantau, dan menganalisis produsen Kinesis Data Streams menggunakan CloudWatch Amazon dan KPL. KPL memancarkan throughput, kesalahan, dan metrik lainnya untuk CloudWatch atas nama Anda, dan dapat dikonfigurasi untuk memantau pada tingkat aliran, pecahan, atau produsen.
**Arsitektur Asinkron**
Karena KPL dapat menyangga catatan sebelum mengirimnya ke Kinesis Data Streams, itu tidak memaksa aplikasi pemanggil untuk memblokir dan menunggu konfirmasi bahwa catatan telah tiba di server sebelum melanjutkan runtime. Panggilan untuk memasukkan catatan ke dalam KPL selalu segera kembali dan tidak menunggu catatan dikirim atau respons diterima dari server. Sebaliknya, `Future` objek dibuat yang menerima hasil pengiriman catatan ke Kinesis Data Streams di lain waktu. Ini adalah perilaku yang sama dengan klien asinkron di SDK. AWS
## Memahami kapan tidak menggunakan KPL
KPL dapat menimbulkan penundaan pemrosesan tambahan hingga di `RecordMaxBufferedTime` dalam perpustakaan (dapat dikonfigurasi pengguna). Nilai yang lebih besar `RecordMaxBufferedTime` menghasilkan efisiensi pengepakan yang lebih tinggi dan kinerja yang lebih baik. Aplikasi yang tidak dapat mentolerir penundaan tambahan ini mungkin perlu menggunakan AWS SDK secara langsung. Untuk informasi selengkapnya tentang penggunaan AWS SDK dengan Kinesis Data Streams, lihat. [Kembangkan produsen menggunakan API Amazon Kinesis Data Streams dengan AWS SDK untuk Java](developing-producers-with-sdk.md) Untuk informasi selengkapnya tentang `RecordMaxBufferedTime` dan properti KPL yang dapat dikonfigurasi pengguna lainnya, lihat. [Konfigurasikan Perpustakaan Produsen Amazon Kinesis](kinesis-kpl-config.md)
# Instal KPL
Amazon menyediakan binari pra-bangun dari C\$1\$1 Amazon Kinesis Producer Library (KPL) untuk macOS, Windows, dan distribusi Linux terbaru (untuk detail platform yang didukung, lihat bagian selanjutnya). Binari ini dikemas sebagai bagian dari file Java .jar dan secara otomatis dipanggil dan digunakan jika Anda menggunakan Maven untuk menginstal paket. Untuk menemukan versi terbaru KPL dan KCL, gunakan tautan pencarian Maven berikut:
+ [KPL](https://search.maven.org/#search|ga|1|amazon-kinesis-producer)
+ [KCL](https://search.maven.org/#search|ga|1|amazon-kinesis-client)
Binari Linux telah dikompilasi dengan GNU Compiler Collection (GCC) dan ditautkan secara statis terhadap libstdc\$1\$1 di Linux. Mereka diharapkan untuk bekerja pada distribusi Linux 64-bit yang mencakup glibc versi 2.5 atau lebih tinggi.
Pengguna distribusi Linux sebelumnya dapat membangun KPL menggunakan instruksi build yang disediakan bersama dengan sumbernya. GitHub Untuk mengunduh KPL dari GitHub, lihat Perpustakaan [Produser Amazon Kinesis](https://github.com/awslabs/amazon-kinesis-producer).
**penting**
Amazon Kinesis Producer Library (KPL) 0.x akan mencapai end-of-support pada 30 Januari 2026. Kami **sangat menyarankan agar** Anda memigrasikan aplikasi KPL Anda menggunakan versi 0.x ke versi KPL terbaru sebelum 30 Januari 2026. Untuk menemukan versi KPL terbaru, lihat [halaman KPL](https://github.com/awslabs/amazon-kinesis-producer) di Github. Untuk informasi tentang migrasi dari KPL 0.x ke KPL 1.x, lihat. [Migrasi dari KPL 0.x ke KPL 1.x](kpl-migration-1x.md)
# Migrasi dari KPL 0.x ke KPL 1.x
Topik ini memberikan step-by-step petunjuk untuk memigrasikan konsumen Anda dari KPL 0.x ke KPL 1.x. KPL 1.x memperkenalkan dukungan untuk AWS SDK untuk Java 2.x sambil mempertahankan kompatibilitas antarmuka dengan versi sebelumnya. Anda tidak perlu memperbarui logika pemrosesan data inti Anda untuk bermigrasi ke KPL 1.x.
1. **Pastikan Anda memiliki prasyarat berikut:**
+ Java Development Kit (JDK) 8 atau lebih baru
+ AWS SDK untuk Java 2.x
+ Maven atau Gradle untuk manajemen ketergantungan
1. **Tambahkan dependensi**
Jika Anda menggunakan Maven, tambahkan dependensi berikut ke file pom.xml Anda. Pastikan Anda memperbarui GroupId dari `com.amazonaws` ke `software.amazon.kinesis` dan versi `1.x.x` ke versi KPL terbaru.
```
software.amazon.kinesis
amazon-kinesis-producer
1.x.x
```
Jika Anda menggunakan Gradle, tambahkan berikut ini ke `build.gradle` file Anda. Pastikan untuk mengganti `1.x.x` dengan versi KPL terbaru.
```
implementation 'software.amazon.kinesis:amazon-kinesis-producer:1.x.x'
```
Anda dapat memeriksa versi terbaru KPL di Repositori Pusat [Maven](https://central.sonatype.com/search?q=amazon-kinesis-producer).
1. **Perbarui pernyataan impor untuk KPL**
KPL 1.x menggunakan AWS SDK untuk Java 2.x dan menggunakan nama paket yang diperbarui yang dimulai dengan`software.amazon.kinesis`, dibandingkan dengan nama paket di KPL sebelumnya yang dimulai dengan. `com.amazonaws.services.kinesis`
Ganti impor untuk `com.amazonaws.services.kinesis` dengan`software.amazon.kinesis`. Tabel berikut mencantumkan impor yang harus Anda ganti.
**Penggantian impor**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/streams/latest/dev/kpl-migration-1x.html)
1. **Perbarui pernyataan impor untuk kelas AWS penyedia kredensional**
Saat bermigrasi ke KPL 1.x, Anda harus memperbarui paket dan kelas dalam impor Anda dalam kode aplikasi KPL Anda yang didasarkan pada AWS SDK untuk Java 1.x ke yang sesuai berdasarkan 2.x. AWS SDK untuk Java Impor umum dalam aplikasi KPL adalah kelas penyedia kredensial. Lihat [Perubahan penyedia kredensial](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration-client-credentials.html) dalam dokumentasi panduan migrasi AWS SDK untuk Java 2.x untuk mengetahui daftar lengkap perubahan penyedia kredensial. Berikut adalah perubahan impor umum yang mungkin perlu Anda lakukan di aplikasi KPL Anda.
**Impor di KPL 0.x**
```
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
```
**Impor di KPL 1.x**
```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
```
Jika Anda mengimpor penyedia kredensi lain berdasarkan AWS SDK untuk Java 1.x, Anda harus memperbaruinya ke yang setara AWS SDK untuk Java 2.x. Jika Anda tidak mengimpor apa pun classes/packages dari AWS SDK untuk Java 1.x, Anda dapat mengabaikan langkah ini.
1. **Perbarui konfigurasi penyedia kredensional dalam konfigurasi KPL**
Konfigurasi penyedia kredensional di KPL 1.x memerlukan penyedia kredensi 2.x. AWS SDK untuk Java Jika Anda meneruskan penyedia kredensi untuk AWS SDK untuk Java 1.x di `KinesisProducerConfiguration` dengan mengganti penyedia kredensil default, Anda harus memperbaruinya dengan penyedia kredensi 2.x. AWS SDK untuk Java Lihat [Perubahan penyedia kredensial](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration-client-credentials.html) dalam dokumentasi panduan migrasi AWS SDK untuk Java 2.x untuk mengetahui daftar lengkap perubahan penyedia kredensial. Jika Anda tidak mengganti penyedia kredensi default dalam konfigurasi KPL, Anda dapat mengabaikan langkah ini.
Misalnya, jika Anda mengganti penyedia kredensi default untuk KPL dengan kode berikut:
```
KinesisProducerConfiguration config = new KinesisProducerConfiguration();
// SDK v1 default credentials provider
config.setCredentialsProvider(new DefaultAWSCredentialsProviderChain());
```
Anda harus memperbaruinya dengan kode berikut untuk menggunakan penyedia kredensi AWS SDK untuk Java 2.x:
```
KinesisProducerConfiguration config = new KinesisProducerConfiguration();
// New SDK v2 default credentials provider
config.setCredentialsProvider(DefaultCredentialsProvider.create());
```
# Transisi ke sertifikat Amazon Trust Services (ATS) untuk KPL
Pada tanggal 9 Februari 2018, pukul 09.00 PST, Amazon Kinesis Data Streams memasang sertifikat ATS. [Untuk terus dapat menulis catatan ke Kinesis Data Streams menggunakan Amazon Kinesis Producer Library (KPL), Anda harus meng-upgrade instalasi KPL Anda ke versi 0.12.6 atau yang lebih baru.](http://search.maven.org/#artifactdetails|com.amazonaws|amazon-kinesis-producer|0.12.6|jar) Perubahan ini mempengaruhi semua AWS Wilayah.
Untuk informasi tentang perpindahan ke ATS, lihat [Cara AWS Mempersiapkan Pindah ke Otoritas Sertifikat Sendiri](https://aws.amazon.com/blogs/security/how-to-prepare-for-aws-move-to-its-own-certificate-authority/).
Jika Anda mengalami masalah dan membutuhkan dukungan teknis, [buat kasus](https://console.aws.amazon.com/support/v1#/case/create) dengan AWS Support Center.
# Platform yang didukung KPL
Amazon Kinesis Producer Library (KPL) ditulis dalam C\$1\$1 dan berjalan sebagai proses turunan ke proses pengguna utama. Binari asli 64-bit yang dikompilasi dibundel dengan rilis Java dan dikelola oleh pembungkus Java.
Paket Java berjalan tanpa perlu menginstal pustaka tambahan pada sistem operasi berikut:
+ Distribusi Linux dengan kernel 2.6.18 (September 2006) dan kemudian
+ Apple iOS X 10.9 dan yang lebih baru
+ Windows Server 2008 dan yang lebih baru
**penting**
Windows Server 2008 dan yang lebih baru didukung untuk semua versi KPL hingga versi 0.14.0.
Platform Windows TIDAK didukung dimulai dengan KPL versi 0.14.0 atau lebih tinggi.
Perhatikan bahwa KPL hanya 64-bit.
## Kode sumber
Jika binari yang disediakan dalam instalasi KPL tidak cukup untuk lingkungan Anda, inti KPL ditulis sebagai modul C\$1\$1. Kode sumber untuk modul C\$1\$1 dan antarmuka Java dirilis di bawah Lisensi Publik Amazon dan tersedia GitHub di Perpustakaan Produsen [Amazon Kinesis](https://github.com/awslabs/amazon-kinesis-producer). Meskipun KPL dapat digunakan pada platform apa pun di mana kompiler C\$1\$1 dan JRE yang sesuai standar baru-baru ini tersedia, Amazon tidak secara resmi mendukung platform apa pun yang tidak ada dalam daftar platform yang didukung.
# Konsep kunci KPL
Bagian berikut berisi konsep dan terminologi yang diperlukan untuk memahami dan mendapatkan manfaat dari Amazon Kinesis Producer Library (KPL).
**Topics**
+ [Catatan](#kinesis-kpl-concepts-records)
+ [Batching](#kinesis-kpl-concepts-batching)
+ [Agregasi](#kinesis-kpl-concepts-aggretation)
+ [Koleksi](#kinesis-kpl-concepts-collection)
## Catatan
Dalam panduan ini, kami membedakan antara *catatan pengguna KPL dan catatan* *Kinesis* Data Streams. Saat kami menggunakan *catatan* istilah tanpa kualifikasi, kami merujuk ke catatan *pengguna KPL*. Ketika kami merujuk ke catatan Kinesis Data Streams, kami *secara eksplisit mengatakan catatan Kinesis* Data Streams.
Catatan pengguna KPL adalah gumpalan data yang memiliki arti khusus bagi pengguna. Contohnya termasuk gumpalan JSON yang mewakili peristiwa UI di situs web, atau entri log dari server web.
Catatan Kinesis Data Streams adalah instance `Record` dari struktur data yang ditentukan oleh API layanan Kinesis Data Streams. Ini berisi kunci partisi, nomor urut, dan gumpalan data.
## Batching
*Batching* mengacu pada melakukan satu tindakan pada beberapa item alih-alih berulang kali melakukan tindakan pada setiap item individu.
Dalam konteks ini, “item” adalah catatan, dan tindakan mengirimkannya ke Kinesis Data Streams. Dalam situasi non-batching, Anda akan menempatkan setiap rekaman dalam catatan Kinesis Data Streams terpisah dan membuat satu permintaan HTTP untuk mengirimkannya ke Kinesis Data Streams. Dengan batching, setiap permintaan HTTP dapat membawa beberapa catatan, bukan hanya satu.
KPL mendukung dua jenis batching:
+ *Agregasi* — Menyimpan beberapa catatan dalam satu catatan Kinesis Data Streams.
+ *Pengumpulan* — Menggunakan operasi API `PutRecords` untuk mengirim beberapa catatan Kinesis Data Streams ke satu atau beberapa pecahan dalam aliran data Kinesis Anda.
Kedua jenis batching KPL dirancang untuk hidup berdampingan dan dapat dihidupkan atau dimatikan secara independen satu sama lain. Secara default, keduanya dihidupkan.
## Agregasi
*Agregasi* mengacu pada penyimpanan beberapa catatan dalam catatan Kinesis Data Streams. Agregasi memungkinkan pelanggan untuk meningkatkan jumlah catatan yang dikirim per panggilan API, yang secara efektif meningkatkan throughput produsen.
Pecahan Kinesis Data Streams mendukung hingga 1.000 rekaman Kinesis Data Streams per detik, atau throughput 1 MB. Catatan Kinesis Data Streams per detik mengikat pelanggan dengan catatan yang lebih kecil dari 1 KB. Agregasi rekaman memungkinkan pelanggan untuk menggabungkan beberapa catatan ke dalam satu catatan Kinesis Data Streams. Hal ini memungkinkan pelanggan untuk meningkatkan throughput per shard mereka.
Pertimbangkan kasus satu pecahan di Wilayah us-east-1 yang saat ini berjalan pada tingkat konstan 1.000 catatan per detik, dengan catatan yang masing-masing 512 byte. Dengan agregasi KPL, Anda dapat mengemas 1.000 catatan hanya ke dalam 10 catatan Kinesis Data Streams, mengurangi RPS menjadi 10 (masing-masing 50 KB).
## Koleksi
*Collection* mengacu pada pengelompokan beberapa data Kinesis Data Streams dan mengirimkannya dalam satu permintaan HTTP dengan panggilan ke `PutRecords` operasi API, alih-alih mengirim setiap catatan Kinesis Data Streams dalam permintaan HTTP-nya sendiri.
Ini meningkatkan throughput dibandingkan dengan tidak menggunakan koleksi karena mengurangi overhead membuat banyak permintaan HTTP terpisah. Bahkan, `PutRecords` dirinya sendiri dirancang khusus untuk tujuan ini.
Koleksi berbeda dari agregasi karena bekerja dengan kelompok catatan Kinesis Data Streams. Rekaman Kinesis Data Streams yang dikumpulkan masih dapat berisi beberapa catatan dari pengguna. Hubungan tersebut dapat divisualisasikan seperti:
```
record 0 --|
record 1 | [ Aggregation ]
... |--> Amazon Kinesis record 0 --|
... | |
record A --| |
|
... ... |
|
record K --| |
record L | | [ Collection ]
... |--> Amazon Kinesis record C --|--> PutRecords Request
... | |
record S --| |
|
... ... |
|
record AA--| |
record BB | |
... |--> Amazon Kinesis record M --|
... |
record ZZ--|
```
# Integrasikan KPL dengan kode produsen
Amazon Kinesis Producer Library (KPL) berjalan dalam proses terpisah, dan berkomunikasi dengan proses pengguna induk Anda menggunakan IPC. Arsitektur ini kadang-kadang disebut [microservice](http://en.wikipedia.org/wiki/Microservices), dan dipilih karena dua alasan utama:
**1) Proses pengguna Anda tidak akan macet bahkan jika KPL mogok**
Proses Anda dapat memiliki tugas yang tidak terkait dengan Kinesis Data Streams, dan mungkin dapat melanjutkan operasi bahkan jika KPL mogok. Dimungkinkan juga bagi proses pengguna induk Anda untuk memulai ulang KPL dan memulihkan ke keadaan berfungsi penuh (fungsi ini ada di pembungkus resmi).
Contohnya adalah server web yang mengirimkan metrik ke Kinesis Data Streams; server dapat terus melayani halaman bahkan jika bagian Kinesis Data Streams telah berhenti bekerja. Merusak seluruh server karena bug di KPL akan menyebabkan pemadaman yang tidak perlu.
**2) Klien arbitrer dapat didukung**
Selalu ada pelanggan yang menggunakan bahasa selain yang didukung secara resmi. Pelanggan ini juga harus dapat menggunakan KPL dengan mudah.
## Matriks penggunaan yang disarankan
Matriks penggunaan berikut mencantumkan pengaturan yang disarankan untuk pengguna yang berbeda dan memberi tahu Anda tentang apakah dan bagaimana Anda harus menggunakan KPL. Perlu diingat bahwa jika agregasi diaktifkan, de-agregasi juga harus digunakan untuk mengekstrak catatan Anda di sisi konsumen.
| Bahasa sampingan produser | Bahasa sisi konsumen | Versi KCL | Logika titik pemeriksaan | Bisakah Anda menggunakan KPL? | Peringatan |
| --- | --- | --- | --- | --- | --- |
| Apa pun kecuali Java | \$1 | \$1 | \$1 | Tidak | N/A |
| Java | Java | Menggunakan Java SDK secara langsung | N/A | Ya | Jika agregasi digunakan, Anda harus menggunakan pustaka de-agregasi yang disediakan setelah panggilan. GetRecords |
| Java | Apa pun kecuali Java | Menggunakan SDK secara langsung | N/A | Ya | Harus menonaktifkan agregasi. |
| Java | Java | 1.3.x | N/A | Ya | Harus menonaktifkan agregasi. |
| Java | Java | 1.4.x | Panggilan pos pemeriksaan tanpa argumen | Ya | Tidak ada |
| Java | Java | 1.4.x | Memanggil pos pemeriksaan dengan nomor urut eksplisit | Ya | Nonaktifkan agregasi, atau ubah kode untuk menggunakan nomor urutan yang diperluas untuk pos pemeriksaan. |
| Java | Apa pun kecuali Java | 1.3.x\$1daemon multibahasa\$1pembungkus khusus bahasa | N/A | Ya | Harus menonaktifkan agregasi. |
# Menulis ke aliran data Kinesis Anda menggunakan KPL
Bagian berikut menunjukkan kode sampel dalam perkembangan dari produsen paling dasar ke kode asinkron sepenuhnya.
## Kode produsen Barebones
Kode berikut adalah semua yang diperlukan untuk menulis produsen kerja minimal. Catatan pengguna Amazon Kinesis Producer Library (KPL) diproses di latar belakang.
```
// KinesisProducer gets credentials automatically like
// DefaultAWSCredentialsProviderChain.
// It also gets region automatically from the EC2 metadata service.
KinesisProducer kinesis = new KinesisProducer();
// Put some records
for (int i = 0; i < 100; ++i) {
ByteBuffer data = ByteBuffer.wrap("myData".getBytes("UTF-8"));
// doesn't block
kinesis.addUserRecord("myStream", "myPartitionKey", data);
}
// Do other stuff ...
```
## Menanggapi hasil secara sinkron
Pada contoh sebelumnya, kode tidak memeriksa apakah catatan pengguna KPL berhasil. KPL melakukan percobaan ulang yang diperlukan untuk memperhitungkan kegagalan. Tetapi jika Anda ingin memeriksa hasilnya, Anda dapat memeriksanya menggunakan `Future` objek yang dikembalikan`addUserRecord`, seperti pada contoh berikut (contoh sebelumnya ditampilkan untuk konteks):
```
KinesisProducer kinesis = new KinesisProducer();
// Put some records and save the Futures
List> putFutures = new LinkedList>();
for (int i = 0; i < 100; i++) {
ByteBuffer data = ByteBuffer.wrap("myData".getBytes("UTF-8"));
// doesn't block
putFutures.add(
kinesis.addUserRecord("myStream", "myPartitionKey", data));
}
// Wait for puts to finish and check the results
for (Future f : putFutures) {
UserRecordResult result = f.get(); // this does block
if (result.isSuccessful()) {
System.out.println("Put record into shard " +
result.getShardId());
} else {
for (Attempt attempt : result.getAttempts()) {
// Analyze and respond to the failure
}
}
}
```
## Menanggapi hasil secara asinkron
Contoh sebelumnya adalah memanggil `get()` `Future` objek, yang memblokir runtime. Jika Anda tidak ingin memblokir runtime, Anda dapat menggunakan callback asinkron, seperti yang ditunjukkan pada contoh berikut:
```
KinesisProducer kinesis = new KinesisProducer();
FutureCallback myCallback = new FutureCallback() {
@Override public void onFailure(Throwable t) {
/* Analyze and respond to the failure */
};
@Override public void onSuccess(UserRecordResult result) {
/* Respond to the success */
};
};
for (int i = 0; i < 100; ++i) {
ByteBuffer data = ByteBuffer.wrap("myData".getBytes("UTF-8"));
ListenableFuture f = kinesis.addUserRecord("myStream", "myPartitionKey", data);
// If the Future is complete by the time we call addCallback, the callback will be invoked immediately.
Futures.addCallback(f, myCallback);
}
```
# Konfigurasikan Perpustakaan Produsen Amazon Kinesis
Meskipun pengaturan default harus berfungsi dengan baik untuk sebagian besar kasus penggunaan, Anda mungkin ingin mengubah beberapa pengaturan default untuk menyesuaikan perilaku dengan `KinesisProducer` kebutuhan Anda. Sebuah instance dari `KinesisProducerConfiguration` kelas dapat diteruskan ke `KinesisProducer` konstruktor untuk melakukannya, misalnya:
```
KinesisProducerConfiguration config = new KinesisProducerConfiguration()
.setRecordMaxBufferedTime(3000)
.setMaxConnections(1)
.setRequestTimeout(60000)
.setRegion("us-west-1");
final KinesisProducer kinesisProducer = new KinesisProducer(config);
```
Anda juga dapat memuat konfigurasi dari file properti:
```
KinesisProducerConfiguration config = KinesisProducerConfiguration.fromPropertiesFile("default_config.properties");
```
Anda dapat mengganti jalur dan nama file apa pun yang dapat diakses oleh proses pengguna. Anda juga dapat memanggil metode set pada `KinesisProducerConfiguration` instance yang dibuat dengan cara ini untuk menyesuaikan konfigurasi.
File properti harus menentukan parameter menggunakan nama mereka di PascalCase. Nama-nama cocok dengan yang digunakan dalam metode set di `KinesisProducerConfiguration` kelas. Contoh:
```
RecordMaxBufferedTime = 100
MaxConnections = 4
RequestTimeout = 6000
Region = us-west-1
```
Untuk informasi selengkapnya tentang aturan penggunaan parameter konfigurasi dan batas nilai, lihat [contoh berkas properti konfigurasi GitHub](https://github.com/awslabs/amazon-kinesis-producer/blob/master/java/amazon-kinesis-producer-sample/default_config.properties).
Perhatikan bahwa setelah `KinesisProducer` diinisialisasi, mengubah `KinesisProducerConfiguration` instance yang digunakan tidak memiliki efek lebih lanjut. `KinesisProducer`saat ini tidak mendukung konfigurasi ulang dinamis.
# Menerapkan de-agregasi konsumen
Dimulai dengan rilis 1.4.0, KCL mendukung de-agregasi otomatis catatan pengguna KPL. Kode aplikasi konsumen yang ditulis dengan versi KCL sebelumnya akan dikompilasi tanpa modifikasi apa pun setelah Anda memperbarui KCL. Namun, jika agregasi KPL digunakan di sisi produsen, ada kehalusan yang melibatkan checkpointing: semua subrecord dalam catatan agregat memiliki nomor urut yang sama, sehingga data tambahan harus disimpan dengan pos pemeriksaan jika Anda perlu membedakan antara subrecord. Data tambahan ini disebut sebagai *nomor urutan*.
**Topics**
+ [Migrasi dari versi KCL sebelumnya](#kinesis-kpl-consumer-deaggregation-migration)
+ [Gunakan ekstensi KCL untuk de-agregasi KPL](#kinesis-kpl-consumer-deaggregation-extensions)
+ [Gunakan GetRecords secara langsung](#kinesis-kpl-consumer-deaggregation-getrecords)
## Migrasi dari versi KCL sebelumnya
Anda tidak diharuskan mengubah panggilan yang ada untuk melakukan checkpointing dengan agregasi. Masih dijamin bahwa Anda dapat mengambil semua catatan yang berhasil disimpan di Kinesis Data Streams. KCL sekarang menyediakan dua operasi pos pemeriksaan baru untuk mendukung kasus penggunaan tertentu, dijelaskan berikut.
Jika kode Anda yang ada ditulis untuk KCL sebelum dukungan KPL, dan operasi pos pemeriksaan Anda dipanggil tanpa argumen, itu setara dengan memeriksa nomor urut catatan pengguna KPL terakhir dalam batch. Jika operasi pos pemeriksaan Anda dipanggil dengan string nomor urut, itu setara dengan pemeriksaan nomor urut yang diberikan dari batch bersama dengan nomor urutan implisit 0 (nol).
Memanggil operasi pos pemeriksaan KCL baru `checkpoint()` tanpa argumen apa pun secara semantik setara dengan pemeriksaan nomor urut `Record` panggilan terakhir dalam batch, bersama dengan nomor urutan implisit 0 (nol).
Memanggil operasi pos pemeriksaan KCL baru `checkpoint(Record record)` secara semantik setara dengan pemeriksaan nomor urut yang diberikan `Record` bersama dengan nomor urutan implisit 0 (nol). Jika `Record` panggilan sebenarnya a`UserRecord`, nomor `UserRecord` urut dan nomor urutan diperiksa.
Memanggil operasi pos pemeriksaan KCL baru `checkpoint(String sequenceNumber, long subSequenceNumber)` secara eksplisit memeriksa nomor urut yang diberikan bersama dengan nomor urutan yang diberikan.
Dalam salah satu kasus ini, setelah pos pemeriksaan disimpan di tabel pos pemeriksaan Amazon DynamoDB, KCL dapat melanjutkan pengambilan catatan dengan benar bahkan ketika aplikasi mogok dan restart. Jika lebih banyak catatan terkandung dalam urutan, pengambilan terjadi dimulai dengan catatan nomor urutan berikutnya dalam catatan dengan nomor urut yang terakhir diperiksa. Jika pos pemeriksaan terbaru menyertakan nomor urutan terakhir dari catatan nomor urut sebelumnya, pengambilan terjadi dimulai dengan catatan dengan nomor urut berikutnya.
Bagian selanjutnya membahas rincian urutan dan urutan checkpointing untuk konsumen yang harus menghindari melewatkan dan duplikasi catatan. Jika melewatkan (atau duplikasi) catatan saat menghentikan dan memulai ulang pemrosesan catatan konsumen Anda tidak penting, Anda dapat menjalankan kode yang ada tanpa modifikasi.
## Gunakan ekstensi KCL untuk de-agregasi KPL
De-agregasi KPL dapat melibatkan checkpointing berikutnya. Untuk memfasilitasi penggunaan checkpointing berikutnya, sebuah `UserRecord` kelas telah ditambahkan ke KCL:
```
public class UserRecord extends Record {
public long getSubSequenceNumber() {
/* ... */
}
@Override
public int hashCode() {
/* contract-satisfying implementation */
}
@Override
public boolean equals(Object obj) {
/* contract-satisfying implementation */
}
}
```
Kelas ini sekarang digunakan sebagai pengganti`Record`. Ini tidak merusak kode yang ada karena merupakan subkelas dari. `Record` `UserRecord`Kelas mewakili subrecord aktual dan standar, catatan non-agregat. Catatan non-agregat dapat dianggap sebagai catatan agregat dengan tepat satu subrecord.
Selain itu, dua operasi baru ditambahkan ke`IRecordProcessorCheckpointer`:
```
public void checkpoint(Record record);
public void checkpoint(String sequenceNumber, long subSequenceNumber);
```
Untuk mulai menggunakan checkpointing nomor urutan, Anda dapat melakukan konversi berikut. Ubah kode formulir berikut:
```
checkpointer.checkpoint(record.getSequenceNumber());
```
Kode formulir baru:
```
checkpointer.checkpoint(record);
```
Kami menyarankan Anda menggunakan `checkpoint(Record record)` formulir untuk checkpointing berikutnya. Namun, jika Anda sudah menyimpan `sequenceNumbers` dalam string untuk digunakan untuk checkpointing, Anda sekarang juga harus menyimpan`subSequenceNumber`, seperti yang ditunjukkan pada contoh berikut:
```
String sequenceNumber = record.getSequenceNumber();
long subSequenceNumber = ((UserRecord) record).getSubSequenceNumber(); // ... do other processing
checkpointer.checkpoint(sequenceNumber, subSequenceNumber);
```
Pemeran dari `Record` untuk `UserRecord` selalu berhasil karena implementasinya selalu menggunakan`UserRecord`. Kecuali ada kebutuhan untuk melakukan aritmatika pada nomor urut, pendekatan ini tidak disarankan.
Saat memproses catatan pengguna KPL, KCL menulis nomor urutan ke Amazon DynamoDB sebagai bidang tambahan untuk setiap baris. Versi KCL sebelumnya digunakan `AFTER_SEQUENCE_NUMBER` untuk mengambil catatan saat melanjutkan pos pemeriksaan. KCL saat ini dengan dukungan KPL menggunakan `AT_SEQUENCE_NUMBER` sebagai gantinya. Ketika catatan pada nomor urut yang diperiksa diambil, nomor urutan yang diperiksa diperiksa, dan subrecord dijatuhkan sebagaimana mestinya (yang mungkin semuanya, jika subrecord terakhir adalah yang diperiksa). Sekali lagi, catatan non-agregat dapat dianggap sebagai catatan agregat dengan satu subrecord, sehingga algoritma yang sama berfungsi untuk catatan agregat dan non-agregat.
## Gunakan GetRecords secara langsung
Anda juga dapat memilih untuk tidak menggunakan KCL tetapi menjalankan operasi API `GetRecords` secara langsung untuk mengambil catatan Kinesis Data Streams. Untuk membongkar catatan yang diambil ini ke dalam catatan pengguna KPL asli Anda, panggil salah satu operasi statis berikut di: `UserRecord.java`
```
public static List deaggregate(List records)
public static List deaggregate(List records, BigInteger startingHashKey, BigInteger endingHashKey)
```
Operasi pertama menggunakan nilai default `0` (nol) untuk `startingHashKey` dan nilai default `2^128 -1` untuk`endingHashKey`.
Masing-masing operasi ini melakukan de-agregasi daftar catatan Kinesis Data Streams yang diberikan ke dalam daftar catatan pengguna KPL. Setiap catatan pengguna KPL yang kunci hash eksplisit atau kunci partisi berada di luar jangkauan `startingHashKey` (inklusif) dan `endingHashKey` (inklusif) dibuang dari daftar catatan yang dikembalikan.
# Gunakan KPL dengan Amazon Data Firehose
Jika Anda menggunakan Kinesis Producer Library (KPL) untuk menulis data ke aliran data Kinesis, Anda dapat menggunakan agregasi untuk menggabungkan catatan yang Anda tulis ke aliran data Kinesis tersebut. Jika Anda kemudian menggunakan aliran data tersebut sebagai sumber untuk aliran pengiriman Firehose Anda, Firehose menghapus agregasi catatan sebelum mengirimkannya ke tujuan. Jika Anda mengonfigurasi aliran pengiriman untuk mengubah data, Firehose menghapus agregasi catatan sebelum mengirimkannya. AWS Lambda Untuk informasi selengkapnya, lihat [Menulis ke Amazon Firehose Menggunakan Kinesis Data Streams](https://docs.aws.amazon.com/firehose/latest/dev/writing-with-kinesis-streams.html).
# Gunakan KPL dengan AWS Glue Schema Registry
Anda dapat mengintegrasikan aliran data Kinesis Anda dengan Registri Skema. AWS Glue Registri AWS Glue Skema memungkinkan Anda untuk menemukan, mengontrol, dan mengembangkan skema secara terpusat, sambil memastikan data yang dihasilkan terus divalidasi oleh skema terdaftar. Sebuah skema mendefinisikan struktur dan format catatan data. Sebuah skema adalah sebuah spesifikasi berversi untuk publikasi data yang handal, konsumsi, atau penyimpanan. Registri AWS Glue Skema memungkinkan Anda untuk meningkatkan kualitas end-to-end data dan tata kelola data dalam aplikasi streaming Anda. Untuk informasi selengkapnya, lihat [AWS Glue Schema Registry](https://docs.aws.amazon.com/glue/latest/dg/schema-registry.html). Salah satu cara untuk mengatur integrasi ini adalah melalui perpustakaan KPL dan Kinesis Client Library (KCL) di Jawa.
**penting**
Saat ini, Kinesis Data AWS Glue Streams dan integrasi registri skema hanya didukung untuk aliran data Kinesis yang menggunakan produsen KPL yang diimplementasikan di Jawa. Support multi-bahasa tidak tersedia.
Untuk petunjuk terperinci tentang cara mengatur integrasi Kinesis Data Streams dengan Schema Registry menggunakan KPL, lihat [bagian “Berinteraksi dengan Data Menggunakan Pustaka” di Kasus KPL/KCL Penggunaan: Mengintegrasikan Amazon Kinesis Data Streams](https://docs.aws.amazon.com/glue/latest/dg/schema-registry-integrations.html#schema-registry-integrations-kds) dengan Glue Schema Registry. AWS
# Konfigurasikan konfigurasi proxy KPL
Untuk aplikasi yang tidak dapat terhubung langsung ke internet, semua klien AWS SDK mendukung penggunaan proxy HTTP atau HTTPS. Dalam lingkungan perusahaan yang khas, semua lalu lintas jaringan keluar harus melalui server proxy. Jika aplikasi Anda menggunakan Kinesis Producer Library (KPL) untuk mengumpulkan dan mengirim data ke AWS lingkungan yang menggunakan server proxy, aplikasi Anda akan memerlukan konfigurasi proxy KPL. KPL adalah perpustakaan tingkat tinggi yang dibangun di atas AWS Kinesis SDK. Ini dibagi menjadi proses asli dan pembungkus. Proses asli melakukan semua pekerjaan pemrosesan dan pengiriman catatan, sementara pembungkus mengelola proses asli dan berkomunikasi dengannya. Untuk informasi selengkapnya, lihat [Menerapkan Produsen yang Efisien dan Andal dengan Perpustakaan Produsen Amazon Kinesis](https://aws.amazon.com/blogs/big-data/implementing-efficient-and-reliable-producers-with-the-amazon-kinesis-producer-library/).
Pembungkus ditulis dalam Java dan proses asli ditulis dalam C \$1\$1 dengan menggunakan Kinesis SDK. KPL versi 0.14.7 dan yang lebih tinggi sekarang mendukung konfigurasi proxy di pembungkus Java yang dapat meneruskan semua konfigurasi proxy ke proses asli. Untuk informasi lebih lanjut, lihat [https://github.com/awslabs/amazon-kinesis-producer/releases/tag/v0.14.7](https://github.com/awslabs/amazon-kinesis-producer/releases/tag/v0.14.7).
Anda dapat menggunakan kode berikut untuk menambahkan konfigurasi proxy ke aplikasi KPL Anda.
```
KinesisProducerConfiguration configuration = new KinesisProducerConfiguration();
// Next 4 lines used to configure proxy
configuration.setProxyHost("10.0.0.0"); // required
configuration.setProxyPort(3128); // default port is set to 443
configuration.setProxyUserName("username"); // no default
configuration.setProxyPassword("password"); // no default
KinesisProducer kinesisProducer = new KinesisProducer(configuration);
```
# Kebijakan siklus hidup versi KPL
Topik ini menguraikan kebijakan siklus hidup versi untuk Amazon Kinesis Producer Library (KPL). AWS secara teratur menyediakan rilis baru untuk versi KPL untuk mendukung fitur dan penyempurnaan baru, perbaikan bug, patch keamanan, dan pembaruan ketergantungan. Kami menyarankan Anda tetap up-to-date menggunakan versi KPL untuk mengikuti fitur-fitur terbaru, pembaruan keamanan, dan dependensi yang mendasarinya. Kami **tidak** menyarankan untuk terus menggunakan versi KPL yang tidak didukung.
Siklus hidup untuk versi KPL utama terdiri dari tiga fase berikut:
+ **Ketersediaan umum (GA)** — Selama fase ini, versi utama didukung sepenuhnya. AWS menyediakan rilis versi minor dan patch reguler yang mencakup dukungan untuk fitur baru atau pembaruan API untuk Kinesis Data Streams, serta perbaikan bug dan keamanan.
+ **Mode pemeliharaan** — AWS membatasi rilis versi patch untuk mengatasi perbaikan bug kritis dan masalah keamanan saja. Versi utama tidak akan menerima pembaruan untuk fitur baru atau APIs Kinesis Data Streams.
+ **E nd-of-support** — Versi utama tidak akan lagi menerima pembaruan atau rilis. Rilis yang diterbitkan sebelumnya akan terus tersedia melalui manajer paket publik dan kode akan tetap aktif GitHub. Penggunaan versi yang telah end-of-support dicapai dilakukan atas kebijaksanaan pengguna. Kami menyarankan Anda meningkatkan ke versi utama terbaru.
| Versi utama | Fase saat ini | Tanggal rilis | Tanggal mode pemeliharaan | End-of-support tanggal |
| --- | --- | --- | --- | --- |
| KPL 0.x | Mode pemeliharaan | 2015-06-02 | 2025-04-17 | 2026-01-30 |
| KPL 1.x | Ketersediaan umum | 2024-12-15 | -- | -- |