Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Gunakan AWS CLI untuk menjalankan operasi Amazon Kinesis Data Streams
Bagian ini menunjukkan cara menjalankan operasi Amazon Kinesis Data Streams dasar menggunakan. AWS Command Line Interface Anda akan mempelajari prinsip-prinsip aliran data Kinesis Data Streams dasar dan langkah-langkah yang diperlukan untuk menempatkan dan mendapatkan data dari aliran data Kinesis.
Jika Anda baru mengenal Kinesis Data Streams, mulailah dengan menjadi akrab dengan konsep dan terminologi yang disajikan dalam. [Terminologi dan konsep Amazon Kinesis Data Streams](key-concepts.md)
**Topics**
+ [Tutorial: Instal dan konfigurasikan AWS CLI untuk Kinesis Data Streams](kinesis-tutorial-cli-installation.md)
+ [Tutorial: Lakukan operasi Kinesis Data Streams dasar menggunakan AWS CLI](fundamental-stream.md)
Untuk akses CLI, Anda memerlukan ID kunci akses dan kunci akses rahasia. Gunakan kredensi sementara alih-alih kunci akses jangka panjang jika memungkinkan. Kredensi sementara mencakup ID kunci akses, kunci akses rahasia, dan token keamanan yang menunjukkan kapan kredensialnya kedaluwarsa. Untuk informasi selengkapnya, lihat [Menggunakan kredensial sementara dengan AWS sumber daya](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) di Panduan Pengguna *IAM*.
Anda dapat menemukan petunjuk step-by-step penyiapan IAM dan kunci keamanan terperinci di [Buat Pengguna IAM](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/get-set-up-for-amazon-ec2.html#create-an-iam-user).
Pada bagian ini, perintah spesifik yang dibahas diberikan kata demi kata, kecuali jika nilai spesifik tentu berbeda untuk setiap proses. Juga, contohnya menggunakan wilayah AS Barat (Oregon), tetapi langkah-langkah di bagian ini berfungsi di salah satu [wilayah di mana Kinesis Data](https://docs.aws.amazon.com/general/latest/gr/rande.html#ak_region) Streams didukung.
# Tutorial: Instal dan konfigurasikan AWS CLI untuk Kinesis Data Streams
## Instal AWS CLI
Untuk langkah-langkah rinci tentang cara menginstal untuk Windows dan AWS CLI untuk Linux, OS X, dan sistem operasi Unix, lihat [Menginstal AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html).
Gunakan perintah berikut untuk membuat daftar opsi dan layanan yang tersedia:
```
aws help
```
Anda akan menggunakan layanan Kinesis Data Streams, sehingga Anda dapat AWS CLI meninjau subperintah yang terkait dengan Kinesis Data Streams menggunakan perintah berikut:
```
aws kinesis help
```
Perintah ini menghasilkan output yang menyertakan perintah Kinesis Data Streams yang tersedia:
```
AVAILABLE COMMANDS
o add-tags-to-stream
o create-stream
o delete-stream
o describe-stream
o get-records
o get-shard-iterator
o help
o list-streams
o list-tags-for-stream
o merge-shards
o put-record
o put-records
o remove-tags-from-stream
o split-shard
o wait
```
Daftar perintah ini sesuai dengan API Kinesis Data Streams yang didokumentasikan dalam Referensi API [Amazon Kinesis Service](https://docs.aws.amazon.com/kinesis/latest/APIReference/). Misalnya, `create-stream` perintah sesuai dengan tindakan `CreateStream` API.
Sekarang berhasil diinstal, tetapi tidak dikonfigurasi. AWS CLI Ini ditunjukkan di bagian selanjutnya.
## Konfigurasikan AWS CLI
Untuk penggunaan umum, `aws configure` perintah adalah cara tercepat untuk mengatur AWS CLI instalasi Anda. Untuk informasi selengkapnya, lihat [Mengonfigurasi AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).
# Tutorial: Lakukan operasi Kinesis Data Streams dasar menggunakan AWS CLI
Bagian ini menjelaskan penggunaan dasar aliran data Kinesis dari baris perintah menggunakan file. AWS CLI Pastikan Anda terbiasa dengan konsep yang dibahas di[Terminologi dan konsep Amazon Kinesis Data Streams](key-concepts.md).
**catatan**
Setelah Anda membuat stream, akun Anda akan dikenakan biaya nominal untuk penggunaan Kinesis Data Streams karena Kinesis Data Streams tidak memenuhi syarat untuk Tingkat Gratis. AWS Setelah Anda selesai dengan tutorial ini, hapus AWS sumber daya Anda untuk menghentikan biaya. Untuk informasi selengkapnya, lihat [Langkah 4: Membersihkan](#clean-up).
**Topics**
+ [Langkah 1: Buat aliran](#create-stream)
+ [Langkah 2: Letakkan catatan](#put-record)
+ [Langkah 3: Dapatkan catatan](#get-records)
+ [Langkah 4: Membersihkan](#clean-up)
## Langkah 1: Buat aliran
Langkah pertama Anda adalah membuat aliran dan memverifikasi bahwa itu berhasil dibuat. Gunakan perintah berikut untuk membuat aliran bernama “Foo”:
```
aws kinesis create-stream --stream-name Foo
```
Selanjutnya, keluarkan perintah berikut untuk memeriksa kemajuan pembuatan stream:
```
aws kinesis describe-stream-summary --stream-name Foo
```
Anda harus mendapatkan output yang mirip dengan contoh berikut:
```
{
"StreamDescriptionSummary": {
"StreamName": "Foo",
"StreamARN": "arn:aws:kinesis:us-west-2:123456789012:stream/Foo",
"StreamStatus": "CREATING",
"RetentionPeriodHours": 48,
"StreamCreationTimestamp": 1572297168.0,
"EnhancedMonitoring": [
{
"ShardLevelMetrics": []
}
],
"EncryptionType": "NONE",
"OpenShardCount": 3,
"ConsumerCount": 0
}
}
```
Dalam contoh ini, aliran memiliki status CREATING, yang berarti belum siap digunakan. Periksa lagi dalam beberapa saat, dan Anda akan melihat output yang mirip dengan contoh berikut:
```
{
"StreamDescriptionSummary": {
"StreamName": "Foo",
"StreamARN": "arn:aws:kinesis:us-west-2:123456789012:stream/Foo",
"StreamStatus": "ACTIVE",
"RetentionPeriodHours": 48,
"StreamCreationTimestamp": 1572297168.0,
"EnhancedMonitoring": [
{
"ShardLevelMetrics": []
}
],
"EncryptionType": "NONE",
"OpenShardCount": 3,
"ConsumerCount": 0
}
}
```
Ada informasi dalam output ini yang tidak Anda perlukan untuk tutorial ini. Informasi penting untuk saat ini adalah`"StreamStatus": "ACTIVE"`, yang memberi tahu Anda bahwa aliran siap digunakan, dan informasi tentang pecahan tunggal yang Anda minta. Anda juga dapat memverifikasi keberadaan aliran baru Anda dengan menggunakan `list-streams` perintah, seperti yang ditunjukkan di sini:
```
aws kinesis list-streams
```
Output:
```
{
"StreamNames": [
"Foo"
]
}
```
## Langkah 2: Letakkan catatan
Sekarang setelah Anda memiliki aliran aktif, Anda siap untuk memasukkan beberapa data. Untuk tutorial ini, Anda akan menggunakan perintah sesederhana mungkin`put-record`, yang menempatkan catatan data tunggal yang berisi teks “testdata” ke dalam aliran:
```
aws kinesis put-record --stream-name Foo --partition-key 123 --data testdata
```
Perintah ini, jika berhasil, akan menghasilkan output yang mirip dengan contoh berikut:
```
{
"ShardId": "shardId-000000000000",
"SequenceNumber": "49546986683135544286507457936321625675700192471156785154"
}
```
Selamat, Anda baru saja menambahkan data ke aliran\$1 Selanjutnya Anda akan melihat cara mengeluarkan data dari aliran.
## Langkah 3: Dapatkan catatan
**GetShardIterator**
Sebelum Anda bisa mendapatkan data dari stream, Anda harus mendapatkan iterator shard untuk shard yang Anda minati. Sebuah iterator shard mewakili posisi aliran dan pecahan dari mana konsumen (`get-record`perintah dalam hal ini) akan membaca. Anda akan menggunakan `get-shard-iterator` perintah sebagai berikut:
```
aws kinesis get-shard-iterator --shard-id shardId-000000000000 --shard-iterator-type TRIM_HORIZON --stream-name Foo
```
Ingat bahwa `aws kinesis` perintah memiliki Kinesis Data Streams API di belakangnya, jadi jika Anda ingin tahu tentang salah satu parameter yang ditampilkan, Anda dapat membacanya [https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetShardIterator.html](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetShardIterator.html)di topik referensi API. Eksekusi yang berhasil akan menghasilkan output yang mirip dengan contoh berikut:
```
{
"ShardIterator": "AAAAAAAAAAHSywljv0zEgPX4NyKdZ5wryMzP9yALs8NeKbUjp1IxtZs1Sp+KEd9I6AJ9ZG4lNR1EMi+9Md/nHvtLyxpfhEzYvkTZ4D9DQVz/mBYWRO6OTZRKnW9gd+efGN2aHFdkH1rJl4BL9Wyrk+ghYG22D2T1Da2EyNSH1+LAbK33gQweTJADBdyMwlo5r6PqcP2dzhg="
}
```
String panjang dari karakter yang tampaknya acak adalah iterator pecahan (milik Anda akan berbeda). Anda harus copy/paste iterator shard ke dalam perintah get, ditampilkan berikutnya. Iterator shard memiliki masa pakai yang valid 300 detik, yang seharusnya cukup waktu bagi Anda untuk copy/paste iterator shard ke perintah berikutnya. Anda harus menghapus baris baru dari iterator shard Anda sebelum menempel ke perintah berikutnya. Jika Anda mendapatkan pesan kesalahan bahwa iterator shard tidak lagi valid, jalankan `get-shard-iterator` perintah lagi.
**GetRecords**
`get-records`Perintah mendapatkan data dari aliran, dan menyelesaikan panggilan ke [https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetRecords.html](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetRecords.html)dalam Kinesis Data Streams API. Iterator shard menentukan posisi dalam pecahan dari mana Anda ingin mulai membaca catatan data secara berurutan. Jika tidak ada catatan yang tersedia di bagian pecahan yang ditunjuk iterator, `GetRecords` mengembalikan daftar kosong. Mungkin diperlukan beberapa panggilan untuk sampai ke sebagian pecahan yang berisi catatan.
Dalam contoh `get-records` perintah berikut:
```
aws kinesis get-records --shard-iterator AAAAAAAAAAHSywljv0zEgPX4NyKdZ5wryMzP9yALs8NeKbUjp1IxtZs1Sp+KEd9I6AJ9ZG4lNR1EMi+9Md/nHvtLyxpfhEzYvkTZ4D9DQVz/mBYWRO6OTZRKnW9gd+efGN2aHFdkH1rJl4BL9Wyrk+ghYG22D2T1Da2EyNSH1+LAbK33gQweTJADBdyMwlo5r6PqcP2dzhg=
```
Jika Anda menjalankan tutorial ini dari prosesor perintah tipe Unix seperti bash, Anda dapat mengotomatiskan akuisisi iterator shard menggunakan perintah bersarang, seperti ini:
```
SHARD_ITERATOR=$(aws kinesis get-shard-iterator --shard-id shardId-000000000000 --shard-iterator-type TRIM_HORIZON --stream-name Foo --query 'ShardIterator')
aws kinesis get-records --shard-iterator $SHARD_ITERATOR
```
Jika Anda menjalankan tutorial ini dari sistem yang mendukung PowerShell, Anda dapat mengotomatiskan akuisisi iterator shard menggunakan perintah seperti ini:
```
aws kinesis get-records --shard-iterator ((aws kinesis get-shard-iterator --shard-id shardId-000000000000 --shard-iterator-type TRIM_HORIZON --stream-name Foo).split('"')[4])
```
Hasil `get-records` perintah yang berhasil akan meminta catatan dari aliran Anda untuk pecahan yang Anda tentukan saat Anda memperoleh iterator shard, seperti pada contoh berikut:
```
{
"Records":[ {
"Data":"dGVzdGRhdGE=",
"PartitionKey":"123”,
"ApproximateArrivalTimestamp": 1.441215410867E9,
"SequenceNumber":"49544985256907370027570885864065577703022652638596431874"
} ],
"MillisBehindLatest":24000,
"NextShardIterator":"AAAAAAAAAAEDOW3ugseWPE4503kqN1yN1UaodY8unE0sYslMUmC6lX9hlig5+t4RtZM0/tALfiI4QGjunVgJvQsjxjh2aLyxaAaPr+LaoENQ7eVs4EdYXgKyThTZGPcca2fVXYJWL3yafv9dsDwsYVedI66dbMZFC8rPMWc797zxQkv4pSKvPOZvrUIudb8UkH3VMzx58Is="
}
```
Perhatikan bahwa `get-records` dijelaskan di atas sebagai *permintaan*, yang berarti Anda mungkin menerima nol atau lebih catatan bahkan jika ada catatan dalam aliran Anda. Catatan apa pun yang dikembalikan mungkin tidak mewakili semua catatan yang saat ini ada di aliran Anda. Ini normal, dan kode produksi akan melakukan polling aliran untuk catatan pada interval yang sesuai. Kecepatan polling ini akan bervariasi tergantung pada persyaratan desain aplikasi spesifik Anda.
Dalam catatan Anda di bagian tutorial ini, Anda akan melihat bahwa data tampaknya sampah - dan itu bukan teks yang jelas yang `testdata` kami kirim. Ini karena cara `put-record` menggunakan pengkodean Base64 untuk memungkinkan Anda mengirim data biner. Namun, dukungan Kinesis Data Streams AWS CLI di tidak *menyediakan* decoding Base64 karena decoding Base64 ke konten biner mentah yang dicetak ke stdout dapat menyebabkan perilaku yang tidak diinginkan dan potensi masalah keamanan pada platform dan terminal tertentu. Jika Anda menggunakan decoder Base64 (misalnya, [https://www.base64decode.org/](https://www.base64decode.org/)) untuk memecahkan kode secara manual, `dGVzdGRhdGE=` Anda akan melihat bahwa itu sebenarnya. `testdata` Ini cukup untuk kepentingan tutorial ini karena, dalam praktiknya, jarang AWS CLI digunakan untuk mengkonsumsi data. Lebih sering, ini digunakan untuk memantau keadaan aliran dan mendapatkan informasi, seperti yang ditunjukkan sebelumnya (`describe-stream`dan`list-streams`). Untuk informasi selengkapnya tentang KCL, lihat [Mengembangkan Konsumen Kustom dengan Throughput Bersama Menggunakan](https://docs.aws.amazon.com/streams/latest/dev/shared-throughput-kcl-consumers.html) KCL.
`get-records`tidak selalu mengembalikan semua catatan dalam stream/shard yang ditentukan. Ketika itu terjadi, gunakan `NextShardIterator` dari hasil terakhir untuk mendapatkan set catatan berikutnya. Jika lebih banyak data dimasukkan ke dalam aliran, yang merupakan situasi normal dalam aplikasi produksi, Anda dapat terus melakukan polling untuk data yang digunakan `get-records` setiap kali. Namun, jika Anda tidak memanggil `get-records` menggunakan iterator shard berikutnya dalam masa pakai iterator shard 300 detik, Anda akan mendapatkan pesan kesalahan, dan Anda harus menggunakan `get-shard-iterator` perintah untuk mendapatkan iterator shard baru.
Juga disediakan dalam output ini adalah`MillisBehindLatest`, yang merupakan jumlah milidetik respons [GetRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetRecords.html)operasi dari ujung aliran, menunjukkan seberapa jauh di belakang waktu konsumen saat ini. Nilai nol menunjukkan pemrosesan catatan tertangkap, dan tidak ada catatan baru untuk diproses saat ini. Dalam kasus tutorial ini, Anda mungkin melihat angka yang cukup besar jika Anda telah meluangkan waktu untuk membaca bersama saat Anda pergi. Secara default, catatan data tetap berada dalam aliran selama 24 jam menunggu Anda untuk mengambilnya. Kerangka waktu ini disebut periode retensi dan dapat dikonfigurasi hingga 365 hari.
`get-records`Hasil yang sukses akan selalu memiliki `NextShardIterator` bahkan jika tidak ada lagi catatan saat ini dalam aliran. Ini adalah model polling yang mengasumsikan produsen berpotensi menempatkan lebih banyak catatan ke dalam aliran pada waktu tertentu. Meskipun Anda dapat menulis rutinitas polling Anda sendiri, jika Anda menggunakan KCL yang disebutkan sebelumnya untuk mengembangkan aplikasi konsumen, polling ini ditangani untuk Anda.
Jika Anda menelepon `get-records` sampai tidak ada lagi catatan dalam aliran dan pecahan yang Anda tarik, Anda akan melihat output dengan catatan kosong yang mirip dengan contoh berikut:
```
{
"Records": [],
"NextShardIterator": "AAAAAAAAAAGCJ5jzQNjmdhO6B/YDIDE56jmZmrmMA/r1WjoHXC/kPJXc1rckt3TFL55dENfe5meNgdkyCRpUPGzJpMgYHaJ53C3nCAjQ6s7ZupjXeJGoUFs5oCuFwhP+Wul/EhyNeSs5DYXLSSC5XCapmCAYGFjYER69QSdQjxMmBPE/hiybFDi5qtkT6/PsZNz6kFoqtDk="
}
```
## Langkah 4: Membersihkan
Hapus streaming Anda untuk mengosongkan sumber daya dan menghindari tagihan yang tidak diinginkan ke akun Anda. Lakukan ini setiap kali Anda telah membuat aliran dan tidak akan menggunakannya, karena biaya bertambah per aliran apakah Anda menempatkan dan mendapatkan data dengannya atau tidak. Perintah pembersihan adalah sebagai berikut:
```
aws kinesis delete-stream --stream-name Foo
```
Sukses menghasilkan tidak ada output. Gunakan `describe-stream` untuk memeriksa kemajuan penghapusan:
```
aws kinesis describe-stream-summary --stream-name Foo
```
Jika Anda menjalankan perintah ini segera setelah perintah delete, Anda akan melihat output yang mirip dengan contoh berikut:
```
{
"StreamDescriptionSummary": {
"StreamName": "samplestream",
"StreamARN": "arn:aws:kinesis:us-west-2:123456789012:stream/samplestream",
"StreamStatus": "ACTIVE",
```
Setelah aliran dihapus sepenuhnya, `describe-stream` akan menghasilkan kesalahan “tidak ditemukan”:
```
A client error (ResourceNotFoundException) occurred when calling the DescribeStreamSummary operation:
Stream Foo under account 123456789012 not found.
```