Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Konektor dan utilitas
Amazon EMR menyediakan sejumlah konektor dan utilitas untuk mengakses AWS layanan lain sebagai sumber data. Anda biasanya dapat mengakses data dalam layanan ini dalam sebuah program. Misalnya, Anda dapat menentukan aliran Kinesis dalam kueri Hive, skrip Babi, atau MapReduce aplikasi dan kemudian mengoperasikannya pada data tersebut.
**Topics**
+ [Ekspor, impor, kueri, dan gabungkan tabel di DynamoDB menggunakan Amazon EMR](EMRforDynamoDB.md)
+ [Kinesis](emr-kinesis.md)
+ [S3 DistCp (s3-dist-cp)](UsingEMR_s3distcp.md)
+ [Membersihkan setelah pekerjaan S3 DistCp gagal](#s3distcp-cleanup)
# Ekspor, impor, kueri, dan gabungkan tabel di DynamoDB menggunakan Amazon EMR
**catatan**
Konektor Amazon EMR-DynamoDB bersumber terbuka. GitHub Untuk informasi selengkapnya, lihat [https://github.com/awslabs/emr-dynamodb-connector](https://github.com/awslabs/emr-dynamodb-connector).
DynamoDB adalah layanan basis data NoSQL terkelola penuh yang memberikan performa yang cepat dan dapat diprediksi dengan skalabilitas sempurna. Pengembang dapat membuat tabel basis data dan menumbuhkan lalu lintas permintaan atau penyimpanan tanpa batas. DynamoDB secara otomatis menyebar data dan lalu lintas untuk tabel ke seluruh server dengan jumlah yang cukup untuk menangani kapasitas permintaan yang ditentukan oleh pelanggan dan jumlah data yang disimpan, sambil mempertahankan performa yang konsisten dan cepat. Dengan menggunakan Amazon EMR dan Hive, Anda dapat dengan cepat dan efisien memproses data dalam jumlah besar, misalnya data yang disimpan dalam DynamoDB. Untuk informasi selengkapnya tentang DynamoDB, lihat [Panduan Developer Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/).
Apache Hive adalah lapisan perangkat lunak yang dapat Anda gunakan untuk melakukan kueri klaster peredam peta dengan menggunakan bahasa kueri sederhana mirip SQL yang disebut dengan HiveQL. Perangkat ini berjalan di atas arsitektur Hadoop. Untuk informasi selengkapnya tentang Hive dan HiveQL, kunjungi [Manual bahasa HiveQL](https://cwiki.apache.org/confluence/display/Hive/LanguageManual). Untuk informasi selengkapnya tentang Hive dan Amazon EMR, lihat [Apache Hive](emr-hive.md).
Anda dapat menggunakan Amazon EMR dengan Hive versi disesuaikan yang mencakup konektivitas ke DynamoDB untuk melakukan operasi pada data yang disimpan dalam DynamoDB:
+ Memuat data DynamoDB ke dalam Hadoop Distributed File System (HDFS) dan menggunakannya sebagai masukan ke dalam klaster Amazon EMR.
+ Membuat kueri data DynamoDB langsung menggunakan pernyataan yang mirip SQL (HiveQL).
+ Menggabungkan data yang disimpan dalam DynamoDB dan mengekspor atau membuat kueri terhadap data yang digabungkan.
+ Mengekspor data yang tersimpan dalam DynamoDB ke Amazon S3.
+ Mengimpor data yang tersimpan di Amazon S3 ke DynamoDB.
**catatan**
Amazon EMR-DynamoDB Connector tidak mendukung klaster yang dikonfigurasi untuk menggunakan [Autentikasi Kerberos](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-kerberos.html).
Untuk melakukan masing-masing tugas berikut, Anda akan meluncurkan klaster Amazon EMR, menentukan lokasi data di DynamoDB, dan mengeluarkan perintah Hive untuk memanipulasi data di DynamoDB.
Ada beberapa cara untuk meluncurkan cluster EMR Amazon: Anda dapat menggunakan konsol EMR Amazon, antarmuka baris perintah (CLI), atau Anda dapat memprogram cluster Anda menggunakan SDK AWS atau Amazon EMR API. Anda juga dapat memilih apakah akan menjalankan klaster Hive secara interaktif atau dari skrip. Pada bagian ini, kami akan menunjukkan cara untuk meluncurkan klaster Hive interaktif dari konsol Amazon EMR dan CLI.
Menggunakan Hive interaktif adalah cara yang bagus untuk menguji performa kueri dan menyetel aplikasi Anda. Setelah Anda telah membentuk satu set perintah Hive yang akan berjalan secara teratur, pertimbangkan untuk membuat skrip Hive yang dapat dijalankan Amazon EMR untuk Anda.
**Awas**
Operasi tulis atau baca Amazon EMR pada tabel DynamoDB merugikan throughput yang disediakan yang Anda tetapkan dan berpotensi meningkatkan frekuensi pengecualian throughput yang disediakan. Untuk permintaan besar, Amazon EMR mengimplementasikan percobaan ulang dengan mundur eksponensial untuk mengelola beban permintaan pada tabel DynamoDB. Menjalankan tugas Amazon EMR secara bersamaan dengan lalu lintas lainnya dapat menyebabkan Anda melebihi tingkat throughput yang disediakan dan dialokasikan. Anda dapat memantau ini dengan memeriksa **ThrottleRequests**metrik di Amazon CloudWatch. Jika permintaan beban terlalu tinggi, Anda dapat meluncurkan kembali klaster dan mengatur [Pengaturan persen baca](EMR_Hive_Optimizing.md#ReadPercent) atau [Pengaturan persentase tulis](EMR_Hive_Optimizing.md#WritePercent) ke nilai yang lebih rendah untuk melakukan throttling operasi Amazon EMR. Untuk informasi tentang pengaturan throughput DynamoDB, lihat [Throughput yang ditetapkan](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithDDTables.html#ProvisionedThroughput).
Jika sebuah tabel dikonfigurasi untuk [Mode Sesuai Permintaan](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.OnDemand), Anda harus mengubah tabel kembali ke mode yang ditetapkan sebelum menjalankan operasi ekspor atau impor. Pipelines membutuhkan rasio throughput untuk menghitung sumber daya yang akan digunakan dari Dynamo. DBtable Mode sesuai permintaan menghapus throughput yang ditetapkan. Untuk menyediakan kapasitas throughput, Anda dapat menggunakan metrik CloudWatch Acara Amazon untuk mengevaluasi throughput agregat yang telah digunakan tabel.
**Topics**
+ [Mengatur tabel Hive untuk menjalankan perintah Hive](EMR_Interactive_Hive.md)
+ [Contoh perintah Hive untuk mengekspor, mengimpor, dan membuat kueri data di DynamoDB](EMR_Hive_Commands.md)
+ [Mengoptimalkan performa untuk operasi Amazon EMR di DynamoDB](EMR_Hive_Optimizing.md)
# Mengatur tabel Hive untuk menjalankan perintah Hive
Apache Hive adalah aplikasi gudang data yang dapat Anda gunakan untuk membuat kueri data yang terkandung dalam klaster Amazon EMR menggunakan bahasa mirip SQL. Untuk informasi selengkapnya tentang Hive, lihat [http://hive.apache.org/](http://hive.apache.org/).
Prosedur berikut mengasumsikan Anda telah membuat sebuah klaster dan menentukan pasangan kunci Amazon EC2. Untuk mempelajari cara memulai membuat klaster, lihat [Memulai Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs) dalam *Panduan Pengelolaan Amazon EMR*.
## Konfigurasikan Hive untuk digunakan MapReduce
Bila Anda menggunakan Hive di Amazon EMR untuk membuat kueri tabel DynamoDB, kesalahan dapat terjadi jika Hive menggunakan mesin eksekusi default, Tez. Untuk alasan ini, saat Anda membuat klaster dengan Hive yang terintegrasi dengan DynamoDB seperti yang dijelaskan di bagian ini, sebaiknya gunakan klasifikasi konfigurasi yang menetapkan Hive untuk digunakan. MapReduce Untuk informasi selengkapnya, lihat [Konfigurasikan aplikasi](emr-configure-apps.md).
Cuplikan berikut menunjukkan klasifikasi konfigurasi dan properti yang akan digunakan untuk disetel MapReduce sebagai mesin eksekusi untuk Hive:
```
[
{
"Classification": "hive-site",
"Properties": {
"hive.execution.engine": "mr"
}
}
]
```
**Untuk menjalankan perintah Hive secara interaktif**
1. Connect ke simpul utama. Untuk informasi selengkapnya, lihat [Connect ke simpul utama menggunakan SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) dalam *Panduan Pengelolaan Amazon EMR*.
1. Pada prompt perintah untuk simpul utama saat ini, ketik `hive`.
Anda akan melihat prompt Hive: `hive>`
1. Masukkan perintah Hive yang memetakan tabel dalam aplikasi Hive ke data di DynamoDB. Tabel ini bertindak sebagai referensi ke data yang disimpan di Amazon DynamoDB; data tidak disimpan secara lokal di Hive dan setiap kueri yang menggunakan tabel ini berjalan berlawanan data langsung di DynamoDB, menghabiskan kapasitas baca atau tulis tabel setiap kali perintah dijalankan. Jika Anda berharap untuk menjalankan beberapa perintah Hive atas set data yang sama, pertimbangkan untuk mengekspornya terlebih dahulu.
Berikut ini menunjukkan sintaks untuk pemetaan tabel Hive ke tabel DynamoDB.
```
CREATE EXTERNAL TABLE hive_tablename (hive_column1_name column1_datatype, hive_column2_name column2_datatype...)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "dynamodb_tablename",
"dynamodb.column.mapping" = "hive_column1_name:dynamodb_attribute1_name,hive_column2_name:dynamodb_attribute2_name...");
```
Bila Anda membuat tabel di Hive dari DynamoDB, Anda harus membuatnya sebagai tabel eksternal menggunakan kata kunci `EXTERNAL`. Perbedaan antara tabel eksternal dan internal adalah bahwa data dalam tabel internal dihapus ketika tabel internal dibuang. Ini bukan perilaku yang diinginkan ketika terhubung ke Amazon DynamoDB, dan dengan demikian hanya tabel eksternal yang didukung.
Misalnya, perintah Hive berikut membuat tabel bernama *hivetable1* di Hive yang melakukan referensi pada tabel DynamoDB bernama *dynamodbtable1*. *Tabel* DynamoDB dynamodbtable1 memiliki skema kunci primer. hash-and-range Elemen kunci hash adalah `name` (tipe string), elemen kunci range adalah `year` (tipe numerik), dan setiap item memiliki nilai atribut untuk `holidays` (tipe set string).
```
CREATE EXTERNAL TABLE hivetable1 (col1 string, col2 bigint, col3 array)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "dynamodbtable1",
"dynamodb.column.mapping" = "col1:name,col2:year,col3:holidays");
```
Baris 1 menggunakan pernyataan `CREATE EXTERNAL TABLE` HiveQL. Untuk *hivetable1*, Anda perlu menetapkan kolom untuk setiap pasangan atribut nama-nilai dalam tabel DynamoDB, dan memberikan tipe data. Nilai-nilai ini tidak peka huruf besar kecil, dan Anda dapat memberikan kolom ini nama apapun (kecuali kata-kata yang tersimpan).
Baris 2 menggunakan pernyataan `STORED BY`. Nilai dari `STORED BY` adalah nama kelas yang menangani hubungan antara Hive dan DynamoDB. Ia harus diatur ke `'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'`.
Baris 3 menggunakan pernyataan `TBLPROPERTIES` untuk mengasosiasikan "hivetable1" dengan tabel dan skema yang benar di DynamoDB. Berikan `TBLPROPERTIES` nilai-nilai untuk parameter `dynamodb.table.name` dan parameter `dynamodb.column.mapping`. Nilai ini *adalah* peka huruf besar kecil.
**catatan**
Semua nama atribut DynamoDB untuk tabel harus memiliki kolom yang sesuai dalam tabel Hive. Bergantung pada versi EMR Amazon Anda, skenario berikut terjadi jika one-to-one pemetaan tidak ada:
Di Amazon EMR versi 5.27.0 dan yang lebih baru, konektor memiliki validasi yang memastikan pemetaan one-to-one antara nama atribut DynamoDB dan kolom di tabel Hive. Kesalahan akan terjadi jika one-to-one pemetaan tidak ada.
Pada Amazon EMR versi 5.26.0 dan sebelumnya, tabel Hive tidak akan berisi pasangan nama-nilai dari DynamoDB. Jika Anda tidak memetakan atribut kunci utama DynamoDB, maka Hive akan menghasilkan kesalahan. Jika Anda tidak memetakan atribut kunci non-utama, tidak ada kesalahan yang dihasilkan, tetapi Anda tidak akan melihat data dalam tabel Hive. Jika tipe data tidak cocok, nilainya nol.
Kemudian Anda dapat mulai menjalankan operasi Hive pada *hivetable1*. Kueri berjalan terhadap *hivetable1* secara internal dijalankan terhadap tabel DynamoDB *dynamodbtable1* akun DynamoDB Anda, menghabiskan unit baca atau tulis dengan setiap eksekusi.
Ketika Anda menjalankan kueri Hive terhadap tabel DynamoDB, Anda perlu memastikan bahwa Anda telah menetapkan unit kapasitas baca dengan jumlah yang cukup.
Misalnya, anggaplah bahwa Anda telah menetapkan 100 unit kapasitas baca untuk tabel DynamoDB Anda. Ini akan memungkinkan Anda melakukan 100 baca, atau 409,600 byte, per detik. Jika tabel yang berisi 20GB data (21.474.836.480 byte), dan kueri Hive Anda melakukan pindai tabel penuh, Anda dapat memperkirakan berapa lama kueri dijalankan:
* 21.474.836.480 / 409.600 = 52.429 detik = 14,56 jam *
Satu-satunya cara untuk mengurangi waktu yang diperlukan adalah menyesuaikan unit kapasitas baca pada tabel DynamoDB sumber. Menambahkan lebih banyak simpul Amazon EMR tidak akan membantu.
Dalam output Hive, persentase penyelesaian diperbarui ketika satu proses pemeta atau lebih telah selesai. Untuk tabel DynamoDB besar dengan pengaturan kapasitas baca ditetapkan yang rendah, output persentase penyelesaian mungkin tidak diperbarui dalam waktu yang lama; dalam kasus di atas, tugas akan muncul menjadi selesai 0% dalam beberapa jam. Untuk status yang lebih rinci pada kemajuan tugas Anda, buka konsol Amazon EMR; Anda akan dapat melihat status tugas pemeta individu, dan statistik untuk baca data. Anda juga dapat masuk ke antarmuka Hadoop pada simpul utama dan melihat statistik Hadoop. Ini akan menunjukkan status tugas peta masing-masing dan beberapa statistik baca data. Untuk informasi selengkapnya, lihat topik berikut:
+ [Antarmuka web yang dihosting di node master](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-web-interfaces.html)
+ [Lihat antarmuka web Hadoop](https://docs.aws.amazon.com/emr/latest/ManagementGuide/UsingtheHadoopUserInterface.html)
Untuk informasi lebih lanjut tentang pernyataan HiveQL contoh untuk melakukan tugas-tugas seperti mengekspor atau mengimpor data dari DynamoDB dan menggabungkan tabel, lihat [Contoh perintah Hive untuk mengekspor, mengimpor, dan membuat kueri data di DynamoDB](EMR_Hive_Commands.md).
**Untuk membatalkan permintaan Hive**
Ketika Anda menjalankan kueri Hive, respon awal dari server termasuk perintah untuk membatalkan permintaan. Untuk membatalkan permintaan kapan saja dalam proses, gunakan **Perintah Bunuh** dari respon server.
1. Masukkan `Ctrl+C` untuk keluar dari klien baris perintah.
1. Pada shell prompt, masukkan **Perintah Bunuh** dari respon server awal untuk permintaan Anda.
Atau, Anda dapat menjalankan perintah berikut dari baris perintah node master untuk membunuh pekerjaan Hadoop, di mana *job-id* adalah pengidentifikasi pekerjaan Hadoop dan dapat diambil dari antarmuka pengguna Hadoop.
```
hadoop job -kill job-id
```
## Jenis data untuk Hive dan DynamoDB
Tabel berikut menunjukkan tipe data Hive yang tersedia, tipe DynamoDB default yang sesuai dengannya, dan tipe DynamoDB alternatif yang juga dapat dipetakan kepadanya.
| Tipe Hive | Tipe DynamoDB default | Tipe DynamoDB alternatif |
| --- | --- | --- |
| string | string (S) | |
| bigint atau ganda | nomor (N) | |
| biner | biner (B) | |
| boolean | boolean (BOOL) | |
| array | daftar (L) | set nomor (NS), set string (SS), atau set biner (BS) |
| peta | Item | peta (M) |
| peta | peta (M) | |
| | nol (NULL) | |
Jika Anda ingin menulis data Hive Anda sebagai tipe DynamoDB alternatif yang sesuai, atau jika data DynamoDB Anda berisi nilai atribut dari tipe DynamoDB alternatif, maka Anda dapat menentukan kolom dan tipe DynamoDB dengan parameter `dynamodb.type.mapping`. Contoh berikut menunjukkan sintaks untuk menentukan pemetaan tipe alternatif.
```
CREATE EXTERNAL TABLE hive_tablename (hive_column1_name column1_datatype, hive_column2_name column2_datatype...)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "dynamodb_tablename",
"dynamodb.column.mapping" = "hive_column1_name:dynamodb_attribute1_name,hive_column2_name:dynamodb_attribute2_name...",
"dynamodb.type.mapping" = "hive_column1_name:dynamodb_attribute1_datatype");
```
Tipe pemetaan parameter bersifat opsional, dan hanya harus ditentukan untuk kolom yang menggunakan tipe alternatif.
Misalnya, perintah Hive berikut membuat tabel bernama `hivetable2` yang membuat referensi pada tabel DynamoDB `dynamodbtable2`. Hal ini mirip dengan `hivetable1`, kecuali bahwa ia memetakan kolom `col3` ke tipe set string (SS).
```
CREATE EXTERNAL TABLE hivetable2 (col1 string, col2 bigint, col3 array)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "dynamodbtable2",
"dynamodb.column.mapping" = "col1:name,col2:year,col3:holidays",
"dynamodb.type.mapping" = "col3:SS");
```
Di Hive, `hivetable1` dan `hivetable2` bersifat identik. Namun, ketika data dari tabel tersebut ditulis ke tabel DynamoDB yang sesuai, `dynamodbtable1` akan berisi daftar, sementara `dynamodbtable2` akan berisi set string.
Jika Anda ingin menulis nilai `null` Hive sebagai atribut tipe `null` DynamoDB, maka Anda dapat melakukannya dengan parameter `dynamodb.null.serialization`. Contoh berikut menunjukkan sintaks untuk menentukan serialisasi `null`.
```
CREATE EXTERNAL TABLE hive_tablename (hive_column1_name column1_datatype, hive_column2_name column2_datatype...)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "dynamodb_tablename",
"dynamodb.column.mapping" = "hive_column1_name:dynamodb_attribute1_name,hive_column2_name:dynamodb_attribute2_name...",
"dynamodb.null.serialization" = "true");
```
Parameter serialisasi nol bersifal opsional, dan diatur menjadi `false` jika tidak ditentukan. Perhatikan bahwa atribut `null` DynamoDB dibaca sebagai nilai `null` dalam Hive terlepas dari pengaturan parameternya. Koleksi Hive dengan nilai `null` dapat ditulis ke DynamoDB hanya jika parameter serialisasi nol ditentukan sebagai `true`. Jika tidak, muncul kesalahan Hive.
Tipe bigint di Hive adalah sama dengan tipe panjang Java, dan tipe ganda Hive adalah sama dengan tipe ganda Java dalam hal presisi. Ini berarti bahwa jika Anda memiliki data numerik yang disimpan dalam DynamoDB yang memiliki presisi lebih tinggi daripada yang tersedia dalam tipe data Hive, dengan menggunakan Hive untuk mengekspor, impor, atau referensi data DynamoDB dapat menyebabkan kehilangan presisi atau kegagalan kueri Hive.
Ekspor tipe biner dari DynamoDB ke Amazon Simple Storage Service (Amazon S3) atau HDFS disimpan sebagai string Base64-encoded. Jika Anda mengimpor data dari Amazon S3 atau HDFS ke dalam tipe biner DynamoDB, maka data itu harus dikodekan sebagai string Base64.
## Pilihan Hive
Anda dapat mengatur pilihan Hive berikut untuk mengelola transfer data dari Amazon DynamoDB. Pilihan ini hanya bertahan untuk sesi Hive saat ini. Jika Anda menutup prompt perintah Hive dan membukanya kembali nanti pada klaster, pengaturan ini akan kembali ke nilai default.
| Pilihan Hive | Deskripsi |
| --- | --- |
| dynamodb.throughput.read.percent | Atur tingkat operasi baca untuk menjaga tingkat tingkat throughput ditetapkan DynamoDB Anda berada dalam kisaran dialokasikan untuk tabel Anda. Nilainya adalah antara `0.1` dan `1.5`, secara inklusif. Nilai 0,5 adalah tingkat baca default, yang berarti bahwa Hive akan mencoba untuk menggunakan setengah dari baca yang ditetapkan di seluruh sumber daya dalam tabel. Menaikkan nilai ini di atas 0,5 akan meningkatkan tingkat permintaan baca. Menurunkannya di bawah 0,5 akan menurunkan tingkat permintaan baca. Tingkat baca ini hanya perkiraan. Tingkat baca sebenarnya akan tergantung pada faktor-faktor seperti apakah ada distribusi kunci yang seragam dalam DynamoDB. Jika Anda menemukan throughput ditetapkan Anda sering dilampaui oleh operasi Hive, atau jika lalu lintas baca langsung yang di-throttling terlalu banyak, maka kurangi nilainya menjadi kurang dari `0.5`. Jika Anda memiliki kapasitas yang cukup dan ingin operasi Hive lebih cepat, atur nilai ini di atas `0.5`. Anda juga dapat melakukan oversubscribe dengan mengaturnya hingga 1,5 jika Anda yakin ada operasi input/output yang tidak terpakai yang tersedia. |
| dynamodb.throughput.write.percent | Atur tingkat operasi tulis untuk menjaga tingkat throughput ditetapkan DynamoDB Anda berada dalam kisaran yang dialokasikan untuk tabel Anda. Nilainya adalah antara `0.1` dan `1.5`, secara inklusif. Nilai 0,5 adalah tingkat tulis default, yang berarti bahwa Hive akan mencoba untuk menggunakan setengah dari tulis yang ditetapkan di seluruh sumber daya dalam tabel. Menaikkan nilai ini di atas 0,5 akan meningkatkan tingkat permintaan tulis. Menurunkannya di bawah 0,5 akan menurunkan tingkat permintaan tulis. Tingkat tulis ini hanya perkiraan. Tingkat tulis sebenarnya akan tergantung pada faktor-faktor seperti apakah ada distribusi kunci yang seragam dalam DynamoDB Jika Anda menemukan throughput ditetapkan Anda sering dilampaui oleh operasi Hive, atau jika lalu lintas tulis langsung yang di-throttling terlalu banyak, maka kurangi nilainya menjadi kurang dari `0.5`. Jika Anda memiliki kapasitas yang cukup dan ingin operasi Hive lebih cepat, atur nilai ini di atas `0.5`. Anda juga dapat melakukan oversubscribe dengan mengaturnya hingga 1,5 jika Anda yakin ada operasi input/output yang tidak terpakai yang tersedia atau ini adalah data awal yang diunggah ke tabel dan belum ada lalu lintas langsung. |
| dynamodb.endpoint | Tentukan titik akhir untuk layanan DynamoDB. Untuk informasi selengkapnya tentang titik akhir DynamoDB yang tersedia, lihat [Wilayah dan titik akhir](https://docs.aws.amazon.com/general/latest/gr/rande.html#ddb_region). |
| dynamodb.max.map.tasks | Tentukan jumlah maksimum tugas peta saat membaca data dari DynamoDB. Nilai ini harus sama dengan atau lebih besar dari 1. |
| dynamodb.retry.duration | Tentukan jumlah menit yang akan digunakan sebagai durasi batas waktu untuk mencoba kembali perintah Hive. Nilai ini harus integer yang sama dengan atau lebih besar dari 0. Durasi batas waktu default adalah dua menit. |
Pilihan ini diatur menggunakan perintah `SET` seperti yang ditunjukkan dalam contoh berikut.
```
SET dynamodb.throughput.read.percent=1.0;
INSERT OVERWRITE TABLE s3_export SELECT *
FROM hiveTableName;
```
# Contoh perintah Hive untuk mengekspor, mengimpor, dan membuat kueri data di DynamoDB
Contoh berikut menggunakan perintah Hive untuk melaksanakan operasi seperti mengekspor data ke Amazon S3 atau HDFS, mengimpor data ke DynamoDB, menggabungkan tabel, melakukan kueri tabel, dan banyak lagi.
Operasi pada data referensi tabel Hive yang disimpan dalam DynamoDB. Perintah Hive tunduk pada pengaturan throughput ditetapkan tabel DynamoDB, dan data yang diambil termasuk data yang ditulis ke tabel DynamoDB pada saat permintaan operasi Hive diproses oleh DynamoDB. Jika proses pengambilan data memakan waktu lama, beberapa data yang dikembalikan oleh perintah Hive mungkin telah diperbarui di DynamoDB sejak perintah Hive dimulai.
Perintah Hive `DROP TABLE` dan `CREATE TABLE` hanya bertindak pada tabel lokal di Hive dan tidak membuat atau menghapus tabel di DynamoDB. Jika kueri Hive Anda membuat referensi tabel di DynamoDB, maka tabel tersebut harus sudah ada sebelum Anda menjalankan kueri. Untuk informasi selengkapnya tentang membuat dan menghapus tabel di DynamoDB, lihat [Bekerja dengan tabel di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html) dalam *Panduan Developer Amazon DynamoDB*.
**catatan**
Saat Anda memetakan tabel Hive ke lokasi di Amazon S3, jangan memetakannya ke jalur root bucket, s3://amzn-s3-demo-bucket, karena ini dapat menyebabkan kesalahan saat Hive menulis data ke Amazon S3. Alih-alih memetakan tabel ke subpath bucket, s3://amzn-s3-demo-bucket/mypath.
## Mengekspor data dari DynamoDB
Anda dapat menggunakan Hive untuk mengekspor data dari DynamoDB.
**Untuk mengekspor tabel DynamoDB ke bucket Amazon S3**
+ Buat tabel Hive yang melakukan referensi data yang disimpan dalam DynamoDB. Kemudian Anda dapat memanggil perintah INSERT OVERWRITE untuk menulis data ke direktori eksternal. Dalam contoh berikut, *s3://amzn-s3-demo-bucket/path/subpath/* adalah jalur yang valid di Amazon S3. Sesuaikan kolom dan tipe data dalam perintah CREATE untuk mencocokkan nilai-nilai dalam DynamoDB Anda. Anda dapat menggunakan ini untuk membuat arsip data DynamoDB Anda di Amazon S3.
```
1. CREATE EXTERNAL TABLE hiveTableName (col1 string, col2 bigint, col3 array)
2. STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
3. TBLPROPERTIES ("dynamodb.table.name" = "dynamodbtable1",
4. "dynamodb.column.mapping" = "col1:name,col2:year,col3:holidays");
5.
6. INSERT OVERWRITE DIRECTORY 's3://amzn-s3-demo-bucket/path/subpath/' SELECT *
7. FROM hiveTableName;
```
**Untuk mengekspor tabel DynamoDB ke bucket Amazon S3 menggunakan format**
+ Buat tabel eksternal yang membuat referensi lokasi di Amazon S3. Hal ini ditunjukkan di bawah sebagai s3\$1export. Selama panggilan CREATE, tentukan baris format untuk tabel. Kemudian, ketika Anda menggunakan INSERT OVERWRITE untuk mengekspor data dari DynamoDB ke s3\$1export, data ditulis dalam format yang ditentukan. Pada contoh berikut, data ditulis sebagai nilai yang dipisahkan oleh koma (CSV).
```
1. CREATE EXTERNAL TABLE hiveTableName (col1 string, col2 bigint, col3 array)
2. STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
3. TBLPROPERTIES ("dynamodb.table.name" = "dynamodbtable1",
4. "dynamodb.column.mapping" = "col1:name,col2:year,col3:holidays");
5.
6. CREATE EXTERNAL TABLE s3_export(a_col string, b_col bigint, c_col array)
7. ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
8. LOCATION 's3://amzn-s3-demo-bucket/path/subpath/';
9.
10. INSERT OVERWRITE TABLE s3_export SELECT *
11. FROM hiveTableName;
```
**Untuk mengekspor tabel DynamoDB ke bucket Amazon S3 tanpa menentukan pemetaan kolom**
+ Membuat tabel Hive yang membuat referensi data yang disimpan dalam DynamoDB. Hal ini mirip dengan contoh sebelumnya, kecuali jika Anda tidak menentukan pemetaan kolom. Tabel harus benar-benar memiliki satu kolom tipe `map`. Jika Anda kemudian membuat tabel `EXTERNAL` di Amazon S3 Anda dapat memanggil perintah `INSERT OVERWRITE` untuk menulis data dari DynamoDB ke Amazon S3. Anda dapat menggunakan ini untuk membuat arsip data DynamoDB Anda di Amazon S3. Karena tidak ada pemetaan kolom, Anda tidak dapat melakukan kueri pada tabel yang diekspor dengan cara ini. Mengekspor data tanpa menentukan pemetaan kolom tersedia di Hive 0.8.1.5 atau setelahnya, yang didukung di Amazon EMR AMI 2.2.*x* dan setelahnya.
```
1. CREATE EXTERNAL TABLE hiveTableName (item map)
2. STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
3. TBLPROPERTIES ("dynamodb.table.name" = "dynamodbtable1");
4.
5. CREATE EXTERNAL TABLE s3TableName (item map)
6. ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' LINES TERMINATED BY '\n'
7. LOCATION 's3://amzn-s3-demo-bucket/path/subpath/';
8.
9. INSERT OVERWRITE TABLE s3TableName SELECT *
10. FROM hiveTableName;
```
**Untuk mengekspor tabel DynamoDB ke bucket Amazon S3 menggunakan kompresi data**
+ Hive menyediakan beberapa codec kompresi yang dapat Anda atur selama sesi Hive Anda. Melakukan hal tersebut akan menyebabkan data yang diekspor dikompresi dalam format yang ditentukan. Contoh berikut mengompres file yang diekspor menggunakan algoritma Lempel-Ziv-Oberhumer (LZO).
```
1. SET hive.exec.compress.output=true;
2. SET io.seqfile.compression.type=BLOCK;
3. SET mapred.output.compression.codec = com.hadoop.compression.lzo.LzopCodec;
4.
5. CREATE EXTERNAL TABLE hiveTableName (col1 string, col2 bigint, col3 array)
6. STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
7. TBLPROPERTIES ("dynamodb.table.name" = "dynamodbtable1",
8. "dynamodb.column.mapping" = "col1:name,col2:year,col3:holidays");
9.
10. CREATE EXTERNAL TABLE lzo_compression_table (line STRING)
11. ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' LINES TERMINATED BY '\n'
12. LOCATION 's3://amzn-s3-demo-bucket/path/subpath/';
13.
14. INSERT OVERWRITE TABLE lzo_compression_table SELECT *
15. FROM hiveTableName;
```
Codec kompresi yang tersedia adalah:
+ org.apache.hadoop.io.compress. GzipCodec
+ org.apache.hadoop.io.compress. DefaultCodec
+ com.hadoop.compression.lzo. LzoCodec
+ com.hadoop.compression.lzo. LzopCodec
+ org.apache.hadoop.io.compress. BZip2Codec
+ org.apache.hadoop.io.compress. SnappyCodec
**Untuk mengekspor tabel DynamoDB ke HDFS**
+ Gunakan perintah Hive berikut, di mana *hdfs:///directoryName* adalah jalur HDFS yang valid dan *hiveTableName* merupakan tabel di Hive yang mereferensikan DynamoDB. Operasi ekspor ini lebih cepat daripada mengekspor tabel DynamoDB ke Amazon S3 karena Hive 0.7.1.1 menggunakan HDFS sebagai langkah lanjutan ketika mengekspor data ke Amazon S3. Contoh berikut juga menunjukkan cara untuk mengatur `dynamodb.throughput.read.percent` menjadi 1,0 untuk meningkatkan tingkat permintaan baca.
```
1. CREATE EXTERNAL TABLE hiveTableName (col1 string, col2 bigint, col3 array)
2. STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
3. TBLPROPERTIES ("dynamodb.table.name" = "dynamodbtable1",
4. "dynamodb.column.mapping" = "col1:name,col2:year,col3:holidays");
5.
6. SET dynamodb.throughput.read.percent=1.0;
7.
8. INSERT OVERWRITE DIRECTORY 'hdfs:///directoryName' SELECT * FROM hiveTableName;
```
Anda juga dapat mengekspor data ke HDFS menggunakan format dan kompresi seperti yang ditunjukkan di atas untuk ekspor ke Amazon S3. Untuk melakukannya, cukup ganti direktori Amazon S3 dalam contoh di atas dengan direktori HDFS.
**Untuk membaca data karakter UTF-8 yang tidak dapat dicetak di Hive**
+ Anda dapat membaca dan menulis data karakter UTF-8 yang tidak dapat dicetak dengan Hive dengan menggunakan klausul `STORED AS SEQUENCEFILE` saat Anda membuat tabel. A SequenceFile adalah format file biner Hadoop; Anda perlu menggunakan Hadoop untuk membaca file ini. Contoh berikut menunjukkan cara mengekspor data dari DynamoDB ke Amazon S3. Anda dapat menggunakan fungsionalitas ini untuk menangani karakter dikodekan UTF-8 yang tidak dapat dicetak.
```
1. CREATE EXTERNAL TABLE hiveTableName (col1 string, col2 bigint, col3 array)
2. STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
3. TBLPROPERTIES ("dynamodb.table.name" = "dynamodbtable1",
4. "dynamodb.column.mapping" = "col1:name,col2:year,col3:holidays");
5.
6. CREATE EXTERNAL TABLE s3_export(a_col string, b_col bigint, c_col array)
7. STORED AS SEQUENCEFILE
8. LOCATION 's3://amzn-s3-demo-bucket/path/subpath/';
9.
10. INSERT OVERWRITE TABLE s3_export SELECT *
11. FROM hiveTableName;
```
## Mengimpor data ke DynamoDB
Ketika Anda menulis data ke DynamoDB menggunakan Hive Anda harus memastikan bahwa jumlah unit kapasitas tulis lebih besar dari jumlah pemeta di klaster. Sebagai contoh, klaster yang berjalan pada instans EC2 m1.xlarge menghasilkan 8 pemeta per instans. Dalam kasus klaster yang memiliki 10 instans, itu berarti ada total 80 pemeta. Jika unit kapasitas tulis Anda tidak lebih besar dari jumlah pemeta di klaster, operasi tulis Hive dapat menghabiskan semua throughput tulis, atau mencoba untuk menghabiskan throughput lebih dari yang ditetapkan. Untuk informasi selengkapnya tentang jumlah pemeta yang dihasilkan oleh setiap tipe instans EC2, lihat [Konfigurasikan Hadoop](emr-hadoop-config.md).
Jumlah pemeta di Hadoop dikendalikan oleh perpecahan masukan. Jika ada terlalu sedikit perpecahan, perintah tulis Anda mungkin tidak dapat menghabiskan semua throughput tulis yang tersedia.
Jika item dengan kunci yang sama ada di tabel DynamoDB target, maka item itu akan ditimpa. Jika tidak ada item dengan kunci yang ada di tabel DynamoDB target, maka item itu akan dimasukkan.
**Untuk mengimpor tabel dari Amazon S3 ke DynamoDB**
+ Anda dapat menggunakan Amazon EMR (Amazon EMR) dan Hive untuk menulis data dari Amazon S3 ke DynamoDB.
```
CREATE EXTERNAL TABLE s3_import(a_col string, b_col bigint, c_col array)
ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
LOCATION 's3://amzn-s3-demo-bucket/path/subpath/';
CREATE EXTERNAL TABLE hiveTableName (col1 string, col2 bigint, col3 array)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "dynamodbtable1",
"dynamodb.column.mapping" = "col1:name,col2:year,col3:holidays");
INSERT OVERWRITE TABLE hiveTableName SELECT * FROM s3_import;
```
**Untuk mengimpor tabel dari bucket Amazon S3 untuk DynamoDB tanpa menentukan pemetaan kolom**
+ Buat tabel `EXTERNAL` yang membuat referensi data yang disimpan di Amazon S3 yang sebelumnya diekspor dari DynamoDB. Sebelum mengimpor, pastikan bahwa tabel ada di DynamoDB dan bahwa tabel tersebut memiliki skema kunci yang sama seperti tabel DynamoDB yang sebelumnya diekspor. Selain itu, tabel harus memiliki tepat satu kolom tipe `map`. Jika Anda kemudian membuat tabel Hive yang terkait dengan DynamoDB, Anda dapat memanggil perintah `INSERT OVERWRITE` untuk menulis data dari Amazon S3 ke DynamoDB. Karena tidak ada pemetaan kolom, Anda tidak dapat melakukan kueri tabel yang diimpor dengan cara ini. Mengimpor data tanpa menentukan pemetaan kolom tersedia di Hive 0.8.1.5 atau setelahnya, yang didukung di Amazon EMR AMI 2.2.3 dan setelahnya.
```
CREATE EXTERNAL TABLE s3TableName (item map)
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' LINES TERMINATED BY '\n'
LOCATION 's3://amzn-s3-demo-bucket/path/subpath/';
CREATE EXTERNAL TABLE hiveTableName (item map)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "dynamodbtable1");
INSERT OVERWRITE TABLE hiveTableName SELECT *
FROM s3TableName;
```
**Untuk mengimpor tabel dari HDFS ke DynamoDB**
+ Anda dapat menggunakan Amazon EMR dan Hive untuk menulis data dari HDFS ke DynamoDB.
```
CREATE EXTERNAL TABLE hdfs_import(a_col string, b_col bigint, c_col array)
ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
LOCATION 'hdfs:///directoryName';
CREATE EXTERNAL TABLE hiveTableName (col1 string, col2 bigint, col3 array)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "dynamodbtable1",
"dynamodb.column.mapping" = "col1:name,col2:year,col3:holidays");
INSERT OVERWRITE TABLE hiveTableName SELECT * FROM hdfs_import;
```
## Melakukan kueri data dalam DynamoDB
Contoh berikut menunjukkan berbagai cara untuk menggunakan Amazon EMR untuk melakukan kueri data yang disimpan di DynamoDB.
**Untuk menemukan nilai terbesar untuk kolom dipetakan (`max`)**
+ Gunakan perintah Hive seperti berikut. Pada perintah pertama, pernyataan CREATE menciptakan tabel Hive yang membuat referensi data yang disimpan dalam DynamoDB. Pernyataan SELECT kemudian menggunakan tabel itu untuk melakukan kueri data yang disimpan dalam DynamoDB. Contoh berikut menemukan pesanan terbesar yang ditempatkan oleh pelanggan tertentu.
```
CREATE EXTERNAL TABLE hive_purchases(customerId bigint, total_cost double, items_purchased array)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "Purchases",
"dynamodb.column.mapping" = "customerId:CustomerId,total_cost:Cost,items_purchased:Items");
SELECT max(total_cost) from hive_purchases where customerId = 717;
```
**Untuk menggabungkan data menggunakan klausul `GROUP BY`**
+ Anda dapat menggunakan klausul `GROUP BY` untuk mengumpulkan data di beberapa catatan. Hal ini sering kali digunakan dengan fungsi agregat seperti sum, count, min, atau max. Contoh berikut mengembalikan daftar pesanan terbesar dari pelanggan yang telah menempatkan lebih dari tiga pesanan.
```
CREATE EXTERNAL TABLE hive_purchases(customerId bigint, total_cost double, items_purchased array)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "Purchases",
"dynamodb.column.mapping" = "customerId:CustomerId,total_cost:Cost,items_purchased:Items");
SELECT customerId, max(total_cost) from hive_purchases GROUP BY customerId HAVING count(*) > 3;
```
**Untuk menggabungkan dua tabel DynamoDB**
+ Contoh berikut memetakan dua tabel Hive ke data yang disimpan dalam DynamoDB. Ia kemudian memanggil gabungan di dua tabel itu. Gabungan dikomputasi pada klaster dan dikembalikan. Gabungan tidak terjadi di DynamoDB. Contoh ini mengembalikan daftar pelanggan dan pembelian mereka untuk pelanggan yang telah menempatkan lebih dari dua pesanan.
```
CREATE EXTERNAL TABLE hive_purchases(customerId bigint, total_cost double, items_purchased array)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "Purchases",
"dynamodb.column.mapping" = "customerId:CustomerId,total_cost:Cost,items_purchased:Items");
CREATE EXTERNAL TABLE hive_customers(customerId bigint, customerName string, customerAddress array)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "Customers",
"dynamodb.column.mapping" = "customerId:CustomerId,customerName:Name,customerAddress:Address");
Select c.customerId, c.customerName, count(*) as count from hive_customers c
JOIN hive_purchases p ON c.customerId=p.customerId
GROUP BY c.customerId, c.customerName HAVING count > 2;
```
**Untuk menggabungkan dua tabel dari sumber yang berbeda**
+ Pada contoh berikut, Customer\$1S3 adalah tabel Hive yang memuat file CSV yang disimpan di Amazon S3 dan hive\$1purchase adalah tabel yang membuat referensi data di DynamoDB. Contoh berikut menggabungkan data pelanggan yang disimpan sebagai file CSV di Amazon S3 dengan data pesanan yang disimpan di DynamoDB untuk mengembalikan satu set data yang mewakili pesanan yang ditempatkan oleh pelanggan yang terdapat kata "Miller" dalam nama mereka.
```
CREATE EXTERNAL TABLE hive_purchases(customerId bigint, total_cost double, items_purchased array)
STORED BY 'org.apache.hadoop.hive.dynamodb.DynamoDBStorageHandler'
TBLPROPERTIES ("dynamodb.table.name" = "Purchases",
"dynamodb.column.mapping" = "customerId:CustomerId,total_cost:Cost,items_purchased:Items");
CREATE EXTERNAL TABLE Customer_S3(customerId bigint, customerName string, customerAddress array)
ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
LOCATION 's3://amzn-s3-demo-bucket/path/subpath/';
Select c.customerId, c.customerName, c.customerAddress from
Customer_S3 c
JOIN hive_purchases p
ON c.customerid=p.customerid
where c.customerName like '%Miller%';
```
**catatan**
Dalam contoh sebelumnya, pernyataan CREATE TABLE disertakan dalam setiap contoh agar jelas dan lengkap. Ketika menjalankan beberapa kueri atau operasi ekspor terhadap tabel Hive tertentu, Anda hanya perlu membuat tabel satu kali, yakni pada awal sesi Hive.
# Mengoptimalkan performa untuk operasi Amazon EMR di DynamoDB
Operasi Amazon EMR pada tabel DynamoDB dihitung sebagai operasi baca, dan tunduk pada pengaturan throughput yang ditetapkan tabel. Amazon EMR mengimplementasikan logikanya sendiri untuk mencoba menyeimbangkan beban pada tabel DynamoDB Anda untuk meminimalkan kemungkinan melebihi throughput ditetapkan Anda. Pada akhir setiap kueri Hive, Amazon EMR mengembalikan informasi tentang klaster yang digunakan untuk memproses kueri, termasuk berapa kali throughput ditetapkan Anda terlampaui. Anda dapat menggunakan informasi ini, serta CloudWatch metrik tentang throughput DynamoDB Anda, untuk mengelola beban pada tabel DynamoDB Anda dengan lebih baik dalam permintaan berikutnya.
Faktor-faktor berikut mempengaruhi performa kueri Hive ketika bekerja dengan tabel DynamoDB.
## Unit kapasitas baca yang ditetapkan
Ketika Anda menjalankan kueri Hive terhadap tabel DynamoDB, Anda harus memastikan bahwa Anda telah menetapkan jumlah unit kapasitas baca yang memadai.
Misalnya, anggaplah bahwa Anda telah menetapkan 100 unit kapasitas baca untuk tabel DynamoDB Anda. Ini akan memungkinkan Anda melakukan 100 baca, atau 409,600 byte, per detik. Jika tabel yang berisi 20GB data (21.474.836.480 byte), dan kueri Hive Anda melakukan pindai tabel penuh, Anda dapat memperkirakan berapa lama kueri dijalankan:
* 21.474.836.480 / 409.600 = 52.429 detik = 14,56 jam *
Satu-satunya cara untuk mengurangi waktu yang diperlukan adalah menyesuaikan unit kapasitas baca pada tabel sumber DynamoDB. Menambahkan lebih banyak simpul ke klaster Amazon EMR tidak akan membantu.
Dalam output Hive, persentase penyelesaian diperbarui ketika satu proses pemeta atau lebih telah selesai dilakukan. Untuk tabel DynamoDB yang besar dengan pengaturan Kapasitas Baca ditetapkan yang rendah, output persentase penyelesaian mungkin tidak diperbarui dalam waktu yang lama; dalam kasus di atas, tugas akan muncul menjadi selesai 0% dalam beberapa jam. Untuk status yang lebih rinci pada kemajuan tugas Anda, buka konsol Amazon EMR; Anda akan dapat melihat status tugas pemeta individu, dan statistik untuk baca data.
Anda juga dapat masuk ke antarmuka Hadoop pada simpul utama dan melihat statistik Hadoop. Ini menunjukkan status tugas peta individu dan beberapa statistik data baca. Untuk informasi selengkapnya, lihat [Antarmuka web yang di-hosting pada simpul utama](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-web-interfaces.html) dalam *Panduan Pengelolaan Amazon EMR*.
## Pengaturan persen baca
Secara default, Amazon EMR mengelola beban permintaan terhadap tabel DynamoDB Anda sesuai dengan throughput ditetapkan Anda saat ini. Namun, ketika Amazon EMR mengembalikan informasi tentang tugas Anda yang mencakup throughput ditetapkan dalam jumlah yang tinggi melebihi tanggapan, Anda dapat menyesuaikan tingkat baca default menggunakan parameter `dynamodb.throughput.read.percent` ketika Anda menyiapkan tabel Hive. Untuk informasi selengkapnya tentang pengaturan parameter persentase baca, lihat [Pilihan Hive](EMR_Interactive_Hive.md#EMR_Hive_Options).
## Pengaturan persentase tulis
Secara default, Amazon EMR mengelola beban permintaan terhadap tabel DynamoDB Anda sesuai dengan throughput ditetapkan Anda saat ini. Namun, ketika Amazon EMR mengembalikan informasi tentang tugas Anda yang mencakup throughput ditetapkan dalam jumlah yang tinggi melebihi tanggapan, Anda dapat menyesuaikan tingkat tulis default menggunakan parameter `dynamodb.throughput.write.percent` ketika Anda menyiapkan tabel Hive. Untuk informasi selengkapnya tentang pengaturan parameter persentase tulis, lihat [Pilihan Hive](EMR_Interactive_Hive.md#EMR_Hive_Options).
## Pengaturan durasi coba lagi
Secara default, Amazon EMR menjalankan kembali kueri Hive jika ia belum mengembalikan hasil dalam waktu dua menit, yang merupakan interval coba lagi default. Anda dapat menyesuaikan interval ini dengan mengatur parameter `dynamodb.retry.duration` ketika Anda menjalankan kueri Hive. Untuk informasi selengkapnya tentang pengaturan parameter persentase tulis, lihat [Pilihan Hive](EMR_Interactive_Hive.md#EMR_Hive_Options).
## Jumlah tugas peta
Pemeta daemon yang diluncurkan Hadoop untuk memproses permintaan Anda untuk mengekspor dan melakukan data kueri pada data yang disimpan dalam DynamoDB dibatasi pada tingkat baca maksimum 1 MiB per detik untuk membatasi kapasitas baca yang digunakan. Jika Anda memiliki throughput ditetapkan tambahan yang tersedia di DynamoDB, Anda dapat meningkatkan performa ekspor Hive dan operasi kueri dengan meningkatkan jumlah pemeta daemon. Untuk melakukan ini, Anda dapat meningkatkan jumlah instans EC2 dalam klaster Anda *atau* meningkatkan jumlah pemeta daemon yang berjalan pada setiap instans EC2.
Anda dapat meningkatkan jumlah instans EC2 dalam sebuah klaster dengan melakukan pemfilteran stopword atas klaster saat ini dan meluncurkannya kembali dengan instans EC2 dalam jumlah besar. Anda menentukan jumlah instans EC2 di kotak dialog **Konfigurasikan Instans EC2** jika Anda meluncurkan klaster dari konsol Amazon EMR, atau dengan pilihan `‑‑num-instances` jika Anda meluncurkan klaster dari CLI.
Jumlah tugas peta yang berjalan pada instans tergantung pada tipe instans EC2. Untuk informasi lebih lanjut tentang tipe instans EC2 yang didukung dan jumlah pemeta yang disediakan masing-masing tipe, lihat [Konfigurasi tugas](emr-hadoop-task-config.md). Di sana, Anda akan menemukan bagian "Konfigurasi Tugas" untuk masing-masing konfigurasi yang didukung.
Cara lain untuk meningkatkan jumlah pemeta daemon adalah dengan mengubah parameter konfigurasi `mapreduce.tasktracker.map.tasks.maximum` Hadoop ke nilai yang lebih tinggi. Ini memiliki keuntungan yang memberikan Anda lebih banyak pemeta tanpa perlu meningkatkan jumlah atau ukuran instans EC2, sehingga Anda bisa menghemat uang Anda. Kerugiannya adalah bahwa dengan mengatur nilai ini terlalu tinggi akan dapat menyebabkan instans EC2 di klaster Anda kehabisan memori. Untuk mengatur `mapreduce.tasktracker.map.tasks.maximum`, luncurkan klaster dan tentukan nilai untuk `mapreduce.tasktracker.map.tasks.maximum` sebagai properti dari klasifikasi konfigurasi peta-situs. Ini ditunjukkan dalam contoh berikut. Untuk informasi selengkapnya, lihat [Konfigurasikan aplikasi](emr-configure-apps.md).
```
{
"configurations": [
{
"classification": "mapred-site",
"properties": {
"mapred.tasktracker.map.tasks.maximum": "10"
}
}
]
}
```
## Permintaan data paralel
Beberapa permintaan data, baik dari lebih dari satu pengguna atau lebih dari satu aplikasi ke satu tabel dapat menguras throughput ditetapkan baca dan performa menjadi lambat.
## Durasi proses
Konsistensi data di DynamoDB bergantung pada urutan operasi baca dan tulis pada setiap simpul. Saat kueri Hive sedang berjalan, aplikasi lain mungkin memuat data baru ke dalam tabel DynamoDB atau memodifikasi atau menghapus data yang ada. Dalam hal ini, hasil kueri Hive mungkin tidak akan mencerminkan perubahan yang dilakukan terhadap data saat kueri sedang berjalan.
## Hindari throughput yang melebihi
Saat menjalankan kueri Hive terhadap DynamoDB, berhati-hatilah untuk tidak melebihi throughput ditetapkan Anda, karena ini akan menguras kapasitas yang dibutuhkan untuk panggilan aplikasi Anda untuk `DynamoDB::Get`. Untuk memastikan bahwa ini tidak terjadi, Anda harus secara teratur memantau volume baca dan pembatasan panggilan aplikasi `DynamoDB::Get` dengan memeriksa log dan metrik pemantauan di Amazon. CloudWatch
## Waktu permintaan
Melakukan penjadwalan kueri Hive yang mengakses tabel DynamoDB ketika ada permintaan yang lebih rendah pada tabel DynamoDB akan dapat meningkatkan performa. Misalnya, jika sebagian besar pengguna aplikasi Anda tinggal di San Francisco, Anda dapat memilih untuk mengekspor data pada pukul 4 pagi setiap hari. PST, ketika sebagian besar pengguna tertidur, dan tidak memperbarui catatan dalam basis data DynamoDB Anda.
## Tabel berbasis waktu
Jika data diatur sebagai serangkaian tabel DynamoDB berbasis waktu, misalnya satu tabel per hari, maka Anda dapat mengekspor data ketika tabel tidak aktif lagi. Anda dapat menggunakan teknik ini untuk membuat cadangan data ke Amazon S3 secara berkelanjutan.
## Data yang diarsipkan
Jika Anda berencana untuk menjalankan banyak kueri Hive terhadap data yang disimpan dalam DynamoDB dan aplikasi Anda dapat mentolerir data yang diarsipkan, Anda mungkin ingin mengekspor data ke HDFS atau Amazon S3 dan menjalankan kueri Hive terhadap salinan data, bukan terhadap DynamoDB. Ini menghemat operasi baca dan throughput ditetapkan Anda.
# Kinesis
Cluster EMR Amazon dapat membaca dan memproses aliran Amazon Kinesis secara langsung, menggunakan alat yang sudah dikenal di ekosistem Hadoop seperti Hive, Pig,, Hadoop Streaming API, dan Cascading. MapReduce Anda juga dapat menggabungkan dengan data waktu nyata dari Amazon Kinesis dengan data yang ada di Amazon S3, Amazon DynamoDB, dan HDFS dalam sebuah klaster yang berjalan. Anda dapat langsung memuat data dari Amazon EMR ke Amazon S3 atau DynamoDB untuk kegiatan setelah pemrosesan. Untuk informasi tentang sorotan dan harga layanan Amazon Kinesis, lihat halaman [Amazon Kinesis](https://aws.amazon.com//kinesis).
## Apa yang dapat saya lakukan dengan integrasi Amazon EMR dan Amazon Kinesis?
Integrasi antara Amazon EMR dan Amazon Kinesis akan membuat skenario tertentu menjadi jauh lebih mudah; misalnya:
+ **Analisis log streaming**–Anda dapat menganalisis log web streaming untuk membuat daftar 10 tipe kesalahan teratas setiap beberapa menit menurut wilayah, peramban, dan domain akses.
+ **Keterlibatan pelanggan**–Anda dapat menulis kueri yang menggabungkan dengan data aliran klik dari Amazon Kinesis dengan informasi kampanye iklan yang disimpan dalam tabel DynamoDB untuk mengidentifikasi kategori iklan paling efektif yang ditampilkan di situs web tertentu.
+ **Kueri interaktif Ad-hoc**–Anda dapat memuat data secara berkala dari pengaliran Amazon Kinesis ke HDFS dan menyediakannya sebagai tabel Impala lokal untuk kueri cepat, interaktif, dan analitik.
## Analisis pengaliran Amazon Kinesis yang telah melalui checkpointing
Pengguna dapat menjalankan analisis berkala yang dikelompokkan dalam batch atas pengaliran Amazon Kinesis dalam apa yang disebut *iterasi*. Karena catatan data pengaliran Amazon Kinesis diambil dengan menggunakan nomor urut, maka batas iterasi ditentukan dengan memulai dan mengakhiri nomor urut yang disimpan oleh Amazon EMR dalam tabel DynamoDB. Misalnya, saat `iteration0` berakhir, ia menyimpan nomor urut akhir di DynamoDB sehingga ketika tugas `iteration1` dimulai, ia dapat mengambil data berikutnya dari pengaliran. Pemetaan iterasi dalam data pengaliran ini disebut *checkpointing*. Untuk informasi selengkapnya, lihat [Konektor Kinesis](https://aws.amazon.com/elasticmapreduce/faqs/#kinesis-connector).
Jika iterasi diperiksa dan pekerjaan gagal memproses iterasi, Amazon EMR mencoba memproses ulang catatan dalam iterasi tersebut.
Checkpointing adalah sebuah fitur yang memungkinkan Anda untuk:
+ Mulai pengolahan data setelah nomor urut diproses oleh kueri sebelumnya yang berjalan pada pengaliran dan nama logis yang sama
+ Memproses ulang batch data yang sama dari Kinesis yang diproses oleh kueri sebelumnya
Untuk mengaktifkan checkpointing, atur parameter `kinesis.checkpoint.enabled` untuk `true` dalam skrip Anda. Juga, konfigurasikan parameter-parameter berikut:
| Pengaturan konfigurasi | Deskripsi |
| --- | --- |
| kinesis.checkpoint.metastore.table.name | Nama tabel DynamoDB di mana informasi pos pemeriksaan akan disimpan |
| kinesis.checkpoint.metastore.hash.key.name | Nama kunci hash untuk tabel DynamoDB |
| kinesis.checkpoint.metastore.hash.range.name | Nama kunci range untuk tabel DynamoDB |
| kinesis.checkpoint.logical.name | Sebuah nama logis untuk pemrosesan saat ini |
| kinesis.checkpoint.iteration.no | Nomor iterasi untuk pemrosesan terkait dengan nama logis |
| kinesis.rerun.iteration.without.wait | Nilai Boolean yang menunjukkan jika iterasi gagal dapat dijalankan ulang tanpa perlu menunggu waktu habis; default-nya adalah false |
### Rekomendasi Provisioned IOPS untuk tabel Amazon DynamoDB
Konektor Amazon EMR untuk Amazon Kinesis menggunakan basis data DynamoDB sebagai dukungan untuk melakukan checkpointing metadata. Anda harus membuat tabel di DynamoDB sebelum menggunakan data dalam pengaliran Amazon Kinesis dengan klaster Amazon EMR dalam interval yang melalui checkpointing. Tabel harus berada dalam wilayah yang sama dengan klaster Amazon EMR. Berikut ini adalah rekomendasi umum untuk jumlah IOPS yang harus Anda sediakan untuk tabel DynamoDB Anda; biarkan `j` menjadi jumlah maksimum tugas Hadoop (dengan nama logis yang berbeda\$1kombinasi nomor iterasi) yang dapat berjalan bersamaan dan `s` menjadi jumlah maksimum serpihan yang akan diproses setiap tugas:
Untuk **Unit Kapasitas Baca**: `j`\$1`s`/`5`
Untuk **Unit Kapasitas Tulis**: `j`\$1`s`
## Pertimbangan performa
Throughput serpihan Amazon Kinesis berbanding lurus dengan ukuran instans simpul di klaster Amazon EMR dan ukuran catatan di pengaliran. Kami menyarankan Anda menggunakan instans m5.xlarge atau yang lebih besar pada simpul utama dan simpul inti.
## Jadwalkan analisis Amazon Kinesis dengan Amazon EMR
Ketika Anda menganalisis data pada pengaliran Amazon Kinesis aktif, yang dibatasi oleh waktu habis dan durasi maksimum untuk setiap iterasi, penting bahwa Anda sering menjalankan analisis untuk mengumpulkan detail periodik dari pengaliran. Ada beberapa cara untuk mengeksekusi skrip dan kueri tersebut secara berkala; sebaiknya gunakan AWS Data Pipeline untuk tugas berulang seperti ini. Untuk informasi selengkapnya, lihat [AWS Data Pipeline PigActivity](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-pigactivity.html)dan [AWS Data Pipeline HiveActivity](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-hiveactivity.html)di *Panduan AWS Data Pipeline Pengembang*.
# Migrasi konektor Spark Kinesis ke SDK 2.x untuk Amazon EMR 7.0
AWS SDK menyediakan seperangkat APIs dan pustaka yang kaya untuk berinteraksi dengan layanan komputasi AWS awan, seperti mengelola kredensil, menghubungkan ke layanan S3 dan Kinesis. Konektor Spark Kinesis digunakan untuk mengkonsumsi data dari Kinesis Data Streams, dan data yang diterima diubah dan diproses di mesin eksekusi Spark. Saat ini konektor ini dibangun di atas 1.x AWS SDK dan Kinesis-client-library (KCL).
Sebagai bagian dari migrasi AWS SDK 2.x, konektor Spark Kinesis juga diperbarui sesuai untuk dijalankan dengan SDK 2.x. Dalam rilis Amazon EMR 7.0, Spark berisi upgrade SDK 2.x yang belum tersedia di versi komunitas Apache Spark. Jika Anda menggunakan konektor Spark Kinesis dari rilis yang lebih rendah dari 7.0, Anda harus memigrasikan kode aplikasi agar berjalan di SDK 2.x sebelum dapat bermigrasi ke Amazon EMR 7.0.
## Panduan migrasi
Bagian ini menjelaskan langkah-langkah untuk memigrasikan aplikasi ke konektor Kinesis Spark yang ditingkatkan. Ini mencakup panduan untuk bermigrasi ke Kinesis Client Library (KCL) 2.x AWS , penyedia kredensi, AWS dan klien layanan di SDK 2.x. AWS Sebagai referensi, ini juga mencakup [WordCount](https://github.com/apache/spark/blob/v3.5.0/connector/kinesis-asl/src/main/scala/org/apache/spark/examples/streaming/KinesisWordCountASL.scala)program sampel yang menggunakan konektor Kinesis.
**Topics**
+ [Migrasi KCL dari 1.x ke 2.x](#migrating-spark-kinesis-KCL-from-1.x-to-2.x)
+ [Memigrasi penyedia AWS kredensional dari AWS SDK 1.x ke 2.x](#migrating-spark-kinesis-creds-from-1.x-to-2.x)
+ [Memigrasi klien AWS layanan dari AWS SDK 1.x ke 2.x](#migrating-spark-kinesis-service-from-1.x-to-2.x)
+ [Contoh kode untuk aplikasi streaming](#migrating-spark-kinesis-streaming-examples)
+ [Pertimbangan saat menggunakan konektor Kinesis Spark yang ditingkatkan](#migrating-spark-kinesis-considerations)
### Migrasi KCL dari 1.x ke 2.x
+ **Tingkat dan dimensi metrik di `KinesisInputDStream`**
Saat membuat instance`KinesisInputDStream`, Anda dapat mengontrol level dan dimensi metrik untuk aliran. Contoh berikut menunjukkan bagaimana Anda dapat menyesuaikan parameter ini dengan KCL 1.x:
```
import com.amazonaws.services.kinesis.clientlibrary.lib.worker.KinesisClientLibConfiguration
import com.amazonaws.services.kinesis.metrics.interfaces.MetricsLevel
val kinesisStream = KinesisInputDStream.builder
.streamingContext(ssc)
.streamName(streamName)
.endpointUrl(endpointUrl)
.regionName(regionName)
.initialPosition(new Latest())
.checkpointAppName(appName)
.checkpointInterval(kinesisCheckpointInterval)
.storageLevel(StorageLevel.MEMORY_AND_DISK_2)
.metricsLevel(MetricsLevel.DETAILED)
.metricsEnabledDimensions(KinesisClientLibConfiguration.DEFAULT_METRICS_ENABLED_DIMENSIONS.asScala.toSet)
.build()
```
Di KCL 2.x, pengaturan konfigurasi ini memiliki nama paket yang berbeda. Untuk bermigrasi ke 2.x:
1. Ubah pernyataan impor untuk `com.amazonaws.services.kinesis.clientlibrary.lib.worker.KinesisClientLibConfiguration` dan `com.amazonaws.services.kinesis.metrics.interfaces.MetricsLevel` ke `software.amazon.kinesis.metrics.MetricsLevel` dan `software.amazon.kinesis.metrics.MetricsUtil` masing-masing.
```
// import com.amazonaws.services.kinesis.metrics.interfaces.MetricsLevel
import software.amazon.kinesis.metrics.MetricsLevel
// import com.amazonaws.services.kinesis.clientlibrary.lib.worker.KinesisClientLibConfiguration
import software.amazon.kinesis.metrics.MetricsUtil
```
1. Ganti garis `metricsEnabledDimensionsKinesisClientLibConfiguration.DEFAULT_METRICS_ENABLED_DIMENSIONS.asScala.toSet` dengan `metricsEnabledDimensionsSet(MetricsUtil.OPERATION_DIMENSION_NAME, MetricsUtil.SHARD_ID_DIMENSION_NAME)`
Berikut ini adalah versi terbaru dari `KinesisInputDStream` dengan tingkat metrik dan dimensi metrik yang disesuaikan:
```
import software.amazon.kinesis.metrics.MetricsLevel
import software.amazon.kinesis.metrics.MetricsUtil
val kinesisStream = KinesisInputDStream.builder
.streamingContext(ssc)
.streamName(streamName)
.endpointUrl(endpointUrl)
.regionName(regionName)
.initialPosition(new Latest())
.checkpointAppName(appName)
.checkpointInterval(kinesisCheckpointInterval)
.storageLevel(StorageLevel.MEMORY_AND_DISK_2)
.metricsLevel(MetricsLevel.DETAILED)
.metricsEnabledDimensions(Set(MetricsUtil.OPERATION_DIMENSION_NAME, MetricsUtil.SHARD_ID_DIMENSION_NAME))
.build()
```
+ Fungsi penangan pesan di `KinesisInputDStream`
Saat membuat instance`KinesisInputDStream`, Anda juga dapat menyediakan “fungsi penangan pesan” yang mengambil Rekaman Kinesis dan mengembalikan objek generik T, jika Anda ingin menggunakan data lain yang disertakan dalam Rekaman seperti kunci partisi.
Di KCL 1.x, tanda tangan fungsi penangan pesan adalah:`Record => T`, di mana Record berada. `com.amazonaws.services.kinesis.model.Record` Di KCL 2.x, tanda tangan handler diubah menjadi:`KinesisClientRecord => T`, where is. KinesisClientRecord `software.amazon.kinesis.retrieval.KinesisClientRecord`
Berikut ini adalah contoh penyediaan handler pesan di KCL 1.x:
```
import com.amazonaws.services.kinesis.model.Record
def addFive(r: Record): Int = JavaUtils.bytesToString(r.getData).toInt + 5
val stream = KinesisInputDStream.builder
.streamingContext(ssc)
.streamName(streamName)
.endpointUrl(endpointUrl)
.regionName(regionName)
.initialPosition(new Latest())
.checkpointAppName(appName)
.checkpointInterval(Seconds(10))
.storageLevel(StorageLevel.MEMORY_ONLY)
.buildWithMessageHandler(addFive)
```
Untuk memigrasikan penangan pesan:
1. Ubah pernyataan impor `com.amazonaws.services.kinesis.model.Record` menjadi`software.amazon.kinesis.retrieval.KinesisClientRecord`.
```
// import com.amazonaws.services.kinesis.model.Record
import software.amazon.kinesis.retrieval.KinesisClientRecord
```
1. Perbarui tanda tangan metode handler pesan.
```
//def addFive(r: Record): Int = JavaUtils.bytesToString(r.getData).toInt + 5
def addFive = (r: KinesisClientRecord) => JavaUtils.bytesToString(r.data()).toInt + 5
```
Berikut ini adalah contoh terbaru dari menyediakan handler pesan di KCL 2.x:
```
import software.amazon.kinesis.retrieval.KinesisClientRecord
def addFive = (r: KinesisClientRecord) => JavaUtils.bytesToString(r.data()).toInt + 5
val stream = KinesisInputDStream.builder
.streamingContext(ssc)
.streamName(streamName)
.endpointUrl(endpointUrl)
.regionName(regionName)
.initialPosition(new Latest())
.checkpointAppName(appName)
.checkpointInterval(Seconds(10))
.storageLevel(StorageLevel.MEMORY_ONLY)
.buildWithMessageHandler(addFive)
```
Untuk informasi selengkapnya tentang migrasi dari KCL 1.x ke 2.x, lihat [Migrasi Konsumen dari KCL 1.x ke KCL](https://docs.aws.amazon.com/streams/latest/dev/kcl-migration.html) 2.x.
### Memigrasi penyedia AWS kredensional dari AWS SDK 1.x ke 2.x
Penyedia kredensial digunakan untuk mendapatkan AWS kredensil untuk interaksi dengan. AWS[Ada beberapa perubahan antarmuka dan kelas yang terkait dengan penyedia kredensional di SDK 2.x, yang dapat ditemukan di sini.](https://github.com/aws/aws-sdk-java-v2/blob/master/docs/LaunchChangelog.md#122-client-credentials) Konektor Spark Kinesis telah mendefinisikan interface `org.apache.spark.streaming.kinesis.SparkAWSCredentials` () dan kelas implementasi yang mengembalikan versi AWS 1.x dari penyedia kredensi. Penyedia kredensi ini diperlukan saat menginisialisasi klien Kinesis. Misalnya, jika Anda menggunakan metode `SparkAWSCredentials.provider` dalam aplikasi, Anda perlu memperbarui kode untuk menggunakan penyedia AWS kredensi versi 2.x.
Berikut ini adalah contoh penggunaan penyedia kredensi di AWS SDK 1.x:
```
import org.apache.spark.streaming.kinesis.SparkAWSCredentials
import com.amazonaws.auth.AWSCredentialsProvider
val basicSparkCredentials = SparkAWSCredentials.builder
.basicCredentials("accessKey", "secretKey")
.build()
val credentialProvider = basicSparkCredentials.provider
assert(credentialProvider.isInstanceOf[AWSCredentialsProvider], "Type should be AWSCredentialsProvider")
```
**Untuk bermigrasi ke SDK 2.x:**
1. Ubah pernyataan impor `com.amazonaws.auth.AWSCredentialsProvider` menjadi `software.amazon.awssdk.auth.credentials.AwsCredentialsProvider`
```
//import com.amazonaws.auth.AWSCredentialsProvider
import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider
```
1. Perbarui kode yang tersisa yang menggunakan kelas ini.
```
import org.apache.spark.streaming.kinesis.SparkAWSCredentials
import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider
val basicSparkCredentials = SparkAWSCredentials.builder
.basicCredentials("accessKey", "secretKey")
.build()
val credentialProvider = basicSparkCredentials.provider
assert (credentialProvider.isInstanceOf[AwsCredentialsProvider], "Type should be AwsCredentialsProvider")
```
### Memigrasi klien AWS layanan dari AWS SDK 1.x ke 2.x
AWS klien layanan memiliki nama paket yang berbeda di 2.x (yaitu`software.amazon.awssdk`). sedangkan SDK 1.x menggunakan. `com.amazonaws` Untuk informasi lebih lanjut tentang perubahan klien, lihat [di sini](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration-whats-different.html). Jika Anda menggunakan klien layanan ini dalam kode, Anda perlu memigrasikan klien yang sesuai.
Berikut ini adalah contoh membuat klien di SDK 1.x:
```
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient
import com.amazonaws.services.dynamodbv2.document.DynamoDB
AmazonDynamoDB ddbClient = AmazonDynamoDBClientBuilder.defaultClient();
AmazonDynamoDBClient ddbClient = new AmazonDynamoDBClient();
```
**Untuk bermigrasi ke 2.x:**
1. Ubah pernyataan impor untuk klien layanan. Ambil klien DynamoDB sebagai contoh. Anda akan perlu untuk mengubah `com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient` atau `com.amazonaws.services.dynamodbv2.document.DynamoDB` untuk`software.amazon.awssdk.services.dynamodb.DynamoDbClient`.
```
// import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient
// import com.amazonaws.services.dynamodbv2.document.DynamoDB
import software.amazon.awssdk.services.dynamodb.DynamoDbClient
```
1. Perbarui kode yang menginisialisasi klien
```
// AmazonDynamoDB ddbClient = AmazonDynamoDBClientBuilder.defaultClient();
// AmazonDynamoDBClient ddbClient = new AmazonDynamoDBClient();
DynamoDbClient ddbClient = DynamoDbClient.create();
DynamoDbClient ddbClient = DynamoDbClient.builder().build();
```
Untuk informasi selengkapnya tentang migrasi AWS SDK dari 1.x ke 2.x, lihat [Apa yang berbeda antara SDK for AWS Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration-whats-different.html) 1.x dan 2.x
### Contoh kode untuk aplikasi streaming
```
import java.net.URI
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider
import software.amazon.awssdk.http.apache.ApacheHttpClient
import software.amazon.awssdk.services.kinesis.KinesisClient
import software.amazon.awssdk.services.kinesis.model.DescribeStreamRequest
import software.amazon.awssdk.regions.Region
import software.amazon.kinesis.metrics.{MetricsLevel, MetricsUtil}
import org.apache.spark.SparkConf
import org.apache.spark.storage.StorageLevel
import org.apache.spark.streaming.{Milliseconds, StreamingContext}
import org.apache.spark.streaming.dstream.DStream.toPairDStreamFunctions
import org.apache.spark.streaming.kinesis.KinesisInitialPositions.Latest
import org.apache.spark.streaming.kinesis.KinesisInputDStream
object KinesisWordCountASLSDKV2 {
def main(args: Array[String]): Unit = {
val appName = "demo-app"
val streamName = "demo-kinesis-test"
val endpointUrl = "https://kinesis.us-west-2.amazonaws.com"
val regionName = "us-west-2"
// Determine the number of shards from the stream using the low-level Kinesis Client
// from the AWS Java SDK.
val credentialsProvider = DefaultCredentialsProvider.create
require(credentialsProvider.resolveCredentials() != null,
"No AWS credentials found. Please specify credentials using one of the methods specified " +
"in https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html")
val kinesisClient = KinesisClient.builder()
.credentialsProvider(credentialsProvider)
.region(Region.US_WEST_2)
.endpointOverride(URI.create(endpointUrl))
.httpClientBuilder(ApacheHttpClient.builder())
.build()
val describeStreamRequest = DescribeStreamRequest.builder()
.streamName(streamName)
.build()
val numShards = kinesisClient.describeStream(describeStreamRequest)
.streamDescription
.shards
.size
// In this example, we are going to create 1 Kinesis Receiver/input DStream for each shard.
// This is not a necessity; if there are less receivers/DStreams than the number of shards,
// then the shards will be automatically distributed among the receivers and each receiver
// will receive data from multiple shards.
val numStreams = numShards
// Spark Streaming batch interval
val batchInterval = Milliseconds(2000)
// Kinesis checkpoint interval is the interval at which the DynamoDB is updated with information
// on sequence number of records that have been received. Same as batchInterval for this
// example.
val kinesisCheckpointInterval = batchInterval
// Setup the SparkConfig and StreamingContext
val sparkConfig = new SparkConf().setAppName("KinesisWordCountASLSDKV2")
val ssc = new StreamingContext(sparkConfig, batchInterval)
// Create the Kinesis DStreams
val kinesisStreams = (0 until numStreams).map { i =>
KinesisInputDStream.builder
.streamingContext(ssc)
.streamName(streamName)
.endpointUrl(endpointUrl)
.regionName(regionName)
.initialPosition(new Latest())
.checkpointAppName(appName)
.checkpointInterval(kinesisCheckpointInterval)
.storageLevel(StorageLevel.MEMORY_AND_DISK_2)
.metricsLevel(MetricsLevel.DETAILED)
.metricsEnabledDimensions(Set(MetricsUtil.OPERATION_DIMENSION_NAME, MetricsUtil.SHARD_ID_DIMENSION_NAME))
.build()
}
// Union all the streams
val unionStreams = ssc.union(kinesisStreams)
// Convert each line of Array[Byte] to String, and split into words
val words = unionStreams.flatMap(byteArray => new String(byteArray).split(" "))
// Map each word to a (word, 1) tuple so we can reduce by key to count the words
val wordCounts = words.map(word => (word, 1)).reduceByKey(_ + _)
// Print the first 10 wordCounts
wordCounts.print()
// Start the streaming context and await termination
ssc.start()
ssc.awaitTermination()
}
}
```
### Pertimbangan saat menggunakan konektor Kinesis Spark yang ditingkatkan
+ Jika aplikasi Anda menggunakan versi `Kinesis-producer-library` With JDK lebih rendah dari 11, Anda mungkin mengalami pengecualian seperti. `java.lang.NoClassDefFoundError: javax/xml/bind/DatatypeConverter` Ini terjadi karena EMR 7.0 hadir dengan JDK 17 secara default dan modul J2EE telah dihapus dari pustaka standar sejak Java 11\$1. Ini bisa diperbaiki dengan menambahkan ketergantungan berikut dalam file pom. Ganti versi perpustakaan dengan satu sesuai keinginan Anda.
```
javax.xml.bind
jaxb-api
${jaxb-api.version}
```
+ Stoples konektor Spark Kinesis dapat ditemukan di bawah jalur ini setelah cluster EMR dibuat: `/usr/lib/spark/connector/lib/`
# S3 DistCp (s3-dist-cp)
Apache DistCp adalah alat sumber terbuka yang dapat Anda gunakan untuk menyalin data dalam jumlah besar. *S3 DistCp* mirip dengan DistCp, tetapi dioptimalkan untuk bekerja dengan AWS, terutama Amazon S3. Perintah untuk S3 DistCp di Amazon EMR versi 4.0 dan yang lebih baru `s3-dist-cp` adalah, yang Anda tambahkan sebagai langkah di cluster atau di baris perintah. Menggunakan S3DistCp, Anda dapat secara efisien menyalin sejumlah besar data dari Amazon S3 ke HDFS di mana ia dapat diproses dengan langkah-langkah selanjutnya di cluster EMR Amazon Anda. Anda juga dapat menggunakan S3 DistCp untuk menyalin data antara bucket Amazon S3 atau dari HDFS ke Amazon S3. S3 DistCp lebih skalabel dan efisien untuk paralel menyalin sejumlah besar objek di seluruh bucket dan di seluruh akun. AWS
Untuk perintah spesifik yang menunjukkan fleksibilitas S3DistCP dalam skenario dunia nyata, lihat [Tujuh tips untuk menggunakan S3 DistCp](https://aws.amazon.com/blogs/big-data/seven-tips-for-using-s3distcp-on-amazon-emr-to-move-data-efficiently-between-hdfs-and-amazon-s3/) di blog Big Data. AWS
Seperti DistCp, S3 DistCp menggunakan MapReduce untuk menyalin secara terdistribusi. Ia berbagi salinan, penanganan kesalahan, pemulihan, dan pelaporan tugas di beberapa server. Untuk informasi lebih lanjut tentang proyek DistCp open source Apache, lihat [DistCppanduan](http://hadoop.apache.org/docs/stable/hadoop-distcp/DistCp.html) dalam dokumentasi Apache Hadoop.
Jika S3 DistCp tidak dapat menyalin beberapa atau semua file yang ditentukan, langkah cluster gagal dan mengembalikan kode kesalahan bukan nol. Jika ini terjadi, S3 DistCp tidak membersihkan file yang disalin sebagian.
**penting**
S3 DistCp tidak mendukung nama bucket Amazon S3 yang berisi karakter garis bawah.
S3 DistCp tidak mendukung penggabungan untuk file Parket. Gunakan PySpark sebagai gantinya. Untuk informasi selengkapnya, lihat [Menggabungkan file parquet di Amazon EMR](https://aws.amazon.com/premiumsupport/knowledge-center/emr-concatenate-parquet-files/).
Untuk menghindari kesalahan penyalinan saat menggunakan S3DistCP untuk menyalin satu file (bukan direktori) dari S3 ke HDFS, gunakan Amazon EMR versi 5.33.0 atau yang lebih baru, atau Amazon EMR versi 6.3.0 atau yang lebih baru.
## Opsi S3 DistCp
Meskipun mirip dengan DistCp, S3 DistCp mendukung serangkaian opsi yang berbeda untuk mengubah cara menyalin dan mengompres data.
Saat Anda memanggil S3DistCp, Anda dapat menentukan opsi yang dijelaskan dalam tabel berikut. Opsi ditambahkan pada langkah menggunakan daftar argumen. Contoh DistCp argumen S3 ditunjukkan pada tabel berikut.
| Opsi | Deskripsi | Wajib |
| --- | --- | --- |
| ‑‑src=LOCATION | Lokasi data yang akan disalin. Ini dapat berupa lokasi HDFS atau lokasi Amazon S3. Contoh: `‑‑src=s3://amzn-s3-demo-bucket/logs/j-3GYXXXXXX9IOJ/node` S3 DistCp tidak mendukung nama bucket Amazon S3 yang berisi karakter garis bawah. | Ya |
| ‑‑dest=LOCATION | Tujuan untuk data. Ini dapat berupa lokasi HDFS atau lokasi Amazon S3. Contoh: `‑‑dest=hdfs:///output` S3 DistCp tidak mendukung nama bucket Amazon S3 yang berisi karakter garis bawah. | Ya |
| ‑‑srcPattern=PATTERN | [ekspresi reguler](http://en.wikipedia.org/wiki/Regular_expression) yang memfilter operasi penyalinan ke data subset di `‑‑src`. Jika tidak ditentukan ke `‑‑srcPattern` dan juga `‑‑groupBy`, maka semua data di `‑‑src` akan disalin ke `‑‑dest`. Jika argumen ekspresi reguler berisi karakter khusus, seperti tanda bintang (\$1), maka ekspresi reguler atau seluruh string `‑‑args` harus diapit menggunakan tanda kutip tunggal ('). Contoh: `‑‑srcPattern=.*daemons.*-hadoop-.*` | Tidak |
| ‑‑groupBy=PATTERN | [Ekspresi reguler](http://en.wikipedia.org/wiki/Regular_expression) yang menyebabkan S3 DistCp menggabungkan file yang cocok dengan ekspresi. Sebagai contoh, Anda dapat menggunakan opsi ini untuk menggabungkan semua berkas log yang ditulis dalam satu jam ke dalam satu file. Nama file gabungan adalah nilai yang cocok dengan ekspresi reguler untuk pengelompokan dalam grup. Tanda kurung menunjukkan bagaimana file harus dikelompokkan dalam grup, dengan semua item yang cocok dengan pernyataan yang ada dalam tanda kurung yang digabungkan menjadi satu file output. Jika ekspresi reguler tidak menyertakan pernyataan tanda kurung, cluster gagal pada DistCp langkah S3 dan mengembalikan kesalahan. Jika argumen ekspresi reguler berisi karakter khusus, seperti tanda bintang (\$1), maka ekspresi reguler atau seluruh string `‑‑args` harus diapit menggunakan tanda kutip tunggal ('). Saat `‑‑groupBy` ditentukan, hanya file yang cocok dengan pola yang ditentukan yang akan disalin. Anda tidak perlu menentukan `‑‑groupBy` dan `‑‑srcPattern` pada saat yang sama. Contoh: `‑‑groupBy=.*subnetid.*([0-9]+-[0-9]+-[0-9]+-[0-9]+).*` | Tidak |
| ‑‑targetSize=SIZE | Ukuran file yang akan dibuat, dalam mebibytes (MIB), ditentukan berdasarkan opsi `‑‑groupBy`. Nilai ini harus berupa integer. Ketika `‑‑targetSize` diatur, S3 DistCp mencoba untuk mencocokkan ukuran ini; ukuran sebenarnya dari file yang disalin mungkin lebih besar atau lebih kecil dari nilai ini. Tugas dikumpulkan berdasarkan ukuran file data, sehingga ada kemungkinan bahwa ukuran file target akan cocok dengan ukuran file data sumber. Jika file yang dirangkai oleh `‑‑groupBy` lebih besar dari nilai `‑‑targetSize`, maka file akan dipecah menjadi beberapa bagian file, dan diberi nama secara berurutan dengan nilai numerik yang ditambahkan pada akhir namanya. Sebagai contoh, sebuah file digabungkan ke dalam `myfile.gz` akan dipecah menjadi beberapa bagian sebagai: `myfile0.gz`, `myfile1.gz`, dll. Contoh: `‑‑targetSize=2` | Tidak |
| ‑‑appendToLastFile | Menentukan perilaku S3 DistCp saat menyalin ke file dari Amazon S3 ke HDFS yang sudah ada. Ini menambahkan data file baru ke file yang ada. Jika Anda menggunakan `‑‑appendToLastFile` dengan `‑‑groupBy`, data baru ditambahkan ke file yang cocok dengan kelompok yang sama. Opsi ini juga menghormati `‑‑targetSize` perilaku ketika digunakan dengan `‑‑groupBy.` | Tidak |
| ‑‑outputCodec=CODEC | Tentukan codec kompresi untuk digunakan untuk file disalin. Ini dapat mengambil nilai: `gzip`, `gz`, `lzo`, `snappy`, atau `none`. Anda dapat menggunakan opsi ini, misalnya, untuk mengkonversi file input yang dikompresi dengan Gzip ke file output dengan kompresi LZO, atau untuk uncompress file sebagai bagian dari operasi penyalinan. Jika Anda memilih codec output, nama file akan ditambahkan dengan ekstensi yang sesuai (misalnya untuk `gz` dan `gzip`, ekstensinya adalah `.gz`) Jika Anda tidak menentukan nilai untuk `‑‑outputCodec`, maka file akan disalin dengan tidak ada perubahan dalam kompresinya. Contoh: `‑‑outputCodec=lzo` | Tidak |
| ‑‑s3ServerSideEncryption | Memastikan bahwa data target ditransfer menggunakan SSL dan dienkripsi secara otomatis di Amazon S3 menggunakan kunci sisi layanan. AWS Saat mengambil data menggunakan S3DistCp, objek secara otomatis tidak terenkripsi. Jika Anda mencoba menyalin objek yang tidak dienkripsi ke bucket Amazon S3 yang mengharuskan enkripsi, maka operasi gagal. Untuk informasi selengkapnya, lihat [Menggunakan enkripsi data](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingEncryption.html). Contoh: `‑‑s3ServerSideEncryption` | Tidak |
| ‑‑deleteOnSuccess | Jika operasi salin berhasil, opsi ini menyebabkan S3 DistCp menghapus file yang disalin dari lokasi sumber. Hal ini berguna jika Anda menyalin file output, misalnya berkas log, dari satu lokasi ke lokasi lain sebagai tugas terjadwal, dan Anda tidak ingin menyalin file yang sama dua kali. Contoh: `‑‑deleteOnSuccess` | Tidak |
| ‑‑disableMultipartUpload | Nonaktifkan penggunaan unggahan multipart. Contoh: `‑‑disableMultipartUpload` | Tidak |
| ‑‑multipartUploadChunkSize=SIZE | Ukuran, dalam MiB, dari setiap bagian dalam unggahan multipart Amazon S3. S3 DistCp menggunakan unggahan multipart saat menyalin data yang lebih besar dari file. `multipartUploadChunkSize` Untuk meningkatkan kinerja pekerjaan, Anda dapat meningkatkan ukuran setiap bagian. Ukuran default adalah 128 MiB. Contoh: `‑‑multipartUploadChunkSize=1000` | Tidak |
| ‑‑numberFiles | Tambahkan file output dengan nomor berurutan. Hitungannya dimulai dari 0 kecuali nilai yang berbeda ditentukan oleh `‑‑startingIndex`. Contoh: `‑‑numberFiles` | Tidak |
| ‑‑startingIndex=INDEX | Digunakan dengan `‑‑numberFiles` untuk menentukan nomor pertama dalam urutan. Contoh: `‑‑startingIndex=1` | Tidak |
| ‑‑outputManifest=FILENAME | Membuat file teks, dikompresi dengan Gzip, yang berisi daftar semua file yang disalin oleh S3. DistCp Contoh: `‑‑outputManifest=manifest-1.gz` | Tidak |
| ‑‑previousManifest=PATH | Membaca file manifes yang dibuat selama panggilan sebelumnya ke S3 DistCp menggunakan `‑‑outputManifest` bendera. Saat `‑‑previousManifest` bendera disetel, S3 DistCp mengecualikan file yang tercantum dalam manifes dari operasi penyalinan. Jika `‑‑outputManifest` ditentukan bersama dengan `‑‑previousManifest`, maka file yang tercantum dalam manifes sebelumnya juga akan muncul di file manifes baru, meskipun file tidak disalin. Contoh: `‑‑previousManifest=/usr/bin/manifest-1.gz` | Tidak |
| ‑‑requirePreviousManifest | Memerlukan manifes sebelumnya yang dibuat selama panggilan sebelumnya ke S3DistCp. Jika ini diatur ke SALAH, maka tidak akan ada kesalahan yang dihasilkan ketika manifes sebelumnya tidak ditentukan. Default-nya adalah BETUL. | Tidak |
| ‑‑copyFromManifest | Membalikkan perilaku `‑‑previousManifest` untuk menyebabkan S3 DistCp menggunakan file manifes yang ditentukan sebagai daftar file yang akan disalin, bukan daftar file yang dikecualikan dari penyalinan. Contoh: `‑‑copyFromManifest ‑‑previousManifest=/usr/bin/manifest-1.gz` | Tidak |
| ‑‑s3Endpoint=ENDPOINT | Tentukan titik akhir Amazon S3 yang akan digunakan saat mengunggah file. Opsi ini menetapkan titik akhir untuk baik untuk sumber maupun tujuan. Jika tidak diatur, maka titik akhir default-nya adalah `s3.amazonaws.com`. Untuk daftar titik akhir Amazon S3, lihat [Wilayah dan titik akhir](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region). Contoh: `‑‑s3Endpoint=s3.eu-west-1.amazonaws.com` | Tidak |
| ‑‑storageClass=CLASS | Kelas penyimpanan yang akan digunakan saat tujuannya adalah Amazon S3. Nilai yang valid adalah STANDARD dan REDUCED\$1REDUNDANCY. Jika opsi ini tidak ditentukan, S3 DistCp mencoba mempertahankan kelas penyimpanan. Contoh: `‑‑storageClass=STANDARD` | Tidak |
| ‑‑srcPrefixesFile=PATH | File teks di Amazon S3 (s3://), HDFS (hdfs:///) atau sistem file lokal (file:/) yang berisi daftar prefiks `src`, satu prefiks per baris. Jika `srcPrefixesFile` disediakan, S3 tidak DistCp akan mencantumkan jalur src. Sebaliknya, ia akan menghasilkan daftar sumber sebagai hasil gabungan dari daftar semua prefiks yang ditentukan dalam file ini. Path relatif dibandingkan dengan path src, bukan prefiks-prefiks ini, akan digunakan untuk menghasilkan path tujuan. Jika `srcPattern` juga ditentukan, ia akan diterapkan pada hasil daftar gabungan dari prefiks sumber untuk mem-filter input lebih lanjut. Jika `copyFromManifest` digunakan, objek dalam manifes akan disalin dan `srcPrefixesFile` akan diabaikan. Contoh: `‑‑srcPrefixesFile=PATH` | Tidak |
Selain opsi di atas, S3 DistCp mengimplementasikan [antarmuka Alat](https://hadoop.apache.org/docs/current/api/org/apache/hadoop/util/Tool.html) yang berarti mendukung opsi generik.
## Menambahkan S3 DistCp sebagai langkah dalam cluster
Anda dapat memanggil S3 DistCp dengan menambahkannya sebagai langkah di cluster Anda. Langkah-langkah dapat ditambahkan ke klaster saat peluncuran atau ke kluster yang sedang berjalan menggunakan konsol tersebut, CLI, atau API. Contoh berikut menunjukkan penambahan DistCp langkah S3 ke cluster yang sedang berjalan. Untuk informasi selengkapnya tentang menambahkan langkah-langkah ke klaster, lihat [Mengirim tugas ke klaster](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-work-with-steps.html) dalam *Panduan Pengelolaan Amazon EMR*.
**Untuk menambahkan DistCp langkah S3 ke cluster yang sedang berjalan menggunakan AWS CLI**
Untuk informasi selengkapnya tentang penggunaan perintah EMR Amazon di AWS CLI, lihat Referensi [AWS CLI Perintah](https://docs.aws.amazon.com/cli/latest/reference/emr).
+ Untuk menambahkan langkah ke cluster yang memanggil S3DistCp, berikan parameter yang menentukan bagaimana S3 DistCp harus melakukan operasi penyalinan sebagai argumen.
Contoh berikut adalah penyalinan daemon log dari Amazon S3 ke `hdfs:///output`. Dalam perintah berikut:
+ `‑‑cluster-id` menentukan klaster
+ `Jar`adalah lokasi file DistCp JAR S3. Untuk contoh cara menjalankan perintah di cluster menggunakan command-runner.jar, lihat [Mengirimkan langkah JAR khusus untuk menjalankan skrip atau perintah](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-commandrunner.html#emr-commandrunner-examples).
+ `Args`adalah daftar yang dipisahkan koma dari pasangan nama-nilai opsi untuk diteruskan ke S3. DistCp Untuk daftar lengkap opsi yang tersedia, lihat [Opsi S3 DistCp](#UsingEMR_s3distcp.options).
Untuk menambahkan langkah DistCp penyalinan S3 ke cluster yang sedang berjalan, letakkan yang berikut ini dalam file JSON yang disimpan di Amazon S3 atau sistem file lokal Anda `myStep.json` seperti contoh ini. Ganti *j-3GYXXXXXX9IOK* dengan ID cluster Anda dan ganti *amzn-s3-demo-bucket* dengan nama bucket Amazon S3 Anda.
```
[
{
"Name":"S3DistCp step",
"Args":["s3-dist-cp","‑‑s3Endpoint=s3.amazonaws.com","‑‑src=s3://amzn-s3-demo-bucket/logs/j-3GYXXXXXX9IOJ/node/","‑‑dest=hdfs:///output","‑‑srcPattern=.*[a-zA-Z,]+"],
"ActionOnFailure":"CONTINUE",
"Type":"CUSTOM_JAR",
"Jar":"command-runner.jar"
}
]
```
```
aws emr add-steps ‑‑cluster-id j-3GYXXXXXX9IOK ‑‑steps file://./myStep.json
```
**Example Salin berkas log dari Amazon S3 ke HDFS**
Contoh ini juga menggambarkan cara menyalin berkas log yang disimpan dalam bucket Amazon S3 ke HDFS dengan menambahkan langkah ke klaster yang sedang berjalan. Dalam contoh ini opsi `‑‑srcPattern` digunakan untuk membatasi data yang disalin ke log daemon.
Untuk menyalin berkas log dari Amazon S3 ke HDFS menggunakan opsi `‑‑srcPattern`, letakkan berikut ini dalam file JSON yang disimpan di Amazon S3 atau sistem file lokal Anda sebagai `myStep.json` untuk contoh ini. Ganti *j-3GYXXXXXX9IOK* dengan ID cluster Anda dan ganti *amzn-s3-demo-bucket* dengan nama bucket Amazon S3 Anda.
```
[
{
"Name":"S3DistCp step",
"Args":["s3-dist-cp","‑‑s3Endpoint=s3.amazonaws.com","‑‑src=s3://amzn-s3-demo-bucket/logs/j-3GYXXXXXX9IOJ/node/","‑‑dest=hdfs:///output","‑‑srcPattern=.*daemons.*-hadoop-.*"],
"ActionOnFailure":"CONTINUE",
"Type":"CUSTOM_JAR",
"Jar":"command-runner.jar"
}
]
```
## Membersihkan setelah pekerjaan S3 DistCp gagal
Jika S3 DistCp tidak dapat menyalin beberapa atau semua file yang ditentukan, perintah atau langkah cluster gagal dan mengembalikan kode kesalahan bukan nol. Jika ini terjadi, S3 DistCp tidak membersihkan file yang disalin sebagian. Anda harus menghapusnya secara manual.
File yang disalin sebagian disimpan ke direktori HDFS di `tmp` sub-direktori dengan pengidentifikasi unik dari pekerjaan S3. DistCp Anda dapat menemukan ID ini dalam output standar tugas.
Misalnya, untuk DistCp pekerjaan S3 dengan ID`4b1c37bb-91af-4391-aaf8-46a6067085a6`, Anda dapat terhubung ke node master cluster dan menjalankan perintah berikut untuk melihat file output yang terkait dengan pekerjaan tersebut.
```
hdfs dfs -ls /tmp/4b1c37bb-91af-4391-aaf8-46a6067085a6/output
```
Perintah ini akan menghasilkan daftar file yang serupa dengan berikut ini:
```
Found 8 items
-rw-r‑‑r‑‑ 1 hadoop hadoop 0 2018-12-10 06:03 /tmp/4b1c37bb-91af-4391-aaf8-46a6067085a6/output/_SUCCESS
-rw-r‑‑r‑‑ 1 hadoop hadoop 0 2018-12-10 06:02 /tmp/4b1c37bb-91af-4391-aaf8-46a6067085a6/output/part-r-00000
-rw-r‑‑r‑‑ 1 hadoop hadoop 0 2018-12-10 06:02 /tmp/4b1c37bb-91af-4391-aaf8-46a6067085a6/output/part-r-00001
-rw-r‑‑r‑‑ 1 hadoop hadoop 0 2018-12-10 06:02 /tmp/4b1c37bb-91af-4391-aaf8-46a6067085a6/output/part-r-00002
-rw-r‑‑r‑‑ 1 hadoop hadoop 0 2018-12-10 06:03 /tmp/4b1c37bb-91af-4391-aaf8-46a6067085a6/output/part-r-00003
-rw-r‑‑r‑‑ 1 hadoop hadoop 0 2018-12-10 06:03 /tmp/4b1c37bb-91af-4391-aaf8-46a6067085a6/output/part-r-00004
-rw-r‑‑r‑‑ 1 hadoop hadoop 0 2018-12-10 06:03 /tmp/4b1c37bb-91af-4391-aaf8-46a6067085a6/output/part-r-00005
-rw-r‑‑r‑‑ 1 hadoop hadoop 0 2018-12-10 06:03 /tmp/4b1c37bb-91af-4391-aaf8-46a6067085a6/output/part-r-00006
```
Anda kemudian dapat menjalankan perintah berikut untuk menghapus direktori dan semua isinya.
```
hdfs dfs rm -rf /tmp/4b1c37bb-91af-4391-aaf8-46a6067085a6
```