Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Orkestrasi di AWS Glue
Bagian berikut memberikan informasi tentang orkestrasi pekerjaan di. AWS Glue
**Topics**
+ [Memulai pekerjaan dan crawler menggunakan pemicu](trigger-job.md)
+ [Melakukan aktivitas ETL yang kompleks menggunakan cetak biru dan alur kerja di AWS Glue](orchestrate-using-workflows.md)
+ [Mengembangkan cetak biru di AWS Glue](orchestrate-using-blueprints.md)
# Memulai pekerjaan dan crawler menggunakan pemicu
Di AWS Glue, Anda dapat membuat objek Katalog Data yang disebut pemicu, yang dapat Anda gunakan untuk memulai secara manual atau secara otomatis satu atau beberapa crawler atau tugas extract, transform, and load (ETL). Dengan menggunakan pemicu, Anda dapat merancang sebuah rantai tugas dan crawler yang dependen.
**catatan**
Anda dapat melakukan hal yang sama dengan menentukan *alur kerja*. Alur kerja lebih disukai untuk menciptakan operasi ETL multi-tugas yang kompleks. Lihat informasi yang lebih lengkap di [Melakukan aktivitas ETL yang kompleks menggunakan cetak biru dan alur kerja di AWS Glue](orchestrate-using-workflows.md).
**Topics**
+ [AWS Gluepemicu](about-triggers.md)
+ [Menambahkan pemicu](console-triggers.md)
+ [Mengaktifkan dan menonaktifkan pemicu](activate-triggers.md)
# AWS Gluepemicu
Saat *diaktifkan*, pemicu dapat memulai tugas dan crawler yang ditentukan. Sebuah pemicu dapat aktif sesuai permintaan, berdasarkan jadwal, atau berdasarkan kombinasi peristiwa.
**catatan**
Hanya dua crawler yang dapat diaktifkan oleh satu pemicu tunggal. Jika Anda ingin melakukan crawling pada beberapa penyimpanan data, maka Anda harus menggunakan beberapa sumber untuk masing-masing crawler, alih-alih menjalankan beberapa crawler secara bersamaan.
Sebuah pemicu bisa berada dalam salah satu dari beberapa status berikut. Sebuah pemicu berada dalam status `CREATED`, `ACTIVATED`, atau `DEACTIVATED`. Ada juga status transisi, seperti `ACTIVATING`. Untuk menghentikan pemicu agar tidak aktif untuk sementara waktu, Anda dapat menonaktifkannya. Anda kemudian dapat mengaktifkannya kembali nanti.
Ada tiga jenis pemicu:
**Terjadwal**
Sebuah pemicu berbasis waktu berdasarkan pada `cron`.
Anda dapat membuat pemicu untuk serangkaian tugas atau crawler berdasarkan jadwal. Anda dapat menentukan batasan-batasan, seperti frekuensi yang dijalankan oleh tugas atau crawler, pada hari apa dalam seminggu pemicu itu berjalan, dan kapan berjalan. Batasan-batasan tersebut ini didasarkan pada `cron`. Ketika Anda menyiapkan jadwal untuk memicu, Anda harus mempertimbangkan fitur dan keterbatasan cron. Misalnya, jika Anda memilih untuk menjalankan crawler pada hari ke 31 setiap bulan, ingatlah bahwa ada bulan yang tidak terdiri dari 31 hari. Untuk informasi selengkapnya tentang cron, lihat [Jadwal berbasis waktu untuk pekerjaan dan crawler](monitor-data-warehouse-schedule.md).
**Bersyarat**
Pemicu yang aktif saat tugas atau crawler atau beberapa tugas atau crawler sebelumnya memenuhi daftar syarat.
Saat membuat sebuah pemicu bersyarat, Anda menentukan daftar tugas dan daftar crawler yang akan diawasi. Untuk setiap tugas atau crawler yang diawasi, tetapkan status yang akan diawasi, seperti berhasil, gagal, habis waktu, dan seterusnya. Pemicu aktif jika tugas yang atau crawler diawasi berakhir dengan status yang ditentukan. Anda dapat mengkonfigurasi pemicu untuk aktif ketika salah satu atau semua peristiwa yang diawasi terjadi.
Misalnya, Anda bisa mengkonfigurasi T1 pemicu untuk memulai tugas J3 ketika kedua tugas J1 dan tugas J2 berhasil diselesaikan, dan pemicu T2 untuk memulai tugas J4 jika tugas J1 atau tugas J2 gagal.
Tabel berikut mencantumkan status penyelesaian tugas dan crawler (peristiwa) yang diawasi pemicu.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/about-triggers.html)
**Sesuai permintaan**
Pemicu yang aktif saat anda mengaktifkannya. Pemicu sesuai permintaan tidak pernah ada dalam status `ACTIVATED` atau `DEACTIVATED`. Mereka selalu ada dalam status `CREATED`.
Sehingga mereka siap untuk langsung aktif setelah mereka ada, Anda dapat mengatur bendera untuk mengaktifkan pemicu terjadwal dan bersyarat saat Anda membuatnya.
**penting**
Tugas atau crawler yang berjalan sebagai hasil dari tugas lain atau penyelesaian crawler disebut sebagai *dependen*. Tugas dependen atau crawler dependen hanya dimulai jika tugas atau crawler yang selesai dimulai oleh pemicu. Semua tugas atau crawler dalam rantai dependensi harus berupa keturunan dari satu pemicu **terjadwal** atau pemicu **sesuai permintaan**.
**Melewati parameter pekerjaan dengan pemicu**
Pemicu dapat memberikan parameter untuk tugas yang dimulai. Parameter termasuk argumen tugas, nilai habis waktu, konfigurasi keamanan, dan banyak lagi. Jika pemicu memulai beberapa tugas, maka parameter tersebut diberikan ke setiap tugas.
Berikut ini adalah aturan untuk argumen tugas yang diberikan oleh pemicu:
+ Jika kunci dalam pasangan nilai kunci cocok dengan argumen tugas default, maka argumen yang diberikan menimpa argumen default. Jika kunci tidak cocok dengan argumen default, maka argumen tersebut akan diberikan sebagai argumen tambahan untuk tugas tersebut.
+ Jika kunci dalam pasangan nilai kunci cocok argumen yang tidak dapat ditimpa, maka argumen yang diberikan akan diabaikan.
Untuk informasi selengkapnya, lihat [Pemicu](aws-glue-api-jobs-trigger.md) di AWS Glue API.
# Menambahkan pemicu
Anda dapat menambahkan pemicu menggunakan AWS Glue konsol, AWS Command Line Interface (AWS CLI), atau AWS Glue API.
**Untuk menambahkan pemicu (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Di panel navigasi, pada **ETL** pilih **Pemicu**. Lalu pilih **Tambahkan pemicu**.
1. Berikan properti berikut:
**Nama**
Berikan pemicu Anda nama yang unik.
**Jenis pemicu**
Tentukan satu dari yang berikut ini:
+ **Jadwal:** Pemicu aktif pada frekuensi dan waktu tertentu.
+ **Peristiwa tugas:** Pemicu bersyarat. Pemicu aktif ketika salah satu atau semua tugas dalam daftar cocok dengan statusnya yang ditentukan. Agar pemicu aktif, tugas yang diawasi harus dimulai oleh pemicu. Untuk tugas apa pun yang Anda pilih, Anda hanya dapat mengawasi satu peristiwa tugas (status penyelesaian).
+ **Sesuai permintaan:** Pemicu aktif saat diaktifkan.
1. Selesaikan penuntun pemicu. Di halaman **Tinjau**, Anda dapat langsung mengaktifkan pemicu (bersyarat) **Jadwal** dan **Peristiwa tugas** dengan memilih **Aktifkan pemicu pada saat dibuat**.
**Untuk menambahkan pemicu (AWS CLI)**
+ Masukkan perintah yang serupa dengan yang berikut ini.
```
aws glue create-trigger --name MyTrigger --type SCHEDULED --schedule "cron(0 12 * * ? *)" --actions CrawlerName=MyCrawler --start-on-creation
```
Perintah ini membuat pemicu jadwal bernama `MyTrigger`, yang berjalan setiap hari pada pukul 12:00 siang UTC dan memulai crawler bernama `MyCrawler`. Pemicu dibuat dalam status diaktifkan.
Lihat informasi yang lebih lengkap di [AWS Gluepemicu](about-triggers.md).
# Jadwal berbasis waktu untuk pekerjaan dan crawler
Anda dapat menentukan jadwal berbasis waktu untuk crawler dan tugas di AWS Glue. Penentuan jadwal ini menggunakan sintaksis [cron](http://en.wikipedia.org/wiki/Cron) yang mirip UNIX. Anda menentukan waktu dalam [Waktu Universal Terkoordinasi (UTC)](http://en.wikipedia.org/wiki/Coordinated_Universal_Time), dan presisi minimum untuk jadwal adalah 5 menit.
Untuk mempelajari lebih lanjut tentang cara mengonfigurasi tugas dan crawler agar dijalankan menggunakan jadwal, lihat [Memulai pekerjaan dan crawler menggunakan pemicu](trigger-job.md).
## Ekspresi Cron
Ekspresi cron memiliki enam bidang yang diperlukan, yang dipisahkan oleh spasi putih.
**Sintaksis**
```
cron(Minutes Hours Day-of-month Month Day-of-week Year)
```
| **Bidang** | **Nilai-nilai** | **Wildcard** |
| --- | --- | --- |
| Menit | 0–59 | , - \$1 / |
| Jam | 0–23 | , - \$1 / |
| D ay-of-month | 1–31 | , - \$1 ? / L W |
| Bulan | 1–12 atau JAN-DEC | , - \$1 / |
| D ay-of-week | 1–7 atau SUN-SAT | , - \$1 ? / L |
| Tahun | 1970–2199 | , - \$1 / |
**Wildcard**
+ Wildcard **,** (koma) mencakup nilai tambahan. Di kolom `Month`, `JAN,FEB,MAR` akan mencakup Januari, Februari, dan Maret.
+ Wildcard **-** (tanda hubung) menentukan rentang. Di kolom `Day`, 1–15 akan mencakup tanggal 1 hingga 15 pada bulan yang ditentukan.
+ Wildcard **\$1** (bintang) mencakup semua nilai di bidang. Di kolom `Hours`, **\$1** akan mencakup setiap jam.
+ Wildcard **/** (garis miring) menentukan tambahan. Di kolom `Minutes`, Anda bisa memasukkan **1/10** untuk menentukan setiap menit ke-10, mulai dari menit pertama jam (sebagai contoh, menit ke-11, ke-21, dan ke-31, dan seterusnya).
+ Wildcard **?** (tanda tanya) menentukan satu atau yang lain. **Di `Day-of-month` lapangan Anda bisa masuk **7**, dan jika Anda tidak peduli hari apa dalam minggu ketujuh, Anda bisa masuk?** di Day-of-week lapangan.
+ Wildcard **L** di kolom `Day-of-month` atau `Day-of-week` menentukan hari terakhir pada bulan atau minggu.
+ Wildcard **W** di kolom `Day-of-month` menentukan hari kerja. Di kolom `Day-of-month`, `3W` menentukan hari kerja yang paling dekat dengan pekan ketiga di bulan itu.
**Batas**
+ Anda tidak dapat menentukan kolom `Day-of-month` dan `Day-of-week` dalam ekspresi cron yang sama. Jika Anda menentukan sebuah nilai di salah satu kolom, maka Anda harus menggunakan **?** (tanda tanya) di kolom yang lain.
+ Ekspresi cron yang mengarahkan ke rate lebih cepat dari 5 menit tidak didukung.
**Contoh**
Anda dapat membuat jadwal, Anda dapat menggunakan contoh cron berikut.
| Menit | Jam | Hari dalam sebulan | Bulan | Hari dalam seminggu | Tahun | Arti |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 10 | \$1 | \$1 | ? | \$1 | Jalankan pada pukul 10:00 pagi (UTC) setiap hari |
| 15 | 12 | \$1 | \$1 | ? | \$1 | Jalankan pada pukul 12.15 (UTC) setiap hari |
| 0 | 18 | ? | \$1 | MON-FRI | \$1 | Jalankan pada pukul 18.00 (UTC) setiap Senin hingga Jumat |
| 0 | 8 | 1 | \$1 | ? | \$1 | Jalankan pada pukul 8:00 (UTC) setiap tanggal satu di bulannya |
| 0/15 | \$1 | \$1 | \$1 | ? | \$1 | Jalankan setiap 15 menit |
| 0/10 | \$1 | ? | \$1 | MON-FRI | \$1 | Jalankan setiap 10 menit Senin hingga Jumat |
| 0/5 | 8–17 | ? | \$1 | MON-FRI | \$1 | Jalankan setiap 5 menit Senin hingga Jumat antara pukul 08.00 dan 17.55 (UTC) |
Sebagai contoh, untuk berjalan pada jadwal setiap hari pada 12:15 UTC, tentukan:
```
cron(15 12 * * ? *)
```
# Mengaktifkan dan menonaktifkan pemicu
Anda dapat mengaktifkan atau menonaktifkan pemicu menggunakan AWS Glue konsol, AWS Command Line Interface (AWS CLI), atau AWS Glue API.
**Untuk mengaktifkan atau menonaktifkan sebuah pemicu (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Di panel navigasi, pada **ETL** pilih **Pemicu**.
1. Pilih kotak centang yang ada di samping pemicu yang diinginkan, dan pada menu **Tindakan**, pilih **Aktifkan pemicu** untuk mengaktifkan pemicu atau pilih **Menonaktifkan pemicu** untuk menonaktifkan pemicu.
**Untuk mengaktifkan atau menonaktifkan pemicu (AWS CLI)**
+ Gunakan salah satu perintah berikut ini.
```
aws glue start-trigger --name MyTrigger
aws glue stop-trigger --name MyTrigger
```
Memulai pemicu akan mengaktifkannya, dan menghentikan pemicu akan menonaktifkannya. Saat Anda mengaktifkan pemicu sesuai permintaan, maka pemicu akan segera aktif.
Lihat informasi yang lebih lengkap di [AWS Gluepemicu](about-triggers.md).
# Melakukan aktivitas ETL yang kompleks menggunakan cetak biru dan alur kerja di AWS Glue
Beberapa proses ekstrak, transformasi, dan pemuatan (ETL) kompleks organisasi Anda mungkin paling baik diimplementasikan dengan menggunakan beberapa AWS Glue pekerjaan dan crawler yang bergantung. Dengan menggunakan AWS Glue *alur kerja*, Anda dapat merancang proses ETL multi-job dan multi-crawler yang kompleks yang AWS Glue dapat dijalankan dan dilacak sebagai entitas tunggal. Setelah Anda membuat alur kerja dan menentukan tugas, crawler, dan pemicu dalam alur kerja, Anda dapat menjalankan alur kerja sesuai permintaan atau jadwal.
**Topics**
+ [Ikhtisar alur kerja di AWS Glue](workflows_overview.md)
+ [Membuat dan membangun alur kerja secara manual di AWS Glue](creating_running_workflows.md)
+ [Memulai AWS Glue alur kerja dengan acara Amazon EventBridge](starting-workflow-eventbridge.md)
+ [Melihat EventBridge peristiwa yang memulai alur kerja](viewing-start-event-info.md)
+ [Menjalankan dan memantau alur kerja di AWS Glue](running_monitoring_workflow.md)
+ [Menghentikan alur kerja](workflow-stopping.md)
+ [Memperbaiki dan melanjutkan alur kerja](resuming-workflow.md)
+ [Mendapatkan dan mengatur alur kerja menjalankan properti di AWS Glue](workflow-run-properties-code.md)
+ [Menanyakan alur kerja menggunakan AWS Glue API](workflows_api_concepts.md)
+ [Pembatasan cetak biru dan alur kerja di AWS Glue](blueprint_workflow_restrictions.md)
+ [Memecahkan masalah kesalahan cetak biru di AWS Glue](blueprint_workflow_troubleshoot.md)
+ [Izin untuk persona dan peran untuk cetak biru AWS Glue](blueprints-personas-permissions.md)
# Ikhtisar alur kerja di AWS Glue
Di AWS Glue, Anda dapat menggunakan alur kerja untuk membuat dan memvisualisasikan kegiatan extract, transform, and load (ETL) kompleks yang melibatkan beberapa crawler, tugas, dan pemicu. Setiap alur kerja mengelola eksekusi dan pemantauan semua tugas dan crawlernya. Saat alur kerja menjalankan setiap komponen, ia mencatat kemajuan eksekusi dan status. Hal ini memberi Anda gambaran umum tentang tugas yang lebih besar dan detail dari setiap langkah. Konsol AWS Glue menyediakan sebuah representasi visual dari sebuah alur kerja dalam bentuk grafik.
Anda dapat membuat alur kerja dari AWS Glue cetak biru, atau Anda dapat membuat alur kerja komponen secara manual pada satu waktu menggunakan atau. Konsol Manajemen AWS AWS Glue API Untuk informasi selengkapnya tentang cetak biru, lihat [Ikhtisar cetak biru di AWS Glue](blueprints-overview.md).
*Pemicu* dalam alur kerja dapat memulai tugas dan crawler dan dapat diaktifkan saat tugas atau crawler selesai. Dengan menggunakan pemicu, Anda dapat membuat rantai besar tugas dan crawler yang saling bergantung. Selain pemicu dalam sebuah alur kerja yang menentukan dependensi tugas dan crawler, setiap alur kerja memiliki *pemicu awal*. Ada tiga jenis pemicu awal:
+ **Terjadwal** — Alur kerja dimulai sesuai jadwal yang Anda tetapkan. Jadwal dapat berupa jadwal harian, mingguan, bulanan, dan sebagainya, atau dapat menjadi jadwal kustom berdasarkan ekspresi `cron`.
+ **Sesuai permintaan** - Alur kerja dimulai secara manual dari AWS Glue konsol, API, atau AWS CLI.
+ **EventBridge event** — Alur kerja dimulai pada saat terjadinya satu EventBridge peristiwa Amazon atau sekumpulan EventBridge peristiwa Amazon. Dengan tipe pemicu ini, AWS Glue dapat menjadi konsumen peristiwa dalam arsitektur didorong-peristiwa. Setiap jenis EventBridge acara dapat memulai alur kerja. Kasus penggunaan umum adalah tibanya objek baru dalam bucket Amazon S3 (operasi `PutObject` S3).
Memulai sebuah alur kerja dengan batch peristiwa berarti menunggu sampai sejumlah peristiwa tertentu telah diterima atau sampai jumlah waktu tertentu telah berlalu. Saat Anda membuat pemicu EventBridge peristiwa, Anda dapat menentukan kondisi batch secara opsional. Jika Anda menentukan syarat batch, maka Anda harus menentukan ukuran batch (jumlah peristiwa), dan secara opsional dapat menentukan jendela batch (jumlah detik). Jendela batch default dan maksimumnya adalah 900 detik (15 menit). Syarat batch yang terpenuhi pertama kali akan memulai alur kerja. Jendela batch dimulai ketika peristiwa pertama datang. Jika Anda tidak menentukan syarat batch saat membuat sebuah pemicu, maka ukuran batch default-nya adalah 1.
Ketika alur kerja tersebut dimulai, syarat batch akan reset dan pemicu peristiwa mulai mengawasi syarat batch berikutnya yang harus dipenuhi untuk memulai alur kerja lagi.
Tabel berikut menunjukkan bagaimana ukuran batch dan jendela batch beroperasi bersama-sama untuk memicu sebuah alur kerja.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/workflows_overview.html)
Operasi API `GetWorkflowRun` mengembalikan syarat batch yang memicu alur kerja.
Terlepas dari bagaimana alur kerja dimulai, Anda dapat menentukan jumlah maksimum eksekusi alur kerja yang bersamaan saat Anda membuat alur kerja.
Jika peristiwa atau batch peristiwa mulai menjalankan sebuah alur kerja yang pada akhirnya gagal, maka peristiwa atau batch peristiwa tidak lagi dianggap untuk memulai eksekusi alur kerja. Eksekusi alur kerja baru akan dimulai hanya ketika peristiwa atau batch peristiwa berikutnya datang.
**penting**
Batasi jumlah total pekerjaan, crawler, dan pemicu dalam alur kerja hingga 100 atau kurang. Jika Anda menyertakan lebih dari 100, Anda mungkin mendapatkan kesalahan saat mencoba melanjutkan atau menghentikan alur kerja berjalan.
Eksekusi alur kerja tidak akan dimulai jika ia akan melebihi batas jumlah eksekusi alur kerja bersamaan yang ditetapkan untuk alur kerja, meskipun syarat peristiwa terpenuhi. Dianjurkan untuk menyesuaikan batas jumlah eksekusi alur kerja bersamaan berdasarkan volume peristiwa yang diharapkan. AWS Glue tidak akan mencoba lagi eksekusi alur kerja yang gagal karena melampaui batas jumlah eksekusi alur kerja bersamaan. Demikian juga, disarankan untuk menyesuaikan batas jumlah eksekusi alur kerja bersamaan untuk tugas dan crawler dalam alur kerja berdasarkan volume peristiwa yang diharapkan.
**Alur kerja menjalankan properti**
Untuk berbagi dan mengelola status di seluruh alur kerja, Anda dapat menentukan properti eksekusi alur kerja default. Properti ini, yang name/value berpasangan, tersedia untuk semua pekerjaan dalam alur kerja. Dengan menggunakan AWS Glue API, pekerjaan dapat mengambil properti alur kerja yang dijalankan dan memodifikasinya untuk pekerjaan yang muncul nanti dalam alur kerja.
**Grafik alur kerja**
Gambar berikut menampilkan grafik alur kerja yang sangat mendasar pada konsol AWS Glue. Alur kerja Anda bisa memiliki belasan komponen.
![\[Cuplikan layar konsol yang menampilkan tab Grafik dari sebuah alur kerja. Grafik berisi lima ikon yang mewakili pemicu terjadwal, dua tugas, pemicu peristiwa berhasil, dan crawler yang memperbarui skema.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/graph-complete-with-tabs.png)
Alur kerja ini dimulai oleh pemicu terjadwal, `Month-close1`, yang memulai dua tugas, `De-duplicate` dan `Fix phone numbers`. Setelah berhasil menyelesaikan kedua tugas, pemicu peristiwa, `Fix/De-dupe succeeded`, memulai crawler, `Update schema`.
**Tampilan alur kerja statis dan dinamis**
Untuk setiap alur kerja, ada gagasan *tampilan statis* dan *tampilan dinamis*. Tampilan statis menunjukkan desain dari alur kerja. Tampilan dinamis adalah tampilan waktu aktif yang mencakup informasi eksekusi terbaru untuk masing-masing tugas dan crawler. Informasi yang dijalankan mencakup detail status sukses dan kesalahan.
Ketika sebuah alur kerja berjalan, konsol menampilkan tampilan dinamis, yang secara grafis menunjukkan tugas yang telah selesai dan yang belum dijalankan. Anda juga dapat mengambil tampilan dinamis dari sebuah alur kerja yang berjalan menggunakan AWS Glue API. Untuk informasi selengkapnya, lihat [Menanyakan alur kerja menggunakan AWS Glue API](workflows_api_concepts.md).
**Lihat juga**
[Membuat alur kerja dari cetak biru di AWS Glue](creating_workflow_blueprint.md)
[Membuat dan membangun alur kerja secara manual di AWS Glue](creating_running_workflows.md)
[Alur kerja](aws-glue-api-workflow.md) (untuk API alur kerja)
# Membuat dan membangun alur kerja secara manual di AWS Glue
Anda dapat menggunakan konsol AWS Glue untuk membuat dan membangun alur kerja satu simpul secara manual pada satu waktu.
Alur kerja berisi tugas, crawler, dan pemicu. Sebelum membuat alur kerja secara manual, buat tugas dan crawler yang harus disertakan alur kerja. Yang terbaik adalah menentukan run-on-demand crawler untuk alur kerja. Anda dapat membuat pemicu baru saat sedang membangun alur kerja Anda, atau Anda dapat *kloning* pemicu yang ada ke dalam alur kerja tersebut. Ketika Anda melakukan kloning pemicu, semua objek katalog yang dikaitkan dengan pemicu—tugas atau crawler yang mengaktifkannya dan tugas atau crawler yang dimulai—ditambahkan ke alur kerja tersebut.
**penting**
Batasi jumlah total pekerjaan, crawler, dan pemicu dalam alur kerja hingga 100 atau kurang. Jika Anda menyertakan lebih dari 100, Anda mungkin mendapatkan kesalahan saat mencoba melanjutkan atau menghentikan alur kerja berjalan.
Anda membangun alur kerja dengan menambahkan pemicu ke grafik alur kerja, dan menentukan peristiwa dan tindakan yang diawasi untuk setiap pemicu. Anda mulai dengan *pemicu mulai*, yang dapat berupa pemicu sesuai permintaan atau terjadwal, dan selesaikan grafik dengan menambahkan pemicu peristiwa (bersyarat).
## Langkah 1: Buat alur kerja
1. Masuk ke Konsol Manajemen AWS dan buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Di panel navigasi, pada **ETL**, pilih **Alur kerja**.
1. Pilih **Tambahkan alur kerja** dan isi lengkap formulir **Tambahkan alur kerja ETL baru**.
Setiap properti eksekusi default opsional yang Anda tambahkan disediakan sebagai argumen untuk semua tugas di alur kerja. Untuk informasi selengkapnya, lihat [Mendapatkan dan mengatur alur kerja menjalankan properti di AWS Glue](workflow-run-properties-code.md).
1. Pilih **Tambahkan alur kerja**.
Alur kerja baru muncul dalam daftar di halaman **alur kerja**.
## Langkah 2: Tambahkan pemicu awal
1. Pada halaman **alur kerja**, pilih alur kerja baru Anda. Kemudian, di bagian bawah halaman, pastikan bahwa tab **Grafik** sudah dipilih.
1. Pilih **Tambahkan pemicu**, dan di kotak dialog **Tambahkan pemicu**, lakukan salah satu hal berikut:
+ Pilih **Kloning yang ada**, dan pilih pemicu yang akan dikloning. Kemudian pilih **Add**.
Pemicu muncul pada grafik, bersama dengan tugas dan crawler yang diawasi dan tugas dan crawler yang dimulai.
Jika Anda keliru memilih pemicu yang salah, pilih pemicu pada grafik, dan kemudian pilih **Hapus**.
+ Pilih **Tambah baru**, dan isi lengkap **Tambahkan pemicu**.
1. Untuk **jenis Pemicu**, pilih **Jadwal**, **Sesuai permintaan**, atau **EventBridgeacara**.
Untuk tipe pemicu **Jadwal**, pilih salah satu pilihan **Frekuensi**. Pilih **Kustom** untuk memasukkan ekspresi `cron`.
Untuk **EventBridge peristiwa** jenis pemicu, masukkan **Jumlah peristiwa** (ukuran batch), dan secara opsional masukkan **Waktu tunda** (jendela batch). Jika Anda menghilangkan **Waktu tunda**, jendela batch secara default menjadi 15 menit. Untuk informasi selengkapnya, lihat [Ikhtisar alur kerja di AWS Glue](workflows_overview.md).
1. Pilih **Tambahkan**.
Pemicu muncul pada grafik, bersama dengan simpul placeholder (berlabel **Tambahkan simpul**). Pada contoh di bawah ini, pemicu mulai adalah pemicu jadwal bernama `Month-close1`.
Pada titik ini, pemicunya masih belum disimpan.
![\[Sebuah grafik dengan dua simpul persegi panjang: sebuah pemicu, dan sebuah simpul placeholder. Sebuah panah mengarahkan dari simpul pemicu ke simpul placeholder.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/graph-start-trigger.png)
1. Jika Anda menambahkan sebuah pemicu baru, selesaikan langkah-langkah berikut:
1. Lakukan salah satu tindakan berikut:
+ Pilih simpul placeholder (**Tambahkan simpul**).
+ Pastikan pemicu awal dipilih, dan pada menu **Tindakan** di atas grafik, pilih **Tambah jobs/crawlers untuk memicu**.
1. Di kotak dialog **Tambahkan tugas dan crawler yang akan dipicu**, pilih satu atau beberapa tugas atau crawler, dan kemudian pilih **Tambahkan**.
Pemicu disimpan, dan tugas atau crawler yang dipilih muncul pada grafik dengan konektor dari pemicu.
Jika Anda keliru menambahkan tugas atau crawler yang salah, maka Anda dapat memilih pemicu atau konektor dan kemudian pilih **Hapus**.
## Langkah 3: Tambahkan lebih banyak pemicu
Lanjutkan untuk membangun alur kerja Anda dengan menambahkan lebih banyak pemicu jenis **Peristiwa**. Untuk memperbesar atau memperkecil kanvas grafik, gunakan ikon di sebelah kanan grafik. Untuk setiap pemicu yang akan ditambahkan, selesaikan langkah berikut:
**catatan**
Tidak ada tindakan yang bisa digunakan untuk menyimpan alur kerja. Setelah Anda menambahkan pemicu terakhir Anda dan menetapkan tindakan ke pemicu, alur kerja selesai dan disimpan. Anda selalu dapat kembali dan menambahkan lebih banyak simpul nanti.
1. Lakukan salah satu tindakan berikut:
+ Untuk mengkloning pemicu yang ada, pastikan bahwa tidak ada simpul pada grafik yang dipilih, dan pada menu **Tindakan**, pilih **Tambahkan pemicu**.
+ Untuk menambahkan pemicu baru yang mengawasi tugas atau crawler tertentu pada grafik, pilih simpul tugas atau crawler, lalu pilih simpul placeholder **Tambahkan pemicu**.
Anda dapat menambahkan lebih banyak tugas atau crawler untuk mengawasi pemicu ini di langkah berikutnya.
1. Di kotak dialog **Tambahkan pemicu**, lakukan salah satu hal berikut:
+ Pilih **Tambah baru**, dan isi lengkap **Tambahkan pemicu**. Kemudian pilih **Add**.
Pemicu akan muncul pada grafik. Anda akan menyelesaikan pemicu di langkah berikutnya.
+ Pilih **Kloning yang ada**, dan pilih pemicu yang akan dikloning. Kemudian pilih **Add**.
Pemicu muncul pada grafik, bersama dengan tugas dan crawler yang diawasi dan tugas dan crawler yang dimulai.
Jika Anda keliru memilih pemicu yang salah, pilih pemicu pada grafik, dan kemudian pilih **Hapus**.
1. Jika Anda menambahkan sebuah pemicu baru, selesaikan langkah-langkah berikut:
1. Pilih pemicu baru.
Sebagaimana yang ditunjukkan pada grafik berikut, pemicu `De-dupe/fix succeeded` sudah dipilih, dan simpul placeholder muncul untuk (1) peristiwa yang akan diawasi dan (2) tindakan.
![\[Sebuah grafik dengan banyak simpul, dua di antaranya adalah simpul placeholder yang dipanggil sebagai angka 1 dan 2.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/graph-dual-placeholders.png)
1. (Opsional jika pemicu sudah mengawasi peristiwa dan Anda ingin menambahkan lebih banyak tugas atau crawler untuk diawasi.) Pilih node events-to-watch placeholder, dan di kotak dialog **Tambah pekerjaan dan crawler untuk menonton**, pilih satu atau beberapa pekerjaan atau crawler. Pilih peristiwa yang akan diawasi (BERHASIL, GAGAL, dll.), dan pilih **Tambahkan**.
1. Pastikan bahwa pemicu sudah dipilih, dan pilih simpul placeholder tindakan.
1. Di kotak dialog **Tambahkan tugas dan crawler yang akan diawasi**, pilih satu atau beberapa tugas atau crawler, lalu pilih **Tambahkan**.
Tugas dan crawler yang dipilih muncul pada grafik dengan konektor dari pemicu.
Untuk informasi selengkapnya tentang alur kerja dan cetak biru, lihat topik berikut.
+ [Ikhtisar alur kerja di AWS Glue](workflows_overview.md)
+ [Menjalankan dan memantau alur kerja di AWS Glue](running_monitoring_workflow.md)
+ [Membuat alur kerja dari cetak biru di AWS Glue](creating_workflow_blueprint.md)
# Memulai AWS Glue alur kerja dengan acara Amazon EventBridge
Amazon EventBridge, juga dikenal sebagai CloudWatch Acara, memungkinkan Anda untuk mengotomatiskan AWS layanan Anda dan merespons secara otomatis peristiwa sistem seperti masalah ketersediaan aplikasi atau perubahan sumber daya. Acara dari AWS layanan dikirimkan ke EventBridge dalam waktu dekat. Anda dapat menulis aturan sederhana untuk menunjukkan kejadian mana yang sesuai kepentingan Anda, dan tindakan otomatis apa yang diambil ketika suatu kejadian sesuai dengan suatu aturan.
Dengan EventBridge dukungan, AWS Glue dapat berfungsi sebagai produser acara dan konsumen dalam arsitektur yang digerakkan oleh acara. Untuk alur kerja, AWS Glue mendukung semua jenis EventBridge acara sebagai konsumen. Kasus penggunaan yang paling umum adalah kedatangan objek baru dalam bucket Amazon S3. Jika Anda memiliki data yang tiba dalam interval yang tidak teratur atau tidak tertentu, maka Anda dapat memproses data ini sedekat mungkin dengan kedatangannya.
**catatan**
AWS Gluetidak memberikan jaminan pengiriman EventBridge pesan. AWS Gluetidak melakukan deduplikasi jika EventBridge mengirimkan pesan duplikat. Anda harus mengelola idempotensi berdasarkan kasus penggunaan Anda.
Pastikan untuk mengonfigurasi EventBridge aturan dengan benar untuk menghindari pengiriman peristiwa yang tidak diinginkan.
**Sebelum Anda mulai**
Jika Anda ingin memulai alur kerja dengan peristiwa data Amazon S3, Anda harus memastikan bahwa peristiwa untuk bucket minat S3 dicatat dan. AWS CloudTrail EventBridge Untuk melakukannya, Anda harus membuat CloudTrail jejak. Untuk informasi selengkapnya, lihat [Membuat jejak untuk AWS akun Anda](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html).
**Untuk memulai alur kerja dengan sebuah acara EventBridge**
**catatan**
Pada perintah berikut, ganti:
**dengan nama yang akan ditetapkan ke alur kerja.
**dengan nama yang akan ditetapkan ke pelatuk.
**dengan nama bucket Amazon S3.
**dengan ID AWS akun yang valid.
**dengan nama Wilayah (misalnya,`us-east-1`).
**dengan nama untuk ditetapkan ke EventBridge aturan.
1. Pastikan Anda memiliki izin AWS Identity and Access Management (IAM) untuk membuat dan melihat EventBridge aturan dan target. Berikut ini adalah contoh kebijakan yang dapat Anda lampirkan. Anda mungkin ingin untuk membuat cakupan untuk menempatkan batas pada operasi dan sumber daya.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"events:PutRule",
"events:DisableRule",
"events:DeleteRule",
"events:PutTargets",
"events:RemoveTargets",
"events:EnableRule",
"events:List*",
"events:Describe*"
],
"Resource": "*"
}
]
}
```
------
1. Buat peran IAM yang dapat diasumsikan oleh EventBridge layanan saat meneruskan AWS Glue acara.
1. Pada halaman **Buat peran** di konsol IAM, pilih **Layanan AWS **. Kemudian pilih layanan **CloudWatch Acara**.
1. Selesaikan penuntun **Buat peran**. Penuntun secara otomatis melampirkan kebijakan `CloudWatchEventsBuiltInTargetExecutionAccess` dan `CloudWatchEventsInvocationAccess`.
1. Lampirkan kebijakan inline ke peran. Kebijakan ini memungkinkan EventBridge layanan untuk mengarahkan acara keAWS Glue.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:notifyEvent"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:workflow/workflow-name"
]
}
]
}
```
------
1. Masukkan perintah berikut untuk membuat alur kerja.
Lihat [create-workflow](https://docs.aws.amazon.com/cli/latest/reference/glue/create-workflow.html) di *Referensi Perintah AWS CLI * untuk informasi tentang tambahan parameter baris perintah opsional.
```
aws glue create-workflow --name
```
1. Masukkan perintah berikut untuk membuat pemicu EventBridge peristiwa untuk alur kerja. Ini akan menjadi pemicu mulai untuk alur kerja tersebut. Ganti ** dengan tindakan yang akan dilakukan (pekerjaan dan crawler untuk memulai).
Lihat [create-trigger](https://docs.aws.amazon.com/cli/latest/reference/glue/create-trigger.html) di *Referensi Perintah AWS CLI * untuk informasi tentang cara meng-coding argumen `actions`.
```
aws glue create-trigger --workflow-name --type EVENT --name --actions
```
Jika Anda ingin alur kerja dipicu oleh sekumpulan peristiwa, bukan satu EventBridge peristiwa, masukkan perintah berikut sebagai gantinya.
```
aws glue create-trigger --workflow-name --type EVENT --name --event-batching-condition BatchSize=,BatchWindow= --actions
```
Untuk argumen `event-batching-condition`, `BatchSize` wajib dan `BatchWindow` opsional. Jika `BatchWindow` dihilangkan, maka jendela default menjadi 900 detik, yang merupakan ukuran jendela maksimum.
**Example**
Contoh berikut menciptakan pemicu yang memulai `eventtest` alur kerja setelah tiga EventBridge peristiwa tiba, atau lima menit setelah acara pertama tiba, mana yang lebih dulu.
```
aws glue create-trigger --workflow-name eventtest --type EVENT --name objectArrival --event-batching-condition BatchSize=3,BatchWindow=300 --actions JobName=test1
```
1. Buat aturan di Amazon EventBridge.
1. Buat objek JSON untuk detail aturan dalam editor teks yang Anda suka.
Contoh berikut menentukan Amazon S3 sebagai sumber peristiwa, `PutObject` sebagai nama peristiwa, dan nama bucket sebagai parameter permintaan. Aturan ini memulai alur kerja ketika objek baru tiba di bucket tersebut.
```
{
"source": [
"aws.s3"
],
"detail-type": [
"AWS API Call via CloudTrail"
],
"detail": {
"eventSource": [
"s3.amazonaws.com"
],
"eventName": [
"PutObject"
],
"requestParameters": {
"bucketName": [
""
]
}
}
}
```
Untuk memulai alur kerja ketika objek baru tiba di folder dalam bucket, Anda dapat mengganti kode berikut dengan `requestParameters`.
```
"requestParameters": {
"bucketName": [
""
]
"key" : [{ "prefix" : "//*"}}]
}
```
1. Gunakan alat pilihan Anda untuk mengkonversi aturan objek JSON menjadi escape string.
```
{\n \"source\": [\n \"aws.s3\"\n ],\n \"detail-type\": [\n \"AWS API Call via CloudTrail\"\n ],\n \"detail\": {\n \"eventSource\": [\n \"s3.amazonaws.com\"\n ],\n \"eventName\": [\n \"PutObject\"\n ],\n \"requestParameters\": {\n \"bucketName\": [\n \"\"\n ]\n }\n }\n}
```
1. Jalankan perintah berikut untuk membuat templat parameter JSON yang dapat Anda edit untuk menentukan parameter input ke perintah `put-rule` berikutnya. Simpan output dalam sebuah file. Dalam contoh ini, file itu disebut `ruleCommand`.
```
aws events put-rule --name --generate-cli-skeleton >ruleCommand
```
Untuk informasi lebih lanjut tentang parameter `--generate-cli-skeleton`, lihat [Menghasilkan kerangka AWS CLI dan parameter input dari file input JSON atau YAML](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) dalam *Panduan Pengguna Command Line Interface AWS *.
File outputnya akan terlihat seperti berikut.
```
{
"Name": "",
"ScheduleExpression": "",
"EventPattern": "",
"State": "ENABLED",
"Description": "",
"RoleArn": "",
"Tags": [
{
"Key": "",
"Value": ""
}
],
"EventBusName": ""
}
```
1. Mengedit file untuk secara opsional menghapus parameter dan untuk menentukan parameter `Name`, `EventPattern`, dan `State` minimum. Untuk parameter `EventPattern`, berikan escape string untuk detail aturan yang Anda buat di langkah sebelumnya.
```
{
"Name": "",
"EventPattern": "{\n \"source\": [\n \"aws.s3\"\n ],\n \"detail-type\": [\n \"AWS API Call via CloudTrail\"\n ],\n \"detail\": {\n \"eventSource\": [\n \"s3.amazonaws.com\"\n ],\n \"eventName\": [\n \"PutObject\"\n ],\n \"requestParameters\": {\n \"bucketName\": [\n \"\"\n ]\n }\n }\n}",
"State": "DISABLED",
"Description": "Start an AWS Glue workflow upon new file arrival in an Amazon S3 bucket"
}
```
**catatan**
Cara terbaik adalah membiarkan aturan dinonaktifkan sampai Anda selesai membangun alur kerja.
1. Masukkan perintah `put-rule` berikut, yang membaca parameter masukan dari file `ruleCommand`.
```
aws events put-rule --name --cli-input-json file://ruleCommand
```
Output berikut menunjukkan keberhasilan.
```
{
"RuleArn": ""
}
```
1. Masukkan perintah berikut untuk melampirkan aturan ke sebuah target. Targetnya adalah alur kerja di AWS Glue. Ganti ** dengan peran yang Anda buat di awal prosedur ini.
```
aws events put-targets --rule --targets "Id"="1","Arn"="arn:aws:glue:::workflow/","RoleArn"="arn:aws:iam:::role/" --region
```
Output berikut menunjukkan keberhasilan.
```
{
"FailedEntryCount": 0,
"FailedEntries": []
}
```
1. Konfirmasikan koneksi berhasil antara aturan dan target dengan memasukkan perintah berikut.
```
aws events list-rule-names-by-target --target-arn arn:aws:glue:::workflow/
```
Output berikut menunjukkan keberhasilan, di mana ** nama aturan yang Anda buat.
```
{
"RuleNames": [
""
]
}
```
1. Masuk ke Konsol Manajemen AWS dan buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Pilih alur kerja, dan verifikasi bahwa pemicu awal dan tindakannya—tugas atau crawler yang dimulai—muncul di grafik alur kerja. Lalu lanjutkan dengan prosedur di [Langkah 3: Tambahkan lebih banyak pemicu](creating_running_workflows.md#workflow-step3). Atau tambahkan lebih banyak komponen ke alur kerja dengan menggunakan API AWS Glue atau AWS Command Line Interface.
1. Bila alur kerja benar-benar ditentukan, aktifkan aturan.
```
aws events enable-rule --name
```
Alur kerja sekarang siap untuk dimulai oleh event atau EventBridge event batch.
**Lihat juga**
[https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html)
[Ikhtisar alur kerja di AWS Glue](workflows_overview.md)
[Membuat dan membangun alur kerja secara manual di AWS Glue](creating_running_workflows.md)
# Melihat EventBridge peristiwa yang memulai alur kerja
Anda dapat melihat ID EventBridge peristiwa Amazon yang memulai alur kerja Anda. Jika alur kerja Anda dimulai oleh sekumpulan peristiwa, Anda dapat melihat peristiwa IDs dari semua peristiwa dalam batch.
Untuk alur kerja dengan ukuran batch yang lebih besar dari satu, Anda juga dapat melihat syarat batch mana yang memulai alur kerja: datangnya jumlah peristiwa dalam ukuran batch, atau kedaluwarsa-nya jendela batch.
**Untuk melihat EventBridge peristiwa yang memulai alur kerja (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Di panel navigasi, pilih **Alur Kerja**.
1. Pilih alur kerja. Kemudian di bagian bawah, pilih tab **Riwayat**.
1. Pilih eksekusi alur kerja, dan kemudian pilih **Lihat detail eksekusi**.
1. Pada halaman detail eksekusi, temukan kolom **Properti eksekusi**, dan cari kunci **aws:eventIds**.
Nilai untuk kunci itu adalah daftar EventBridge acara IDs.
**Untuk melihat EventBridge peristiwa yang memulai alur kerja (AWS API)**
+ Sertakan kode berikut dalam skrip Python Anda.
```
workflow_params = glue_client.get_workflow_run_properties(Name=workflow_name,RunId=workflow_run_id)
batched_events = workflow_params['aws:eventIds']
```
`batched_events` adalah daftar string, di mana setiap string adalah ID peristiwa.
**Lihat juga**
[https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html)
[Ikhtisar alur kerja di AWS Glue](workflows_overview.md)
# Menjalankan dan memantau alur kerja di AWS Glue
Jika pemicu awal untuk sebuah alur kerja adalah pemicu sesuai permintaan, Anda dapat memulai alur kerja tersebut dari konsol AWS Glue. Selesaikan langkah-langkah berikut untuk menjalankan dan memantau sebuah alur kerja. Jika sebuah alur kerja gagal, Anda dapat melihat grafik eksekusinya untuk menentukan simpul yang gagal. Untuk membantu memecahkan masalah, jika alur kerja dibuat dari sebuah cetak biru, Anda dapat melihat eksekusi cetak biru untuk melihat nilai parameter cetak biru yang digunakan untuk membuat alur kerja tersebut. Untuk informasi selengkapnya, lihat [Melihat cetak biru berjalan di AWS Glue](viewing_blueprint_runs.md).
Anda dapat menjalankan dan memantau alur kerja dengan menggunakan konsol AWS Glue, API, atau AWS Command Line Interface (AWS CLI).
**Untuk menjalankan dan memantau sebuah alur kerja (konsol)**
1. Buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Di panel navigasi, pada **ETL**, pilih **Alur kerja**.
1. Pilih sebuah alur kerja. Pada menu **Tindakan**, pilih **Jalankan**.
1. Periksa kolom **Status eksekusi terakhir** dalam daftar alur kerja. Pilih tombol refresh untuk melihat status alur kerja yang sedang berlangsung.
1. Saat alur kerja sedang berjalan atau setelah selesai (atau gagal), lihat detail eksekusi dengan menyelesaikan langkah-langkah berikut.
1. Pastikan bahwa alur kerja sudah dipilih, dan pilih tab **Riwayat**.
1. Pilih eksekusi alur kerja saat ini atau terbaru, lalu pilih **Tampilkan detail eksekusi**.
Grafik waktu aktif alur kerja menunjukkan status eksekusi saat ini.
1. Pilih simpul dalam grafik untuk melihat detail dan status simpul tersebut.
![\[Grafik eksekusi menunjukkan sebuah pemicu awal, yang memulai sebuah tugas. Pemicu lainnya mengawasi penyelesaian tugas. Simpul tugas (persegi panjang yang membungkus ikon clipboard dan nama tugas) sudah dipilih, dan detail tugas ditampilkan dalam panel di sebelah kanan. Detail tugas mencakup ID dan status eksekusi tugas.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/workflow-pre-select-resume.png)
**Untuk menjalankan dan memantau sebuah alur kerja (AWS CLI)**
1. Masukkan perintah berikut. Ganti ** dengan alur kerja untuk dijalankan.
```
aws glue start-workflow-run --name
```
Jika alur kerja berhasil dimulai, perintah mengembalikan ID eksekusi.
1. Tampilkan status eksekusi alur kerja dengan menggunakan perintah `get-workflow-run`. Berikan nama alur kerja dan ID eksekusi.
```
aws glue get-workflow-run --name myWorkflow --run-id wr_d2af14217e8eae775ba7b1fc6fc7a42c795aed3cbcd8763f9415452e2dbc8705
```
Berikut adalah contoh output perintah.
```
{
"Run": {
"Name": "myWorkflow",
"WorkflowRunId": "wr_d2af14217e8eae775ba7b1fc6fc7a42c795aed3cbcd8763f9415452e2dbc8705",
"WorkflowRunProperties": {
"run_state": "COMPLETED",
"unique_id": "fee63f30-c512-4742-a9b1-7c8183bdaae2"
},
"StartedOn": 1578556843.049,
"CompletedOn": 1578558649.928,
"Status": "COMPLETED",
"Statistics": {
"TotalActions": 11,
"TimeoutActions": 0,
"FailedActions": 0,
"StoppedActions": 0,
"SucceededActions": 9,
"RunningActions": 0,
"ErroredActions": 0
}
}
}
```
**Lihat juga:**
[Ikhtisar alur kerja di AWS Glue](workflows_overview.md)
[Ikhtisar cetak biru di AWS Glue](blueprints-overview.md)
# Menghentikan alur kerja
Anda dapat menggunakan AWS Glue konsol, AWS Command Line Interface (AWS CLI) atau AWS Glue API untuk menghentikan proses alur kerja. Bila Anda menghentikan sebuah eksekusi alur kerja, semua tugas dan crawler yang sedang berjalan akan segera diakhiri, dan tugas dan crawler yang belum dimulai tidak akan pernah dimulai. Mungkin diperlukan waktu hingga satu menit untuk semua tugas dan crawler yang sedang berjalan untuk berhenti. Status eksekusi alur kerja berubah dari **Berjalan** menjadi **Akan berhenti**, dan ketika eksekusi alur kerja benar-benar berhenti, statusnya akan menjadi **Berhenti**.
Setelah eksekusi alur kerja sudah dihentikan, Anda dapat melihat grafik eksekusi untuk melihat tugas dan crawler yang selesai dan yang tidak pernah dimulai. Anda kemudian dapat menentukan apakah Anda perlu melakukan langkah-langkah untuk memastikan integritas data. Menghentikan eksekusi alur kerja akan menyebabkan tidak ada operasi rollback otomatis yang akan dilakukan.
**Untuk menghentikan eksekusi alur kerja (konsol)**
1. Buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Di panel navigasi, pada **ETL**, pilih **Alur kerja**.
1. Pilih alur kerja yang sedang berjalan, lalu pilih tab **Riwayat**.
1. Pilih eksekusi alur kerja, lalu pilih **Hentikan eksekusi**.
Status eksekusi berubah menjadi **Akan berhenti**.
1. (Opsional) Pilih eksekusi alur kerja, pilih **Tampilkan detail eksekusi**, dan tinjau grafik eksekusi.
**Untuk menghentikan eksekusi alur kerja (AWS CLI)**
+ Masukkan perintah berikut. Ganti ** dengan nama alur kerja dan ** dengan ID run dari alur kerja untuk berhenti.
```
aws glue stop-workflow-run --name --run-id
```
Berikut ini adalah contoh perintah **stop-workflow-run**.
```
aws glue stop-workflow-run --name my-workflow --run-id wr_137b88917411d128081069901e4a80595d97f719282094b7f271d09576770354
```
# Memperbaiki dan melanjutkan alur kerja
Jika satu atau beberapa simpul (tugas atau crawler) dalam sebuah alur kerja tidak berhasil selesai, ini berarti bahwa alur kerja hanya dieksekusi sebagian. Setelah Anda menemukan akar penyebab dan melakukan koreksi, Anda dapat memilih satu atau beberapa simpul sebagai tempat melanjutkan eksekusi alur kerja, dan kemudian melanjutkan eksekusi alur kerja. Simpul yang dipilih dan semua simpul yang menjadi hilir dari simpul tersebut kemudian dijalankan.
**Topics**
+ [Melanjutkan alur kerja: Cara kerjanya](#resume-workflow-howitworks)
+ [Melanjutkan alur kerja](#how-to-resume-workflow)
+ [Catatan dan batasan untuk melanjutkan alur kerja berjalan](#resume-workflow-notes)
## Melanjutkan alur kerja: Cara kerjanya
Perhatikan alur kerja W1 dalam diagram berikut.
![\[Pemicu ditunjukkan dalam persegi panjang dan tugas ditunjukkan dalam lingkaran. Pemicu T1 di sebelah kiri memulai alur kerja dengan menjalankan tugas J1. Pemicu dan tugas berikutnya ada, tetapi tugas J2 dan J3 gagal, sehingga pemicu hilir dan tugas ditampilkan sebagai tidak berjalan.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/workflow_W1.png)
Eksekusi alur kerja dilanjutkan sebagai berikut:
1. Pemicu T1 memulai tugas J1.
1. Keberhasilan penyelesaian J1 mengaktifkan pemicu T2 dan T3, yang masing-masing menjalankan tugas J2 dan J3.
1. Tugas J2 dan J3 gagal.
1. Pemicu T4 dan T5 tergantung pada keberhasilan penyelesaian J2 dan J3, sehingga pemicu tersebut tidak aktif, dan tugas J4 dan J5 tidak berjalan. Alur kerja W1 hanya dieksekusi sebagian.
Sekarang, anggap bahwa masalah-masalah yang menyebabkan J2 dan J3 gagal diperbaiki. J2 dan J3 dipilih sebagai titik awal untuk melanjutkan eksekusi alur kerja.
![\[Tugas J2 dan J3 diberi bendera sebagai simpul yang akan dilanjutkan. Pemicu dan tugas hilir ditunjukkan sebagai berhasil dijalankan.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/workflow_W1_resumed.png)
Eksekusi alur kerja berjalan kembali seperti berikut ini:
1. Tugas J2 dan J3 berjalan dengan sukses.
1. Pemicu T4 dan T5 aktif.
1. Tugas J4 dan J5 berjalan dengan sukses.
Eksekusi alur kerja yang dilanjutkan dilacak sebagai alur kerja terpisah yang dijalankan dengan ID eksekusi baru. Ketika Anda melihat riwayat alur kerja, Anda dapat melihat ID eksekusi sebelumnya untuk setiap eksekusi alur kerja. Dalam contoh pada tangkapan layar berikut, eksekusi alur kerja dengan ID eksekusi `wr_c7a22...` (baris kedua) mempunyai simpul yang tidak lengkap. Pengguna memperbaiki masalah dan melanjutkan eksekusi alur kerja, yang menghasilkan ID eksekusi `wr_a07e55...` (baris pertama).
![\[Tabel pada tab Riwayat untuk sebuah alur kerja berisi dua baris, satu baris untuk masing-masing eksekusi alur kerja. Baris pertama memiliki ID eksekusi dan ID eksekusi sebelumnya. Baris kedua hanya memiliki sebuah ID eksekusi. ID eksekusi sebelumnya pada baris pertama adalah sama dengan ID eksekusi di baris ke-2.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/previous-run-id.png)
**catatan**
Untuk sisa pembahasan ini, istilah "eksekusi alur kerja yang dilanjutkan" mengacu pada alur kerja yang dibuat ketika eksekusi alur kerja sebelumnya dilanjutkan. "Eksekusi alur kerja asli" mengacu pada eksekusi alur kerja yang hanya dieksekusi sebagian dan perlu dilanjutkan.
**Grafik lari alur kerja yang dilanjutkan**
Dalam eksekusi alur kerja yang dilanjutkan, meskipun hanya satu subset dari simpul yang dijalankan, tetapi grafik eksekusi adalah sebuah grafik yang lengkap. Artinya, simpul yang tidak dijalankan di alur kerja yang dilanjutkan disalin dari grafik eksekusi dari eksekusi alur kerja asli. Simpul tugas dan crawler yang disalin yang berjalan di eksekusi alur kerja asli mencakup detail eksekusi.
Pertimbangkan lagi alur kerja W1 pada diagram sebelumnya. Ketika eksekusi alur kerja yang dilanjutkan memulai dengan J2 dan J3, grafik eksekusi untuk eksekusi alur kerja yang dilanjutkan menunjukkan semua tugas, J1 hingga J5, dan semua pemicu, T1 hingga T5. Detail eksekusi untuk J1 disalin dari eksekusi alur kerja asli.
**Alur kerja menjalankan snapshot**
Ketika eksekusi alur kerja dimulai, AWS Glue mengambil snapshot dari grafik desain alur kerja pada saat itu. Snapshot yang digunakan di sepanjang eksekusi alur kerja. Jika Anda membuat perubahan pada pemicu setelah eksekusi dimulai, perubahan tersebut tidak akan mempengaruhi eksekusi alur kerja saat ini. Snapshot memastikan bahwa eksekusi alur kerja berjalan dengan cara yang konsisten.
Snapshot hanya membuat pemicu tetap. Perubahan yang Anda buat untuk tugas dan crawler hilir selama eksekusi alur kerja berlaku untuk eksekusi saat ini.
## Melanjutkan alur kerja
Ikuti langkah-langkah ini untuk melanjutkan sebuah eksekusi alur kerja. Anda dapat melanjutkan alur kerja yang dijalankan menggunakan AWS Glue konsol, API, atau AWS Command Line Interface (AWS CLI).
**Untuk melanjutkan sebuah eksekusi alur kerja (konsol)**
1. Buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Masuk sebagai pengguna yang memiliki izin untuk melihat alur kerja dan melanjutkan eksekusi alur kerja.
**catatan**
Untuk melanjutkan alur kerja berjalan, Anda memerlukan izin `glue:ResumeWorkflowRun` AWS Identity and Access Management (IAM).
1. Di panel navigasi, pilih **Alur Kerja**.
1. Pilih alur kerja, lalu pilih tab **Riwayat**.
1. Pilih eksekusi alur kerja yang hanya dieksekusi sebagian, dan kemudian pilih **Lihat detail eksekusi**.
1. Dalam grafik eksekusi, pilih simpul pertama (atau satu-satunya) yang ingin Anda mulai ulang dan yang ingin Anda jadikan tempat di mana eksekusi alur kerja dilanjutkan.
1. Di panel detail di sebelah kanan grafik, pilih kotak centang **Lanjutkan**.
![\[Grafik eksekusi menunjukkan tiga simpul, termasuk simpul tugas gagal. Panel detail tugas di sebelah kanan mencakup kotak centang Lanjutkan.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/workflow-pre-select-resume.png)
Simpul berubah warna dan menunjukkan ikon resume kecil di kanan atas.
![\[Perubahan grafik eksekusi dijelaskan dalam teks. Kotak centang Lanjutkan dipilih.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/workflow-post-select-resume.png)
1. Selesaikan dua langkah sebelumnya untuk setiap simpul tambahan untuk memulai ulang.
1. Pilih **Lanjutkan eksekusi**.
**Untuk melanjutkan sebuah eksekusi alur kerja (AWS CLI)**
1. Pastikan bahwa Anda memiliki Izin IAM `glue:ResumeWorkflowRun`.
1. Ambil node IDs untuk node yang ingin Anda restart.
1. Jalankan perintah `get-workflow-run` untuk eksekusi alur kerja asli. Berikan nama alur kerja dan ID eksekusi, dan tambahkan opsi `--include-graph`, seperti yang ditunjukkan dalam contoh berikut. Dapatkan ID eksekusi dari tab **Riwayat** pada konsol, atau dengan menjalankan perintah `get-workflow`.
```
aws glue get-workflow-run --name cloudtrailtest1 --run-id wr_a07e55f2087afdd415a404403f644a4265278f68b13ba3da08c71924ebe3c3a8 --include-graph
```
Perintah tersebut akan mengembalikan simpul dan edge dari grafik tersebut sebagai objek JSON besar.
1. Cari simpul yang menarik berdasarkan properti `Type` dan `Name` dari objek simpul tersebut.
Berikut ini adalah sebuah simpul objek contoh dari output.
```
{
"Type": "JOB",
"Name": "test1_post_failure_4592978",
"UniqueId": "wnode_d1b2563c503078b153142ee76ce545fe5ceef66e053628a786ddd74a05da86fd",
"JobDetails": {
"JobRuns": [
{
"Id": "jr_690b9f7fc5cb399204bc542c6c956f39934496a5d665a42de891e5b01f59e613",
"Attempt": 0,
"TriggerName": "test1_aggregate_failure_649b2432",
"JobName": "test1_post_failure_4592978",
"StartedOn": 1595358275.375,
"LastModifiedOn": 1595358298.785,
"CompletedOn": 1595358298.785,
"JobRunState": "FAILED",
"PredecessorRuns": [],
"AllocatedCapacity": 0,
"ExecutionTime": 16,
"Timeout": 2880,
"MaxCapacity": 0.0625,
"LogGroupName": "/aws-glue/python-jobs"
}
]
}
}
```
1. Dapatkan ID simpul dari properti `UniqueId` dari objek simpul tersebut.
1. Jalankan perintah `resume-workflow-run`. Berikan nama alur kerja, jalankan ID, dan daftar node IDs dipisahkan oleh spasi, seperti yang ditunjukkan pada contoh berikut.
```
aws glue resume-workflow-run --name cloudtrailtest1 --run-id wr_a07e55f2087afdd415a404403f644a4265278f68b13ba3da08c71924ebe3c3a8 --node-ids wnode_ca1f63e918fb855e063aed2f42ec5762ccf71b80082ae2eb5daeb8052442f2f3 wnode_d1b2563c503078b153142ee76ce545fe5ceef66e053628a786ddd74a05da86fd
```
Perintah tersebut menghasilkan output ID eksekusi dari eksekusi alur kerja (baru) yang dilanjutkan dan daftar simpul yang akan dimulai.
```
{
"RunId": "wr_2ada0d3209a262fc1156e4291134b3bd643491bcfb0ceead30bd3e4efac24de9",
"NodeIds": [
"wnode_ca1f63e918fb855e063aed2f42ec5762ccf71b80082ae2eb5daeb8052442f2f3"
]
}
```
Perhatikan bahwa meskipun contoh perintah `resume-workflow-run` mencantumkan dua simpul untuk memulai ulang, contoh output menunjukkan bahwa hanya satu simpul yang akan dimulai ulang. Hal ini karena satu simpul merupakan hilir dari simpul yang lain, dan simpul hilir bagaimanapun akan dimulai ulang oleh alur normal dari alur kerja tersebut.
## Catatan dan batasan untuk melanjutkan alur kerja berjalan
Simpan catatan dan batasan berikut ini saat melanjutkan eksekusi alur kerja.
+ Anda dapat melanjutkan eksekusi alur kerja hanya jika alur kerja tersebut dalam status `COMPLETED`.
**catatan**
Bahkan jika satu simpul atau beberapa simpul dalam eksekusi alur kerja tidak selesai, status eksekusi alur kerja ditampilkan sebagai `COMPLETED`. Pastikan untuk memeriksa grafik eksekusi untuk menemukan simpul yang tidak berhasil diselesaikan.
+ Anda dapat melanjutkan eksekusi alur kerja dari setiap simpul tugas atau crawler yang berusaha dijalankan oleh eksekusi alur kerja asli. Anda tidak dapat melanjutkan eksekusi alur kerja dari sebuah simpul pemicu.
+ Memulai ulang simpul tidak akan me-reset statusnya. Setiap data yang diproses sebagian tidak akan dicabut.
+ Anda dapat melanjutkan alur kerja yang gagal beberapa kali. Namun, lari yang dilanjutkan hanya dapat dilanjutkan sekali lagi. Untuk percobaan ulang tambahan, lanjutkan proses gagal asli
+ Jika Anda memilih dua simpul untuk memulai ulang dan mereka bergantung satu sama lain, maka simpul hulu akan dijalankan sebelum simpul hilir. Bahkan, memilih simpul hilir adalah sebuah redundansi, karena simpul hilir akan dieksekusi sesuai dengan alur normal dari alur kerja tersebut.
# Mendapatkan dan mengatur alur kerja menjalankan properti di AWS Glue
Gunakan properti alur kerja untuk berbagi dan mengelola status di antara pekerjaan dalam AWS Glue alur kerja Anda. Anda dapat mengatur properti eksekusi default ketika Anda membuat alur kerja. Kemudian, saat tugas Anda berjalan, mereka dapat mengambil nilai properti eksekusi dan secara opsional memodifikasinya untuk input ke tugas yang ada kemudian dalam alur kerja. Ketika sebuah tugas memodifikasi properti eksekusi, nilai baru ada hanya untuk eksekusi alur kerja. Properti eksekusi default tidak terpengaruh.
Jika pekerjaan AWS Glue Anda bukan bagian dari alur kerja, properti ini tidak akan disetel.
Kode Python sampel berikut dari tugas extract, transform, and load (ETL) menunjukkan bagaimana untuk mendapatkan properti eksekusi alur kerja.
```
import sys
import boto3
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from awsglue.context import GlueContext
from pyspark.context import SparkContext
glue_client = boto3.client("glue")
args = getResolvedOptions(sys.argv, ['JOB_NAME','WORKFLOW_NAME', 'WORKFLOW_RUN_ID'])
workflow_name = args['WORKFLOW_NAME']
workflow_run_id = args['WORKFLOW_RUN_ID']
workflow_params = glue_client.get_workflow_run_properties(Name=workflow_name,
RunId=workflow_run_id)["RunProperties"]
target_database = workflow_params['target_database']
target_s3_location = workflow_params['target_s3_location']
```
Kode berikut berlanjut dengan menetapkan properti eksekusi `target_format` ke `'csv'`.
```
workflow_params['target_format'] = 'csv'
glue_client.put_workflow_run_properties(Name=workflow_name, RunId=workflow_run_id, RunProperties=workflow_params)
```
Untuk informasi selengkapnya, lihat informasi berikut:
+ [GetWorkflowRunProperties tindakan (Python: get\$1workflow\$1run\$1properties)](aws-glue-api-workflow.md#aws-glue-api-workflow-GetWorkflowRunProperties)
+ [PutWorkflowRunProperties tindakan (Python: put\$1workflow\$1run\$1properties)](aws-glue-api-workflow.md#aws-glue-api-workflow-PutWorkflowRunProperties)
# Menanyakan alur kerja menggunakan AWS Glue API
AWS Glue menyediakan API yang kaya untuk mengelola alur kerja. Anda dapat mengambil tampilan statis dari sebuah alur kerja atau tampilan dinamis dari sebuah alur kerja yang berjalan dengan menggunakan AWS Glue API. Untuk informasi selengkapnya, lihat [Alur kerja](aws-glue-api-workflow.md).
**Topics**
+ [Menanyakan tampilan statis](#workflows_api_concepts_static)
+ [Menanyakan tampilan dinamis](#workflows_api_concepts_dynamic)
## Menanyakan tampilan statis
Gunakan operasi API `GetWorkflow` untuk mendapatkan tampilan statis yang menunjukkan desain sebuah alur kerja. Operasi ini mengembalikan grafik diarahkan yang terdiri dari simpul dan edge, di mana simpul merupakan pemicu, tugas, atau crawler. Edge menentukan hubungan antara simpul. Mereka diwakili oleh konektor (panah) pada grafik di konsol AWS Glue.
Anda juga dapat menggunakan operasi ini dengan pustaka pemrosesan grafik populer seperti NetworkX, igraph, JGraph T, dan Java Universal (JUNG) Framework. Network/Graph Karena semua perpustakaan ini mewakili grafik yang sama, maka diperlukan hanya transformasi minimal.
Tampilan statis yang dikembalikan oleh API ini adalah up-to-date tampilan terbanyak menurut definisi pemicu terbaru yang terkait dengan alur kerja.
### Definisi grafik
Sebuah grafik alur kerja G adalah pasangan diurutkan (N, E), di mana N adalah satu set simpul dan E satu set edge. *Simpul* adalah simpul dalam grafik yang diidentifikasi oleh nomor unik. Sebuah simpul dapat berupa jenis pemicu, tugas, atau crawler. Sebagai contoh: `{name:T1, type:Trigger, uniqueId:1}, {name:J1, type:Job, uniqueId:2}`.
*Edge* adalah 2-tuple dalam bentuk (`src, dest`), di mana `src` dan `dest` adalah simpul dan ada edge diarahkan dari `src` ke `dest`.
### Contoh kueri tampilan statis
Anggap pemicu bersyarat T, yang memicu tugas J2 setelah penyelesaian tugas J1.
```
J1 ---> T ---> J2
```
Simpul: J1, T, J2
Edge: (J1, T), (T, J2)
## Menanyakan tampilan dinamis
Gunakan operasi API `GetWorkflowRun` untuk mendapatkan tampilan dinamis dari alur kerja yang berjalan. Operasi ini mengembalikan tampilan statis yang sama dari grafik bersama dengan metadata yang dikaitkan ke eksekusi alur kerja.
Untuk menjalankan, simpul yang mewakili tugas dalam panggilan `GetWorkflowRun` memiliki daftar eksekusi tugas yang dimulai sebagai bagian dari eksekusi alur kerja terbaru. Anda dapat menggunakan daftar ini untuk menampilkan status eksekusi dari setiap tugas dalam grafik itu sendiri. Untuk dependensi hilir yang belum dijalankan, kolom ini diatur ke `null`. Informasi grafik membuat Anda mengetahui status alur kerja saat ini pada setiap titik waktu.
Tampilan dinamis yang dikembalikan oleh API ini didasarkan pada tampilan statis yang disajikan saat eksekusi alur kerja dimulai.
*Contoh simpul waktu aktif:* `{name:T1, type: Trigger, uniqueId:1}`, `{name:J1, type:Job, uniqueId:2, jobDetails:{jobRuns}}`, `{name:C1, type:Crawler, uniqueId:3, crawlerDetails:{crawls}}`
### Contoh 1: Tampilan dinamis
Contoh berikut mengilustrasikan sebuah alur kerja dua pemicu sederhana.
+ Simpul: t1, j1, t2, j2
+ Edge: (t1, j1), (j1, t2), (t2, j2)
Respons `GetWorkflow` berisi hal berikut ini.
```
{
Nodes : [
{
"type" : Trigger,
"name" : "t1",
"uniqueId" : 1
},
{
"type" : Job,
"name" : "j1",
"uniqueId" : 2
},
{
"type" : Trigger,
"name" : "t2",
"uniqueId" : 3
},
{
"type" : Job,
"name" : "j2",
"uniqueId" : 4
}
],
Edges : [
{
"sourceId" : 1,
"destinationId" : 2
},
{
"sourceId" : 2,
"destinationId" : 3
},
{
"sourceId" : 3,
"destinationId" : 4
}
}
```
Respons `GetWorkflowRun` berisi hal berikut ini.
```
{
Nodes : [
{
"type" : Trigger,
"name" : "t1",
"uniqueId" : 1,
"jobDetails" : null,
"crawlerDetails" : null
},
{
"type" : Job,
"name" : "j1",
"uniqueId" : 2,
"jobDetails" : [
{
"id" : "jr_12334",
"jobRunState" : "SUCCEEDED",
"errorMessage" : "error string"
}
],
"crawlerDetails" : null
},
{
"type" : Trigger,
"name" : "t2",
"uniqueId" : 3,
"jobDetails" : null,
"crawlerDetails" : null
},
{
"type" : Job,
"name" : "j2",
"uniqueId" : 4,
"jobDetails" : [
{
"id" : "jr_1233sdf4",
"jobRunState" : "SUCCEEDED",
"errorMessage" : "error string"
}
],
"crawlerDetails" : null
}
],
Edges : [
{
"sourceId" : 1,
"destinationId" : 2
},
{
"sourceId" : 2,
"destinationId" : 3
},
{
"sourceId" : 3,
"destinationId" : 4
}
}
```
### Contoh 2: Beberapa pekerjaan dengan pemicu bersyarat
Contoh berikut menunjukkan sebuah alur kerja dengan beberapa eksekusi dan sebuah pemicu bersyarat (t3).
```
Consider Flow:
T(t1) ---> J(j1) ---> T(t2) ---> J(j2)
| |
| |
>+------> T(t3) <-----+
|
|
J(j3)
Graph generated:
Nodes: t1, t2, t3, j1, j2, j3
Edges: (t1, j1), (j1, t2), (t2, j2), (j1, t3), (j2, t3), (t3, j3)
```
# Pembatasan cetak biru dan alur kerja di AWS Glue
Berikut ini adalah pembatasan untuk cetak biru dan alur kerja.
## Pembatasan cetak biru
Ingatlah pembatasan cetak biru berikut:
+ Cetak biru harus terdaftar di AWS Wilayah yang sama tempat bucket Amazon S3 berada.
+ Untuk membagikan cetak biru di seluruh AWS akun, Anda harus memberikan izin baca pada arsip ZIP cetak biru di Amazon S3. Pelanggan yang telah membaca izin pada arsip cetak biru ZIP dapat mendaftarkan cetak biru di akun mereka dan menggunakannya. AWS
+ Sekumpulan parameter cetak biru disimpan sebagai satu objek JSON tunggal. Panjang maksimum objek tersebut adalah 128 KB.
+ Ukuran maksimum tidak terkompresi dari arsip ZIP cetak biru adalah 5 MB. Ukuran terkompresi maksimum adalah 1 MB.
+ Batasi jumlah total pekerjaan, crawler, dan pemicu dalam alur kerja hingga 100 atau kurang. Jika Anda menyertakan lebih dari 100, Anda mungkin mendapatkan kesalahan saat mencoba melanjutkan atau menghentikan alur kerja berjalan.
## Pembatasan alur kerja
Perhatikan pembatasan alur kerja berikut ini. Beberapa komentar ini ditujukan lebih kepada para pengguna yang membuat alur kerja secara manual.
+ Ukuran batch maksimum untuk pemicu EventBridge peristiwa Amazon adalah 100. Ukuran jendela maksimum adalah 900 detik (15 menit).
+ Pemicu dapat dikaitkan hanya dengan satu alur kerja saja.
+ Hanya satu pemicu awal (sesuai permintaan atau terjadwal) yang diizinkan.
+ Jika tugas atau crawler dalam sebuah alur kerja dimulai oleh pemicu yang berada di luar alur kerja, maka pemicu apa pun yang ada di dalam alur kerja yang bergantung pada penyelesaian tugas atau crawler (berhasil atau lainnya) tidak akan aktif.
+ Demikian pula, jika tugas atau crawler dalam sebuah alur kerja memiliki pemicu yang bergantung pada penyelesaian tugas atau crawler (berhasil atau lainnya) baik yang ada di dalam alur kerja maupun di luar alur kerja, dan jika tugas atau crawler dimulai dari dalam alur kerja, maka hanya pemicu di dalam alur kerja saja yang akan aktif saat tugas atau crawler selesai.
# Memecahkan masalah kesalahan cetak biru di AWS Glue
Jika Anda mengalami kesalahan saat menggunakan AWS Glue cetak biru, gunakan solusi berikut untuk membantu Anda menemukan sumber masalah dan memperbaikinya.
**Topics**
+ [Kesalahan: PySpark modul hilang](#blueprint-workflow-error-1)
+ [Kesalahan: file konfigurasi cetak biru hilang](#blueprint-workflow-error-2)
+ [Kesalahan: file impor hilang](#blueprint-workflow-error-3)
+ [Kesalahan: tidak diizinkan untuk tampil iamPassRole di sumber daya](#blueprint-workflow-error-4)
+ [Kesalahan: jadwal cron tidak valid](#blueprint-workflow-error-5)
+ [Kesalahan: pemicu dengan nama yang sama sudah ada](#blueprint-workflow-error-6)
+ [Kesalahan: alur kerja dengan nama: foo sudah ada.](#blueprint-workflow-error-7)
+ [Kesalahan: modul tidak ditemukan di jalur LayoutGenerator yang ditentukan](#blueprint-workflow-error-8)
+ [Kesalahan: kesalahan validasi di bidang Koneksi](#blueprint-workflow-error-9)
## Kesalahan: PySpark modul hilang
AWS Gluemengembalikan kesalahan “Kesalahan tidak diketahui menjalankan fungsi generator tata letak ModuleNotFoundError: Tidak ada modul bernama 'pyspark'”.
Saat Anda membuka zip arsip cetak biru, itu bisa seperti salah satu dari berikut ini:
```
$ unzip compaction.zip
Archive: compaction.zip
creating: compaction/
inflating: compaction/blueprint.cfg
inflating: compaction/layout.py
inflating: compaction/README.md
inflating: compaction/compaction.py
$ unzip compaction.zip
Archive: compaction.zip
inflating: blueprint.cfg
inflating: compaction.py
inflating: layout.py
inflating: README.md
```
*Dalam kasus pertama, semua file yang terkait dengan cetak biru ditempatkan di bawah folder bernama compaction dan kemudian diubah menjadi file zip bernama compaction.zip.*
*Dalam kasus kedua, semua file yang diperlukan untuk cetak biru tidak dimasukkan ke dalam folder dan ditambahkan sebagai file root di bawah file zip compaction.zip.*
Membuat file dalam salah satu format di atas diperbolehkan. Namun pastikan bahwa `blueprint.cfg` memiliki jalur yang benar ke nama fungsi dalam skrip yang menghasilkan tata letak.
**Contoh**
Dalam kasus 1: `blueprint.cfg` harus memiliki `layoutGenerator` sebagai berikut:
```
layoutGenerator": "compaction.layout.generate_layout"
```
Dalam kasus 2: `blueprint.cfg` harus memiliki `layoutGenerator` sebagai berikut
```
layoutGenerator": "layout.generate_layout"
```
Jika jalur ini tidak disertakan dengan benar, Anda bisa melihat kesalahan seperti yang ditunjukkan. Misalnya, jika Anda memiliki struktur folder seperti yang disebutkan dalam kasus 2 dan Anda memiliki `layoutGenerator` indikasi seperti dalam kasus 1, Anda dapat melihat kesalahan di atas.
## Kesalahan: file konfigurasi cetak biru hilang
AWS Gluemengembalikan kesalahan “Kesalahan tidak diketahui menjalankan fungsi generator tata letak FileNotFoundError: [Errno 2] Tidak ada file atau direktori seperti itu: '/ tmp/compaction/blueprint .cfg'”.
blueprint.cfg harus ditempatkan pada tingkat root arsip ZIP atau di dalam folder yang memiliki nama yang sama dengan arsip ZIP.
Ketika kita mengekstrak arsip cetak biru ZIP, blueprint.cfg diharapkan dapat ditemukan di salah satu jalur berikut. Jika tidak ditemukan di salah satu jalur berikut, Anda dapat melihat kesalahan di atas.
```
$ unzip compaction.zip
Archive: compaction.zip
creating: compaction/
inflating: compaction/blueprint.cfg
$ unzip compaction.zip
Archive: compaction.zip
inflating: blueprint.cfg
```
## Kesalahan: file impor hilang
AWS Gluemengembalikan kesalahan “Kesalahan tidak diketahui menjalankan fungsi generator tata letak FileNotFoundError: [Errno 2] Tidak ada file atau direktori seperti itu: \$1 \$1 'demo-project/foo.py'”.
Jika skrip pembuatan tata letak Anda memiliki fungsionalitas untuk membaca file lain, pastikan Anda memberikan jalur lengkap untuk file yang akan diimpor. Misalnya, skrip Conversion.py dapat direferensikan di Layout.py. Untuk informasi selengkapnya, lihat [Contoh Blueprint Project](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-sample.html).
## Kesalahan: tidak diizinkan untuk tampil iamPassRole di sumber daya
AWS Gluemengembalikan kesalahan “User: arn:aws:sts: :123456789012: assumed-” role/AWSGlueServiceRole/GlueSession is not authorized to perform: iam:PassRole on resource: arn:aws:iam::123456789012:role/AWSGlueServiceRole
Jika pekerjaan dan crawler dalam alur kerja memiliki peran yang sama dengan peran yang diteruskan untuk membuat alur kerja dari cetak biru, maka peran cetak biru perlu menyertakan izin itu sendiri. `iam:PassRole`
Jika pekerjaan dan crawler dalam alur kerja mengambil peran selain peran yang diteruskan untuk membuat entitas alur kerja dari cetak biru, maka peran cetak biru harus menyertakan `iam:PassRole` izin pada peran lain tersebut, bukan pada peran cetak biru.
Untuk informasi selengkapnya, lihat [Izin untuk Peran cetak biru](https://docs.aws.amazon.com/glue/latest/dg/blueprints-personas-permissions.html#blueprints-role-permissions).
## Kesalahan: jadwal cron tidak valid
AWS Gluemengembalikan kesalahan “Jadwal cron (0 0 \$1 \$1 \$1 \$1) tidak valid.”
Berikan ekspresi [cron](https://en.wikipedia.org/wiki/Cron) yang valid. Untuk informasi selengkapnya, lihat [Jadwal Berbasis Waktu untuk Tugas dan Perayap](https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html).
## Kesalahan: pemicu dengan nama yang sama sudah ada
AWS Gluemengembalikan kesalahan “Pemicu dengan nama 'foo\$1starting\$1trigger' sudah dikirimkan dengan konfigurasi yang berbeda”.
Cetak biru tidak mengharuskan Anda untuk menentukan pemicu dalam skrip tata letak untuk pembuatan alur kerja. Pembuatan pemicu dikelola oleh pustaka cetak biru berdasarkan dependensi yang ditentukan antara dua tindakan.
Penamaan untuk pemicunya adalah sebagai berikut:
+ Untuk pemicu awal dalam alur kerja penamaannya adalah \$1starting\$1trigger.
+ Untuk node (job/crawler) dalam alur kerja yang bergantung pada penyelesaian salah satu atau beberapa node upstream; AWS Glue mendefinisikan pemicu dengan nama \$1 \$1trigger
Kesalahan ini berarti pemicu dengan nama yang sama sudah ada. Anda dapat menghapus pemicu yang ada dan menjalankan kembali pembuatan alur kerja.
**catatan**
Menghapus alur kerja tidak menghapus node dalam alur kerja. Ada kemungkinan bahwa meskipun alur kerja dihapus, pemicu tertinggal. Karena ini, Anda mungkin tidak menerima kesalahan 'alur kerja sudah ada', tetapi Anda mungkin menerima kesalahan 'pemicu sudah ada' dalam kasus di mana Anda membuat alur kerja, menghapusnya dan kemudian mencoba membuatnya kembali dengan nama yang sama dari cetak biru yang sama.
## Kesalahan: alur kerja dengan nama: foo sudah ada.
Nama alur kerja harus unik. Silakan coba dengan nama yang berbeda.
## Kesalahan: modul tidak ditemukan di jalur LayoutGenerator yang ditentukan
AWS Gluemengembalikan kesalahan “Kesalahan tidak diketahui menjalankan fungsi generator tata letak ModuleNotFoundError: Tidak ada modul bernama 'crawl\$1s3\$1locations'”.
```
layoutGenerator": "crawl_s3_locations.layout.generate_layout"
```
Misalnya, jika Anda memiliki jalur LayoutGenerator di atas, maka ketika Anda unzip arsip cetak biru, itu perlu terlihat seperti berikut:
```
$ unzip crawl_s3_locations.zip
Archive: crawl_s3_locations.zip
creating: crawl_s3_locations/
inflating: crawl_s3_locations/blueprint.cfg
inflating: crawl_s3_locations/layout.py
inflating: crawl_s3_locations/README.md
```
Ketika Anda unzip arsip, jika arsip cetak biru terlihat seperti berikut, maka Anda bisa mendapatkan kesalahan di atas.
```
$ unzip crawl_s3_locations.zip
Archive: crawl_s3_locations.zip
inflating: blueprint.cfg
inflating: layout.py
inflating: README.md
```
Anda dapat melihat bahwa tidak ada folder bernama `crawl_s3_locations` dan ketika `layoutGenerator` path mengacu ke file tata letak melalui modul`crawl_s3_locations`, Anda bisa mendapatkan kesalahan di atas.
## Kesalahan: kesalahan validasi di bidang Koneksi
AWS Gluemengembalikan kesalahan “Kesalahan tidak diketahui menjalankan fungsi generator tata letak TypeError: Nilai ['foo'] untuk kunci Koneksi harus bertipe \$1”.
Ini adalah kesalahan validasi. `Connections`Bidang di `Job` kelas mengharapkan kamus dan sebagai gantinya daftar nilai disediakan menyebabkan kesalahan.
```
User input was list of values
Connections= ['string']
Should be a dict like the following
Connections*=*{'Connections': ['string']}
```
[Untuk menghindari kesalahan waktu proses ini saat membuat alur kerja dari cetak biru, Anda dapat memvalidasi definisi alur kerja, pekerjaan, dan perayap seperti yang diuraikan dalam Menguji cetak biru.](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-testing.html)
Lihat sintaks di [Referensi Kelas AWS Glue cetak biru](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-code-classes.html) untuk menentukan AWS Glue pekerjaan, crawler, dan alur kerja dalam skrip tata letak.
# Izin untuk persona dan peran untuk cetak biru AWS Glue
Berikut ini adalah kebijakan izin persona dan saran AWS Identity and Access Management (IAM) khas untuk persona dan peran untuk cetak biru. AWS Glue
**Topics**
+ [Blueprint persona](#blueprints-personas)
+ [Izin untuk persona cetak biru](#blueprints-permssions)
+ [Izin untuk peran cetak biru](#blueprints-role-permissions)
## Blueprint persona
Berikut ini adalah persona yang biasanya terlibat dalam siklus hidup cetak biru. AWS Glue
| Persona | Deskripsi |
| --- | --- |
| AWS Gluepengembang | Mengembangkan, menguji, dan menerbitkan cetak biru. |
| AWS Glueadministrator | Mendaftar, memelihara, dan memberikan izin pada cetak biru. |
| Analis data | Menjalankan cetak biru untuk membuat alur kerja. |
Untuk informasi selengkapnya, lihat [Ikhtisar cetak biru di AWS Glue](blueprints-overview.md).
## Izin untuk persona cetak biru
Berikut ini adalah izin yang disarankan untuk masing-masing persona cetak biru.
### AWS Glueizin pengembang untuk cetak biru
AWS GluePengembang harus memiliki izin menulis di bucket Amazon S3 yang digunakan untuk menerbitkan cetak biru. Seringkali, developer mendaftarkan cetak biru setelah mengunggahnya. Dalam hal ini, developer membutuhkan izin yang tercantum dalam [AWS Glueizin administrator untuk cetak biru](#bp-persona-admin). Selain itu, jika developer ingin menguji cetak biru setelah terdaftar, maka ia juga membutuhkan izin yang tercantum di [Izin analis data untuk cetak biru](#bp-persona-analyst).
### AWS Glueizin administrator untuk cetak biru
Kebijakan berikut memberikan izin untuk mendaftar, melihat, dan memelihara AWS Glue cetak biru.
**penting**
Dalam kebijakan berikut, ganti ** dan ** dengan jalur Amazon S3 ke arsip ZIP cetak biru yang diunggah untuk mendaftar.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:CreateBlueprint",
"glue:UpdateBlueprint",
"glue:DeleteBlueprint",
"glue:GetBlueprint",
"glue:ListBlueprints",
"glue:BatchGetBlueprints"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/prefix/*"
}
]
}
```
------
### Izin analis data untuk cetak biru
Kebijakan berikut memberikan izin untuk menjalankan cetak biru dan melihat komponen-komponen alur kerja dan alur kerja yang dihasilkan. Ini juga memberikan peran yang `PassRole` AWS Glue mengasumsikan untuk membuat alur kerja dan komponen alur kerja.
Kebijakan ini memberikan izin pada setiap sumber daya. Jika Anda ingin mengonfigurasi akses berbutir halus ke cetak biru individual, gunakan format berikut untuk cetak biru: ARNs
```
arn:aws:glue:::blueprint/
```
**penting**
Dalam kebijakan berikut, ganti ** dengan AWS akun yang valid dan ganti ** dengan nama peran yang digunakan untuk menjalankan cetak biru. Lihat [Izin untuk peran cetak biru](#blueprints-role-permissions) untuk melihat izin yang diperlukan peran ini.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:ListBlueprints",
"glue:GetBlueprint",
"glue:StartBlueprintRun",
"glue:GetBlueprintRun",
"glue:GetBlueprintRuns",
"glue:GetCrawler",
"glue:ListTriggers",
"glue:ListJobs",
"glue:BatchGetCrawlers",
"glue:GetTrigger",
"glue:BatchGetWorkflows",
"glue:BatchGetTriggers",
"glue:BatchGetJobs",
"glue:BatchGetBlueprints",
"glue:GetWorkflowRun",
"glue:GetWorkflowRuns",
"glue:ListCrawlers",
"glue:ListWorkflows",
"glue:GetJob",
"glue:GetWorkflow",
"glue:StartWorkflowRun"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
## Izin untuk peran cetak biru
Berikut ini adalah izin yang disarankan untuk IAM role yang digunakan untuk membuat alur kerja dari sebuah cetak biru. Peran tersebut harus memiliki hubungan kepercayaan dengan `glue.amazonaws.com`.
**penting**
Dalam kebijakan berikut, ganti ** dengan AWS akun yang valid, dan ganti ** dengan nama peran.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:CreateJob",
"glue:GetCrawler",
"glue:GetTrigger",
"glue:DeleteCrawler",
"glue:CreateTrigger",
"glue:DeleteTrigger",
"glue:DeleteJob",
"glue:CreateWorkflow",
"glue:DeleteWorkflow",
"glue:GetJob",
"glue:GetWorkflow",
"glue:CreateCrawler"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
**catatan**
Jika tugas dan crawler dalam alur kerja tersebut mengambil peran selain peran ini, maka kebijakan ini harus menyertakan izin `iam:PassRole` pada peran lain, bukan pada peran cetak biru.
# Mengembangkan cetak biru di AWS Glue
Organisasi Anda mungkin memiliki serangkaian kasus penggunaan ETL serupa yang dapat mengambil manfaat dari kemampuan membuat parameter satu alur kerja untuk menangani semuanya. Untuk mengatasi kebutuhan ini, AWS Glue memungkinkan Anda untuk menentukan *cetak biru*, yang dapat Anda gunakan untuk menghasilkan alur kerja. Sebuah cetak biru menerima banyak parameter, sehingga dari cetak biru tunggal, seorang analis data dapat membuat alur kerja yang berbeda untuk menangani kasus penggunaan ETL yang sama. Setelah membuat sebuah cetak biru, Anda dapat menggunakannya kembali untuk departemen, tim, dan proyek yang berbeda.
**Topics**
+ [Ikhtisar cetak biru di AWS Glue](blueprints-overview.md)
+ [Mengembangkan cetak biru di AWS Glue](developing-blueprints.md)
+ [Mendaftarkan cetak biru di AWS Glue](registering-blueprints.md)
+ [Melihat cetak biru di AWS Glue](viewing_blueprints.md)
+ [Memperbarui cetak biru di AWS Glue](updating_blueprints.md)
+ [Membuat alur kerja dari cetak biru di AWS Glue](creating_workflow_blueprint.md)
+ [Melihat cetak biru berjalan di AWS Glue](viewing_blueprint_runs.md)
# Ikhtisar cetak biru di AWS Glue
**catatan**
Fitur cetak biru saat ini tidak tersedia di Wilayah berikut di konsol AWS Glue: Asia Pasifik (Jakarta) dan Timur Tengah (UEA).
AWS Gluecetak biru menyediakan cara untuk membuat dan berbagi alur kerja. AWS Glue Ketika ada proses ETL kompleks yang dapat digunakan untuk kasus penggunaan serupa, daripada membuat AWS Glue alur kerja untuk setiap kasus penggunaan, Anda dapat membuat cetak biru tunggal.
Cetak biru menentukan tugas dan crawler untuk disertakan dalam alur kerja, dan menentukan parameter yang disediakan pengguna alur kerja saat mereka menjalankan cetak biru untuk membuat alur kerja. Penggunaan parameter memungkinkan satu cetak biru tunggal untuk menghasilkan alur kerja untuk berbagai kasus penggunaan serupa. Untuk informasi lebih lanjut tentang alur kerja, lihat [Ikhtisar alur kerja di AWS Glue](workflows_overview.md).
Berikut adalah contoh kasus penggunaan cetak biru:
+ Anda ingin melakukan partisi pada set data yang ada. Parameter masukan untuk cetak biru adalah path sumber dan target Amazon Simple Storage Service (Amazon S3) dan daftar kolom partisi.
+ Anda ingin membuat snapshot tabel Amazon DynamoDB ke penyimpanan data SQL seperti Amazon Redshift. Parameter input ke cetak biru adalah nama tabel DynamoDB dan koneksi, AWS Glue yang menunjuk cluster Amazon Redshift dan database tujuan.
+ Anda ingin mengkonversi data CSV di beberapa path Amazon S3 ke Parquet. Anda ingin AWS Glue alur kerja menyertakan crawler dan pekerjaan terpisah untuk setiap jalur. Parameter input adalah database tujuan dalam Katalog AWS Glue Data dan daftar jalur Amazon S3 yang dibatasi koma. Perhatikan bahwa dalam kasus ini, jumlah crawler dan tugas yang dibuat alur kerja adalah variabel.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/s3Bm8ay53Ms)
**Komponen cetak biru**
Cetak biru adalah arsip ZIP yang berisi komponen-komponen berikut:
+ Sebuah skrip generator tata letak Python
Berisi fungsi yang menentukan *tata letak* alur kerja—crawler dan tugas yang dapat dibuat untuk alur kerja, properti tugas dan crawler, serta dependensi antara tugas dan crawler. Fungsi menerima parameter cetak biru dan mengembalikan struktur alur kerja (objek JSON) yang AWS Glue digunakan untuk menghasilkan alur kerja. Karena Anda menggunakan skrip Python untuk menghasilkan alur kerja, dengan demikian Anda dapat menambahkan logika Anda sendiri yang cocok untuk kasus penggunaan Anda.
+ Sebuah file konfigurasi
Menentukan nama yang memenuhi syarat dari fungsi Python yang menghasilkan tata letak alur kerja. Juga menentukan nama, tipe data, dan properti lainnya dari semua parameter cetak biru yang digunakan oleh skrip.
+ (Opsional) Skrip ETL dan file pendukung
Sebagai kasus penggunaan lanjutan, Anda dapat melakukan parameterisasi pada lokasi skrip ETL yang digunakan tugas Anda. Anda dapat menyertakan file skrip tugas dalam arsip ZIP dan menentukan parameter cetak biru untuk lokasi Amazon S3 tempat di mana skrip akan disalin. Skrip generator tata letak dapat menyalin skrip ETL ke lokasi yang ditentukan dan menentukan lokasi itu sebagai properti lokasi skrip tugas. Anda juga dapat menyertakan perpustakaan atau file pendukung lainnya, dengan ketentuan bahwa skrip Anda menanganinya.
![\[Kotak berlabel Blueprint berisi dua kotak yang lebih kecil, satu berlabel Python Script dan lainnya berlabel Config File.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/blueprint.png)
**Eksekusi Cetak Biru**
Saat Anda membuat alur kerja dari cetak biru, AWS Glue jalankan cetak biru, yang memulai proses asinkron untuk membuat alur kerja dan pekerjaan, crawler, dan pemicu yang dienkapsulasi alur kerja. AWS Gluemenggunakan blueprint run untuk mengatur pembuatan alur kerja dan komponennya. Anda melihat status proses pembuatan dengan melihat status eksekusi cetak biru. Eksekusi cetak biru juga menyimpan nilai-nilai yang Anda sediakan untuk parameter cetak biru.
![\[Kotak berlabel Blueprint run berisi ikon berlabel Workflow dan Nilai Parameter.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/blueprint-run.png)
Anda dapat melihat blueprint berjalan menggunakan AWS Glue konsol atau AWS Command Line Interface ().AWS CLI Saat melihat atau memecahkan masalah alur kerja, Anda selalu dapat kembali ke eksekusi cetak biru untuk melihat nilai parameter cetak biru yang digunakan untuk membuat alur kerja.
**Siklus hidup cetak biru**
cetak biru dikembangkan, diuji, didaftarkanAWS Glue, dan dijalankan untuk membuat alur kerja. Biasanya ada tiga persona yang terlibat dalam siklus hidup cetak biru.
| Persona | Tugas |
| --- | --- |
| AWS Gluepengembang | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/blueprints-overview.html) |
| AWS Glueadministrator | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/blueprints-overview.html) |
| Analis data | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/blueprints-overview.html) |
**Lihat juga**
[Mengembangkan cetak biru di AWS Glue](developing-blueprints.md)
[Membuat alur kerja dari cetak biru di AWS Glue](creating_workflow_blueprint.md)
[Izin untuk persona dan peran untuk cetak biru AWS Glue](blueprints-personas-permissions.md)
# Mengembangkan cetak biru di AWS Glue
Sebagai AWS Glue pengembang, Anda dapat membuat dan menerbitkan cetak biru yang dapat digunakan analis data untuk menghasilkan alur kerja.
**Topics**
+ [Ikhtisar pengembangan cetak biru](developing-blueprints-overview.md)
+ [Prasyarat untuk mengembangkan cetak biru](developing-blueprints-prereq.md)
+ [Menulis kode cetak biru](developing-blueprints-code.md)
+ [Contoh proyek cetak biru](developing-blueprints-sample.md)
+ [Menguji cetak biru](developing-blueprints-testing.md)
+ [Menerbitkan cetak biru](developing-blueprints-publishing.md)
+ [AWS Gluereferensi kelas cetak biru](developing-blueprints-code-classes.md)
+ [Sampel cetak biru](developing-blueprints-samples.md)
**Lihat juga**
[Ikhtisar cetak biru di AWS Glue](blueprints-overview.md)
# Ikhtisar pengembangan cetak biru
Langkah pertama dalam proses pengembangan Anda adalah mengidentifikasi kasus penggunaan umum yang akan memanfaatkan sebuah cetak biru. Sebuah kasus penggunaan biasa melibatkan masalah ETL berulang yang Anda yakini harus diselesaikan secara umum. Berikutnya, rancang sebuah cetak biru yang mengimplementasikan kasus penggunaan umum, dan tentukan parameter masukan cetak biru yang bersama-sama dapat menentukan kasus penggunaan spesifik dari kasus penggunaan umum.
Sebuah cetak biru terdiri dari sebuah proyek yang berisi file konfigurasi parameter cetak biru dan skrip yang mendefinisikan *tata letak* alur kerja yang akan dibuat. Tata letak tersebut menentukan tugas dan crawler (atau *entitas* dalam terminologi skrip cetak biru) yang akan dibuat.
Anda tidak secara langsung menentukan pemicu apa pun dalam skrip tata letak tersebut. Sebagai gantinya, Anda menulis kode untuk menentukan dependensi antara pekerjaan dan crawler yang dibuat skrip. AWS Gluemenghasilkan pemicu berdasarkan spesifikasi ketergantungan Anda. Output dari skrip tata letak tersebut adalah sebuah objek alur kerja, yang berisi spesifikasi untuk semua entitas alur kerja.
Anda membangun objek alur kerja menggunakan pustaka AWS Glue cetak biru berikut:
+ `awsglue.blueprint.base_resource` — Sebuah perpustakaan sumber daya dasar yang digunakan oleh perpustakaan tersebut.
+ `awsglue.blueprint.workflow` — Sebuah perpustakaan untuk mendefinisikan kelas `Workflow`.
+ `awsglue.blueprint.job` — Sebuah perpustakaan untuk mendefinisikan kelas `Job`.
+ `awsglue.blueprint.crawler` — Sebuah perpustakaan untuk mendefinisikan kelas `Crawler`.
Satu-satunya perpustakaan lain yang didukung untuk pembuatan tata letak adalah perpustakaan yang tersedia untuk shell Python.
Sebelum menerbitkan cetak biru Anda, Anda dapat menggunakan metode yang didefinisikan dalam perpustakaan cetak biru untuk menguji cetak biru secara lokal.
Ketika Anda siap untuk membuat cetak biru yang tersedia untuk analis data, maka Anda mengemas skrip, file konfigurasi parameter, dan file pendukung apa pun, seperti skrip dan perpustakaan tambahan, menjadi satu aset yang dapat di-deploy. Anda kemudian mengunggah aset ke Amazon S3 dan meminta administrator untuk mendaftarkannya. AWS Glue
Untuk informasi tentang contoh proyek cetak biru lainnya, lihat [Contoh proyek cetak biru](developing-blueprints-sample.md) dan [Sampel cetak biru](developing-blueprints-samples.md).
# Prasyarat untuk mengembangkan cetak biru
Untuk mengembangkan cetak biru, Anda harus terbiasa menggunakan AWS Glue dan menulis skrip untuk pekerjaan Apache Spark ETL atau pekerjaan shell Python. Di samping itu, anda harus menyelesaikan tugas penyiapan berikut.
+ Unduh empat pustaka AWS Python untuk digunakan dalam skrip tata letak cetak biru Anda.
+ Mengatur AWS SDKs.
+ Mengatur AWS CLI.
## Unduh pustaka Python
Unduh pustaka berikut dari GitHub, dan instal ke dalam proyek Anda:
+ [https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/base\$1resource.py](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/base_resource.py)
+ [https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/workflow.py](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/workflow.py)
+ [https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/crawler.py](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/crawler.py)
+ [https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/job.py](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/job.py)
## Siapkan AWS Java SDK
Untuk AWS Java SDK, Anda harus menambahkan `jar` file yang menyertakan API untuk cetak biru.
1. Jika Anda belum melakukannya, siapkan AWS SDK for Java.
+ Untuk Java 1.x, ikuti petunjuk di [Menyiapkan AWS SDK untuk Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html) di *Panduan Developer AWS SDK untuk Java *.
+ Untuk Java 2.x, ikuti petunjuk di [Menyiapkan AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html) di *Panduan Developer AWS SDK for Java 2.x *.
1. Unduh `jar` file klien yang memiliki akses ke cetak biru APIs for.
+ Untuk Java 1.x: s3://awsglue-custom-blueprints-preview- -1.11.x.jar artifacts/awsglue-java-sdk-preview/AWSGlueJavaClient
+ Untuk Java 2.x: s3://awsglue-custom-blueprints-preview- -Glue-2.0.jar artifacts/awsglue-java-sdk-v2-preview/AwsJavaSdk
1. Tambahkan klien `jar` ke bagian depan classpath Java untuk mengganti klien AWS Glue yang disediakan oleh Java SDK AWS .
```
export CLASSPATH=:$CLASSPATH
```
1. (Opsional) Uji SDK dengan aplikasi Java berikut. Aplikasi harus menampilkan sebuah daftar kosong.
Ganti `accessKey` dan `secretKey` dengan kredensial Anda, dan ganti `us-east-1` dengan Wilayah Anda.
```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.services.glue.AWSGlue;
import com.amazonaws.services.glue.AWSGlueClientBuilder;
import com.amazonaws.services.glue.model.ListBlueprintsRequest;
public class App{
public static void main(String[] args) {
AWSCredentials credentials = new BasicAWSCredentials("accessKey", "secretKey");
AWSCredentialsProvider provider = new AWSStaticCredentialsProvider(credentials);
AWSGlue glue = AWSGlueClientBuilder.standard().withCredentials(provider)
.withRegion("us-east-1").build();
ListBlueprintsRequest request = new ListBlueprintsRequest().withMaxResults(2);
System.out.println(glue.listBlueprints(request));
}
}
```
## Siapkan SDK AWS Python
Langkah-langkah berikut mengasumsikan bahwa Anda memiliki Python versi 2.7 atau yang lebih baru, atau versi 3.9 atau yang lebih baru diinstal pada komputer Anda.
1. Unduh file roda boto3 berikut. Jika diminta untuk membuka atau menyimpan, simpan file. s3://awsglue-custom-blueprints-preview- 3-1.17.31-py2.py3-none-any.whl artifacts/aws-python-sdk-preview/boto
1. Unduh file roda botocore berikut: s3://- -1.20.31-py2.py3-none-any.whl awsglue-custom-blueprints-preview artifacts/aws-python-sdk-preview/botocore
1. Periksa versi Python anda.
```
python --version
```
1. Tergantung pada versi Python Anda, masukkan perintah berikut (untuk Linux):
+ Untuk Python 2.7 atau yang lebih baru.
```
python3 -m pip install --user virtualenv
source env/bin/activate
```
+ Untuk Python 3.9 atau yang lebih baru.
```
python3 -m venv python-sdk-test
source python-sdk-test/bin/activate
```
1. Instal file roda botocore.
```
python3 -m pip install /botocore-1.20.31-py2.py3-none-any.whl
```
1. Instal file roda boto3.
```
python3 -m pip install /boto3-1.17.31-py2.py3-none-any.whl
```
1. Konfigurasi kredensial dan wilayah default Anda di `~/.aws/credentials` dan `~/.aws/config`. Untuk informasi lebih lanjut, lihat [Mengonfigurasi AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) di *Panduan Pengguna AWS Command Line Interface *.
1. (Opsional) Uji penyiapan Anda. Perintah berikut harus mengembalikan sebuah daftar kosong.
Ganti `us-east-1` dengan Wilayah Anda.
```
$ python
>>> import boto3
>>> glue = boto3.client('glue', 'us-east-1')
>>> glue.list_blueprints()
```
## Siapkan pratinjau AWS CLI
1. Jika Anda belum melakukannya, instal and/or update AWS Command Line Interface (AWS CLI) di komputer Anda. Cara termudah untuk melakukannya adalah dengan `pip`, utilitas penginstal Python:
```
pip install awscli --upgrade --user
```
Anda dapat menemukan petunjuk instalasi lengkap untuk AWS CLI di sini: [Menginstal AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html).
1. Unduh file AWS CLI roda dari: s3://awsglue-custom-blueprints-preview- -1.19.31-py2.py3-none-any.whl artifacts/awscli-preview-build/awscli
1. Instal file AWS CLI roda.
```
python3 -m pip install awscli-1.19.31-py2.py3-none-any.whl
```
1. Jalankan perintah `aws configure`. Konfigurasikan AWS kredensil Anda (termasuk kunci akses, dan kunci rahasia) dan AWS Wilayah. Anda dapat menemukan informasi tentang mengkonfigurasi di AWS CLI sini: [Mengkonfigurasi file. AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
1. Uji AWS CLI. Perintah berikut harus mengembalikan sebuah daftar kosong.
Ganti `us-east-1` dengan Wilayah Anda.
```
aws glue list-blueprints --region us-east-1
```
# Menulis kode cetak biru
Setiap proyek cetak biru yang Anda buat harus berisi paling tidak file-file berikut ini:
+ Skrip tata letak Python yang mendefinisikan alur kerja. Skrip yang berisi fungsi yang mendefinisikan entitas (tugas dan crawler) dalam sebuah alur kerja, dan dependensi di antara mereka.
+ File konfigurasi, `blueprint.cfg`, yang mendefinisikan:
+ Path lengkap dari fungsi definisi tata letak alur kerja.
+ Parameter yang diterima cetak biru.
**Topics**
+ [Membuat skrip tata letak cetak biru](developing-blueprints-code-layout.md)
+ [Membuat file konfigurasi](developing-blueprints-code-config.md)
+ [Menentukan parameter cetak biru](developing-blueprints-code-parameters.md)
# Membuat skrip tata letak cetak biru
Skrip tata letak cetak biru harus menyertakan fungsi yang menghasilkan entitas dalam alur kerja Anda. Anda dapat memberi nama fungsi ini apa pun yang Anda suka. AWS Gluemenggunakan file konfigurasi untuk menentukan nama fungsi yang sepenuhnya memenuhi syarat.
Fungsi tata letak Anda melakukan hal-hal berikut:
+ (Opsional) Instansiasi kelas `Job` untuk membuat objek `Job`, dan memberikan argumen seperti `Command` dan `Role`. Ini adalah properti pekerjaan yang akan Anda tentukan jika Anda membuat pekerjaan menggunakan AWS Glue konsol atau API.
+ (Opsional) Instansiasi kelas `Crawler` untuk membuat objek `Crawler`, dan memberikan nama, peran, dan argumen target.
+ Untuk menunjukkan dependensi antara objek (entitas alur kerja), berikan `DependsOn` dan argumen tambahan `WaitForDependencies` untuk `Job()` dan `Crawler()`. Argumen ini dijelaskan nanti dalam bagian ini.
+ Membuat instance `Workflow` kelas untuk membuat objek alur kerja yang dikembalikan keAWS Glue, meneruskan argumen, `Name` argumen, dan `Entities` argumen opsional. `OnSchedule` Argumen `Entities` menentukan semua tugas dan crawler yang akan disertakan dalam alur kerja. Untuk melihat bagaimana membangun sebuah objek `Entities`, lihat contoh proyek dalam bagian ini nanti.
+ Mengembalikan objek `Workflow`.
Untuk definisi `Job`, `Crawler`, dan kelas `Workflow`, lihat [AWS Gluereferensi kelas cetak biru](developing-blueprints-code-classes.md).
Fungsi tata letak harus menerima argumen-argumen masukan berikut.
| Pendapat | Deskripsi |
| --- | --- |
| user\$1params | Kamus Python tentang nama parameter dan nilai-nilai cetak biru. Untuk informasi selengkapnya, lihat [Menentukan parameter cetak biru](developing-blueprints-code-parameters.md). |
| system\$1params | Kamus Python berisi dua properti: region dan accountId. |
Berikut ini adalah contoh skrip tata letak generator dalam sebuah file bernama `Layout.py`:
```
import argparse
import sys
import os
import json
from awsglue.blueprint.workflow import *
from awsglue.blueprint.job import *
from awsglue.blueprint.crawler import *
def generate_layout(user_params, system_params):
etl_job = Job(Name="{}_etl_job".format(user_params['WorkflowName']),
Command={
"Name": "glueetl",
"ScriptLocation": user_params['ScriptLocation'],
"PythonVersion": "2"
},
Role=user_params['PassRole'])
post_process_job = Job(Name="{}_post_process".format(user_params['WorkflowName']),
Command={
"Name": "pythonshell",
"ScriptLocation": user_params['ScriptLocation'],
"PythonVersion": "2"
},
Role=user_params['PassRole'],
DependsOn={
etl_job: "SUCCEEDED"
},
WaitForDependencies="AND")
sample_workflow = Workflow(Name=user_params['WorkflowName'],
Entities=Entities(Jobs=[etl_job, post_process_job]))
return sample_workflow
```
Skrip contoh mengimpor perpustakaan cetak biru yang diperlukan dan menyertakan fungsi `generate_layout` yang menghasilkan sebuah alur kerja dengan dua tugas. Ini adalah skrip yang sangat sederhana. Skrip yang lebih kompleks dapat menggunakan logika dan parameter tambahan untuk menghasilkan sebuah alur kerja dengan banyak tugas dan crawler, atau bahkan sejumlah variabel tugas dan crawler.
## Menggunakan DependsOn argumen
Argumen `DependsOn` adalah sebuah representasi kamus dependensi yang dimiliki entitas ini atas entitas lain dalam alur kerja. Ia memiliki bentuk berikut.
```
DependsOn = {dependency1 : state, dependency2 : state, ...}
```
Kunci dalam kamus ini mewakili referensi objek, bukan nama, entitas, sedangkan nilainya adalah string yang sesuai dengan status yang harus diperhatikan. AWS Gluemenyimpulkan pemicu yang tepat. Untuk status yang valid, lihat [Struktur Kondisi](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-trigger.html#aws-glue-api-jobs-trigger-Condition).
Sebagai contoh, sebuah tugas mungkin bergantung pada keberhasilan penyelesaian sebuah crawler. Jika anda menentukan sebuah objek crawler bernama `crawler2` sebagai berikut:
```
crawler2 = Crawler(Name="my_crawler", ...)
```
Maka sebuah objek yang tergantung pada `crawler2` akan mencakup argumen konstruktor seperti:
```
DependsOn = {crawler2 : "SUCCEEDED"}
```
Contoh:
```
job1 = Job(Name="Job1", ..., DependsOn = {crawler2 : "SUCCEEDED", ...})
```
Jika `DependsOn` dihilangkan dan diganti sebuah entitas, maka entitas tersebut tergantung pada pemicu awal alur kerja.
## Menggunakan WaitForDependencies argumen
Argumen `WaitForDependencies` mendefinisikan apakah sebuah entitas tugas atau crawler harus menunggu sampai *semua* entitas yang tergantung selesai atau sampai *salah satu* selesai.
Nilai yang diijinkan adalah "`AND`" atau "`ANY`".
## Menggunakan OnSchedule argumen
Argumen `OnSchedule` untuk konstruktor kelas `Workflow` adalah sebuah ekspresi `cron` yang menentukan definisi pemicu awal untuk alur kerja.
Jika argumen ini ditentukan, AWS Glue membuat pemicu jadwal dengan jadwal yang sesuai. Jika tidak ditentukan, maka pemicu awal untuk alur kerja adalah pemicu sesuai permintaan.
# Membuat file konfigurasi
File konfigurasi cetak biru adalah sebuah file yang diperlukan yang menentukan titik entri skrip untuk menghasilkan alur kerja, dan parameter yang diterima cetak biru. File tersebut harus diberi nama `blueprint.cfg`.
Berikut ini adalah file konfigurasi sampel.
```
{
"layoutGenerator": "DemoBlueprintProject.Layout.generate_layout",
"parameterSpec" : {
"WorkflowName" : {
"type": "String",
"collection": false
},
"WorkerType" : {
"type": "String",
"collection": false,
"allowedValues": ["G1.X", "G2.X"],
"defaultValue": "G1.X"
},
"Dpu" : {
"type" : "Integer",
"allowedValues" : [2, 4, 6],
"defaultValue" : 2
},
"DynamoDBTableName": {
"type": "String",
"collection" : false
},
"ScriptLocation" : {
"type": "String",
"collection": false
}
}
}
```
Properti `layoutGenerator` menentukan nama memenuhi syarat fungsi dalam skrip yang menghasilkan tata letak.
Properti `parameterSpec` menentukan parameter yang diterima cetak biru ini. Untuk informasi selengkapnya, lihat [Menentukan parameter cetak biru](developing-blueprints-code-parameters.md).
**penting**
File konfigurasi Anda harus menyertakan nama alur kerja sebagai sebuah parameter cetak biru, atau Anda harus membuat nama alur kerja yang unik dalam skrip tata letak Anda.
# Menentukan parameter cetak biru
File konfigurasi berisi spesifikasi parameter cetak biru dalam objek JSON `parameterSpec`. `parameterSpec` berisi satu atau beberapa objek parameter.
```
"parameterSpec": {
"": {
"type": "",
"collection": true|false,
"description": "",
"defaultValue": ""
"allowedValues": ""
},
"": {
...
}
}
```
Berikut ini adalah aturan untuk melakukan coding pada setiap objek parameter:
+ Nama parameter dan `type` adalah wajib. Semua properti lainnya opsional.
+ Jika Anda menentukan properti `defaultValue`, maka parameter bersifat opsional. Jika tidak, parameter tersebut bersifat wajib dan analis data yang menciptakan alur kerja dari cetak biru tersebut harus memberikan nilai untuk itu.
+ Jika Anda mengatur properti `collection` ke `true`, maka parameter dapat mengambil koleksi nilai-nilai. Koleksi tersebut dapat berupa jenis data apa pun.
+ Jika Anda menentukan`allowedValues`, AWS Glue konsol akan menampilkan daftar tarik-turun nilai untuk dipilih analis data saat membuat alur kerja dari cetak biru.
Berikut ini adalah nilai yang diizinkan untuk `type`:
| Jenis data parameter | Catatan |
| --- | --- |
| String | - |
| Integer | - |
| Double | - |
| Boolean | Kemungkinan nilainya adalah true and false. Menghasilkan kotak centang pada Buat alur kerja dari halaman di AWS Glue konsol. |
| S3Uri | Lengkapi path Amazon S3, yang dimulai dengan s3://. Buat bidang teks dan tombol Jelajahi pada halaman Membuat alur kerja dari . |
| S3Bucket | Nama bucket Amazon S3 saja. Buat pemilih bucket pada halaman Membuat alur kerja dari . |
| IAMRoleArn | Nama Sumber Daya Amazon (ARN) dari peran AWS Identity and Access Management (IAM). Buat pemilih peran pada halaman Membuat alur kerja dari . |
| IAMRoleName | Nama dari sebuah IAM role. Buat pemilih peran pada halaman Membuat alur kerja dari . |
# Contoh proyek cetak biru
Konversi format data adalah kasus penggunaan extract, transform, and load (ETL) yang sering terjadi. Pada beban kerja analitik yang khas, format file berbasis kolom seperti Parquet atau ORC lebih disukai daripada format teks seperti CSV atau JSON. Cetak biru sampel ini memungkinkan Anda mengonversi data dariCSV/JSON/etc. menjadi Parket untuk file di Amazon S3.
Cetak biru ini mengambil daftar path S3 yang didefinisikan oleh parameter cetak biru, mengkonversi data ke format Parquet, dan menulis ke lokasi S3 yang ditentukan oleh parameter cetak biru lain. Skrip tata letak menciptakan sebuah crawler dan tugas untuk setiap path. Skrip tata letak juga mengunggah skrip ETL di `Conversion.py` ke bucket S3 yang ditentukan oleh parameter cetak biru lain. Skrip tata letak kemudian menentukan skrip yang sudah diunggah sebagai skrip ETL untuk setiap tugas. Arsip ZIP untuk proyek berisi skrip tata letak, skrip ETL, dan file konfigurasi cetak biru.
Untuk informasi tentang contoh proyek cetak biru lainnya, lihat [Sampel cetak biru](developing-blueprints-samples.md).
Berikut ini adalah skrip tata letak, dalam file `Layout.py`.
```
from awsglue.blueprint.workflow import *
from awsglue.blueprint.job import *
from awsglue.blueprint.crawler import *
import boto3
s3_client = boto3.client('s3')
# Ingesting all the S3 paths as Glue table in parquet format
def generate_layout(user_params, system_params):
#Always give the full path for the file
with open("ConversionBlueprint/Conversion.py", "rb") as f:
s3_client.upload_fileobj(f, user_params['ScriptsBucket'], "Conversion.py")
etlScriptLocation = "s3://{}/Conversion.py".format(user_params['ScriptsBucket'])
crawlers = []
jobs = []
workflowName = user_params['WorkflowName']
for path in user_params['S3Paths']:
tablePrefix = "source_"
crawler = Crawler(Name="{}_crawler".format(workflowName),
Role=user_params['PassRole'],
DatabaseName=user_params['TargetDatabase'],
TablePrefix=tablePrefix,
Targets= {"S3Targets": [{"Path": path}]})
crawlers.append(crawler)
transform_job = Job(Name="{}_transform_job".format(workflowName),
Command={"Name": "glueetl",
"ScriptLocation": etlScriptLocation,
"PythonVersion": "3"},
Role=user_params['PassRole'],
DefaultArguments={"--database_name": user_params['TargetDatabase'],
"--table_prefix": tablePrefix,
"--region_name": system_params['region'],
"--output_path": user_params['TargetS3Location']},
DependsOn={crawler: "SUCCEEDED"},
WaitForDependencies="AND")
jobs.append(transform_job)
conversion_workflow = Workflow(Name=workflowName, Entities=Entities(Jobs=jobs, Crawlers=crawlers))
return conversion_workflow
```
Berikut ini adalah file `blueprint.cfg` konfigurasi cetak biru yang sesuai.
```
{
"layoutGenerator": "ConversionBlueprint.Layout.generate_layout",
"parameterSpec" : {
"WorkflowName" : {
"type": "String",
"collection": false,
"description": "Name for the workflow."
},
"S3Paths" : {
"type": "S3Uri",
"collection": true,
"description": "List of Amazon S3 paths for data ingestion."
},
"PassRole" : {
"type": "IAMRoleName",
"collection": false,
"description": "Choose an IAM role to be used in running the job/crawler"
},
"TargetDatabase": {
"type": "String",
"collection" : false,
"description": "Choose a database in the Data Catalog."
},
"TargetS3Location": {
"type": "S3Uri",
"collection" : false,
"description": "Choose an Amazon S3 output path: ex:s3:///."
},
"ScriptsBucket": {
"type": "S3Bucket",
"collection": false,
"description": "Provide an S3 bucket name(in the same AWS Region) to store the scripts."
}
}
}
```
Skrip yang ada dalam file `Conversion.py` berikut adalah skrip ETL yang telah diunggah. Perhatikan bahwa ia mempertahankan skema partisi selama konversi.
```
import sys
from pyspark.sql.functions import *
from pyspark.context import SparkContext
from awsglue.transforms import *
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
import boto3
args = getResolvedOptions(sys.argv, [
'JOB_NAME',
'region_name',
'database_name',
'table_prefix',
'output_path'])
databaseName = args['database_name']
tablePrefix = args['table_prefix']
outputPath = args['output_path']
glue = boto3.client('glue', region_name=args['region_name'])
glue_context = GlueContext(SparkContext.getOrCreate())
spark = glue_context.spark_session
job = Job(glue_context)
job.init(args['JOB_NAME'], args)
def get_tables(database_name, table_prefix):
tables = []
paginator = glue.get_paginator('get_tables')
for page in paginator.paginate(DatabaseName=database_name, Expression=table_prefix+"*"):
tables.extend(page['TableList'])
return tables
for table in get_tables(databaseName, tablePrefix):
tableName = table['Name']
partitionList = table['PartitionKeys']
partitionKeys = []
for partition in partitionList:
partitionKeys.append(partition['Name'])
# Create DynamicFrame from Catalog
dyf = glue_context.create_dynamic_frame.from_catalog(
name_space=databaseName,
table_name=tableName,
additional_options={
'useS3ListImplementation': True
},
transformation_ctx='dyf'
)
# Resolve choice type with make_struct
dyf = ResolveChoice.apply(
frame=dyf,
choice='make_struct',
transformation_ctx='resolvechoice_' + tableName
)
# Drop null fields
dyf = DropNullFields.apply(
frame=dyf,
transformation_ctx="dropnullfields_" + tableName
)
# Write DynamicFrame to S3 in glueparquet
sink = glue_context.getSink(
connection_type="s3",
path=outputPath,
enableUpdateCatalog=True,
partitionKeys=partitionKeys
)
sink.setFormat("glueparquet")
sink.setCatalogInfo(
catalogDatabase=databaseName,
catalogTableName=tableName[len(tablePrefix):]
)
sink.writeFrame(dyf)
job.commit()
```
**catatan**
Hanya dua path Amazon S3 yang dapat diberikan sebagai masukan untuk cetak biru sampel. Ini karena AWS Glue pemicu terbatas untuk memanggil hanya dua tindakan crawler.
# Menguji cetak biru
Sementara Anda mengembangkan kode Anda, Anda harus melakukan pengujian secara lokal untuk memverifikasi bahwa tata letak alur kerja sudah benar.
Pengujian lokal tidak menghasilkan AWS Glue pekerjaan, crawler, atau pemicu. Sebaliknya, Anda jalankan skrip tata letak secara lokal dan gunakan metode `to_json()` dan `validate()` untuk mencetak objek dan menemukan kesalahan. Metode ini tersedia di semua tiga kelas yang ditentukan dalam perpustakaan.
Ada dua cara untuk menangani `user_params` dan `system_params` argumen yang AWS Glue lolos ke fungsi tata letak Anda. Kode test-bench Anda dapat membuat sebuah kamus sampel nilai parameter cetak biru dan memberikannya untuk fungsi tata letak sebagai argumen `user_params`. Atau, Anda dapat menghapus referensi ke `user_params` dan menggantinya dengan string yang di-hardcoding.
Jika kode Anda menggunakan properti `region` dan `accountId` di `system_params`, Anda dapat memberikan dalam kamus Anda sendiri untuk `system_params`.
**Untuk menguji sebuah cetak biru**
1. Mulai sebuah interpreter Python dalam direktori yang memiliki perpustakaan, atau muat file cetak biru dan perpustakaan yang disediakan ke lingkungan pengembangan terpadu (IDE) pilihan Anda.
1. Pastikan bahwa kode Anda mengimpor perpustakaan yang disediakan.
1. Tambahkan kode ke fungsi tata letak Anda untuk memanggil `validate()` atau `to_json()` pada entitas apa pun atau objek `Workflow`. Sebagai contoh, jika kode Anda membuat objek `Crawler` bernama `mycrawler`, maka Anda dapat memanggil `validate()` sebagai berikut.
```
mycrawler.validate()
```
Anda dapat mencetak `mycrawler` sebagai berikut:
```
print(mycrawler.to_json())
```
Jika Anda memanggil `to_json` pada sebuah objek, maka Anda tidak perlu juga memanggil `validate()`, karena ` to_json()` memanggil `validate()`.
Hal ini akan sangat berguna untuk memanggil metode ini pada objek alur kerja. Dengan asumsi bahwa skrip Anda memberi nama objek alur kerja `my_workflow`, validasi dan cetak objek alur kerja sebagai berikut.
```
print(my_workflow.to_json())
```
Untuk informasi selengkapnya tentang `to_json()` dan `validate()`, lihat [Metode kelas](developing-blueprints-code-classes.md#developing-blueprints-code-methods).
Anda juga dapat mengimpor `pprint` dan melakukan pretty-print pada objek alur kerja, seperti yang ditunjukkan pada contoh nanti di bagian ini.
1. Jalankan kode, perbaiki kesalahan, dan akhirnya hapus setiap panggilan ke `validate()` atau `to_json()`.
**Example**
Contoh berikut menunjukkan cara membangun kamus parameter cetak biru sampel dan menyebarkannya sebagai argumen `user_params` ke fungsi tata letak `generate_compaction_workflow`. Hal ini juga menunjukkan cara melakukan pretty-print pada objek alur kerja yang dihasilkan.
```
from pprint import pprint
from awsglue.blueprint.workflow import *
from awsglue.blueprint.job import *
from awsglue.blueprint.crawler import *
USER_PARAMS = {"WorkflowName": "compaction_workflow",
"ScriptLocation": "s3://amzn-s3-demo-bucket/scripts/threaded-compaction.py",
"PassRole": "arn:aws:iam::111122223333:role/GlueRole-ETL",
"DatabaseName": "cloudtrial",
"TableName": "ct_cloudtrail",
"CoalesceFactor": 4,
"MaxThreadWorkers": 200}
def generate_compaction_workflow(user_params: dict, system_params: dict) -> Workflow:
compaction_job = Job(Name=f"{user_params['WorkflowName']}_etl_job",
Command={"Name": "glueetl",
"ScriptLocation": user_params['ScriptLocation'],
"PythonVersion": "3"},
Role="arn:aws:iam::111122223333:role/AWSGlueServiceRoleDefault",
DefaultArguments={"DatabaseName": user_params['DatabaseName'],
"TableName": user_params['TableName'],
"CoalesceFactor": user_params['CoalesceFactor'],
"max_thread_workers": user_params['MaxThreadWorkers']})
catalog_target = {"CatalogTargets": [{"DatabaseName": user_params['DatabaseName'], "Tables": [user_params['TableName']]}]}
compacted_files_crawler = Crawler(Name=f"{user_params['WorkflowName']}_post_crawl",
Targets = catalog_target,
Role=user_params['PassRole'],
DependsOn={compaction_job: "SUCCEEDED"},
WaitForDependencies="AND",
SchemaChangePolicy={"DeleteBehavior": "LOG"})
compaction_workflow = Workflow(Name=user_params['WorkflowName'],
Entities=Entities(Jobs=[compaction_job],
Crawlers=[compacted_files_crawler]))
return compaction_workflow
generated = generate_compaction_workflow(user_params=USER_PARAMS, system_params={})
gen_dict = generated.to_json()
pprint(gen_dict)
```
# Menerbitkan cetak biru
Setelah Anda mengembangkan sebuah cetak biru, Anda harus mengunggahnya ke Amazon S3. Anda harus memiliki izin tulis pada bucket Amazon S3 yang Anda gunakan untuk menerbitkan cetak biru. Anda juga harus memastikan bahwa AWS Glue administrator, yang akan mendaftarkan cetak biru, telah membaca akses ke bucket Amazon S3. Untuk kebijakan izin AWS Identity and Access Management (IAM) yang disarankan untuk persona dan peran untuk AWS Glue cetak biru, lihat. [Izin untuk persona dan peran untuk cetak biru AWS Glue](blueprints-personas-permissions.md)
**Untuk menerbitkan sebuah cetak biru**
1. Membuat skrip, sumber daya, dan file konfigurasi cetak biru yang diperlukan.
1. Tambahkan semua file ke arsip ZIP dan unggah file ZIP ke Amazon S3. Gunakan sebuah bucket S3 yang berada di Wilayah yang sama dengan Wilayah dimana pengguna akan mendaftar dan menjalankan cetak biru tersebut.
Anda dapat membuat file ZIP dari baris perintah dengan menggunakan perintah berikut.
```
zip -r folder.zip folder
```
1. Tambahkan kebijakan bucket yang memberikan izin baca ke akun yang AWS diinginkan. Berikut ini adalah contoh outputnya.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::my-blueprints/*"
}
]
}
```
------
1. Berikan `s3:GetObject` izin IAM di bucket Amazon S3 kepada administrator atau kepada siapa pun AWS Glue yang akan mendaftarkan cetak biru. Untuk contoh kebijakan untuk memberikan izin kepada administrator, lihat [AWS Glueizin administrator untuk cetak biru](blueprints-personas-permissions.md#bp-persona-admin).
Setelah Anda menyelesaikan pengujian lokal cetak biru Anda, Anda mungkin juga ingin menguji cetak biru. AWS Glue Untuk menguji cetak biruAWS Glue, itu harus terdaftar. Anda dapat membatasi siapa yang melihat cetak biru terdaftar dengan menggunakan otorisasi IAM, atau dengan menggunakan akun pengujian terpisah.
**Lihat juga:**
[Mendaftarkan cetak biru di AWS Glue](registering-blueprints.md)
# AWS Gluereferensi kelas cetak biru
Pustaka untuk AWS Glue cetak biru menentukan tiga kelas yang Anda gunakan dalam skrip tata letak alur kerja Anda:,, dan. `Job` `Crawler` `Workflow`
**Topics**
+ [Kelas Job](#developing-blueprints-code-jobclass)
+ [Kelas crawler](#developing-blueprints-code-crawlerclass)
+ [Kelas alur kerja](#developing-blueprints-code-workflowclass)
+ [Metode kelas](#developing-blueprints-code-methods)
## Kelas Job
`Job`Kelas mewakili pekerjaan AWS Glue ETL.
**Argumen konstruktor wajib**
Berikut ini adalah argumen konstruktor wajib untuk kelas `Job`.
| Nama argumen | Tipe | Deskripsi |
| --- | --- | --- |
| Name | str | Nama untuk ditugaskan ke pekerjaan. AWS Gluemenambahkan akhiran yang dihasilkan secara acak ke nama untuk membedakan pekerjaan dari yang dibuat oleh blueprint run lainnya. |
| Role | str | Amazon Resource Name (ARN) dari peran yang harus diambil oleh tugas tersebut saat mengeksekusi. |
| Command | dict | Perintah tugas, sebagaimana yang ditentukan pada [JobCommand struktur](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-JobCommand) dalam dokumentasi API. |
**Argumen konstruktor opsional**
Berikut ini adalah argumen konstruktor opsional untuk kelas `Job`.
| Nama argumen | Tipe | Deskripsi |
| --- | --- | --- |
| DependsOn | dict | Daftar entitas alur kerja yang padanya tugas bergantung. Untuk informasi selengkapnya, lihat [Menggunakan DependsOn argumen](developing-blueprints-code-layout.md#developing-blueprints-code-layout-depends-on). |
| WaitForDependencies | str | Menunjukkan apakah tugas harus menunggu sampai semua entitas yang padanya ia bergantung selesai sebelum mengeksekusi atau sampai salah satu selesai. Untuk informasi selengkapnya, lihat [Menggunakan WaitForDependencies argumen](developing-blueprints-code-layout.md#developing-blueprints-code-layout-wait-for-dependencies). Abaikan jika tugas tergantung pada hanya satu entitas saja. |
| (Properti tugas) | - | Properti pekerjaan apa pun yang tercantum [Struktur Job](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-Job) dalam dokumentasi AWS Glue API (kecuali CreatedOn danLastModifiedOn). |
## Kelas crawler
`Crawler`Kelas mewakili AWS Glue crawler.
**Argumen konstruktor wajib**
Berikut ini adalah argumen konstruktor wajib untuk kelas `Crawler`.
| Nama argumen | Tipe | Deskripsi |
| --- | --- | --- |
| Name | str | Nama untuk ditetapkan ke crawler. AWS Gluemenambahkan akhiran yang dihasilkan secara acak ke nama untuk membedakan crawler dari yang dibuat oleh blueprint run lainnya. |
| Role | str | ARN dari peran yang harus diambil crawler saat berjalan. |
| Targets | dict | Koleksi target yang harus di-crawling. Argumen konstruktor kelas Targets ditentukan dalam [CrawlerTargets struktur](aws-glue-api-crawler-crawling.md#aws-glue-api-crawler-crawling-CrawlerTargets) dalam dokumentasi API. Semua argumen konstruktor Targets bersifat opsional, tetapi Anda harus memberikan setidaknya satu argumen. |
**Argumen konstruktor opsional**
Berikut ini adalah argumen konstruktor opsional untuk kelas `Crawler`.
| Nama argumen | Tipe | Deskripsi |
| --- | --- | --- |
| DependsOn | dict | Daftar entitas alur kerja yang padanya crawler bergantung. Untuk informasi selengkapnya, lihat [Menggunakan DependsOn argumen](developing-blueprints-code-layout.md#developing-blueprints-code-layout-depends-on). |
| WaitForDependencies | str | Menunjukkan apakah crawler harus menunggu sampai semua entitas yang padanya ia bergantung selesai sebelum berjalan atau sampai salah satu selesai. Untuk informasi selengkapnya, lihat [Menggunakan WaitForDependencies argumen](developing-blueprints-code-layout.md#developing-blueprints-code-layout-wait-for-dependencies). Abaikan jika crawler tergantung hanya pada satu entitas saja. |
| (Properti Crawler) | - | Properti crawler apa pun yang tercantum [Struktur perayap](aws-glue-api-crawler-crawling.md#aws-glue-api-crawler-crawling-Crawler) dalam dokumentasi AWS Glue API, dengan pengecualian berikut:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/developing-blueprints-code-classes.html) |
## Kelas alur kerja
`Workflow`Kelas mewakili AWS Glue alur kerja. Skrip tata letak alur kerja mengembalikan `Workflow` objek. AWS Gluemembuat alur kerja berdasarkan objek ini.
**Argumen konstruktor wajib**
Berikut ini adalah argumen konstruktor wajib untuk kelas `Workflow`.
| Nama argumen | Tipe | Deskripsi |
| --- | --- | --- |
| Name | str | Nama yang akan ditetapkan untuk alur kerja tersebut. |
| Entities | Entities | Koleksi entitas (tugas dan crawler) yang akan disertakan dalam alur kerja. Kelas konstruktor Entities menerima sebuah argumen Jobs, yang merupakan daftar dari objek Job, dan Crawlers, yang merupakan daftar dari objek Crawler. |
**Argumen konstruktor opsional**
Berikut ini adalah argumen konstruktor opsional untuk kelas `Workflow`.
| Nama argumen | Tipe | Deskripsi |
| --- | --- | --- |
| Description | str | Lihat [Struktur alur kerja](aws-glue-api-workflow.md#aws-glue-api-workflow-Workflow). |
| DefaultRunProperties | dict | Lihat [Struktur alur kerja](aws-glue-api-workflow.md#aws-glue-api-workflow-Workflow). |
| OnSchedule | str | Sebuah ekspresi cron. |
## Metode kelas
Ketiga kelas tersebut mencakup metode-metode berikut.
**validate()**
Memvalidasi properti objek dan apakah ada kesalahan yang ditemukan, membuat keluaran pesan dan menutup. Tidak menghasilkan output jika tidak ada kesalahan. Untuk kelas `Workflow`, memanggil dirinya sendiri pada setiap entitas dalam alur kerja.
**to\$1json()**
Melakukan serialisasi pada objek untuk JSON. Juga memanggil `validate()`. Untuk kelas `Workflow`, objek JSON termasuk tugas dan daftar crawler, serta daftar pemicu yang dihasilkan oleh spesifikasi dependensi tugas dan crawler.
# Sampel cetak biru
Ada sejumlah proyek cetak biru sampel yang tersedia di repositori cetak [AWS Gluebiru](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/samples) Github. Sampel ini hanya untuk referensi saja dan tidak dimaksudkan untuk penggunaan produksi.
Judul dari proyek sampel tersebut adalah:
+ Perapatan: cetak biru ini menciptakan sebuah tugas yang merapatkan file input menjadi potongan yang lebih besar berdasarkan ukuran file yang diinginkan.
+ Konversi: cetak biru ini mengubah file input dalam berbagai format file standar menjadi format Apache Parquet, yang dioptimalkan untuk beban kerja analitik.
+ Melakukan crawling pada lokasi Amazon S3: cetak biru ini melakukan crawling pada beberapa lokasi Amazon S3 untuk menambahkan tabel metadata ke Katalog Data.
+ Koneksi khusus ke Katalog Data: cetak biru ini mengakses penyimpanan data menggunakan konektor AWS Glue khusus, membaca catatan, dan mengisi definisi tabel di Katalog Data AWS Glue berdasarkan skema rekaman.
+ Pengkodean: cetak biru ini mengubah file non-UTF Anda menjadi file UTF yang sudah dikodekan.
+ Partisi: cetak biru ini menciptakan tugas pemartisian yang menempatkan file output ke partisi-partisi berdasarkan kunci partisi tertentu.
+ Mengimpor data Amazon S3 ke dalam tabel DynamoDB: cetak biru ini mengimpor data dari Amazon S3 ke dalam sebuah tabel DynamoDB.
+ Tabel standar yang diatur: cetak biru ini mengimpor tabel Katalog Data AWS Glue ke dalam tabel Lake Formation.
# Mendaftarkan cetak biru di AWS Glue
Setelah AWS Glue pengembang mengkodekan cetak biru dan mengunggah arsip ZIP ke Amazon Simple Storage Service (Amazon S3), administrator harus mendaftarkan cetak biru. AWS Glue Mendaftarkan cetak biru akan membuatnya siap tersedia untuk digunakan.
Saat Anda mendaftarkan cetak biru, salin arsip cetak biru AWS Glue ke lokasi Amazon S3 yang dipesan. Anda kemudian dapat menghapus arsip tersebut dari lokasi pengunggahan.
Untuk mendaftarkan sebuah cetak biru, Anda perlu izin baca di lokasi Amazon S3 yang berisi arsip yang telah diunggah. Anda juga memerlukan izin AWS Identity and Access Management `glue:CreateBlueprint` (IAM). Untuk izin yang disarankan untuk AWS Glue administrator yang harus mendaftar, melihat, dan memelihara cetak biru, lihat. [AWS Glueizin administrator untuk cetak biru](blueprints-personas-permissions.md#bp-persona-admin)
Anda dapat mendaftarkan cetak biru menggunakan AWS Glue konsol, AWS Glue API, atau AWS Command Line Interface ().AWS CLI
**Untuk mendaftarkan sebuah cetak biru (konsol)**
1. Pastikan bahwa Anda memiliki izin baca (`s3:GetObject`) pada arsip ZIP cetak biru di Amazon S3.
1. Buka konsol AWS Glue di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Masuk sebagai pengguna yang memiliki izin untuk mendaftarkan sebuah cetak biru. Beralih ke Wilayah AWS yang sama sebagai bucket Amazon S3 yang berisi arsip ZIP cetak biru.
1. Di panel navigasi, pilih **cetak biru**. **Kemudian pada halaman **cetak biru, pilih Tambahkan cetak** biru.**
1. Masukkan nama dan deskripsi opsional untuk cetak biru.
1. Untuk **Lokasi arsip ZIP (S3)**, masukkan path Amazon S3 dari arsip ZIP cetak biru yang telah diunggah. Sertakan nama file arsip di path dan mulai path dengan `s3://`.
1. (Opsional) Tambahkan satu tag satu atau beberapa tag.
1. Pilih **Tambahkan cetak biru**.
Halaman **cetak biru** mengembalikan dan menunjukkan bahwa status cetak biru adalah. `CREATING` Pilih tombol refresh hingga status berubah menjadi `ACTIVE` atau `FAILED`.
1. Jika statusnya adalah `FAILED`, pilih cetak biru, dan pada menu **Tindakan**, pilih **Lihat**.
Halaman detail menunjukkan alasan kegagalan. Jika pesan kesalahan "Tidak dapat mengakses objek di lokasi..." atau "Akses ditolak pada objek di lokasi...", tinjau persyaratan berikut:
+ Pengguna yang Anda gunakan masuk harus memiliki izin baca pada arsip ZIP cetak biru di Amazon S3.
+ Bucket Amazon S3 yang berisi arsip ZIP harus memiliki kebijakan bucket yang memberikan izin baca pada objek ke ID akun Anda AWS . Untuk informasi selengkapnya, lihat [Mengembangkan cetak biru di AWS Glue](developing-blueprints.md).
+ Bucket Amazon S3 yang Anda gunakan harus berada dalam Wilayah yang sama dengan Wilayah yang Anda masuki di konsol tersebut.
1. Pastikan bahwa analis data memiliki izin pada cetak biru tersebut.
Kebijakan IAM yang disarankan bagi analisis data ditunjukkan dalam [Izin analis data untuk cetak biru](blueprints-personas-permissions.md#bp-persona-analyst). Kebijakan ini memberikan `glue:GetBlueprint` pada sumber daya apa pun. Jika kebijakan Anda lebih detail pada tingkat sumber daya, maka berikan izin analis data pada sumber daya yang baru dibuat ini.
**Untuk mendaftarkan cetak biru (CLI)AWS**
1. Masukkan perintah berikut.
```
aws glue create-blueprint --name [--description ] --blueprint-location s3:///
```
1. Masukkan perintah berikut untuk memeriksa status cetak biru. Ulangi perintah sampai status menjadi `ACTIVE` atau `FAILED`.
```
aws glue get-blueprint --name
```
Jika statusnya adalah `FAILED` dan pesan kesalahannya adalah "Tidak dapat mengakses objek di lokasi..." atau "Akses ditolak pada objek di lokasi...", tinjau persyaratan berikut:
+ Pengguna yang Anda gunakan masuk harus memiliki izin baca pada arsip ZIP cetak biru di Amazon S3.
+ Bucket Amazon S3 yang berisi arsip ZIP harus memiliki kebijakan bucket yang memberikan izin baca pada objek ke ID akun Anda AWS . Untuk informasi selengkapnya, lihat [Menerbitkan cetak biru](developing-blueprints-publishing.md).
+ Bucket Amazon S3 yang Anda gunakan harus berada dalam Wilayah yang sama dengan Wilayah yang Anda masuki di konsol tersebut.
**Lihat juga:**
[Ikhtisar cetak biru di AWS Glue](blueprints-overview.md)
# Melihat cetak biru di AWS Glue
Melihat cetak biru untuk meninjau deskripsi cetak biru, status, dan spesifikasi parameter, dan untuk mengunduh arsip ZIP tempat cetak biru.
Anda dapat melihat cetak biru menggunakan AWS Glue konsol, AWS Glue API, atau AWS Command Line Interface ().AWS CLI
**Untuk melihat cetak biru (konsol)**
1. Buka konsol AWS Glue di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Di panel navigasi, pilih **cetak biru**.
1. Pada halaman **cetak biru, pilih cetak** biru. Di menu **Tindakan**, pilih **Lihat**.
**Untuk melihat cetak biru (CLI)AWS**
+ Masukkan perintah berikut untuk melihat nama cetak biru saja, deskripsi, dan status saja. Ganti ** dengan nama cetak biru untuk dilihat.
```
aws glue get-blueprint --name
```
Output perintah tersebut terlihat seperti berikut ini.
```
{
"Blueprint": {
"Name": "myDemoBP",
"CreatedOn": 1587414516.92,
"LastModifiedOn": 1587428838.671,
"BlueprintLocation": "s3://amzn-s3-demo-bucket1/demo/DemoBlueprintProject.zip",
"Status": "ACTIVE"
}
}
```
Masukkan perintah berikut untuk juga melihat spesifikasi parameter.
```
aws glue get-blueprint --name --include-parameter-spec
```
Output perintah tersebut terlihat seperti berikut ini.
```
{
"Blueprint": {
"Name": "myDemoBP",
"CreatedOn": 1587414516.92,
"LastModifiedOn": 1587428838.671,
"ParameterSpec": "{\"WorkflowName\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null},\"PassRole\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null},\"DynamoDBTableName\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null},\"ScriptLocation\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null}}",
"BlueprintLocation": "s3://awsexamplebucket1/demo/DemoBlueprintProject.zip",
"Status": "ACTIVE"
}
}
```
Tambahkan `--include-blueprint` argumen untuk menyertakan URL dalam output yang dapat Anda tempel ke browser Anda untuk mengunduh arsip cetak biru ZIP yang disimpan. AWS Glue
**Lihat juga:**
[Ikhtisar cetak biru di AWS Glue](blueprints-overview.md)
# Memperbarui cetak biru di AWS Glue
Anda dapat memperbarui sebuah cetak biru jika Anda memiliki skrip tata letak yang direvisi, serangkaian parameter cetak biru yang direvisi, atau file pendukung yang direvisi. Memperbarui cetak biru akan menciptakan cetak biru versi baru.
Memperbarui cetak biru tidak akan memengaruhi alur kerja yang ada yang dibuat dari cetak biru tersebut.
Anda dapat memperbarui cetak biru menggunakan AWS Glue konsol, AWS Glue API, atau AWS Command Line Interface ().AWS CLI
Prosedur berikut mengasumsikan bahwa AWS Glue pengembang telah membuat dan mengunggah arsip ZIP cetak biru yang diperbarui ke Amazon S3.
**Untuk memperbarui sebuah cetak biru (konsol)**
1. Pastikan bahwa Anda memiliki izin baca (`s3:GetObject`) pada arsip ZIP cetak biru di Amazon S3.
1. Buka konsol AWS Glue di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Masuk sebagai pengguna yang memiliki izin untuk memperbarui sebuah cetak biru. Beralih ke Wilayah AWS yang sama sebagai bucket Amazon S3 yang berisi arsip ZIP cetak biru.
1. Di panel navigasi, pilih **cetak biru**.
1. ****Pada halaman **cetak biru, pilih cetak** biru, dan pada menu Tindakan, pilih Edit.****
1. Pada halaman **Edit cetak biru**, perbarui **Deskripsi** cetak biru atau **Lokasi arsip ZIP (S3)**. Pastikan untuk menyertakan nama file arsip dalam path.
1. Pilih **Simpan**.
Halaman **cetak biru** mengembalikan dan menunjukkan bahwa status cetak biru adalah. `UPDATING` Pilih tombol refresh hingga status berubah menjadi `ACTIVE` atau `FAILED`.
1. Jika statusnya adalah `FAILED`, pilih cetak biru, dan pada menu **Tindakan**, pilih **Lihat**.
Halaman detail menunjukkan alasan kegagalan. Jika pesan kesalahan "Tidak dapat mengakses objek di lokasi..." atau "Akses ditolak pada objek di lokasi...", tinjau persyaratan berikut:
+ Pengguna yang Anda gunakan masuk harus memiliki izin baca pada arsip ZIP cetak biru di Amazon S3.
+ Bucket Amazon S3 yang berisi arsip ZIP harus memiliki kebijakan bucket yang memberikan izin baca pada objek ke ID akun Anda AWS . Untuk informasi selengkapnya, lihat [Menerbitkan cetak biru](developing-blueprints-publishing.md).
+ Bucket Amazon S3 yang Anda gunakan harus berada dalam Wilayah yang sama dengan Wilayah yang Anda masuki di konsol tersebut.
**catatan**
Jika pembaruan gagal, eksekusi cetak biru berikutnya akan menggunakan cetak biru versi terbaru yang berhasil terdaftar atau diperbarui.
**Untuk memperbarui sebuah cetak biru (AWS CLI)**
1. Masukkan perintah berikut.
```
aws glue update-blueprint --name [--description ] --blueprint-location s3:///
```
1. Masukkan perintah berikut untuk memeriksa status cetak biru. Ulangi perintah sampai status menjadi `ACTIVE` atau `FAILED`.
```
aws glue get-blueprint --name
```
Jika statusnya adalah `FAILED` dan pesan kesalahannya adalah "Tidak dapat mengakses objek di lokasi..." atau "Akses ditolak pada objek di lokasi...", tinjau persyaratan berikut:
+ Pengguna yang Anda gunakan masuk harus memiliki izin baca pada arsip ZIP cetak biru di Amazon S3.
+ Bucket Amazon S3 yang berisi arsip ZIP harus memiliki kebijakan bucket yang memberikan izin baca pada objek ke ID akun Anda AWS . Untuk informasi selengkapnya, lihat [Menerbitkan cetak biru](developing-blueprints-publishing.md).
+ Bucket Amazon S3 yang Anda gunakan harus berada dalam Wilayah yang sama dengan Wilayah yang Anda masuki di konsol tersebut.
**Lihat juga**
[Ikhtisar cetak biru di AWS Glue](blueprints-overview.md)
# Membuat alur kerja dari cetak biru di AWS Glue
[Anda dapat membuat AWS Glue alur kerja secara manual, menambahkan satu komponen pada satu waktu, atau Anda dapat membuat alur kerja dari cetak biru. AWS Glue](blueprints-overview.md) AWS Gluetermasuk cetak biru untuk kasus penggunaan umum. AWS GluePengembang Anda dapat membuat cetak biru tambahan.
**penting**
Batasi jumlah total pekerjaan, crawler, dan pemicu dalam alur kerja hingga 100 atau kurang. Jika Anda menyertakan lebih dari 100, Anda mungkin mendapatkan kesalahan saat mencoba melanjutkan atau menghentikan alur kerja berjalan.
Bila Anda menggunakan sebuah cetak biru, maka Anda dapat dengan cepat menghasilkan sebuah alur kerja untuk sebuah kasus penggunaan tertentu berdasarkan kasus penggunaan umum yang ditentukan oleh cetak biru tersebut. Anda menentukan kasus penggunaan tertentu dengan memberikan nilai untuk parameter cetak biru. Sebagai contoh, cetak biru yang memartisi set data bisa memiliki path sumber dan target Amazon S3 sebagai parameter.
AWS Glue*membuat alur kerja dari cetak biru dengan menjalankan cetak biru.* Eksekusi cetak menyimpan nilai parameter yang Anda berikan, dan digunakan untuk melacak kemajuan dan hasil pembuatan alur kerja dan komponen-komponennya. Saat memecahkan masalah alur kerja, Anda dapat melihat eksekusi cetak biru untuk menentukan nilai parameter cetak biru yang digunakan untuk membuat sebuah alur kerja.
Untuk membuat dan melihat alur kerja, Anda memerlukan izin IAM tertentu. Untuk kebijakan IAM yang disarankan, lihat [Izin analis data untuk cetak biru](blueprints-personas-permissions.md#bp-persona-analyst).
Anda dapat membuat alur kerja dari cetak biru menggunakan AWS Glue konsol, AWS Glue API, atau (). AWS Command Line Interface AWS CLI
**Untuk membuat sebuah alur kerja dari sebuah cetak biru (konsol)**
1. Buka konsol AWS Glue di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Masuk sebagai pengguna yang memiliki izin untuk membuat sebuah alur kerja.
1. Di panel navigasi, pilih **cetak biru**.
1. Pilih cetak biru, dan pada menu **Tindakan**, pilih **Buat alur kerja**.
1. Pada halaman **Membuat alur kerja dari **, masukkan informasi berikut:
**Parameter cetak biru**
Parameter ini bervariasi tergantung pada desain cetak biru. Untuk pertanyaan tentang parameter, lihat pengembang. cetak biru biasanya menyertakan parameter untuk nama alur kerja.
**IAM Role**
Peran yang AWS Glue mengasumsikan untuk membuat alur kerja dan komponennya. Peran tersebut harus memiliki izin untuk membuat dan menghapus alur kerja, tugas, crawler, dan pemicu. Untuk kebijakan yang disarankan untuk peran tersebut, lihat [Izin untuk peran cetak biru](blueprints-personas-permissions.md#blueprints-role-permissions).
1. Pilih **Kirim**.
Halaman **Detail Cetak Biru** muncul, menampilkan daftar eksekusi cetak biru di bagian bawah.
1. Dalam daftar eksekusi cetak biru, periksa cetak biru paling atas untuk status pembuatan alur kerja.
Status awal adalah `RUNNING`. Pilih tombol refresh hingga status masuk ke `SUCCEEDED` atau `FAILED`.
1. Lakukan salah satu tindakan berikut:
+ Jika status penyelesaian adalah `SUCCEEDED`, maka Anda dapat masuk **alur kerja**, pilih alur kerja yang baru dibuat, dan jalankan. Sebelum menjalankan alur kerja, Anda dapat meninjau grafik desainnya.
+ Jika status penyelesaian adalah `FAILED`, pilih eksekusi cetak biru, dan pada menu **Tindakan**, pilih **Lihat** untuk melihat pesan kesalahan.
Untuk informasi selengkapnya tentang alur kerja dan cetak biru, lihat topik berikut.
+ [Ikhtisar alur kerja di AWS Glue](workflows_overview.md)
+ [Memperbarui cetak biru di AWS Glue](updating_blueprints.md)
+ [Membuat dan membangun alur kerja secara manual di AWS Glue](creating_running_workflows.md)
# Melihat cetak biru berjalan di AWS Glue
Melihat eksekusi cetak biru untuk melihat informasi berikut:
+ Nama alur kerja yang dibuat.
+ nilai parameter cetak biru yang digunakan untuk membuat alur kerja.
+ Status operasi pembuatan alur kerja.
Anda dapat melihat cetak biru yang dijalankan menggunakan AWS Glue konsol, AWS Glue API, atau AWS Command Line Interface ().AWS CLI
**Untuk melihat eksekusi cetak biru (konsol)**
1. Buka konsol AWS Glue di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Di panel navigasi, pilih **cetak biru**.
1. Pada halaman **cetak biru, pilih cetak** biru. Di menu **Tindakan**, pilih **Lihat**.
1. Pada halaman **Detail Cetak Biru**, pilih eksekusi cetak biru, dan pada menu **Tindakan**, pilih **Lihat**.
**Untuk melihat eksekusi cetak biru (AWS CLI)**
+ Masukkan perintah berikut. Ganti ** dengan nama cetak biru. Ganti ** dengan blueprint run ID.
```
aws glue get-blueprint-run --blueprint-name --run-id
```
**Lihat juga:**
[Ikhtisar cetak biru di AWS Glue](blueprints-overview.md)