Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Reshard aliran
**penting**
Anda dapat mengubah streaming Anda menggunakan API. [UpdateShardCount](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_UpdateShardCount.html) Jika tidak, Anda dapat terus melakukan pemisahan dan penggabungan seperti yang dijelaskan di sini.
Amazon Kinesis Data *Streams* mendukung resharding, yang memungkinkan Anda menyesuaikan jumlah pecahan dalam aliran Anda untuk beradaptasi dengan perubahan laju aliran data melalui aliran. Resharding dianggap sebagai operasi lanjutan. Jika Anda baru mengenal Kinesis Data Streams, kembali ke subjek ini setelah Anda terbiasa dengan semua aspek lain dari Kinesis Data Streams.
Ada dua jenis operasi resharding: shard split dan shard merge. Dalam pecahan pecahan, Anda membagi satu pecahan menjadi dua pecahan. Dalam penggabungan pecahan, Anda menggabungkan dua pecahan menjadi satu pecahan. Resharding selalu *berpasangan* dalam arti bahwa Anda tidak dapat membagi menjadi lebih dari dua pecahan dalam satu operasi, dan Anda tidak dapat menggabungkan lebih dari dua pecahan dalam satu operasi. *Pecahan atau sepasang pecahan tempat operasi resharding bekerja disebut sebagai pecahan induk.* *Pecahan atau sepasang pecahan yang dihasilkan dari operasi resharding disebut sebagai pecahan anak.*
Pemisahan meningkatkan jumlah pecahan dalam aliran Anda dan karenanya meningkatkan kapasitas data aliran. Karena Anda dikenakan biaya per shard, pemisahan meningkatkan biaya streaming Anda. Demikian pula, penggabungan mengurangi jumlah pecahan dalam aliran Anda dan karenanya mengurangi kapasitas data—dan biaya—aliran.
Resharding biasanya dilakukan oleh aplikasi administratif yang berbeda dari aplikasi produsen (put) dan aplikasi konsumen (get). Aplikasi administratif semacam itu memantau kinerja keseluruhan aliran berdasarkan metrik yang disediakan oleh Amazon CloudWatch atau berdasarkan metrik yang dikumpulkan dari produsen dan konsumen. Aplikasi administratif juga membutuhkan seperangkat izin IAM yang lebih luas daripada konsumen atau produsen karena konsumen dan produsen biasanya tidak memerlukan akses ke yang APIs digunakan untuk resharding. Untuk informasi selengkapnya tentang izin IAM untuk Kinesis Data Streams, lihat. [Mengontrol akses ke sumber daya Amazon Kinesis Data Streams menggunakan IAM](controlling-access.md)
Untuk informasi selengkapnya tentang resharding, lihat [Bagaimana cara mengubah jumlah pecahan terbuka di Kinesis Data Streams](https://aws.amazon.com/premiumsupport/knowledge-center/kinesis-data-streams-open-shards/)?
**Topics**
+ [
# Tentukan strategi untuk resharding
](kinesis-using-sdk-java-resharding-strategies.md)
+ [
# Pisahkan pecahan
](kinesis-using-sdk-java-resharding-split.md)
+ [
# Gabungkan dua pecahan
](kinesis-using-sdk-java-resharding-merge.md)
+ [
# Selesaikan tindakan resharding
](kinesis-using-sdk-java-after-resharding.md)
# Tentukan strategi untuk resharding
Tujuan resharding di Amazon Kinesis Data Streams adalah untuk memungkinkan streaming Anda beradaptasi dengan perubahan laju aliran data. Anda membagi pecahan untuk meningkatkan kapasitas (dan biaya) aliran Anda. Anda menggabungkan pecahan untuk mengurangi biaya (dan kapasitas) aliran Anda.
Salah satu pendekatan untuk resharding adalah dengan membagi setiap pecahan di aliran—yang akan menggandakan kapasitas aliran. Namun, ini mungkin memberikan lebih banyak kapasitas tambahan daripada yang sebenarnya Anda butuhkan dan karenanya menghasilkan biaya yang tidak perlu.
Anda juga dapat menggunakan metrik untuk menentukan pecahan *panas* atau *dingin* Anda, yaitu pecahan yang menerima lebih banyak data, atau data yang jauh lebih sedikit, dari yang diharapkan. Anda kemudian dapat secara selektif membagi pecahan panas untuk meningkatkan kapasitas kunci hash yang menargetkan pecahan tersebut. Demikian pula, Anda dapat menggabungkan pecahan dingin untuk memanfaatkan kapasitas yang tidak terpakai dengan lebih baik.
Anda dapat memperoleh beberapa data performa untuk streaming Anda dari CloudWatch metrik Amazon yang diterbitkan oleh Kinesis Data Streams. Namun, Anda juga dapat mengumpulkan beberapa metrik Anda sendiri untuk aliran Anda. Salah satu pendekatannya adalah dengan mencatat nilai kunci hash yang dihasilkan oleh kunci partisi untuk catatan data Anda. Ingat bahwa Anda menentukan kunci partisi pada saat Anda menambahkan catatan ke aliran.
```
putRecordRequest.setPartitionKey( String.format( "myPartitionKey" ) );
```
Kinesis Data [MD5](http://en.wikipedia.org/wiki/MD5)Streams digunakan untuk menghitung kunci hash dari kunci partisi. Karena Anda menentukan kunci partisi untuk catatan, Anda dapat menggunakan MD5 untuk menghitung nilai kunci hash untuk catatan itu dan mencatatnya.
Anda juga bisa mencatat pecahan tempat catatan data Anda ditetapkan. IDs ID pecahan tersedia dengan menggunakan `getShardId` metode `putRecordResults` objek dikembalikan oleh `putRecords` metode, dan `putRecordResult` objek dikembalikan oleh `putRecord` metode.
```
String shardId = putRecordResult.getShardId();
```
Dengan shard IDs dan nilai kunci hash, Anda dapat menentukan pecahan dan kunci hash mana yang menerima lalu lintas paling banyak atau paling sedikit. Anda kemudian dapat menggunakan resharding untuk memberikan kapasitas yang lebih atau kurang, yang sesuai untuk kunci ini.
# Pisahkan pecahan
Untuk membagi pecahan di Amazon Kinesis Data Streams, Anda perlu menentukan bagaimana nilai kunci hash dari shard induk harus didistribusikan kembali ke pecahan turunan. Ketika Anda menambahkan catatan data ke aliran, itu ditetapkan ke pecahan berdasarkan nilai kunci hash. Nilai kunci hash adalah [MD5](http://en.wikipedia.org/wiki/MD5)hash dari kunci partisi yang Anda tentukan untuk catatan data pada saat Anda menambahkan catatan data ke aliran. Catatan data yang memiliki kunci partisi yang sama juga memiliki nilai kunci hash yang sama.
Nilai kunci hash yang mungkin untuk pecahan tertentu merupakan satu set bilangan bulat non-negatif berurutan yang bersebelahan. Rentang kemungkinan nilai kunci hash ini diberikan oleh yang berikut:
```
shard.getHashKeyRange().getStartingHashKey();
shard.getHashKeyRange().getEndingHashKey();
```
Saat Anda membagi pecahan, Anda menentukan nilai dalam rentang ini. Nilai kunci hash dan semua nilai kunci hash yang lebih tinggi didistribusikan ke salah satu pecahan anak. Semua nilai kunci hash yang lebih rendah didistribusikan ke pecahan anak lainnya.
Kode berikut menunjukkan operasi pecahan pecahan yang mendistribusikan kembali kunci hash secara merata di antara masing-masing pecahan anak, pada dasarnya membelah pecahan induk menjadi dua. Ini hanyalah salah satu cara yang mungkin untuk membagi pecahan induk. Anda dapat, misalnya, membagi pecahan sehingga sepertiga bagian bawah kunci dari orang tua pergi ke satu pecahan anak dan dua pertiga bagian atas kunci pergi ke pecahan anak lainnya. Namun, untuk banyak aplikasi, membelah pecahan menjadi dua adalah pendekatan yang efektif.
Kode mengasumsikan bahwa `myStreamName` memegang nama aliran Anda dan variabel objek `shard` menahan pecahan untuk dipecah. Mulailah dengan membuat instance `splitShardRequest` objek baru dan mengatur nama aliran dan ID shard.
```
SplitShardRequest splitShardRequest = new SplitShardRequest();
splitShardRequest.setStreamName(myStreamName);
splitShardRequest.setShardToSplit(shard.getShardId());
```
Tentukan nilai kunci hash yang berada di tengah-tengah antara nilai terendah dan tertinggi dalam pecahan. Ini adalah nilai kunci hash awal untuk pecahan anak yang akan berisi bagian atas kunci hash dari pecahan induk. Tentukan nilai ini dalam `setNewStartingHashKey` metode. Anda hanya perlu tentukan nilai ini. Kinesis Data Streams secara otomatis mendistribusikan kunci hash di bawah nilai ini ke pecahan anak lain yang dibuat oleh split. Langkah terakhir adalah memanggil `splitShard` metode pada klien Kinesis Data Streams.
```
BigInteger startingHashKey = new BigInteger(shard.getHashKeyRange().getStartingHashKey());
BigInteger endingHashKey = new BigInteger(shard.getHashKeyRange().getEndingHashKey());
String newStartingHashKey = startingHashKey.add(endingHashKey).divide(new BigInteger("2")).toString();
splitShardRequest.setNewStartingHashKey(newStartingHashKey);
client.splitShard(splitShardRequest);
```
Langkah pertama setelah prosedur ini ditunjukkan di[Tunggu streaming menjadi aktif kembali](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-wait-until-active).
# Gabungkan dua pecahan
Operasi penggabungan shard membutuhkan dua pecahan tertentu dan menggabungkannya menjadi satu pecahan. Setelah penggabungan, pecahan anak tunggal menerima data untuk semua nilai kunci hash yang dicakup oleh dua pecahan induk.
**Ketinggian Shard**
*Untuk menggabungkan dua pecahan, pecahan harus berdekatan.* Dua pecahan dianggap berdekatan jika penyatuan rentang kunci hash untuk dua pecahan membentuk satu set yang berdekatan tanpa celah. Misalnya, Anda memiliki dua pecahan, satu dengan rentang kunci hash 276... 381 dan yang lainnya dengan rentang kunci hash 382... 454. Anda dapat menggabungkan dua pecahan ini menjadi pecahan tunggal yang akan memiliki rentang kunci hash 276... 454.
Untuk mengambil contoh lain, misalkan Anda memiliki dua pecahan, satu dengan rentang kunci hash 276.. 381 dan yang lainnya dengan rentang kunci hash 455... 560. Anda tidak dapat menggabungkan dua pecahan ini karena akan ada satu atau lebih pecahan di antara keduanya yang mencakup kisaran 382.. 454.
Himpunan semua `OPEN` pecahan dalam aliran — sebagai grup — selalu mencakup seluruh rentang nilai kunci hash. MD5 Untuk informasi lebih lanjut tentang status pecahan — seperti —lihat. `CLOSED` [Pertimbangkan perutean data, persistensi data, dan status pecahan setelah reshard](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-data-routing)
Untuk mengidentifikasi pecahan yang merupakan kandidat untuk digabungkan, Anda harus menyaring semua pecahan yang berada dalam keadaan. `CLOSED` Pecahan yang `OPEN` —yaitu, bukan `CLOSED` —memiliki nomor urut akhir. `null` Anda dapat menguji nomor urut akhir untuk pecahan menggunakan:
```
if( null == shard.getSequenceNumberRange().getEndingSequenceNumber() )
{
// Shard is OPEN, so it is a possible candidate to be merged.
}
```
Setelah memfilter pecahan tertutup, urutkan pecahan yang tersisa dengan nilai kunci hash tertinggi yang didukung oleh setiap pecahan. Anda dapat mengambil nilai ini menggunakan:
```
shard.getHashKeyRange().getEndingHashKey();
```
Jika dua pecahan berdekatan dalam daftar yang difilter dan diurutkan ini, mereka dapat digabungkan.
**Kode untuk Operasi Gabungan**
Kode berikut menggabungkan dua pecahan. Kode mengasumsikan bahwa `myStreamName` memegang nama aliran Anda dan variabel objek `shard1` dan `shard2` menahan dua pecahan yang berdekatan untuk digabungkan.
Untuk operasi penggabungan, mulailah dengan membuat instance objek baru. `mergeShardsRequest` Tentukan nama aliran dengan `setStreamName` metode. Kemudian tentukan dua pecahan untuk digabungkan menggunakan metode `setShardToMerge` and`setAdjacentShardToMerge`. Terakhir, panggil `mergeShards` metode pada klien Kinesis Data Streams untuk melakukan operasi.
```
MergeShardsRequest mergeShardsRequest = new MergeShardsRequest();
mergeShardsRequest.setStreamName(myStreamName);
mergeShardsRequest.setShardToMerge(shard1.getShardId());
mergeShardsRequest.setAdjacentShardToMerge(shard2.getShardId());
client.mergeShards(mergeShardsRequest);
```
Langkah pertama setelah prosedur ini ditunjukkan di[Tunggu streaming menjadi aktif kembali](kinesis-using-sdk-java-after-resharding.md#kinesis-using-sdk-java-resharding-wait-until-active).
# Selesaikan tindakan resharding
Setelah segala jenis prosedur resharding di Amazon Kinesis Data Streams, dan sebelum pemrosesan rekaman normal dilanjutkan, prosedur dan pertimbangan lain diperlukan. Bagian berikut menjelaskan ini.
**Topics**
+ [
## Tunggu streaming menjadi aktif kembali
](#kinesis-using-sdk-java-resharding-wait-until-active)
+ [
## Pertimbangkan perutean data, persistensi data, dan status pecahan setelah reshard
](#kinesis-using-sdk-java-resharding-data-routing)
## Tunggu streaming menjadi aktif kembali
Setelah Anda memanggil operasi resharding, salah satu `splitShard` atau`mergeShards`, Anda harus menunggu streaming menjadi aktif kembali. Kode yang digunakan sama seperti ketika Anda menunggu aliran menjadi aktif setelah [membuat aliran](kinesis-using-sdk-java-create-stream.md). Kode itu adalah sebagai berikut:
```
DescribeStreamRequest describeStreamRequest = new DescribeStreamRequest();
describeStreamRequest.setStreamName( myStreamName );
long startTime = System.currentTimeMillis();
long endTime = startTime + ( 10 * 60 * 1000 );
while ( System.currentTimeMillis() < endTime )
{
try {
Thread.sleep(20 * 1000);
}
catch ( Exception e ) {}
try {
DescribeStreamResult describeStreamResponse = client.describeStream( describeStreamRequest );
String streamStatus = describeStreamResponse.getStreamDescription().getStreamStatus();
if ( streamStatus.equals( "ACTIVE" ) ) {
break;
}
//
// sleep for one second
//
try {
Thread.sleep( 1000 );
}
catch ( Exception e ) {}
}
catch ( ResourceNotFoundException e ) {}
}
if ( System.currentTimeMillis() >= endTime )
{
throw new RuntimeException( "Stream " + myStreamName + " never went active" );
}
```
## Pertimbangkan perutean data, persistensi data, dan status pecahan setelah reshard
Kinesis Data Streams adalah layanan streaming data real-time. Aplikasi Anda harus berasumsi bahwa data mengalir terus menerus melalui pecahan di aliran Anda. Saat Anda melakukan reshard, catatan data yang mengalir ke pecahan induk dirutekan ulang untuk mengalir ke pecahan anak berdasarkan nilai kunci hash yang dipetakan oleh kunci partisi rekam data. Namun, catatan data apa pun yang ada di pecahan induk sebelum reshard tetap berada di pecahan tersebut. Pecahan induk tidak hilang saat reshard terjadi. Mereka bertahan bersama dengan data yang mereka isi sebelum reshard. Rekaman data dalam pecahan induk dapat diakses menggunakan [`getShardIterator`dan `getRecords`](developing-consumers-with-sdk.md#kinesis-using-sdk-java-get-data) operasi di Kinesis Data Streams API, atau melalui Perpustakaan Klien Kinesis.
**catatan**
Catatan data dapat diakses sejak ditambahkan ke aliran ke periode retensi saat ini. Ini berlaku terlepas dari perubahan apa pun pada pecahan dalam aliran selama periode waktu tersebut. Untuk informasi selengkapnya tentang periode retensi aliran, lihat[Ubah periode retensi data](kinesis-extended-retention.md).
Dalam proses resharding, pecahan induk bertransisi dari suatu `OPEN` keadaan ke keadaan ke negara `CLOSED` bagian. `EXPIRED`
+ **BUKA**: Sebelum operasi reshard, pecahan induk berada dalam `OPEN` status, yang berarti bahwa catatan data dapat ditambahkan ke pecahan dan diambil dari pecahan.
+ **DITUTUP**: Setelah operasi reshard, pecahan induk bertransisi ke status. `CLOSED` Ini berarti bahwa catatan data tidak lagi ditambahkan ke pecahan. Catatan data yang akan ditambahkan ke pecahan ini sekarang ditambahkan ke pecahan anak sebagai gantinya. Namun, catatan data masih dapat diambil dari pecahan untuk waktu yang terbatas.
+ **KEDALUWARSA**: Setelah periode retensi streaming kedaluwarsa, semua catatan data di pecahan induk telah kedaluwarsa dan tidak lagi dapat diakses. Pada titik ini, pecahan itu sendiri beralih ke suatu `EXPIRED` keadaan. Panggilan `getStreamDescription().getShards` untuk menghitung pecahan dalam aliran tidak termasuk pecahan dalam `EXPIRED` pecahan daftar yang dikembalikan. Untuk informasi selengkapnya tentang periode retensi aliran, lihat[Ubah periode retensi data](kinesis-extended-retention.md).
Setelah reshard terjadi dan aliran kembali dalam `ACTIVE` keadaan, Anda dapat segera mulai membaca data dari pecahan anak. Namun, pecahan induk yang tersisa setelah reshard mungkin masih berisi data yang belum Anda baca yang ditambahkan ke aliran sebelum reshard. Jika Anda membaca data dari pecahan anak sebelum membaca semua data dari pecahan induk, Anda dapat membaca data untuk kunci hash tertentu di luar urutan yang diberikan oleh nomor urut catatan data. Oleh karena itu, dengan asumsi bahwa urutan data itu penting, Anda harus, setelah reshard, selalu terus membaca data dari pecahan induk hingga habis. Hanya dengan begitu Anda harus mulai membaca data dari pecahan anak. Ketika `getRecordsResult.getNextShardIterator` kembali`null`, ini menunjukkan bahwa Anda telah membaca semua data di pecahan induk.