Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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)