",
transformationContext="datasource"
).getDynamicFrame()
val ruleset = """
Rules = [
(ColumnValues "age" >= 26) OR (ColumnLength "name" >= 4)
]
"""
val dq_results = EvaluateDataQuality.processRows(
frame=datasource,
ruleset=ruleset,
additionalOptions=JsonOptions("""
{
"compositeRuleEvaluation.method":"ROW"
}
"""
)
)
}
```
Di AWS Glue Data Catalog, Anda dapat dengan mudah mengkonfigurasi opsi ini di antarmuka pengguna seperti yang ditunjukkan di bawah ini.
![\[Tangkapan layar menunjukkan jendela pengaturan aturan komposit di mana Anda dapat memilih konfigurasi evaluasi aturan antara baris dan kolom. Jika Anda memilih Baris, aturan komposit akan berperilaku sebagai aturan tunggal yang mengevaluasi seluruh baris. Jika Anda memilih Kolom, aturan komposit akan mengevaluasi aturan individual di seluruh kumpulan data dan menggabungkan hasilnya.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/composite-rule-settings.png)
Setelah ditetapkan, aturan komposit akan berperilaku sebagai aturan tunggal yang mengevaluasi seluruh baris. Contoh berikut menggambarkan perilaku ini.
```
# Row Level outcome
+------+------+------------------------------------------------------------+---------------------------+
|myCol1|myCol2|DataQualityRulesPass |DataQualityEvaluationResult|
+------+------+------------------------------------------------------------+---------------------------+
|2 |1 |[(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)]|Passed |
|0 |3 |[(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)]|Passed |
+------+------+------------------------------------------------------------+---------------------------+
```
Beberapa aturan tidak dapat didukung dalam fitur ini karena hasil keseluruhannya bergantung pada ambang batas atau rasio. Mereka tercantum di bawah ini.
Aturan yang mengandalkan rasio:
+ Kelengkapan
+ DatasetMatch
+ ReferentialIntegrity
+ Keunikan
Aturan tergantung pada ambang batas:
Ketika aturan berikut termasuk dengan ambang batas, mereka tidak didukung. Namun, aturan yang tidak melibatkan `with threshold` tetap didukung.
+ ColumnDataType
+ ColumnValues
+ CustomSQL
### Ekspresi
Jika tipe aturan tidak menghasilkan respons Boolean, Anda harus memberikan ekspresi sebagai parameter untuk membuat respons Boolean. Misalnya, aturan berikut memeriksa rata-rata (rata-rata) dari semua nilai dalam kolom terhadap ekspresi untuk mengembalikan hasil benar atau salah.
```
Mean "colA" between 80 and 100
```
Beberapa jenis aturan seperti `IsUnique` dan `IsComplete` sudah mengembalikan respons Boolean.
Tabel berikut mencantumkan ekspresi yang dapat Anda gunakan dalam aturan DQDL.
**Ekspresi DQDL yang didukung**
| Ekspresi | Deskripsi | Contoh |
| --- | --- | --- |
| =x | Menyelesaikan true jika respons tipe aturan sama dengan. x | Completeness "colA" = "1.0",
ColumnValues "colA" = "2022-06-30"
|
| \$1=x | x Menyelesaikan ke true jika respons tipe aturan tidak sama dengan. x | ColumnValues "colA" != "a",
ColumnValues "colA" != "2022-06-30"
|
| > x | Menyelesaikan true jika respons tipe aturan lebih besar dari. x | ColumnValues "colA" > 10
|
| < x | Menyelesaikan true jika respons tipe aturan kurang dari. x | ColumnValues "colA" < 1000,
ColumnValues "colA" < "2022-06-30"
|
| >= x | Menyelesaikan true jika respons tipe aturan lebih besar dari atau sama dengan. x | ColumnValues "colA" >= 10
|
| <= x | Menyelesaikan true jika respons tipe aturan kurang dari atau sama dengan. x | ColumnValues "colA" <= 1000
|
| antara x dan y | Menyelesaikan true jika respons tipe aturan jatuh dalam rentang tertentu (eksklusif). Hanya gunakan jenis ekspresi ini untuk tipe numerik dan tanggal. | Mean "colA" between 8 and 100,
ColumnValues "colA" between "2022-05-31" and "2022-06-30"
|
| Bukan antara x dan y | Menyelesaikan ke true jika respons tipe aturan tidak termasuk dalam rentang tertentu (inklusif). Anda hanya harus menggunakan tipe ekspresi ini untuk tipe numerik dan tanggal. | ColumnValues "colA" not between "2022-05-31" and "2022-06-30"
|
| di [a, b, c, ...] | Menyelesaikan true jika respons tipe aturan ada di set yang ditentukan. | ColumnValues "colA" in [ 1, 2, 3 ],
ColumnValues "colA" in [ "a", "b", "c" ]
|
| tidak di [a, b, c, ...] | Menyelesaikan true jika respons tipe aturan tidak ada dalam set yang ditentukan. | ColumnValues "colA" not in [ 1, 2, 3 ],
ColumnValues "colA" not in [ "a", "b", "c" ]
|
| pertandingan /ab\$1c/i | Menyelesaikan true jika respons tipe aturan cocok dengan ekspresi reguler. | ColumnValues "colA" matches "[a-zA-Z]*"
|
| tidak cocok /ab\$1c/i | Menyelesaikan true jika respons tipe aturan tidak cocok dengan ekspresi reguler. | ColumnValues "colA" not matches "[a-zA-Z]*"
|
| now() | Bekerja hanya dengan jenis ColumnValues aturan untuk membuat ekspresi tanggal. | ColumnValues "load_date" > (now() - 3 days)
|
| matches/in […]/not matches/notdi [...] with threshold | Menentukan persentase nilai yang cocok dengan kondisi aturan. Bekerja hanya denganColumnValues,ColumnDataType, dan jenis CustomSQL aturan. | ColumnValues "colA" in ["A", "B"] with threshold > 0.8,
ColumnValues "colA" matches "[a-zA-Z]*" with threshold between 0.2 and 0.9
ColumnDataType "colA" = "Timestamp" with threshold > 0.9
|
#### Kata kunci untuk NULL, EMPTY dan WHITESPACES\$1ONLY
Jika Anda ingin memvalidasi jika kolom string memiliki nol, kosong atau string dengan hanya spasi putih Anda dapat menggunakan kata kunci berikut:
+ NULL/null — Kata kunci ini menyelesaikan true untuk `null` nilai dalam kolom string.
`ColumnValues "colA" != NULL with threshold > 0.5`akan mengembalikan true jika lebih dari 50% data Anda tidak memiliki nilai nol.
`(ColumnValues "colA" = NULL) or (ColumnLength "colA" > 5)`akan mengembalikan true untuk semua baris yang memiliki nilai nol atau memiliki panjang> 5. *Perhatikan bahwa ini akan memerlukan penggunaan opsi “compositeRuleEvaluation.method” = “ROW”.*
+ EMPTY/empty - Kata kunci ini menyelesaikan true untuk nilai string kosong (“”) dalam kolom string. Beberapa format data mengubah nol dalam kolom string menjadi string kosong. Kata kunci ini membantu menyaring string kosong dalam data Anda.
`(ColumnValues "colA" = EMPTY) or (ColumnValues "colA" in ["a", "b"])`akan mengembalikan true jika baris kosong, “a” atau “b”. *Perhatikan bahwa ini memerlukan penggunaan opsi “compositeRuleEvaluation.method” = “ROW”.*
+ WHITESPACES\$1ONLY/whitespaces\$1only — Kata kunci ini menyelesaikan true untuk string dengan hanya spasi putih (“”) nilai dalam kolom string.
`ColumnValues "colA" not in ["a", "b", WHITESPACES_ONLY]`akan mengembalikan true jika baris bukan “a” atau “b” atau hanya spasi putih.
Aturan yang didukung:
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
Untuk ekspresi berbasis numerik atau tanggal, jika Anda ingin memvalidasi jika kolom memiliki nol, Anda dapat menggunakan kata kunci berikut.
+ NULL/null — Kata kunci ini menyelesaikan true untuk nilai null dalam kolom string.
`ColumnValues "colA" in [NULL, "2023-01-01"]`akan mengembalikan true jika tanggal di kolom Anda salah satu `2023-01-01` atau null.
`(ColumnValues "colA" = NULL) or (ColumnValues "colA" between 1 and 9)`akan mengembalikan true untuk semua baris yang memiliki nilai nol atau memiliki nilai antara 1 dan 9. *Perhatikan bahwa ini akan memerlukan penggunaan opsi “compositeRuleEvaluation.method” = “ROW”.*
Aturan yang didukung:
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
#### Pemfilteran dengan Klausul Where
**catatan**
Di mana Klausul hanya didukung di AWS Glue 4.0.
Anda dapat memfilter data Anda saat membuat aturan. Ini sangat membantu ketika Anda ingin menerapkan aturan bersyarat.
```
where " "
```
Filter harus ditentukan dengan `where` kata kunci, diikuti oleh pernyataan SparkSQL yang valid yang terlampir dalam tanda kutip. `("")`
Jika aturan Anda ingin menambahkan klausa where ke aturan dengan ambang batas, klausa where harus ditentukan sebelum kondisi ambang batas.
```
where "valid SparkSQL statement>" with threshold
```
Dengan sintaks ini Anda dapat menulis aturan seperti berikut ini.
```
Completeness "colA" > 0.5 where "colB = 10"
ColumnValues "colB" in ["A", "B"] where "colC is not null" with threshold > 0.9
ColumnLength "colC" > 10 where "colD != Concat(colE, colF)"
```
Kami akan memvalidasi bahwa pernyataan SparkSQL yang diberikan valid. Jika tidak valid, evaluasi aturan akan gagal dan kami akan melempar a `IllegalArgumentException` dengan format berikut:
```
Rule where "" has provided an invalid where clause :
```
**Di mana perilaku klausa saat identifikasi catatan kesalahan tingkat baris diaktifkan**
Dengan AWS Glue Data Quality, Anda dapat mengidentifikasi catatan spesifik yang gagal. Saat menerapkan klausa where ke aturan yang mendukung hasil tingkat baris, kami akan memberi label pada baris yang disaring oleh klausa where sebagai. `Passed`
Jika Anda lebih suka memberi label secara terpisah pada baris yang difilter sebagai`SKIPPED`, Anda dapat mengatur yang berikut ini `additionalOptions` untuk pekerjaan ETL.
```
object GlueApp {
val datasource = glueContext.getCatalogSource(
database="",
tableName="",
transformationContext="datasource"
).getDynamicFrame()
val ruleset = """
Rules = [
IsComplete "att2" where "att1 = 'a'"
]
"""
val dq_results = EvaluateDataQuality.processRows(
frame=datasource,
ruleset=ruleset,
additionalOptions=JsonOptions("""
{
"rowLevelConfiguration.filteredRowLabel":"SKIPPED"
}
"""
)
)
}
```
Sebagai contoh, lihat aturan dan kerangka data berikut:
```
IsComplete att2 where "att1 = 'a'"
```
| id | att1 | att2 | Hasil tingkat baris (Default) | Hasil Tingkat Baris (Opsi Dilewati) | Komentar |
| --- | --- | --- | --- | --- | --- |
| 1 | a | f | BERLALU | BERLALU | |
| 2 | b | d | BERLALU | DILEWATI | Baris disaring, att1 karena tidak "a" |
| 3 | a | null | FAILED | FAILED | |
| 4 | a | f | BERLALU | BERLALU | |
| 5 | b | null | BERLALU | DILEWATI | Baris disaring, att1 karena tidak "a" |
| 6 | a | f | BERLALU | BERLALU | |
### Konstanta
Di DQDL, Anda dapat menentukan nilai konstan dan mereferensikannya di seluruh skrip Anda. Ini membantu mencegah masalah yang terkait dengan batas ukuran kueri—misalnya, saat bekerja dengan pernyataan SQL besar yang mungkin melebihi batas yang diizinkan. Dengan menetapkan nilai-nilai ini ke Konstanta, Anda dapat menyederhanakan DQDL Anda dan menghindari mencapai batas tersebut.
Contoh berikut menunjukkan bagaimana mendefinisikan dan menggunakan konstanta:
```
mySql = "select count(*) from primary"
Rules = [
CustomSql $mySql between 0 and 100
]
```
Dalam contoh ini, kueri SQL ditugaskan ke konstanta`mySql`, yang kemudian direferensikan dalam aturan menggunakan awalan. `$`
### Label
Label menyediakan cara yang efektif untuk mengatur dan menganalisis hasil kualitas data. Anda dapat menanyakan hasil berdasarkan label tertentu untuk mengidentifikasi aturan yang gagal dalam kategori tertentu, menghitung hasil aturan berdasarkan tim atau domain, dan membuat laporan terfokus untuk pemangku kepentingan yang berbeda.
Misalnya, Anda dapat menerapkan semua aturan yang berkaitan dengan tim keuangan dengan label `"team=finance"` dan membuat laporan khusus untuk menampilkan metrik kualitas khusus untuk tim keuangan. Anda dapat memberi label aturan prioritas tinggi `"criticality=high"` untuk memprioritaskan upaya remediasi. Label dapat ditulis sebagai bagian dari DQDL. Anda dapat menanyakan label sebagai bagian dari hasil aturan, hasil tingkat baris, dan respons API, sehingga memudahkan integrasi dengan alur kerja pemantauan dan pelaporan yang ada.
**catatan**
Label hanya tersedia di AWS Glue ETL dan tidak tersedia dalam Kualitas Data berbasis Katalog Data AWS Glue.
#### Sintaks untuk label DQDL
DQDL mendukung label default dan khusus aturan. Label default didefinisikan pada tingkat set aturan dan secara otomatis berlaku untuk semua aturan dalam kumpulan aturan tersebut. Aturan individual juga dapat memiliki labelnya sendiri, dan karena label diimplementasikan sebagai pasangan nilai kunci, label khusus aturan dapat mengganti label default saat menggunakan kunci yang sama.
Contoh berikut menunjukkan cara menggunakan label default dan khusus aturan:
```
DefaultLabels=["frequency"="monthly"]
Rules = [
// Auto includes the default label ["frequency"="monthly"]
ColumnValues "col" > 21,
// Add ["foo"="bar"] to default label. Labels for this rule would be ["frequency"="monthly", "foo"="bar"]
Rule 1 with threshold > 0.8 labels=["foo"="bar"],
// Override default label. Labels for this rule would be ["frequency"="daily", "foo"="bar"]
Rule 2 with threshold > 0.8 labels=["foo"="bar", "frequency"="daily"]
// Labels must be applied to the entire composite rule (parentheses required)
(Rule 1 AND Rule 2) labels=["foo"="bar]
]
```
##### Kendala label
Label memiliki kendala berikut:
+ Maksimal 10 label per aturan DQDL.
+ Label ditentukan sebagai daftar pasangan kunci-nilai.
+ Kunci label dan nilai label peka huruf besar/kecil.
+ Panjang kunci label maksimum adalah 128 karakter. Kunci label tidak boleh kosong atau nol.
+ Panjang nilai label maksimum adalah 256 karakter. Nilai label mungkin kosong atau nol.
#### Mengambil label DQDL
Anda dapat mengambil label DQDL dari hasil aturan, hasil tingkat baris, dan respons API.
##### Hasil aturan
Label DQDL selalu terlihat dalam hasil aturan. Tidak diperlukan konfigurasi tambahan untuk mengaktifkannya.
##### Hasil tingkat baris
Label DQDL dinonaktifkan secara default dalam hasil tingkat baris tetapi dapat diaktifkan menggunakan in. `AdditionalOptions` `EvaluateDataQuality`
Contoh berikut menunjukkan cara mengaktifkan label dalam hasil tingkat baris:
```
val evaluateResult = EvaluateDataQuality.processRows(
frame=AmazonS3_node1754591511068,
ruleset=example_ruleset,
publishingOptions=JsonOptions("""{
"dataQualityEvaluationContext": "evaluateResult",
"enableDataQualityCloudWatchMetrics": "true",
"enableDataQualityResultsPublishing": "true"
}"""),
additionalOptions=JsonOptions("""{
"performanceTuning.caching":"CACHE_NOTHING",
"observations.scope":"ALL",
"rowLevelConfiguration.ruleWithLabels":"ENABLED"
}""")
)
```
Saat diaktifkan, kerangka data hasil tingkat baris menyertakan label untuk setiap aturan di,, dan kolom. `DataQualityRulesPass` `DataQualityRulesFail` `DataQualityRulesSkip`
##### Respon API
Label DQDL selalu terlihat dalam respons API di bawah bidang baru `Labels` di objek. `RuleResults`
Contoh berikut menunjukkan label dalam respons API:
```
{
"ResultId": "dqresult-example",
"ProfileId": "dqprofile-example",
"Score": 0.6666666666666666,
"RulesetName": "EvaluateDataQuality_node1754591514205",
"EvaluationContext": "EvaluateDataQuality_node1754591514205",
"StartedOn": "2025-08-22T19:36:10.448000+00:00",
"CompletedOn": "2025-08-22T19:36:16.368000+00:00",
"JobName": "anniezc-test-labels",
"JobRunId": "jr_068f6d7a45074d9105d14e4dee09db12c3b95664b45f6ee44fa29ed7e5619ba8",
"RuleResults": [
{
"Name": "Rule_0",
"Description": "IsComplete colA",
"EvaluationMessage": "Input data does not include column colA!",
"Result": "FAIL",
"EvaluatedMetrics": {},
"EvaluatedRule": "IsComplete colA",
"Labels": {
"frequency": "monthly"
}
},
{
"Name": "Rule_1",
"Description": "Rule 1 with threshold > 0.8",
"Result": "PASS",
"EvaluatedMetrics": {},
"EvaluatedRule": "Rule 1 with threshold > 0.8",
"Labels": {
"frequency": "monthly",
"foo": "bar"
}
},
{
"Name": "Rule_3",
"Description": "Rule 2 with threshold > 0.8",
"Result": "PASS",
"EvaluatedMetrics": {},
"EvaluatedRule": "Rule 2 with threshold > 0.8",
"Labels": {
"frequency": "daily",
"foo": "bar"
}
}
]
}
```
### Aturan dinamis
**catatan**
Aturan Dinamis hanya didukung di AWS Glue ETL dan tidak didukung di AWS Glue Data Catalog.
Anda sekarang dapat membuat aturan dinamis untuk membandingkan metrik saat ini yang dihasilkan oleh aturan Anda dengan nilai historisnya. Perbandingan historis ini diaktifkan dengan menggunakan `last()` operator dalam ekspresi. Misalnya, aturan `RowCount > last()` akan berhasil ketika jumlah baris dalam proses saat ini lebih besar dari jumlah baris sebelumnya terbaru untuk kumpulan data yang sama. `last()`mengambil argumen bilangan asli opsional yang menjelaskan berapa banyak metrik sebelumnya untuk dipertimbangkan; `last(k)` di mana `k >= 1` akan merujuk metrik terakhir`k`.
+ Jika tidak ada titik data yang tersedia, `last(k)` akan mengembalikan nilai default 0.0.
+ Jika kurang dari `k` metrik yang tersedia, `last(k)` akan mengembalikan semua metrik sebelumnya.
Untuk membentuk ekspresi yang valid gunakan`last(k)`, di mana `k > 1` memerlukan fungsi agregasi untuk mengurangi beberapa hasil historis menjadi satu nomor. Misalnya, `RowCount > avg(last(5))` akan memeriksa apakah jumlah baris kumpulan data saat ini benar-benar lebih besar dari rata-rata jumlah lima baris terakhir untuk kumpulan data yang sama. `RowCount > last(5)`akan menghasilkan kesalahan karena jumlah baris kumpulan data saat ini tidak dapat dibandingkan secara bermakna dengan daftar.
Fungsi agregasi yang didukung:
+ `avg`
+ `median`
+ `max`
+ `min`
+ `sum`
+ `std`(standar deviasi)
+ `abs`(nilai absolut)
+ `index(last(k), i)`akan memungkinkan untuk memilih nilai terbaru dari yang terakhir`k`. `i` `i`diindeks nol, jadi `index(last(3), 0)` akan mengembalikan titik data terbaru dan `index(last(3), 3)` akan menghasilkan kesalahan karena hanya ada tiga titik data dan kami mencoba untuk mengindeks yang terbaru ke-4.
**Ekspresi sampel**
**ColumnCorrelation**
+ `ColumnCorrelation "colA" "colB" < avg(last(10))`
**DistinctValuesCount**
+ `DistinctValuesCount "colA" between min(last(10))-1 and max(last(10))+1`
Sebagian besar tipe aturan dengan kondisi numerik atau ambang batas mendukung aturan dinamis; lihat tabel yang disediakan, [Analisa dan Aturan](#dqdl-analyzers-table), untuk menentukan apakah aturan dinamis didukung untuk jenis aturan Anda.
**Tidak termasuk statistik dari aturan dinamis**
Terkadang, Anda perlu mengecualikan statistik data dari perhitungan aturan dinamis Anda. Katakanlah Anda melakukan pemuatan data historis dan Anda tidak ingin itu memengaruhi rata-rata Anda. Untuk melakukan ini, buka pekerjaan di AWS Glue ETL dan pilih Tab **Kualitas Data**, lalu pilih **Statistik** dan pilih statistik yang ingin Anda kecualikan. Anda akan dapat melihat grafik tren bersama dengan tabel statistik. Pilih nilai yang ingin Anda kecualikan dan pilih **Kecualikan Statistik**. Sekarang statistik yang dikecualikan tidak akan dimasukkan dalam perhitungan aturan dinamis.
![\[Tangkapan layar menunjukkan opsi untuk mengecualikan atau menyertakan statistik dari menu tarik-turun setelah memilih statistik.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/data-quality-excluding-statistics-from-dynamic-rules.png)
### Analisa
**catatan**
Analyzer tidak didukung di AWS Glue Data Catalog.
Aturan DQDL menggunakan fungsi yang disebut *penganalisis* untuk mengumpulkan informasi tentang data Anda. Informasi ini digunakan oleh ekspresi Boolean aturan untuk menentukan apakah aturan harus berhasil atau gagal. Misalnya, RowCount aturan `RowCount > 5 ` akan menggunakan penganalisis hitungan baris untuk menemukan jumlah baris dalam kumpulan data Anda, dan membandingkan jumlah itu dengan ekspresi `> 5` untuk memeriksa apakah ada lebih dari lima baris dalam kumpulan data saat ini.
Terkadang, alih-alih membuat aturan, kami sarankan untuk membuat penganalisis dan kemudian membuatnya menghasilkan statistik yang dapat digunakan untuk mendeteksi anomali. Untuk contoh seperti itu, Anda dapat membuat penganalisis. Penganalisis berbeda dari aturan dengan cara berikut.
| Karakteristik | Analisa | Aturan |
| --- | --- | --- |
| Bagian dari ruleset | Ya | Ya |
| Menghasilkan statistik | Ya | Ya |
| Menghasilkan pengamatan | Ya | Ya |
| Dapat mengevaluasi dan menegaskan suatu kondisi | Tidak | Ya |
| Anda dapat mengonfigurasi tindakan seperti menghentikan pekerjaan pada kegagalan, melanjutkan pekerjaan pemrosesan | Tidak | Ya |
Analyzer dapat eksis secara independen tanpa aturan, sehingga Anda dapat dengan cepat mengonfigurasinya dan secara progresif membangun aturan kualitas data.
Beberapa jenis aturan dapat dimasukkan ke dalam `Analyzers` blok kumpulan aturan Anda untuk menjalankan aturan yang diperlukan untuk penganalisis dan mengumpulkan informasi tanpa menerapkan pemeriksaan untuk kondisi apa pun. Beberapa penganalisis tidak terkait dengan aturan dan hanya dapat dimasukkan ke dalam `Analyzers` blok. Tabel berikut menunjukkan apakah setiap item didukung sebagai aturan atau penganalisis mandiri, bersama dengan detail tambahan untuk setiap jenis aturan.
**Contoh Ruleset dengan Analyzer**
Ruleset berikut menggunakan:
+ aturan dinamis untuk memeriksa apakah kumpulan data tumbuh di atas rata-rata trailing untuk tiga pekerjaan terakhir
+ `DistinctValuesCount`analyzer untuk mencatat jumlah nilai yang berbeda di kolom dataset `Name`
+ `ColumnLength`analyzer untuk melacak `Name` ukuran minimum dan maksimum dari waktu ke waktu
Hasil metrik penganalisis dapat dilihat di tab Kualitas Data untuk menjalankan pekerjaan Anda.
```
Rules = [
RowCount > avg(last(3))
]
Analyzers = [
DistinctValuesCount "Name",
ColumnLength "Name"
]
```
AWS Glue Data Quality mendukung analisa berikut.
| Nama penganalisis | Fungsionalitas |
| --- | --- |
| RowCount | Menghitung jumlah baris untuk kumpulan data |
| Completeness | Menghitung persentase kelengkapan kolom |
| Uniqueness | Menghitung persentase keunikan kolom |
| Mean | Menghitung rata-rata kolom numerik |
| Sum | Menghitung jumlah kolom numerik |
| StandardDeviation | Menghitung standar deviasi kolom numerik |
| Entropy | Menghitung entropi kolom numerik |
| DistinctValuesCount | Menghitung jumlah nilai yang berbeda dalam kolom |
| UniqueValueRatio | Menghitung rasio nilai unik dalam kolom |
| ColumnCount | Menghitung jumlah kolom dalam kumpulan data |
| ColumnLength | Menghitung panjang kolom |
| ColumnValues | Menghitung minimum, maksimum untuk kolom numerik. Menghitung Minimum ColumnLength dan Maksimum ColumnLength untuk kolom non-numerik |
| ColumnCorrelation | Menghitung korelasi kolom untuk kolom yang diberikan |
| CustomSql | Menghitung statistik yang dikembalikan oleh CustomSQL |
| AllStatistics | Menghitung statistik berikut: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/dqdl.html) |
### Komentar
Anda dapat menggunakan karakter '\$1' untuk menambahkan komentar ke dokumen DQDL Anda. Apa pun setelah karakter '\$1' dan sampai akhir baris diabaikan oleh DQDL.
```
Rules = [
# More items should generally mean a higher price, so correlation should be positive
ColumnCorrelation "price" "num_items" > 0
]
```
# Referensi tipe aturan DQDL
Bagian ini memberikan referensi untuk setiap jenis aturan yang didukung AWS Glue Data Quality.
**catatan**
DQDL saat ini tidak mendukung data kolom bersarang atau tipe daftar.
Nilai kurung pada tabel di bawah ini akan diganti dengan informasi yang disediakan dalam argumen aturan.
Aturan biasanya memerlukan argumen tambahan untuk ekspresi.
| Jenis aturan | Deskripsi | Pendapat | Metrik yang Dilaporkan | Didukung sebagai Aturan? | Didukung sebagai Analyzer? | Mengembalikan Hasil tingkat baris? | Dukungan aturan dinamis? | Menghasilkan Pengamatan | Mendukung Sintaks Klausul Dimana? |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| AggregateMatch | Memeriksa apakah dua kumpulan data cocok dengan membandingkan metrik ringkasan seperti jumlah total penjualan. Berguna bagi lembaga keuangan untuk membandingkan jika semua data dicerna dari sistem sumber. | Satu atau lebih agregasi | Ketika nama kolom agregasi pertama dan kedua cocok: `Column.[Column].AggregateMatch` Ketika nama kolom agregasi pertama dan kedua berbeda: `Column.[Column1,Column2].AggregateMatch` | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| AllStatistics | Penganalisis mandiri untuk mengumpulkan beberapa metrik untuk kolom yang disediakan dalam kumpulan data. | Nama kolom tunggal | Untuk kolom dari semua jenis: `Dataset.*.RowCount` `Column.[Column].Completeness` `Column.[Column].Uniqueness` Metrik tambahan untuk kolom bernilai string: `ColumnLength metrics` Metrik tambahan untuk kolom bernilai numerik: `ColumnValues metrics` | Tidak | Ya | Tidak | Tidak | Tidak | Tidak |
| ColumnCorrelation | Memeriksa seberapa baik dua kolom berkorelasi. | Tepat dua nama kolom | Multicolumn.[Column1,Column2].ColumnCorrelation | Ya | Ya | Tidak | Ya | Tidak | Ya |
| ColumnCount | Memeriksa apakah ada kolom yang dijatuhkan. | Tidak ada | Dataset.\$1.ColumnCount | Ya | Ya | Tidak | Ya | Ya | Tidak |
| ColumnDataType | Memeriksa apakah kolom sesuai dengan tipe data. | Tepat satu nama kolom | Column.[Column].ColumnDataType.Compliance | Ya | Tidak | Tidak | Ya, dalam ekspresi ambang batas tingkat baris | Tidak | Ya |
| ColumnExists | Memeriksa apakah kolom ada dalam kumpulan data. Hal ini memungkinkan pelanggan membangun platform data layanan mandiri untuk memastikan kolom tertentu tersedia. | Tepat satu nama kolom | N/A | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| ColumnLength | Memeriksa apakah panjang data konsisten. | Tepat satu nama kolom | `Column.[Column].MaximumLength` `Column.[Column].MinimumLength` Metrik tambahan saat ambang tingkat baris disediakan: `Column.[Column].ColumnValues.Compliance` | Ya | Ya | Ya, ketika ambang batas tingkat baris disediakan | Tidak | Ya. Hanya menghasilkan pengamatan dengan menganalisis panjang Minimum dan Maksimum | Ya |
| ColumnNamesMatchPattern | Memeriksa apakah nama kolom cocok dengan pola yang ditentukan. Berguna bagi tim tata kelola untuk menegakkan konsistensi nama kolom. | Sebuah regex untuk nama kolom | Dataset.\$1.ColumnNamesPatternMatchRatio | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| ColumnValues | Memeriksa apakah data konsisten per nilai yang ditentukan. Aturan ini mendukung ekspresi reguler. | Tepat satu nama kolom | `Column.[Column].Maximum` `Column.[Column].Minimum` Metrik tambahan saat ambang tingkat baris disediakan: `Column.[Column].ColumnValues.Compliance` | Ya | Ya | Ya, ketika ambang batas tingkat baris disediakan | Tidak | Ya. Hanya menghasilkan pengamatan dengan menganalisis nilai Minimum dan Maksimum | Ya |
| Kelengkapan | Memeriksa data kosong atau NULLs dalam data. | Tepat satu nama kolom | `Column.[Column].Completeness` | Ya | Ya | Ya | Ya | Ya | Ya |
| CustomSql | Pelanggan dapat menerapkan hampir semua jenis pemeriksaan kualitas data di SQL. | Pernyataan SQL (Opsional) Ambang batas tingkat baris | `Dataset.*.CustomSQL` Metrik tambahan saat ambang tingkat baris disediakan: `Dataset.*.CustomSQL.Compliance` | Ya | Tidak | Ya, ketika ambang batas tingkat baris disediakan | Ya | Tidak | Tidak |
| DataFreshness | Memeriksa apakah data masih segar. | Tepat satu nama kolom | Column.[Column].DataFreshness.Compliance | Ya | Tidak | Ya | Tidak | Tidak | Ya |
| DatasetMatch | Membandingkan dua kumpulan data dan mengidentifikasi jika mereka sinkron. | Nama dataset referensi Pemetaan kolom (Opsional) Kolom untuk memeriksa kecocokan | Dataset.[ReferenceDatasetAlias].DatasetMatch | Ya | Tidak | Ya | Ya | Tidak | Tidak |
| DistinctValuesCount | Memeriksa nilai duplikat. | Tepat satu nama kolom | Column.[Column].DistinctValuesCount | Ya | Ya | Ya | Ya | Ya | Ya |
| DetectAnomalies | Memeriksa anomali dalam metrik yang dilaporkan tipe aturan lain. | Jenis aturan | Metrik yang dilaporkan oleh argumen tipe aturan | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| Entropi | Memeriksa entropi data. | Tepat satu nama kolom | Column.[Column].Entropy | Ya | Ya | Tidak | Ya | Tidak | Ya |
| IsComplete | Memeriksa apakah 100% data selesai. | Tepat satu nama kolom | Column.[Column].Completeness | Ya | Tidak | Ya | Tidak | Tidak | Ya |
| IsPrimaryKey | Memeriksa apakah kolom adalah kunci utama (bukan NULL dan unik). | Tepat satu nama kolom | Untuk kolom tunggal: `Column.[Column].Uniqueness` Untuk beberapa kolom: `Multicolumn.[CommaDelimitedColumns].Uniqueness` | Ya | Tidak | Ya | Tidak | Tidak | Ya |
| IsUnique | Memeriksa apakah 100% data unik. | Tepat satu nama kolom | Column.[Column].Uniqueness | Ya | Tidak | Ya | Tidak | Tidak | Ya |
| Berarti | Memeriksa apakah mean cocok dengan ambang batas yang ditetapkan. | Tepat satu nama kolom | Column.[Column].Mean | Ya | Ya | Ya | Ya | Tidak | Ya |
| ReferentialIntegrity | Memeriksa apakah dua kumpulan data memiliki integritas referensial. | Satu atau beberapa nama kolom dari dataset Satu atau beberapa nama kolom dari dataset referensi | Column.[ReferenceDatasetAlias].ReferentialIntegrity | Ya | Tidak | Ya | Ya | Tidak | Tidak |
| RowCount | Memeriksa apakah jumlah catatan cocok dengan ambang batas. | Tidak ada | Dataset.\$1.RowCount | Ya | Ya | Tidak | Ya | Ya | Ya |
| RowCountMatch | Memeriksa apakah jumlah rekaman antara dua kumpulan data cocok. | Alias dataset referensi | Dataset.[ReferenceDatasetAlias].RowCountMatch | Ya | Tidak | Tidak | Ya | Tidak | Tidak |
| StandardDeviation | Memeriksa apakah standar deviasi cocok dengan ambang batas. | Tepat satu nama kolom | Column.[Column].StandardDeviation | Ya | Ya | Ya | Ya | Tidak | Ya |
| SchemaMatch | Memeriksa apakah skema antara dua kumpulan data cocok. | Alias dataset referensi | Dataset.[ReferenceDatasetAlias].SchemaMatch | Ya | Tidak | Tidak | Ya | Tidak | Tidak |
| Jumlah | Memeriksa apakah jumlah cocok dengan ambang batas yang ditetapkan. | Tepat satu nama kolom | Column.[Column].Sum | Ya | Ya | Tidak | Ya | Tidak | Ya |
| Keunikan | Memeriksa apakah keunikan kumpulan data cocok dengan ambang batas. | Tepat satu nama kolom | Column.[Column].Uniqueness | Ya | Ya | Ya | Ya | Tidak | Ya |
| UniqueValueRatio | Memeriksa apakah ransum nilai unik cocok dengan ambang batas. | Tepat satu nama kolom | Column.[Column].UniqueValueRatio | Ya | Ya | Ya | Ya | Tidak | Ya |
| FileFreshness | Memeriksa apakah file di Amazon S3 masih segar. | Jalur file atau Folder dan ambang batas. | `Dataset.*.FileFreshness.Compliance` `Dataset.*.FileCount` | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| FileMatch | Memeriksa apakah isi file cocok dengan checksum atau dengan file lain. Aturan ini menggunakan checksum untuk memvalidasi jika dua file sama. | Sumber File atau jalur Folder dan file Target atau jalur folder. | Tidak ada statistik yang dihasilkan. | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| FileSize | Memeriksa apakah ukuran file cocok dengan kondisi tertentu. | Jalur dan ambang batas file atau folder. | `Dataset.*.FileSize.Compliance` `Dataset.*.FileCount` `Dataset.*.MaximumFileSize` `Dataset.*.MinimumFileSize` | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| FileUniqueness | Memeriksa apakah file unik menggunakan checksum. | Jalur dan ambang batas file atau folder. | `Dataset.*.FileUniquenessRatio` `Dataset.*.FileCount` | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
**Topics**
+ [
# AggregateMatch
](dqdl-rule-types-AggregateMatch.md)
+ [
# ColumnCorrelation
](dqdl-rule-types-ColumnCorrelation.md)
+ [
# ColumnCount
](dqdl-rule-types-ColumnCount.md)
+ [
# ColumnDataType
](dqdl-rule-types-ColumnDataType.md)
+ [
# ColumnExists
](dqdl-rule-types-ColumnExists.md)
+ [
# ColumnLength
](dqdl-rule-types-ColumnLength.md)
+ [
# ColumnNamesMatchPattern
](dqdl-rule-types-ColumnNamesMatchPattern.md)
+ [
# ColumnValues
](dqdl-rule-types-ColumnValues.md)
+ [
# Kelengkapan
](dqdl-rule-types-Completeness.md)
+ [
# CustomSQL
](dqdl-rule-types-CustomSql.md)
+ [
# DataFreshness
](dqdl-rule-types-DataFreshness.md)
+ [
# DatasetMatch
](dqdl-rule-types-DatasetMatch.md)
+ [
# DistinctValuesCount
](dqdl-rule-types-DistinctValuesCount.md)
+ [
# Entropi
](dqdl-rule-types-Entropy.md)
+ [
# IsComplete
](dqdl-rule-types-IsComplete.md)
+ [
# IsPrimaryKey
](dqdl-rule-types-IsPrimaryKey.md)
+ [
# IsUnique
](dqdl-rule-types-IsUnique.md)
+ [
# Berarti
](dqdl-rule-types-Mean.md)
+ [
# ReferentialIntegrity
](dqdl-rule-types-ReferentialIntegrity.md)
+ [
# RowCount
](dqdl-rule-types-RowCount.md)
+ [
# RowCountMatch
](dqdl-rule-types-RowCountMatch.md)
+ [
# StandardDeviation
](dqdl-rule-types-StandardDeviation.md)
+ [
# Jumlah
](dqdl-rule-types-Sum.md)
+ [
# SchemaMatch
](dqdl-rule-types-SchemaMatch.md)
+ [
# Keunikan
](dqdl-rule-types-Uniqueness.md)
+ [
# UniqueValueRatio
](dqdl-rule-types-UniqueValueRatio.md)
+ [
# DetectAnomalies
](dqdl-rule-types-DetectAnomalies.md)
+ [
# FileFreshness
](dqdl-rule-types-FileFreshness.md)
+ [
# FileMatch
](dqdl-rule-types-FileMatch.md)
+ [
# FileUniqueness
](dqdl-rule-types-FileUniqueness.md)
+ [
# FileSize
](dqdl-rule-types-FileSize.md)
# AggregateMatch
Memeriksa rasio agregasi dua kolom terhadap ekspresi yang diberikan. Ruletype ini bekerja pada beberapa dataset. Dua agregasi kolom dievaluasi dan rasio dihasilkan dengan membagi hasil agregasi kolom pertama dengan hasil agregasi kolom kedua. Rasio diperiksa terhadap ekspresi yang disediakan untuk menghasilkan respons boolean.
**Sintaksis**
**Agregasi kolom**
```
AggregateMatch (.)
```
+ **AGG\$1OPERATION — Operasi** yang digunakan untuk agregasi. Saat ini, `sum` dan `avg` didukung.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **OPTIONAL\$1REFERENCE\$1ALIAS** - Parameter ini perlu disediakan jika kolom berasal dari kumpulan data referensi dan bukan kumpulan data utama. Jika Anda menggunakan aturan ini di Katalog Data AWS Glue, alias referensi Anda harus mengikuti format ". .
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **COL\$1NAME** — Nama kolom untuk agregat.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
**Contoh: Rata-rata**
```
"avg(rating)"
```
**Contoh: Jumlah**
```
"sum(amount)"
```
**Contoh: Rata-rata kolom dalam dataset referensi**
```
"avg(reference.rating)"
```
**Aturan**
```
AggregateMatch
```
+ **AGG\$1EXP\$11** - Agregasi kolom pertama.
Jenis kolom yang didukung: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **AGG\$1EXP\$12** - Agregasi kolom kedua.
Jenis kolom yang didukung: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Pencocokan Agregat menggunakan jumlah**
Contoh aturan berikut memeriksa apakah jumlah nilai dalam `amount` kolom persis sama dengan jumlah nilai dalam `total_amount` kolom.
```
AggregateMatch "sum(amount)" "sum(total_amount)" = 1.0
```
**Contoh: Pencocokan Agregat menggunakan rata-rata**
Contoh aturan berikut memeriksa apakah rata-rata nilai dalam `ratings` kolom sama dengan setidaknya 90% dari rata-rata nilai dalam `ratings` kolom dalam `reference` dataset. Dataset referensi disediakan sebagai sumber data tambahan dalam pengalaman ETL atau Katalog Data.
Di AWS Glue ETL, Anda dapat menggunakan:
```
AggregateMatch "avg(ratings)" "avg(reference.ratings)" >= 0.9
```
Dalam Katalog Data AWS Glue, Anda dapat menggunakan:
```
AggregateMatch "avg(ratings)" "avg(database_name.tablename.ratings)" >= 0.9
```
**Perilaku nol**
`AggregateMatch`Aturan akan mengabaikan baris dengan nilai NULL dalam perhitungan metode agregasi (jumlah/mean). Contoh:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
Rata-rata kolom `units` adalah (0 \$1 20 \$1 40)/3 = 20. Baris 101 dan 103 tidak dipertimbangkan dalam perhitungan ini.
# ColumnCorrelation
Memeriksa *korelasi* antara dua kolom terhadap ekspresi yang diberikan. AWS Glue Data Quality menggunakan koefisien korelasi Pearson untuk mengukur korelasi linier antara dua kolom. Hasilnya adalah angka antara -1 dan 1 yang mengukur kekuatan dan arah hubungan.
**Sintaksis**
```
ColumnCorrelation
```
+ **COL\$11\$1NAME** — Nama kolom pertama yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **COL\$12\$1NAME** — Nama kolom kedua yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Korelasi kolom**
Contoh aturan berikut memeriksa apakah koefisien korelasi antara kolom `height` dan `weight` memiliki korelasi positif yang kuat (nilai koefisien lebih besar dari 0,8).
```
ColumnCorrelation "height" "weight" > 0.8
```
```
ColumnCorrelation "weightinkgs" "Salary" > 0.8 where "weightinkgs > 40"
```
**Contoh aturan dinamis**
+ `ColumnCorrelation "colA" "colB" between min(last(10)) and max(last(10))`
+ `ColumnCorrelation "colA" "colB" < avg(last(5)) + std(last(5))`
**Perilaku nol**
`ColumnCorrelation`Aturan akan mengabaikan baris dengan `NULL` nilai dalam perhitungan korelasi. Contoh:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
Baris 101 dan 103 akan diabaikan, dan `ColumnCorrelation` akan menjadi 1.0.
# ColumnCount
Memeriksa jumlah kolom dari dataset primer terhadap ekspresi yang diberikan. Dalam ekspresi, Anda dapat menentukan jumlah kolom atau rentang kolom menggunakan operator seperti `>` dan`<`.
**Sintaksis**
```
ColumnCount
```
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Pemeriksaan numerik hitungan kolom**
Contoh aturan berikut memeriksa apakah jumlah kolom berada dalam rentang tertentu.
```
ColumnCount between 10 and 20
```
**Contoh aturan dinamis**
+ `ColumnCount >= avg(last(10))`
+ `ColumnCount between min(last(10))-1 and max(last(10))+1`
# ColumnDataType
Memeriksa apakah nilai dalam kolom tertentu dapat dilemparkan di Apache Spark ke jenis yang disediakan. Menerima `with threshold` ekspresi untuk memeriksa subset nilai di kolom.
**Sintaksis**
```
ColumnDataType =
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
Jenis kolom yang didukung: Jenis string
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **EXPECTED\$1TYPE** — Jenis nilai yang diharapkan di kolom.
Nilai yang didukung: Boolean, Date, Timestamp, Integer, Double, Float, Long
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **EKSPRESI** - Ekspresi opsional untuk menentukan persentase nilai yang harus dari tipe yang diharapkan.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
**Contoh: Kolom tipe data bilangan bulat sebagai string**
Contoh aturan berikut memeriksa apakah nilai-nilai dalam kolom yang diberikan, yang bertipe string, dapat dilemparkan sebagai bilangan bulat.
```
ColumnDataType "colA" = "INTEGER"
```
**Contoh: Kolom tipe data bilangan bulat sebagai string memeriksa subset dari nilai**
Contoh aturan berikut memeriksa apakah lebih dari 90% nilai dalam kolom yang diberikan, yang bertipe string, dapat dilemparkan sebagai bilangan bulat.
```
ColumnDataType "colA" = "INTEGER" with threshold > 0.9
```
# ColumnExists
Memeriksa apakah kolom ada.
**Sintaksis**
```
ColumnExists
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
**Contoh: Kolom ada**
Contoh aturan berikut memeriksa apakah kolom bernama `Middle_Name` ada.
```
ColumnExists "Middle_Name"
```
# ColumnLength
Memeriksa apakah panjang setiap baris dalam kolom sesuai dengan ekspresi yang diberikan.
**Sintaksis**
```
ColumnLength
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: String
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Panjang baris kolom**
Contoh aturan berikut memeriksa apakah nilai di setiap baris dalam kolom bernama `Postal_Code` adalah 5 karakter panjang.
```
ColumnLength "Postal_Code" = 5
ColumnLength "weightinkgs" = 2 where "weightinkgs > 10"
```
**Perilaku nol**
`ColumnLength`Aturan memperlakukan `NULL` s sebagai 0 string panjang. Untuk satu `NULL` baris:
```
ColumnLength "Postal_Code" > 4 # this will fail
```
```
ColumnLength "Postal_Code" < 6 # this will succeed
```
Contoh aturan majemuk berikut menyediakan cara untuk secara eksplisit gagal `NULL` nilai:
```
(ColumnLength "Postal_Code" > 4) AND (ColumnValues "Postal_Code" != NULL)
```
# ColumnNamesMatchPattern
Memeriksa apakah nama semua kolom dalam kumpulan data utama cocok dengan ekspresi reguler yang diberikan.
**Sintaksis**
```
ColumnNamesMatchPattern
```
+ **POLA** — Pola yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
**Contoh: Pola pencocokan nama kolom**
Contoh aturan berikut memeriksa apakah semua kolom dimulai dengan awalan “aws\$1”
```
ColumnNamesMatchPattern "aws_.*"
ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10"
```
# ColumnValues
Menjalankan ekspresi terhadap nilai-nilai dalam kolom.
**Sintaksis**
```
ColumnValues
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Nilai yang diizinkan**
Contoh aturan berikut memeriksa apakah setiap nilai dalam kolom yang ditentukan berada dalam satu set nilai yang diizinkan (termasuk nol, kosong, dan string dengan hanya spasi putih).
```
ColumnValues "Country" in [ "US", "CA", "UK", NULL, EMPTY, WHITESPACES_ONLY ]
ColumnValues "gender" in ["F", "M"] where "weightinkgs < 10"
```
**Contoh: Ekspresi reguler**
Contoh aturan berikut memeriksa nilai-nilai dalam kolom terhadap ekspresi reguler.
```
ColumnValues "First_Name" matches "[a-zA-Z]*"
```
**Contoh: Nilai tanggal**
Contoh aturan berikut memeriksa nilai-nilai dalam kolom tanggal terhadap ekspresi tanggal.
```
ColumnValues "Load_Date" > (now() - 3 days)
```
**Contoh: Nilai numerik**
Contoh aturan berikut memeriksa apakah nilai kolom cocok dengan kendala numerik tertentu.
```
ColumnValues "Customer_ID" between 1 and 2000
```
**Perilaku nol**
Untuk semua `ColumnValues` aturan (selain `!=` dan`NOT IN`), `NULL` baris akan gagal aturan. Jika aturan gagal karena nilai nol, alasan kegagalan akan menampilkan yang berikut:
```
Value: NULL does not meet the constraint requirement!
```
Contoh aturan majemuk berikut menyediakan cara untuk secara eksplisit mengizinkan nilai: `NULL`
```
(ColumnValues "Age" > 21) OR (ColumnValues "Age" = NULL)
```
ColumnValues Aturan yang dinegasikan menggunakan `not in` sintaks `!=` dan akan diteruskan untuk `NULL` baris. Contoh:
```
ColumnValues "Age" != 21
```
```
ColumnValues "Age" not in [21, 22, 23]
```
Contoh berikut memberikan cara untuk secara eksplisit gagal nilai `NULL`
```
(ColumnValues "Age" != 21) AND (ColumnValues "Age" != NULL)
```
```
ColumnValues "Age" not in [21, 22, 23, NULL]
```
# Kelengkapan
Memeriksa persentase nilai lengkap (non-null) dalam kolom terhadap ekspresi yang diberikan.
**Sintaksis**
```
Completeness
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Persentase nilai nol**
Contoh aturan berikut memeriksa apakah lebih dari 95 persen nilai dalam kolom selesai.
```
Completeness "First_Name" > 0.95
Completeness "First_Name" > 0.95 where "weightinkgs > 10"
```
**Contoh aturan dinamis**
+ `Completeness "colA" between min(last(5)) - 1 and max(last(5)) + 1`
+ `Completeness "colA" <= avg(last(10))`
**Perilaku nol**
Catatan tentang Format Data CSV: Baris kosong pada kolom CSV dapat menampilkan beberapa perilaku.
+ Jika kolom `String` bertipe, baris kosong akan dikenali sebagai string kosong dan tidak akan gagal `Completeness` aturannya.
+ Jika kolom adalah tipe data lain seperti`Int`, baris kosong akan dikenali sebagai `NULL` dan akan gagal `Completeness` aturan.
# CustomSQL
Jenis aturan ini telah diperluas untuk mendukung dua kasus penggunaan:
+ Jalankan pernyataan SQL kustom terhadap dataset dan periksa nilai kembali terhadap ekspresi yang diberikan.
+ Jalankan pernyataan SQL kustom di mana Anda menentukan nama kolom dalam pernyataan SELECT Anda yang Anda bandingkan dengan beberapa kondisi untuk mendapatkan hasil tingkat baris.
**Sintaksis**
```
CustomSql
```
+ **SQL\$1STATEMENT — Pernyataan** SQL yang mengembalikan nilai numerik tunggal, dikelilingi oleh tanda kutip ganda.
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Kustom SQL untuk mengambil hasil aturan keseluruhan**
Aturan contoh ini menggunakan pernyataan SQL untuk mengambil jumlah catatan untuk kumpulan data. Aturan kemudian memeriksa bahwa jumlah rekor adalah antara 10 dan 20.
```
CustomSql "select count(*) from primary" between 10 and 20
```
**Contoh: SQL khusus untuk mengambil hasil tingkat baris**
Aturan contoh ini menggunakan pernyataan SQL di mana Anda menentukan nama kolom dalam pernyataan SELECT Anda yang Anda bandingkan dengan beberapa kondisi untuk mendapatkan hasil tingkat baris. Ekspresi kondisi ambang batas mendefinisikan ambang batas berapa banyak catatan yang harus gagal agar seluruh aturan gagal. Perhatikan bahwa aturan mungkin tidak mengandung kondisi dan kata kunci bersama-sama.
```
CustomSql "select Name from primary where Age > 18"
```
atau
```
CustomSql "select Name from primary where Age > 18" with threshold > 3
```
**penting**
`primary`Alias singkatan dari nama kumpulan data yang ingin Anda evaluasi. Saat Anda bekerja dengan pekerjaan ETL visual di konsol, `primary` selalu mewakili `DynamicFrame` diteruskan ke `EvaluateDataQuality.apply()` transformasi. Bila Anda menggunakan AWS Glue Data Catalog untuk menjalankan tugas kualitas data terhadap tabel, `primary` mewakili tabel.
Jika Anda berada di Katalog AWS Glue Data, Anda juga dapat menggunakan nama tabel yang sebenarnya:
```
CustomSql "select count(*) from database.table" between 10 and 20
```
Anda juga dapat bergabung dengan beberapa tabel untuk membandingkan elemen data yang berbeda:
```
CustomSql "select count(*) from database.table inner join database.table2 on id1 = id2" between 10 and 20
```
Di AWS Glue ETL, CustomSQL dapat mengidentifikasi catatan yang gagal dalam pemeriksaan kualitas data. Agar ini berfungsi, Anda perlu mengembalikan catatan yang merupakan bagian dari tabel utama tempat Anda mengevaluasi kualitas data. Catatan yang dikembalikan sebagai bagian dari kueri dianggap berhasil dan catatan yang tidak dikembalikan dianggap gagal. Ini berfungsi dengan menggabungkan hasil kueri CustomSQL Anda dengan kumpulan data asli. Mungkin ada implikasi kinerja berdasarkan kompleksitas kueri SQL Anda.
Untuk melakukannya:
+ Anda harus memilih setidaknya 1 kolom dari tabel utama Anda.
+ `select count(*) from primary`adalah kueri yang valid untuk aturan DQ CUSTOMSQL KESELURUHAN tetapi tidak untuk SQL Kustom Tingkat Baris.
+ Aturan ini akan menimbulkan kesalahan selama evaluasi: `The output from CustomSQL must contain at least one column that matches the input dataset for AWS Glue Data Quality to provide row level results. The SQL query is a valid query but the columns from the SQL result are not present in the Input Dataset. Ensure that matching columns are returned from the SQL.`
+ Dalam kueri SQL Anda, pilih `Kunci Utama` dari tabel Anda atau pilih satu set kolom yang membentuk kunci komposit. Tidak melakukannya dapat mengakibatkan hasil yang tidak konsisten karena pencocokan baris duplikat dan kinerja yang menurun.
+ Pilih kunci HANYA dari tabel utama Anda dan bukan dari tabel referensi Anda.
Aturan berikut akan memastikan bahwa catatan dengan usia < 100 diidentifikasi sebagai berhasil dan catatan yang di atas ditandai sebagai gagal.
```
CustomSql "select id from primary where age < 100"
```
Aturan CustomSQL ini akan berlalu ketika 50% dari catatan memiliki usia> 10 dan juga akan mengidentifikasi catatan yang gagal. Catatan yang dikembalikan oleh CustomSQL ini akan dianggap lulus sementara yang tidak dikembalikan akan dianggap gagal.
```
CustomSQL "select ID, CustomerID from primary where age > 10" with threshold > 0.5
```
Catatan: Aturan CustomSQL akan gagal jika Anda mengembalikan catatan yang tidak tersedia di kumpulan data.
# DataFreshness
Memeriksa kesegaran data dalam kolom dengan mengevaluasi perbedaan antara waktu saat ini dan nilai kolom tanggal. Anda dapat menentukan ekspresi berbasis waktu untuk jenis aturan ini untuk memastikan bahwa nilai kolom up to date.
**Sintaksis**
```
DataFreshness
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Tanggal
+ **EKSPRESI — Ekspresi** numerik dalam jam atau hari. Anda harus menentukan satuan waktu dalam ekspresi Anda.
**Contoh: Kesegaran data**
Contoh aturan berikut memeriksa kesegaran data.
```
DataFreshness "Order_Date" <= 24 hours
DataFreshness "Order_Date" between 2 days and 5 days
```
**Perilaku nol**
`DataFreshness`Aturan akan gagal untuk baris dengan `NULL` nilai. Jika aturan gagal karena nilai nol, alasan kegagalan akan menampilkan yang berikut:
```
80.00 % of rows passed the threshold
```
di mana 20% dari baris yang gagal termasuk baris dengan`NULL`.
Contoh aturan majemuk berikut menyediakan cara untuk secara eksplisit mengizinkan nilai: `NULL`
```
(DataFreshness "Order_Date" <= 24 hours) OR (ColumnValues "Order_Date" = NULL)
```
**Kesegaran Data untuk objek Amazon S3**
Terkadang Anda perlu memvalidasi kesegaran data berdasarkan waktu pembuatan file Amazon S3. Untuk melakukan ini, Anda dapat menggunakan kode berikut untuk mendapatkan stempel waktu dan menambahkannya ke kerangka data Anda, dan kemudian menerapkan pemeriksaan Kesegaran Data.
```
df = glueContext.create_data_frame.from_catalog(database = "default", table_name = "mytable")
df = df.withColumn("file_ts", df["_metadata.file_modification_time"])
Rules = [
DataFreshness "file_ts" < 24 hours
]
```
# DatasetMatch
Memeriksa apakah data dalam kumpulan data utama cocok dengan data dalam kumpulan data referensi. Kedua kumpulan data digabungkan menggunakan pemetaan kolom kunci yang disediakan. Pemetaan kolom tambahan dapat disediakan jika Anda ingin memeriksa kesetaraan data hanya di kolom tersebut. Perhatikan bahwa **DataSetMatch**agar berfungsi, kunci gabungan Anda harus unik dan tidak boleh NULL (harus menjadi kunci utama). Jika Anda tidak memenuhi kondisi ini, Anda akan mendapatkan pesan kesalahan, “Peta kunci yang disediakan tidak cocok untuk bingkai data yang diberikan”. Dalam kasus di mana Anda tidak dapat memiliki kunci gabungan yang unik, pertimbangkan untuk menggunakan tipe aturan lain seperti **AggregateMatch**untuk mencocokkan data ringkasan.
**Sintaksis**
```
DatasetMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS — Alias** dari dataset referensi yang Anda gunakan untuk membandingkan data dari kumpulan data utama.
+ **KEY\$1COLUMN\$1MAPPINGS** - Daftar nama kolom yang dipisahkan koma yang membentuk kunci dalam kumpulan data. Jika nama kolom tidak sama di kedua kumpulan data, Anda harus memisahkannya dengan `->`
+ **OPTIONAL\$1MATCH\$1COLUMN\$1MAPPINGS** - Anda dapat menyediakan parameter ini jika Anda ingin memeriksa data yang cocok hanya di kolom tertentu. Ini menggunakan sintaks yang sama dengan pemetaan kolom kunci. Jika parameter ini tidak disediakan, kami akan mencocokkan data di semua kolom yang tersisa. Kolom non-kunci yang tersisa harus memiliki nama yang sama di kedua kumpulan data.
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Cocokkan set dataset menggunakan kolom ID**
Aturan contoh berikut memeriksa bahwa lebih dari 90% kumpulan data utama cocok dengan kumpulan data referensi, menggunakan kolom “ID” untuk menggabungkan dua kumpulan data. Ini membandingkan semua kolom dalam kasus ini.
```
DatasetMatch "reference" "ID" >= 0.9
```
**Contoh: Cocokkan set dataset menggunakan beberapa kolom kunci**
Dalam contoh berikut, dataset primer dan dataset referensi memiliki nama yang berbeda untuk kolom kunci. `ID_1`dan `ID_2` bersama-sama membentuk kunci komposit dalam dataset primer. `ID_ref1`dan `ID_ref2` bersama-sama membentuk kunci komposit dalam dataset referensi. Dalam skenario ini, Anda dapat menggunakan sintaks khusus untuk menyediakan nama kolom.
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" >= 0.9
```
**Contoh: Cocokkan kumpulan data set menggunakan beberapa kolom kunci dan periksa apakah kolom tertentu cocok**
Contoh ini dibangun di atas contoh sebelumnya. Kami ingin memeriksa bahwa hanya kolom yang berisi jumlah yang cocok. Kolom ini dinamai `Amount1` dalam kumpulan data utama dan `Amount2` dalam kumpulan data referensi. Anda menginginkan kecocokan yang tepat.
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" "Amount1->Amount2" >= 0.9
```
# DistinctValuesCount
Memeriksa jumlah nilai yang berbeda dalam kolom terhadap ekspresi yang diberikan.
**Sintaksis**
```
DistinctValuesCount
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Jumlah nilai kolom yang berbeda**
Contoh aturan berikut memeriksa bahwa kolom bernama `State` berisi lebih dari 3 nilai yang berbeda.
```
DistinctValuesCount "State" > 3
DistinctValuesCount "Customer_ID" < 6 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
+ `DistinctValuesCount "colA" between avg(last(10))-1 and avg(last(10))+1`
+ `DistinctValuesCount "colA" <= index(last(10),2) + std(last(5))`
# Entropi
Memeriksa apakah nilai *entropi* kolom cocok dengan ekspresi yang diberikan. Entropi mengukur tingkat informasi yang terkandung dalam pesan. Mengingat distribusi probabilitas atas nilai dalam kolom, entropi menjelaskan berapa banyak bit yang diperlukan untuk mengidentifikasi nilai.
**Sintaksis**
```
Entropy
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Entropi kolom**
Contoh aturan berikut memeriksa bahwa kolom bernama `Feedback` memiliki nilai entropi lebih besar dari satu.
```
Entropy "Star_Rating" > 1
Entropy "First_Name" > 1 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
+ `Entropy "colA" < max(last(10))`
+ `Entropy "colA" between min(last(10)) and max(last(10))`
# IsComplete
Memeriksa apakah semua nilai dalam kolom selesai (non-null).
**Sintaksis**
```
IsComplete
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
**Contoh: Nilai nol**
Contoh berikut memeriksa apakah semua nilai dalam kolom bernama `email` non-null.
```
IsComplete "email"
IsComplete "Email" where "Customer_ID between 1 and 50"
IsComplete "Customer_ID" where "Customer_ID < 16 and Customer_ID != 12"
IsComplete "passenger_count" where "payment_type<>0"
```
**Perilaku nol**
Catatan tentang Format Data CSV: Baris kosong pada kolom CSV dapat menampilkan beberapa perilaku.
+ Jika kolom `String` bertipe, baris kosong akan dikenali sebagai string kosong dan tidak akan gagal `Completeness` aturannya.
+ Jika kolom adalah tipe data lain seperti`Int`, baris kosong akan dikenali sebagai `NULL` dan akan gagal `Completeness` aturan.
# IsPrimaryKey
Memeriksa apakah kolom berisi kunci utama. Kolom berisi kunci primer jika semua nilai dalam kolom unik dan lengkap (non-null). Anda juga dapat memeriksa kunci utama dengan beberapa kolom.
**Sintaksis**
```
IsPrimaryKey
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
**Contoh: Kunci utama**
Contoh aturan berikut memeriksa apakah kolom bernama `Customer_ID` berisi kunci utama.
```
IsPrimaryKey "Customer_ID"
IsPrimaryKey "Customer_ID" where "Customer_ID < 10"
```
**Contoh: Kunci primer dengan beberapa kolom. Salah satu contoh berikut ini valid.**
```
IsPrimaryKey "colA" "colB"
IsPrimaryKey "colA" "colB" "colC"
IsPrimaryKey colA "colB" "colC"
```
# IsUnique
Memeriksa apakah semua nilai dalam kolom unik, dan mengembalikan nilai Boolean.
**Sintaksis**
```
IsUnique
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
**Contoh**
Contoh aturan berikut memeriksa apakah semua nilai dalam kolom bernama `email` unik.
```
IsUnique "email"
IsUnique "Customer_ID" where "Customer_ID < 10"]
```
Contoh aturan berikut memeriksa beberapa kolom.
```
IsUnique "vendorid" "tpep_pickup_datetime"
```
# Berarti
Memeriksa apakah mean (rata-rata) dari semua nilai dalam kolom cocok dengan ekspresi yang diberikan.
**Sintaksis**
```
Mean
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Nilai rata-rata**
Contoh aturan berikut memeriksa apakah rata-rata semua nilai dalam kolom melebihi ambang batas.
```
Mean "Star_Rating" > 3
Mean "Salary" < 6200 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
+ `Mean "colA" > avg(last(10)) + std(last(2))`
+ `Mean "colA" between min(last(5)) - 1 and max(last(5)) + 1`
**Perilaku nol**
`Mean`Aturan akan mengabaikan baris dengan `NULL` nilai dalam perhitungan mean. Contoh:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
Rata-rata kolom `units` adalah (0 \$1 20 \$1 40)/3 = 20. Baris 101 dan 103 tidak dipertimbangkan dalam perhitungan ini.
# ReferentialIntegrity
Memeriksa sejauh mana nilai dari satu set kolom dalam dataset primer adalah bagian dari nilai-nilai dari satu set kolom dalam dataset referensi.
**Sintaksis**
```
ReferentialIntegrity
```
+ **PRIMARY\$1COLS** — Daftar nama kolom yang dipisahkan koma dalam kumpulan data utama.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **REFERENCE\$1DATASET\$1COLS** — Parameter ini berisi dua bagian yang dipisahkan oleh titik. Bagian pertama adalah alias dari dataset referensi. Bagian kedua adalah daftar nama kolom yang dipisahkan koma dalam kumpulan data referensi yang terlampir dalam tanda kurung gigi.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Periksa integritas referensial kolom kode pos**
Contoh aturan berikut memeriksa bahwa lebih dari 90% dari nilai-nilai dalam `zipcode` kolom dalam dataset utama, hadir di `zipcode` kolom dalam `reference` dataset.
```
ReferentialIntegrity "zipcode" "reference.zipcode" >= 0.9
```
**Contoh: Periksa integritas referensial kolom kota dan negara bagian**
Dalam contoh berikut, kolom yang berisi informasi kota dan negara bagian ada di kumpulan data utama dan kumpulan data referensi. Nama-nama kolom berbeda di kedua kumpulan data. Aturan memeriksa apakah himpunan nilai kolom dalam dataset primer persis sama dengan himpunan nilai kolom dalam dataset referensi.
```
ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" = 1.0
```
**Contoh aturan dinamis**
+ `ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" > avg(last(10))`
+ `ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" between min(last(10)) - 1 and max(last(10)) + 1`
# RowCount
Memeriksa jumlah baris dataset terhadap ekspresi yang diberikan. Dalam ekspresi, Anda dapat menentukan jumlah baris atau rentang baris menggunakan operator seperti `>` dan`<`.
**Sintaksis**
```
RowCount
```
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Cek numerik hitungan baris**
Contoh aturan berikut memeriksa apakah jumlah baris berada dalam rentang tertentu.
```
RowCount between 10 and 100
RowCount between 1 and 50 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
```
RowCount > avg(last(10)) *0.8
```
# RowCountMatch
Memeriksa rasio jumlah baris dari kumpulan data utama dan jumlah baris dari kumpulan data referensi terhadap ekspresi yang diberikan.
**Sintaksis**
```
RowCountMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS — Alias** dari dataset referensi yang digunakan untuk membandingkan jumlah baris.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Pemeriksaan jumlah baris terhadap kumpulan data referensi**
Contoh aturan berikut memeriksa apakah jumlah baris dari dataset primer setidaknya 90% dari jumlah baris dari dataset referensi.
```
RowCountMatch "reference" >= 0.9
```
# StandardDeviation
Memeriksa standar deviasi dari semua nilai dalam kolom terhadap ekspresi yang diberikan.
**Sintaksis**
```
StandardDeviation
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Standar deviasi**
Contoh aturan berikut memeriksa apakah standar deviasi nilai dalam kolom bernama `colA` kurang dari nilai yang ditentukan.
```
StandardDeviation "Star_Rating" < 1.5
StandardDeviation "Salary" < 3500 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
+ `StandardDeviation "colA" > avg(last(10) + 0.1`
+ `StandardDeviation "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**Perilaku nol**
`StandardDeviation`Aturan akan mengabaikan baris dengan `NULL` nilai dalam perhitungan standar deviasi. Contoh:
```
+---+-----------+-----------+
|id |units1 |units2 |
+---+-----------+-----------+
|100|0 |0 |
|101|null |0 |
|102|20 |20 |
|103|null |0 |
|104|40 |40 |
+---+-----------+-----------+
```
Standar deviasi kolom tidak `units1` akan mempertimbangkan baris 101 dan 103 dan hasilnya menjadi 16,33. Standar deviasi untuk kolom `units2` akan menghasilkan 16.
# Jumlah
Memeriksa jumlah semua nilai dalam kolom terhadap ekspresi yang diberikan.
**Sintaksis**
```
Sum
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Jumlah**
Contoh aturan berikut memeriksa apakah jumlah semua nilai dalam kolom melebihi ambang batas yang diberikan.
```
Sum "transaction_total" > 500000
Sum "Salary" < 55600 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
+ `Sum "ColA" > avg(last(10))`
+ `Sum "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**Perilaku nol**
`Sum`Aturan akan mengabaikan baris dengan `NULL` nilai dalam perhitungan jumlah. Contoh:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
Jumlah kolom tidak `units` akan mempertimbangkan baris 101 dan 103 dan hasilnya menjadi (0 \$1 20 \$1 40) = 60.
# SchemaMatch
Memeriksa apakah skema kumpulan data utama cocok dengan skema kumpulan data referensi. Pemeriksaan skema dilakukan kolom demi kolom. Skema dua kolom cocok jika nama identik dan jenisnya identik. Urutan kolom tidak masalah.
**Sintaksis**
```
SchemaMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS — Alias** dari dataset referensi yang digunakan untuk membandingkan skema.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: SchemaMatch**
Contoh aturan berikut memeriksa apakah skema dataset primer sama persis dengan skema dataset referensi.
```
SchemaMatch "reference" = 1.0
```
# Keunikan
Memeriksa persentase nilai unik dalam kolom terhadap ekspresi yang diberikan. Nilai unik terjadi tepat sekali.
**Sintaksis**
```
Uniqueness
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh**
Contoh aturan berikut memeriksa apakah persentase nilai unik dalam kolom cocok dengan kriteria numerik tertentu.
```
Uniqueness "email" = 1.0
Uniqueness "Customer_ID" != 1.0 where "Customer_ID < 10"
```
Contoh aturan berikut memeriksa beberapa kolom.
```
Uniqueness "vendorid" "tpep_pickup_datetime" = 1
```
**Contoh aturan dinamis**
+ `Uniqueness "colA" between min(last(10)) and max(last(10))`
+ `Uniqueness "colA" >= avg(last(10))`
# UniqueValueRatio
Memeriksa *rasio nilai unik* kolom terhadap ekspresi yang diberikan. Rasio nilai unik adalah pecahan dari nilai unik dibagi dengan jumlah semua nilai yang berbeda dalam kolom. Nilai unik terjadi tepat satu kali, sedangkan nilai yang berbeda terjadi *setidaknya* sekali.
Misalnya, himpunan `[a, a, b]` berisi satu nilai unik (`b`) dan dua nilai berbeda (`a`dan`b`). Jadi rasio nilai unik dari himpunan adalah ½ = 0,5.
**Sintaksis**
```
UniqueValueRatio
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Rasio nilai unik**
Contoh ini memeriksa rasio nilai unik kolom terhadap rentang nilai.
```
UniqueValueRatio "test_score" between 0 and 0.5
UniqueValueRatio "Customer_ID" between 0 and 0.9 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
+ `UniqueValueRatio "colA" > avg(last(10))`
+ `UniqueValueRatio "colA" <= index(last(10),2) + std(last(5))`
# DetectAnomalies
Mendeteksi anomali untuk aturan kualitas data tertentu. Setiap eksekusi DetectAnomalies aturan menghasilkan penghematan nilai yang dievaluasi untuk aturan yang diberikan. Ketika ada cukup data yang dikumpulkan, algoritma deteksi anomali mengambil semua data historis untuk aturan yang diberikan dan menjalankan deteksi anomali. DetectAnomalies aturan gagal ketika anomali terdeteksi. Info lebih lanjut tentang anomali apa yang terdeteksi dapat diperoleh dari Observasi.
**Sintaksis**
```
DetectAnomalies
```
`RULE_NAME`— Nama aturan yang ingin Anda evaluasi dan deteksi anomali. Aturan yang didukung:
+ "RowCount"
+ “Kelengkapan”
+ “Keunikan”
+ “Berarti”
+ “Jumlah”
+ "StandardDeviation"
+ “Entropi”
+ "DistinctValuesCount"
+ "UniqueValueRatio"
+ "ColumnLength"
+ "ColumnValues"
+ "ColumnCorrelation"
+ “CustomSQL”
+ "ColumnCount"
`RULE_PARAMETERS`— beberapa aturan memerlukan parameter tambahan untuk dijalankan. Lihat dokumentasi aturan yang diberikan untuk melihat parameter yang diperlukan.
**Contoh: Anomali untuk RowCount**
Misalnya, jika kami ingin mendeteksi RowCount anomali, kami berikan RowCount sebagai nama aturan.
```
DetectAnomalies "RowCount"
```
**Contoh: Anomali untuk ColumnLength**
Misalnya, jika kita ingin mendeteksi ColumnLength anomali, kita berikan ColumnLength sebagai nama aturan dan nama kolom.
```
DetectAnomalies "ColumnLength" "id"
```
# FileFreshness
FileFreshness memastikan file data Anda segar berdasarkan kondisi yang Anda berikan. Ini menggunakan waktu modifikasi terakhir file Anda untuk memastikan bahwa file data atau seluruh folder. up-to-date
Aturan ini mengumpulkan dua metrik:
+ FileFreshness kepatuhan berdasarkan aturan yang Anda atur
+ Jumlah file yang dipindai oleh aturan
```
{"Dataset.*.FileFreshness.Compliance":1,"Dataset.*.FileCount":1}
```
Deteksi anomali tidak mempertimbangkan metrik ini.
**Memeriksa kesegaran file**
Aturan berikut memastikan bahwa tiket.parket dibuat dalam 24 jam terakhir.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/tickets.parquet" > (now() - 24 hours)
```
**Memeriksa kesegaran folder**
Aturan berikut berlalu jika semua file dalam folder dibuat atau dimodifikasi dalam 24 jam terakhir.
```
FileFreshness "s3://bucket/" >= (now() -1 days)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" >= (now() - 24 hours)
```
**Memeriksa kesegaran folder atau file dengan ambang batas**
Aturan berikut berlalu jika 10% dari file dalam folder “tiket “dibuat atau dimodifikasi dalam 10 hari terakhir.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" < (now() - 10 days) with threshold > 0.1
```
**Memeriksa file atau folder dengan tanggal tertentu**
Anda dapat memeriksa kesegaran file untuk hari-hari tertentu.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "2020-01-01"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "2023-01-01" and "2024-01-01"
```
**Memeriksa file atau folder dengan waktu**
Anda dapat menggunakan FileFreshness untuk memastikan bahwa file telah tiba berdasarkan waktu-waktu tertentu.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between now() and (now() - 45 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "9:30 AM" and "9:30 PM"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > (now() - 10 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > now()
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between (now() - 2 hours) and (now() + 15 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between (now() - 3 days) and (now() + 15 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "2001-02-07" and (now() + 15 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45""
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "2024-01-01"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "02:30" and "04:30"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "9:30 AM" and "22:15"
```
Pertimbangan utama:
+ FileFreshness dapat mengevaluasi file menggunakan unit hari, jam, dan menit
+ Untuk waktu, ini mendukung AM/PM dan 24 jam
+ Waktu dihitung dalam UTC kecuali penggantian ditentukan
+ Tanggal dihitung dalam UTC pada waktu 00:00
FileFreshness yang merupakan karya berbasis waktu sebagai berikut:
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45"
```
+ Pertama, waktu “21:45" digabungkan dengan tanggal hari ini dalam format UTC untuk membuat bidang tanggal-waktu
+ Selanjutnya, tanggal-waktu dikonversi ke zona waktu yang telah Anda tentukan
+ Akhirnya, aturan dievaluasi
**Tag Aturan Berbasis File Opsional:**
Tag memungkinkan Anda mengontrol perilaku aturan.
**RecentFiles**
Tag ini membatasi jumlah file yang diproses dengan menyimpan file terbaru terlebih dahulu.
```
FileFreshness "s3://amzn-s3-demo-bucket/" between (now() - 100 minutes) and (now() + 10 minutes) with recentFiles = 1
```
**UriRegex**
**catatan**
`uriRegex`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Tag ini memfilter file dengan menerapkan pola regex ke jalur file. Hanya file yang jalurnya cocok dengan pola yang diproses. Anda juga dapat menggunakan lookahead negatif untuk mengecualikan file yang cocok dengan pola.
```
# Match only files with a .csv extension
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = "\.csv$"
# Match Parquet files that contain "orders_" in the path
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = ".*orders_.*\.parquet"
# Exclude files ending in .tmp using a negative lookahead
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = "(?!.*\.tmp$).*"
```
**FilterOrder**
**catatan**
`filterOrder`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Bila Anda menggunakan beberapa tag filter seperti `recentFiles` dan `uriRegex` bersama-sama, `filterOrder` tag mengontrol urutan penerapannya. Urutan default adalah yang `recentFiles` pertama, lalu`uriRegex`.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with recentFiles = 1 with uriRegex = "inventory_" with filterOrder = ["uriRegex","recentFiles"]
```
Dalam contoh di atas, `uriRegex` filter diterapkan terlebih dahulu untuk memilih hanya file yang cocok dengan “inventaris\$1”, dan kemudian `recentFiles = 1` mengambil file terbaru dari set yang difilter itu. Tanpa`filterOrder`, perilaku default akan mengambil satu file terbaru terlebih dahulu dan kemudian menerapkan regex, yang dapat mengakibatkan tidak ada file yang cocok jika file terbaru tidak cocok dengan polanya.
**catatan**
Semua nilai dalam `filterOrder` daftar harus mereferensikan tag filter lain (`recentFiles`atau`uriRegex`) yang juga ada pada aturan yang sama. Tag non-filter seperti `timeZone` atau `failFast` tidak valid di`filterOrder`.
**FailFast**
Saat disetel ke`"true"`, aturan segera mengembalikan kegagalan pada file pertama yang gagal dalam kondisi kesegaran, alih-alih mengevaluasi semua file dan menghitung rasio kepatuhan.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with failFast = "true"
```
**Zona Waktu**
Penggantian zona waktu yang diterima, lihat Zona Waktu yang [Diizinkan untuk zona waktu](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html) yang didukung.
```
FileFreshness "s3://path/" > "21:45" with timeZone = "America/New_York"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "America/Chicago"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "Europe/Paris"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "Asia/Shanghai"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "Australia/Darwin"
```
**Menyimpulkan nama file langsung dari bingkai data**
Anda tidak selalu harus menyediakan jalur file. Misalnya, ketika Anda menulis aturan di Katalog Data AWS Glue, mungkin sulit untuk menemukan folder mana yang digunakan tabel katalog. AWS Glue Data Quality dapat menemukan folder atau file tertentu yang digunakan untuk mengisi kerangka data Anda dan dapat mendeteksi apakah masih segar.
**catatan**
Fitur ini hanya akan berfungsi ketika file berhasil dibaca ke dalam DynamicFrame atau DataFrame.
```
FileFreshness > (now() - 24 hours)
```
Aturan ini akan menemukan jalur folder atau file yang digunakan untuk mengisi frame dinamis atau bingkai data. Ini berfungsi untuk jalur Amazon S3 atau tabel Katalog Data AWS Glue berbasis Amazon S3. Ada beberapa pertimbangan:
1. Di AWS Glue ETL, Anda harus memiliki **EvaluateDataQuality**Transform segera setelah transformasi Amazon S3 atau AWS Glue Data Catalog.
![\[Tangkapan layar menunjukkan node Evaluasi Kualitas Data yang terhubung ke node Amazon S3.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/data-quality-file-freshness.png)
1. Aturan ini tidak akan berfungsi di AWS Glue Interactive Sessions.
Jika Anda mencoba ini di kedua kasus, atau ketika AWS Glue tidak dapat menemukan file, AWS Glue akan memunculkan kesalahan berikut: `“Unable to parse file path from DataFrame”`
# FileMatch
FileMatch Aturan ini memungkinkan Anda membandingkan file dengan file atau checksum lain. Ini dapat berguna dalam beberapa skenario:
1. Memvalidasi file yang diterima dari sumber eksternal: Anda dapat menggunakan FileMatch untuk memastikan bahwa Anda telah menerima file yang benar dari sumber eksternal dengan membandingkan dengan checksum. Ini membantu memvalidasi integritas data yang Anda konsumsi.
1. Membandingkan data dalam dua folder yang berbeda: FileMatch dapat digunakan untuk membandingkan file antara dua folder.
Aturan ini mengumpulkan satu metrik: jumlah file yang dipindai oleh aturan.
```
{"Dataset.*.FileCount":1}
```
**Validasi file dengan checksum:**
FileMatch menerima file dan set checksum untuk memastikan bahwa setidaknya satu checksum cocok dengan file.
```
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1"
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256"
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"]
```
Algoritma standar berikut didukung:
+ MD5
+ SHA-1
+ SHA-256
Jika Anda tidak menyediakan algoritma, defaultnya adalah SHA-256.
**Validasi semua file dalam folder dengan set checksum:**
```
FileMatch "s3://amzn-s3-demo-bucket /" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch "s3://amzn-s3-demo-bucket /internal-folder/" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"]
```
**Bandingkan file di folder yang berbeda**
```
# Compare all files across two buckets
FileMatch "s3://original_bucket/" "s3://archive_bucket/"
# Compare files within specific subfolders
FileMatch "s3://original_bucket/internal-folder/" "s3://original_bucket/other-folder/"
# Compare only .json files across two folders
FileMatch "s3://original_bucket/" "s3://archive_bucket/" with uriRegex = "\.json$"
# Compare only the 5 most recent .csv files
FileMatch "s3://original_bucket/" "s3://archive_bucket/" with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
FileMatch akan memeriksa isi file `original_bucket` dan memastikan mereka cocok dengan apa yang ada di dalamnya`archive_bucket`. Aturan akan gagal jika mereka tidak benar-benar cocok. Itu juga dapat memeriksa isi folder internal atau file individual.
FileMatch juga dapat memeriksa file individual terhadap satu sama lain.
```
FileMatch "s3://amzn-s3-demo-bucket /file_old.json" "s3://amzn-s3-demo-bucket /file_new.json"
```
**Menyimpulkan nama file langsung dari bingkai data**
Anda tidak selalu harus menyediakan jalur file. Misalnya, saat Anda membuat aturan di Katalog Data AWS Glue (didukung oleh Amazon S3), mungkin sulit untuk menemukan folder mana yang digunakan tabel katalog. AWS Glue Data Quality dapat menemukan folder atau file tertentu yang digunakan untuk mengisi bingkai data Anda.
**catatan**
Fitur ini hanya akan berfungsi ketika file berhasil dibaca ke dalam DynamicFrame atau DataFrame.
```
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"]
```
Jika checksum yang disediakan berbeda dari yang dihitung, FileMatch akan mengingatkan Anda akan perbedaannya.
![\[Tangkapan layar menunjukkan aturan dengan status DQ dari Aturan gagal. FileMatch menjelaskan kegagalan.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/data-quality-file-match.png)
**Tag Aturan Berbasis File Opsional:**
Tag memungkinkan Anda untuk mengontrol perilaku aturan.
**RecentFiles**
Tag ini membatasi jumlah file yang diproses dengan menyimpan file terbaru terlebih dahulu.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1
```
**UriRegex**
**catatan**
`uriRegex`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Tag ini memfilter file dengan menerapkan pola regex ke jalur file. Hanya file yang jalurnya cocok dengan pola yang diproses. Anda juga dapat menggunakan lookahead negatif untuk mengecualikan file yang cocok dengan pola.
```
# Match only files with a .json extension
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with uriRegex = "\.json$"
# Exclude files ending in .tmp using a negative lookahead
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with uriRegex = "(?!.*\.tmp$).*"
```
**FilterOrder**
**catatan**
`filterOrder`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Bila Anda menggunakan beberapa tag filter seperti `recentFiles` dan `uriRegex` bersama-sama, `filterOrder` tag mengontrol urutan penerapannya. Urutan default adalah yang `recentFiles` pertama, lalu`uriRegex`.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1 with uriRegex = "\.json$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Tag ini memastikan bahwa file tidak memiliki nama duplikat. Perilaku default adalah false.
```
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac04179sam4713e5ef8f319"] with matchFileName = "true"
```
Ada beberapa pertimbangan:
1. Di AWS Glue ETL, Anda harus memiliki **EvaluateDataQuality**Transform segera setelah transformasi Amazon S3 atau AWS Glue Data Catalog.
![\[Tangkapan layar menunjukkan aturan dengan status DQ dari Aturan gagal. FileMatch menjelaskan kegagalan.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/data-quality-file-match-transform.png)
1. Aturan ini tidak akan berfungsi di AWS Glue Interactive Sessions.
# FileUniqueness
Keunikan File memungkinkan Anda untuk memastikan bahwa tidak ada file duplikat dalam data yang Anda terima dari produsen data Anda.
Ini mengumpulkan statistik data berikut:
1. Jumlah file yang dipindai oleh aturan
1. Rasio Keunikan file
```
Dataset.*.FileUniquenessRatio: 1.00, Dataset.*.FileCount: 8.00
```
**Temukan file duplikat dalam folder:**
```
FileUniqueness "s3://bucket/" > 0.5
FileUniqueness "s3://bucket/folder/" = 1
```
**Menyimpulkan nama folder langsung dari bingkai data untuk mendeteksi duplikat:**
Anda tidak selalu harus menyediakan jalur file. Misalnya, ketika Anda menulis aturan di Katalog Data AWS Glue, mungkin sulit untuk menemukan folder mana yang digunakan tabel katalog. AWS Glue Data Quality dapat menemukan folder atau file tertentu yang digunakan untuk mengisi bingkai data Anda.
**catatan**
Saat menggunakan inferensi, aturan berbasis file hanya dapat mendeteksi file yang berhasil dibaca ke dalam atau. DynamicFrame DataFrame
```
FileUniqueness > 0.5
```
**Tag Aturan Berbasis File Opsional:**
Tag memungkinkan Anda untuk mengontrol perilaku aturan.
**RecentFiles**
Tag ini membatasi jumlah file yang diproses dengan menyimpan file terbaru terlebih dahulu.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with recentFiles = 1
```
**UriRegex**
**catatan**
`uriRegex`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Tag ini memfilter file dengan menerapkan pola regex ke jalur file. Hanya file yang jalurnya cocok dengan pola yang diproses. Anda juga dapat menggunakan lookahead negatif untuk mengecualikan file yang cocok dengan pola.
```
# Match only files with a .csv extension
FileUniqueness "s3://bucket/" > 0.5 with uriRegex = "\.csv$"
# Exclude files ending in .tmp using a negative lookahead
FileUniqueness "s3://bucket/" > 0.5 with uriRegex = "(?!.*\.tmp$).*"
```
**FilterOrder**
**catatan**
`filterOrder`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Bila Anda menggunakan beberapa tag filter seperti `recentFiles` dan `uriRegex` bersama-sama, `filterOrder` tag mengontrol urutan penerapannya. Urutan default adalah yang `recentFiles` pertama, lalu`uriRegex`.
```
FileUniqueness "s3://bucket/" > 0.5 with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Tag ini memastikan bahwa file tidak memiliki nama duplikat. Perilaku default adalah false.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with matchFileName = "true"
```
Ada beberapa pertimbangan:
1. Di AWS Glue ETL, Anda harus memiliki **EvaluateDataQuality**Transform segera setelah transformasi Amazon S3 atau AWS Glue Data Catalog.
1. Aturan ini tidak akan berfungsi di AWS Glue Interactive Sessions.
# FileSize
FileSize RuleType memungkinkan Anda untuk memastikan bahwa file memenuhi kriteria ukuran file tertentu. Ini berguna untuk kasus penggunaan berikut:
1. Pastikan produsen tidak mengirim file kosong atau jauh lebih kecil untuk diproses.
1. Pastikan bucket target Anda tidak memiliki file yang lebih kecil yang dapat menyebabkan masalah kinerja.
FileSize mengumpulkan metrik berikut:
1. Kepatuhan: mengembalikan% file yang memenuhi ambang batas aturan yang telah Anda buat
1. Jumlah File: jumlah file yang dipindai oleh aturan
1. Ukuran file minimum dalam byte
1. Ukuran file maksimum dalam byte
```
Dataset.*.FileSize.Compliance: 1.00,
Dataset.*.FileCount: 8.00,
Dataset.*.MaximumFileSize: 327413121.00,
Dataset.*.MinimumFileSize: 204558920.00
```
Deteksi anomali tidak didukung untuk metrik ini.
**Validasi ukuran file**
Aturan ini akan berlalu ketika file.dat lebih besar dari 2 MB.
```
FileSize "s3://amzn-s3-demo-bucket/file.dat" > 2 MB
```
Unites yang didukung termasuk B (byte), MB (mega byte), GB (giga byte) dan TB (terra byte).
**Validasi ukuran file dalam folder**
```
FileSize "s3://bucket/" > 5 B
FileSize "s3://bucket/" < 2 GB
```
Aturan ini akan berlalu jika 70% file di s3://amzn-s3-demo-bucket adalah antara 2 GB dan 1 TB.
```
FileSize "s3://amzn-s3-demo-bucket/" between 2 GB and 1 TB with threshold > 0.7
```
**Menyimpulkan nama file langsung dari bingkai data**
Anda tidak selalu harus menyediakan jalur file. Misalnya, ketika Anda menulis aturan di Katalog Data, mungkin sulit untuk menemukan folder mana yang digunakan tabel katalog. AWS Glue Data Quality dapat menemukan folder atau file tertentu yang digunakan untuk mengisi bingkai data Anda.
**catatan**
Fitur ini hanya akan berfungsi ketika file berhasil dibaca ke dalam DynamicFrame atau DataFrame.
```
FileSize < 10 MB with threshold > 0.7
```
**Tag Aturan Berbasis File Opsional:**
Tag memungkinkan Anda mengontrol perilaku aturan.
**RecentFiles**
Tag ini membatasi jumlah file yang diproses dengan menyimpan file terbaru terlebih dahulu.
```
FileSize "s3://amzn-s3-demo-bucket/" > 5 B with recentFiles = 1
```
**UriRegex**
**catatan**
`uriRegex`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Tag ini memfilter file dengan menerapkan pola regex ke jalur file. Hanya file yang jalurnya cocok dengan pola yang diproses. Anda juga dapat menggunakan lookahead negatif untuk mengecualikan file yang cocok dengan pola.
```
# Match only files with a .dat extension
FileSize "s3://bucket/" > 5 B with uriRegex = "\.dat$"
# Exclude files ending in .tmp using a negative lookahead
FileSize "s3://bucket/" > 5 B with uriRegex = "(?!.*\.tmp$).*"
```
**FilterOrder**
**catatan**
`filterOrder`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Bila Anda menggunakan beberapa tag filter seperti `recentFiles` dan `uriRegex` bersama-sama, `filterOrder` tag mengontrol urutan penerapannya. Urutan default adalah yang `recentFiles` pertama, lalu`uriRegex`.
```
FileSize "s3://bucket/" > 5 B with recentFiles = 5 with uriRegex = "\.dat$" with filterOrder = ["uriRegex","recentFiles"]
```
**FailFast**
Saat disetel ke`"true"`, aturan segera mengembalikan kegagalan pada file pertama yang gagal dalam kondisi ukuran, alih-alih mengevaluasi semua file dan menghitung rasio kepatuhan.
```
FileSize "s3://bucket/" > 2 MB with failFast = "true"
```
Ada beberapa pertimbangan:
1. Di AWS Glue ETL, Anda harus memiliki DataQuality Evaluate Transform segera setelah Amazon S3 atau Data Catalog berubah.
1. Aturan ini tidak akan berfungsi di AWS Glue Interactive Sessions.
# Menggunakan APIs untuk mengukur dan mengelola kualitas data
Topik ini menjelaskan cara menggunakan APIs untuk mengukur dan mengelola kualitas data.
**Contents**
+ [
## Prasyarat
](#using-apis-prerequisites)
+ [
## Bekerja dengan rekomendasi Kualitas Data AWS Glue
](#using-apis-recommendations)
+ [
## Bekerja dengan Aturan Kualitas Data AWS Glue
](#using-apis-rulesets)
+ [
## Bekerja dengan AWS Glue Data Quality berjalan
](#using-apis-runs)
+ [
## Bekerja dengan hasil Kualitas Data AWS Glue
](#using-apis-results)
## Prasyarat
+ Pastikan versi boto3 Anda mutakhir sehingga menyertakan API Kualitas Data AWS Glue terbaru.
+ Pastikan versi AWS CLI Anda mutakhir, sehingga menyertakan CLI terbaru.
Jika Anda menggunakan pekerjaan AWS Glue untuk menjalankan ini APIs, Anda dapat menggunakan opsi berikut untuk memperbarui pustaka boto3 ke versi terbaru:
```
—additional-python-modules boto3==
```
## Bekerja dengan rekomendasi Kualitas Data AWS Glue
**Untuk memulai rekomendasi AWS Glue Data Quality, jalankan:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def start_data_quality_rule_recommendation_run(self, database_name, table_name, role_arn):
"""
Starts a recommendation run that is used to generate rules when you don't know what rules to write. AWS Glue Data Quality
analyzes the data and comes up with recommendations for a potential ruleset. You can then triage the ruleset
and modify the generated ruleset to your liking.
:param database_name: The name of the AWS Glue database which contains the dataset.
:param table_name: The name of the AWS Glue table against which we want a recommendation
:param role_arn: The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM) role that grants permission to let AWS Glue access the resources it needs.
"""
try:
response = self.client.start_data_quality_rule_recommendation_run(
DataSource={
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name
}
},
Role=role_arn
)
except ClientError as err:
logger.error(
"Couldn't start data quality recommendation run %s. Here's why: %s: %s", name,
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response['RunId']
```
Untuk menjalankan rekomendasi, Anda dapat menggunakan `pushDownPredicates` atau `catalogPartitionPredicates` untuk meningkatkan kinerja dan menjalankan rekomendasi hanya pada partisi tertentu dari sumber katalog Anda.
```
client.start_data_quality_rule_recommendation_run(
DataSource={
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name,
'AdditionalOptions': {
'pushDownPredicate': "year=2022"
}
}
},
Role=role_arn,
NumberOfWorkers=2,
CreatedRulesetName=''
)
```
**Untuk mendapatkan hasil rekomendasi AWS Glue Data Quality, jalankan:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_data_quality_rule_recommendation_run(self, run_id):
"""
Gets the specified recommendation run that was used to generate rules.
:param run_id: The id of the data quality recommendation run
"""
try:
response = self.client.get_data_quality_rule_recommendation_run(RunId=run_id)
except ClientError as err:
logger.error(
"Couldn't get data quality recommendation run %. Here's why: %s: %s", run_id,
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
Dari objek respon di atas, Anda dapat mengekstrak RuleSet yang direkomendasikan oleh run, untuk digunakan dalam langkah selanjutnya:
```
print(response['RecommendedRuleset'])
Rules = [
RowCount between 2000 and 8000,
IsComplete "col1",
IsComplete "col2",
StandardDeviation "col3" between 58138330.8 and 64258155.09,
ColumnValues "col4" between 1000042965 and 1214474826,
IsComplete "col5"
]
```
**Untuk mendapatkan daftar semua rekomendasi Anda berjalan yang dapat difilter dan dicantumkan:**
```
response = client.list_data_quality_rule_recommendation_runs(
Filter={
'DataSource': {
'GlueTable': {
'DatabaseName': '',
'TableName': ''
}
}
)
```
**Untuk membatalkan tugas rekomendasi Kualitas Data AWS Glue yang ada:**
```
response = client.cancel_data_quality_rule_recommendation_run(
RunId='dqrun-d4b6b01957fdd79e59866365bf9cb0e40fxxxxxxx'
)
```
## Bekerja dengan Aturan Kualitas Data AWS Glue
**Untuk membuat aturan Kualitas Data AWS Glue:**
```
response = client.create_data_quality_ruleset(
Name='',
Ruleset='Rules = [IsComplete "col1", IsPrimaryKey "col2", RowCount between 2000 and 8000]',
TargetTable={
'TableName': '',
'DatabaseName': ''
}
)
```
**Untuk mendapatkan aturan kualitas data:**
```
response = client.get_data_quality_ruleset(
Name=''
)
print(response)
```
Anda dapat menggunakan API ini untuk kemudian mengekstrak set aturan:
```
print(response['Ruleset'])
```
**Untuk membuat daftar semua aturan kualitas data untuk tabel:**
```
response = client.list_data_quality_rulesets()
```
Anda dapat menggunakan kondisi filter dalam API untuk memfilter semua aturan yang dilampirkan ke database atau tabel tertentu:
```
response = client.list_data_quality_rulesets(
Filter={
'TargetTable': {
'TableName': '',
'DatabaseName': ''
}
},
)
```
**Untuk memperbarui kumpulan aturan kualitas data:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def update_data_quality_ruleset(self, ruleset_name, ruleset_string):
"""
Update an AWS Glue Data Quality Ruleset
:param ruleset_name: The name of the AWS Glue Data Quality ruleset to update
:param ruleset_string: The DQDL ruleset string to update the ruleset with
"""
try:
response = self.client.update_data_quality_ruleset(
Name=ruleset_name,
Ruleset=ruleset_string
)
except ClientError as err:
logger.error(
"Couldn't update the AWS Glue Data Quality ruleset. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
**Untuk menghapus kumpulan aturan kualitas data:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def delete_data_quality_ruleset(self, ruleset_name):
"""
Delete a AWS Glue Data Quality Ruleset
:param ruleset_name: The name of the AWS Glue Data Quality ruleset to delete
"""
try:
response = self.client.delete_data_quality_ruleset(
Name=ruleset_name
)
except ClientError as err:
logger.error(
"Couldn't delete the AWS Glue Data Quality ruleset. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
## Bekerja dengan AWS Glue Data Quality berjalan
**Untuk memulai menjalankan AWS Glue Data Quality:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def start_data_quality_ruleset_evaluation_run(self, database_name, table_name, role_name, ruleset_list):
"""
Start an AWS Glue Data Quality evaluation run
:param database_name: The name of the AWS Glue database which contains the dataset.
:param table_name: The name of the AWS Glue table against which we want to evaluate.
:param role_arn: The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM) role that grants permission to let AWS Glue access the resources it needs.
:param ruleset_list: The list of AWS Glue Data Quality ruleset names to evaluate.
"""
try:
response = client.start_data_quality_ruleset_evaluation_run(
DataSource={
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name
}
},
Role=role_name,
RulesetNames=ruleset_list
)
except ClientError as err:
logger.error(
"Couldn't start the AWS Glue Data Quality Run. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response['RunId']
```
Ingat bahwa Anda dapat meneruskan `catalogPartitionPredicate` parameter `pushDownPredicate` atau untuk memastikan kualitas data Anda berjalan hanya menargetkan sekumpulan partisi tertentu dalam tabel katalog Anda. Contoh:
```
response = client.start_data_quality_ruleset_evaluation_run(
DataSource={
'GlueTable': {
'DatabaseName': '',
'TableName': '',
'AdditionalOptions': {
'pushDownPredicate': 'year=2023'
}
}
},
Role='',
NumberOfWorkers=5,
Timeout=123,
AdditionalRunOptions={
'CloudWatchMetricsEnabled': False
},
RulesetNames=[
'',
]
)
```
Anda juga dapat mengonfigurasi bagaimana aturan komposit dalam kumpulan aturan Anda dievaluasi, baik di tingkat ROW atau COLUMN. Untuk informasi lebih lanjut tentang cara kerja aturan komposit, silakan lihat [Cara kerja aturan komposit](dqdl.md#dqdl-syntax-composite-rules) dalam dokumentasi.
Contoh tentang cara mengatur metode evaluasi aturan komposit dalam permintaan Anda:
```
response = client.start_data_quality_ruleset_evaluation_run(
DataSource={
'GlueTable': {
'DatabaseName': '',
'TableName': '',
'AdditionalOptions': {
'pushDownPredicate': 'year=2023'
}
}
},
Role='',
NumberOfWorkers=5,
Timeout=123,
AdditionalRunOptions={
'CompositeRuleEvaluationMethod':ROW
},
RulesetNames=[
'',
]
)
```
**Untuk mendapatkan informasi tentang AWS Glue Data Quality run:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_data_quality_ruleset_evaluation_run(self, run_id):
"""
Get details about an AWS Glue Data Quality Run
:param run_id: The AWS Glue Data Quality run ID to look up
"""
try:
response = self.client.get_data_quality_ruleset_evaluation_run(
RunId=run_id
)
except ClientError as err:
logger.error(
"Couldn't look up the AWS Glue Data Quality run ID. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
**Untuk mendapatkan hasil dari AWS Glue Data Quality menjalankan:**
Untuk menjalankan Kualitas Data AWS Glue tertentu, Anda dapat mengekstrak hasil evaluasi run menggunakan metode berikut:
```
response = client.get_data_quality_ruleset_evaluation_run(
RunId='d4b6b01957fdd79e59866365bf9cb0e40fxxxxxxx'
)
resultID = response['ResultIds'][0]
response = client.get_data_quality_result(
ResultId=resultID
)
print(response['RuleResults'])
```
**Untuk mencantumkan semua AWS Glue Data Quality Anda berjalan:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def list_data_quality_ruleset_evaluation_runs(self, database_name, table_name):
"""
Lists all the AWS Glue Data Quality runs against a given table
:param database_name: The name of the database where the data quality runs
:param table_name: The name of the table against which the data quality runs were created
"""
try:
response = self.client.list_data_quality_ruleset_evaluation_runs(
Filter={
'DataSource': {
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name
}
}
}
)
except ClientError as err:
logger.error(
"Couldn't list the AWS Glue Quality runs. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
Anda dapat memodifikasi klausa filter untuk hanya menampilkan hasil antara waktu tertentu atau berjalan terhadap tabel tertentu.
**Untuk menghentikan proses AWS Glue Data Quality yang sedang berlangsung:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def cancel_data_quality_ruleset_evaluation_run(self, result_id):
"""
Cancels a given AWS Glue Data Quality run
:param result_id: The result id of a AWS Glue Data Quality run to cancel
"""
try:
response = self.client.cancel_data_quality_ruleset_evaluation_run(
ResultId=result_id
)
except ClientError as err:
logger.error(
"Couldn't cancel the AWS Glue Data Quality run. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
## Bekerja dengan hasil Kualitas Data AWS Glue
**Untuk mendapatkan hasil AWS Glue Data Quality run Anda:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_data_quality_result(self, result_id):
"""
Outputs the result of an AWS Glue Data Quality Result
:param result_id: The result id of an AWS Glue Data Quality run
"""
try:
response = self.client.get_data_quality_result(
ResultId=result_id
)
except ClientError as err:
logger.error(
"Couldn't get the AWS Glue Data Quality result. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
**Untuk melihat statistik yang dikumpulkan untuk hasil kualitas data tertentu:**
```
import boto3
from botocore.exceptions import ClientError
import logging
logger = logging.getLogger(__name__)
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_profile_for_data_quality_result(self, result_id):
"""
Outputs the statistic profile for a AWS Glue Data Quality Result
:param result_id: The result id of a AWS Glue Data Quality run
"""
try:
response = self.glue_client.get_data_quality_result(
ResultId=result_id
)
# the profile contains all statistics gathered for the result
profile_id = response['ProfileId']
profile = self.glue_client.list_data_quality_statistics(
ProfileId = profile_id
)
return profile
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality profile. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Untuk melihat rentang waktu untuk statistik yang dikumpulkan di beberapa proses kualitas data:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_statistics_for_data_quality_result(self, profile_id):
"""
Outputs an array of datapoints for each statistic in the input result.
:param result_id: The profile id of a AWS Glue Data Quality run
"""
try:
profile = self.glue_client.list_data_quality_statistics(
ProfileId = profile_id
)
statistics = [self.glue_client.list_data_quality_statistics(
StatisticId = s['StatisticId']
) for s in profile['Statistics']]
return statistics
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality statistics. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Untuk melihat model deteksi anomali untuk statistik tertentu:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_model_training_result_for_statistic(self, statistic_id, profile_id):
"""
Outputs the details (bounds) of anomaly detection training for the given statistic at the given profile.
:param statistic_id the model's statistic (the timeseries it is tracking)
:param profile_id the profile associated with the model (a point in the timeseries)
"""
try:
model = self.glue_client.get_data_quality_model_result(
ProfileId = profile_id, StatisticId = statistic_id
)
return model
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality model results. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Untuk mengecualikan titik data dari garis dasar deteksi anomali model statistiknya:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def apply_exclusions_to_statistic(self, statistic_id, profile_ids):
"""
Annotate some points along a given statistic timeseries.
This example excludes the provided values; INCLUDE can also be used to undo this action.
:param statistic_id the statistic timeseries to annotate
:param profile_id the profiles we want to exclude (points in the timeseries)
"""
try:
response = self.glue_client.batch_put_data_quality_statistic_annotation(
InclusionAnnotations = [
{'ProfileId': prof_id,
'StatisticId': statistic_id,
'InclusionAnnotation': 'EXCLUDE'} for prof_id in profile_ids
]
)
return response['FailedInclusionAnnotations']
except ClientError as err:
logger.error(
"Couldn't store Data Quality annotations. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Untuk melihat status pelatihan model deteksi anomali untuk statistik tertentu:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_model_training_status_for_statistic(self, statistic_id, profile_id):
"""
Outputs the status of anomaly detection training for the given statistic at the given profile.
:param statistic_id the model's statistic (the timeseries it is tracking)
:param profile_id the profile associated with the model (a point in the timeseries)
"""
try:
model = self.glue_client.get_data_quality_model(
ProfileId = profile_id, StatisticId = statistic_id
)
return model
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality statistics. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Untuk mengecualikan semua hasil dari kualitas data tertentu, jalankan dari garis dasar deteksi anomali:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def apply_exclusions_to_profile(self, profile_id):
"""
Exclude datapoints produced by a run across statistic timeseries.
This example excludes the provided values; INCLUDE can also be used to undo this action.
:param profile_id the profiles we want to exclude (points in the timeseries)
"""
try:
response = self.glue_client.put_data_quality_profile_annotation(
ProfileId = profile_id,
InclusionAnnotation = "EXCLUDE"
)
return response
except ClientError as err:
logger.error(
"Couldn't store Data Quality annotations. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Untuk mendapatkan hasil dari kualitas data yang diberikan, jalankan dan tampilkan hasilnya:**
Dengan Kualitas Data AWS Glue`runID`, Anda dapat mengekstrak `resultID` untuk kemudian mendapatkan hasil aktual, seperti yang ditunjukkan di bawah ini:
```
response = client.get_data_quality_ruleset_evaluation_run(
RunId='dqrun-abca77ee126abe1378c1da1ae0750d7dxxxx'
)
resultID = response['ResultIds'][0]
response = client.get_data_quality_result(
ResultId=resultID
)
print(resp['RuleResults'])
```
# Menyiapkan peringatan, penerapan, dan penjadwalan
Topik ini menjelaskan cara mengatur peringatan, penerapan, dan penjadwalan untuk Kualitas Data AWS Glue.
**Contents**
+ [
## Menyiapkan peringatan dan pemberitahuan dalam integrasi Amazon EventBridge
](#data-quality-alerts-eventbridge)
+ [
### Opsi konfigurasi tambahan untuk pola acara
](#data-quality-alerts-eventbridge-config-options)
+ [
### Memformat pemberitahuan sebagai email
](#data-quality-alerts-eventbridge-format-notifications)
+ [
## Siapkan peringatan dan notifikasi dalam integrasi CloudWatch
](#data-quality-alerts-cloudwatch)
+ [
## Menanyakan hasil kualitas data untuk membangun dasbor
](#data-quality-alerts-querying-results)
+ [
## Menerapkan aturan kualitas data menggunakan AWS CloudFormation
](#data-quality-deploy-cfn)
+ [
## Menjadwalkan aturan kualitas data
](#data-quality-scheduling-rules)
## Menyiapkan peringatan dan pemberitahuan dalam integrasi Amazon EventBridge
AWS Glue Data Quality mendukung penerbitan EventBridge peristiwa, yang dipancarkan setelah menyelesaikan evaluasi aturan Kualitas Data. Dengan ini, Anda dapat dengan mudah mengatur peringatan ketika aturan kualitas data gagal.
Berikut adalah contoh peristiwa saat Anda mengevaluasi kumpulan aturan kualitas data di Katalog Data. Dengan informasi ini, Anda dapat meninjau data yang tersedia dengan Amazon EventBridge. Anda dapat mengeluarkan panggilan API tambahan untuk mendapatkan detail selengkapnya. Misalnya, panggil `get_data_quality_result` API dengan ID hasil untuk mendapatkan detail eksekusi tertentu.
```
{
"version":"0",
"id":"abcdef00-1234-5678-9abc-def012345678",
"detail-type":"Data Quality Evaluation Results Available",
"source":"aws.glue-dataquality",
"account":"123456789012",
"time":"2017-09-07T18:57:21Z",
"region":"us-west-2",
"resources":[],
"detail":{
"context": {
"contextType": "GLUE_DATA_CATALOG",
"runId":"dqrun-12334567890",
"databaseName": "db-123",
"tableName": "table-123",
"catalogId": "123456789012"
},
"resultID": "dqresult-12334567890",
"rulesetNames": ["rulset1"],
"state":"SUCCEEDED",
"score": 1.00,
"rulesSucceeded": 100,
"rulesFailed": 0,
"rulesSkipped": 0
}
}
```
Berikut adalah contoh peristiwa yang dipublikasikan saat Anda mengevaluasi set aturan kualitas data di notebook Glue ETL atau AWS AWS Glue Studio.
```
{
"version":"0",
"id":"abcdef00-1234-5678-9abc-def012345678",
"detail-type":"Data Quality Evaluation Results Available",
"source":"aws.glue-dataquality",
"account":"123456789012",
"time":"2017-09-07T18:57:21Z",
"region":"us-west-2",
"resources":[],
"detail":{
"context": {
"contextType": "GLUE_JOB",
"jobId": "jr-12334567890",
"jobName": "dq-eval-job-1234",
"evaluationContext": "",
}
"resultID": "dqresult-12334567890",
"rulesetNames": ["rulset1"],
"state":"SUCCEEDED",
"score": 1.00
"rulesSucceeded": 100,
"rulesFailed": 0,
"rulesSkipped": 0
}
}
```
Untuk evaluasi Kualitas Data berjalan baik di Katalog Data dan dalam pekerjaan ETL, Amazon CloudWatch opsi **Publikasikan metrik ke**, yang dipilih secara default, harus tetap dipilih agar EventBridge penerbitan berfungsi.
**Menyiapkan EventBridge notifikasi**
![\[Properti kualitas data di AWS CloudFormation\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/data-quality-properties-cfn.png)
Untuk menerima peristiwa yang dipancarkan dan menentukan target, Anda harus mengonfigurasi aturan Amazon EventBridge . Untuk membuat aturan:
1. Buka EventBridge konsol Amazon.
1. Pilih **Aturan** di bawah bagian **Bus** pada bilah navigasi.
1. Pilih **Buat aturan**.
1. Tentang **Tentukan Rincian Aturan**:
1. Untuk Nama, masukkan`myDQRule`.
1. Masukkan deskripsi (opsional).
1. Untuk bus acara, pilih bus acara Anda. Jika Anda tidak memilikinya, biarkan sebagai default.
1. Untuk Jenis aturan pilih **Aturan dengan pola acara** lalu pilih **Berikutnya**.
1. Pada **Pola Acara Bangun**:
1. Untuk sumber acara pilih **AWS acara atau acara EventBridge mitra**.
1. Lewati bagian contoh acara.
1. Untuk metode pembuatan pilih **Gunakan formulir pola**.
1. Untuk pola acara:
1. Pilih **AWS layanan** untuk sumber Acara.
1. Pilih **Glue Data Quality** untuk AWS layanan.
1. Pilih **Hasil Evaluasi Kualitas Data yang Tersedia** untuk jenis Acara.
1. Pilih **GAGAL** untuk status tertentu. Kemudian Anda melihat pola acara yang mirip dengan berikut ini:
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"state": ["FAILED"]
}
}
```
1. Untuk opsi konfigurasi lainnya, lihat[Opsi konfigurasi tambahan untuk pola acara](#data-quality-alerts-eventbridge-config-options).
1. Pada **Target Pilih**:
1. Untuk **Jenis Target** pilih **AWS layanan**.
1. **Gunakan menu tarik-turun **Pilih target** untuk memilih AWS layanan yang Anda inginkan untuk terhubung (SNS, Lambda, SQS, dll.), Lalu pilih Berikutnya.**
1. Pada **Konfigurasi tag** klik **Tambahkan tag baru untuk menambahkan tag** opsional lalu pilih **Berikutnya**.
1. Anda melihat halaman ringkasan dari semua pilihan. Pilih **Buat aturan** di bagian bawah.
### Opsi konfigurasi tambahan untuk pola acara
Selain memfilter acara Anda tentang keberhasilan atau kegagalan, Anda mungkin ingin memfilter lebih lanjut peristiwa pada parameter yang berbeda.
Untuk melakukan ini, buka bagian Pola Acara, dan pilih **Edit pola** untuk menentukan parameter tambahan. Perhatikan bahwa bidang dalam pola peristiwa peka huruf besar/kecil. Berikut ini adalah contoh konfigurasi pola acara.
Untuk menangkap peristiwa dari tabel tertentu yang mengevaluasi kumpulan aturan tertentu, gunakan jenis pola ini:
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"context": {
"contextType": ["GLUE_DATA_CATALOG"],
"databaseName": "db-123",
"tableName": "table-123",
},
"rulesetNames": ["ruleset1", "ruleset2"]
"state": ["FAILED"]
}
}
```
Untuk menangkap peristiwa dari pekerjaan tertentu dalam pengalaman ETL, gunakan jenis pola ini:
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"context": {
"contextType": ["GLUE_JOB"],
"jobName": ["dq_evaluation_job1", "dq_evaluation_job2"]
},
"state": ["FAILED"]
}
}
```
Untuk menangkap peristiwa dengan skor di bawah ambang tertentu (misalnya 70%):
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"score": [{
"numeric": ["<=", 0.7]
}]
}
}
```
### Memformat pemberitahuan sebagai email
Terkadang Anda perlu mengirim pemberitahuan email yang diformat dengan baik ke tim bisnis Anda. Anda dapat menggunakan Amazon EventBridge dan AWS Lambda untuk mencapai ini.
![\[Pemberitahuan kualitas data diformat sebagai email\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/data_quality_sample_email.png)
Kode contoh berikut dapat digunakan untuk memformat pemberitahuan kualitas data Anda untuk menghasilkan email.
```
import boto3
import json
from datetime import datetime
sns_client = boto3.client('sns')
glue_client = boto3.client('glue')
sns_topic_arn = 'arn:aws:sns:::'
def lambda_handler(event, context):
log_metadata = {}
message_text = ""
subject_text = ""
if event['detail']['context']['contextType'] == 'GLUE_DATA_CATALOG':
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['tableName'] = str(event['detail']['context']['tableName'])
log_metadata['databaseName'] = str(event['detail']['context']['databaseName'])
log_metadata['runId'] = str(event['detail']['context']['runId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_table_name: {}\n".format(log_metadata['tableName'])
message_text += "glue_database_name: {}\n".format(log_metadata['databaseName'])
message_text += "run_id: {}\n".format(log_metadata['runId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
else:
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['jobName'] = str(event['detail']['context']['jobName'])
log_metadata['jobId'] = str(event['detail']['context']['jobId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_job_name: {}\n".format(log_metadata['jobName'])
message_text += "job_id: {}\n".format(log_metadata['jobId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
resultID = str(event['detail']['resultId'])
response = glue_client.get_data_quality_result(ResultId=resultID)
RuleResults = response['RuleResults']
message_text += "\n\nruleset details evaluation steps results:\n\n"
subresult_info = []
for dic in RuleResults:
subresult = "Name: {}\t\tResult: {}\t\tDescription: \t{}".format(dic['Name'], dic['Result'], dic['Description'])
if 'EvaluationMessage' in dic:
subresult += "\t\tEvaluationMessage: {}".format(dic['EvaluationMessage'])
subresult_info.append({
'Name': dic['Name'],
'Result': dic['Result'],
'Description': dic['Description'],
'EvaluationMessage': dic.get('EvaluationMessage', '')
})
message_text += "\n" + subresult
log_metadata['resultrun'] = subresult_info
sns_client.publish(
TopicArn=sns_topic_arn,
Message=message_text,
Subject=subject_text
)
return {
'statusCode': 200,
'body': json.dumps('Message published to SNS topic')
}
```
## Siapkan peringatan dan notifikasi dalam integrasi CloudWatch
Pendekatan yang kami rekomendasikan adalah menyiapkan peringatan kualitas data menggunakan Amazon EventBridge, karena Amazon EventBridge memerlukan penyiapan satu kali untuk mengingatkan pelanggan. Namun, beberapa pelanggan lebih suka Amazon CloudWatch karena keakraban. Untuk pelanggan seperti itu, kami menawarkan integrasi dengan Amazon CloudWatch.
Setiap evaluasi Kualitas Data AWS Glue memancarkan sepasang metrik bernama `glue.data.quality.rules.passed` (menunjukkan sejumlah aturan yang lolos) dan `glue.data.quality.rules.failed` (menunjukkan jumlah aturan yang gagal) per kualitas data yang dijalankan. Anda dapat menggunakan metrik yang dipancarkan ini untuk membuat alarm untuk mengingatkan pengguna jika kualitas data tertentu berjalan di bawah ambang batas. Untuk memulai dengan mengatur alarm yang akan mengirim email melalui pemberitahuan Amazon SNS, ikuti langkah-langkah di bawah ini:
Untuk memulai dengan mengatur alarm yang akan mengirim email melalui pemberitahuan Amazon SNS, ikuti langkah-langkah di bawah ini:
1. Buka CloudWatch konsol Amazon.
1. Pilih **Semua metrik** di bawah **Metrik**. Anda akan melihat namespace tambahan di bawah ruang nama Kustom berjudul Glue Data Quality.
**catatan**
Saat memulai proses AWS Glue Data Quality, pastikan CloudWatch kotak centang **Publikasikan metrik ke Amazon** diaktifkan. Jika tidak, metrik untuk proses tertentu tidak akan dipublikasikan ke Amazon CloudWatch.
Di bawah `Glue Data Quality` namespace, Anda dapat melihat metrik yang dipancarkan per tabel, per kumpulan aturan. Untuk tujuan topik ini, kami akan menggunakan `glue.data.quality.rules.failed` aturan dan alarm jika nilai ini melebihi 1 (menunjukkan bahwa, jika kami melihat sejumlah evaluasi aturan yang gagal lebih besar dari 1, kami ingin diberi tahu).
1. Untuk membuat alarm, pilih **Semua alarm di bawah **Alarm****.
1. Pilih **Buat alarm**.
1. Pilih **Pilih Metrik**.
1. Pilih `glue.data.quality.rules.failed` metrik yang sesuai dengan tabel yang telah Anda buat, lalu **pilih Pilih metrik**.
1. Di bawah tab **Tentukan metrik dan kondisi**, di bawah bagian **Metrik**:
1. Untuk **Statistik** pilih **Jumlah**.
1. Untuk **Periode**, pilih **1 menit**.
1. Di bawah bagian **Kondisi**:
1. Untuk **Jenis ambang batas**, pilih **Statis**.
1. Untuk **Setiap kali glue.data.quality.rules.failed** adalah... , pilih **Greater/Equal**.
1. Untuk **dari...** , masukkan **1** sebagai nilai ambang batas.
Pilihan ini menyiratkan bahwa jika `glue.data.quality.rules.failed` metrik memancarkan nilai lebih besar dari atau sama dengan 1, kami akan memicu alarm. Namun, jika tidak ada data, kami akan memperlakukannya sebagai dapat diterima.
1. Pilih **Berikutnya**.
1. Pada **tindakan Konfigurasi**:
1. Untuk bagian **Pemicu status alarm**, pilih **Dalam alarm**.
1. Untuk **Kirim pemberitahuan ke bagian topik SNS berikut**, pilih **Buat topik baru untuk mengirim pemberitahuan melalui topik SNS baru**.
1. Untuk **titik akhir Email yang akan menerima notifikasi,** masukkan alamat email Anda. Kemudian klik **Buat Topik**.
1. Pilih **Berikutnya**.
1. Untuk **nama Alarm**, masukkan`myFirstDQAlarm`, lalu pilih **Berikutnya**.
1. Anda melihat halaman ringkasan dari semua pilihan. Pilih **Buat alarm** di bagian bawah.
Anda sekarang dapat melihat alarm dibuat dari dasbor CloudWatch alarm Amazon.
## Menanyakan hasil kualitas data untuk membangun dasbor
Anda mungkin ingin membangun dasbor untuk menampilkan hasil kualitas data Anda. Ada dua cara untuk melakukan hal ini:
**Siapkan Amazon EventBridge dengan kode berikut untuk menulis data ke Amazon S3:**
```
import boto3
import json
from datetime import datetime
s3_client = boto3.client('s3')
glue_client = boto3.client('glue')
s3_bucket = 's3-bucket-name'
def write_logs(log_metadata):
try:
filename = datetime.now().strftime("%m%d%Y%H%M%S") + ".json"
key_opts = {
'year': datetime.now().year,
'month': "{:02d}".format(datetime.now().month),
'day': "{:02d}".format(datetime.now().day),
'filename': filename
}
s3key = "gluedataqualitylogs/year={year}/month={month}/day={day}/{filename}".format(**key_opts)
s3_client.put_object(Bucket=s3_bucket, Key=s3key, Body=json.dumps(log_metadata))
except Exception as e:
print(f'Error writing logs to S3: {e}')
def lambda_handler(event, context):
log_metadata = {}
message_text = ""
subject_text = ""
if event['detail']['context']['contextType'] == 'GLUE_DATA_CATALOG':
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['tableName'] = str(event['detail']['context']['tableName'])
log_metadata['databaseName'] = str(event['detail']['context']['databaseName'])
log_metadata['runId'] = str(event['detail']['context']['runId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_table_name: {}\n".format(log_metadata['tableName'])
message_text += "glue_database_name: {}\n".format(log_metadata['databaseName'])
message_text += "run_id: {}\n".format(log_metadata['runId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
else:
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['jobName'] = str(event['detail']['context']['jobName'])
log_metadata['jobId'] = str(event['detail']['context']['jobId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_job_name: {}\n".format(log_metadata['jobName'])
message_text += "job_id: {}\n".format(log_metadata['jobId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
resultID = str(event['detail']['resultId'])
response = glue_client.get_data_quality_result(ResultId=resultID)
RuleResults = response['RuleResults']
message_text += "\n\nruleset details evaluation steps results:\n\n"
subresult_info = []
for dic in RuleResults:
subresult = "Name: {}\t\tResult: {}\t\tDescription: \t{}".format(dic['Name'], dic['Result'], dic['Description'])
if 'EvaluationMessage' in dic:
subresult += "\t\tEvaluationMessage: {}".format(dic['EvaluationMessage'])
subresult_info.append({
'Name': dic['Name'],
'Result': dic['Result'],
'Description': dic['Description'],
'EvaluationMessage': dic.get('EvaluationMessage', '')
})
message_text += "\n" + subresult
log_metadata['resultrun'] = subresult_info
write_logs(log_metadata)
return {
'statusCode': 200,
'body': json.dumps('Message published to SNS topic')
}
```
Setelah menulis ke Amazon S3, Anda dapat menggunakan perayap AWS Glue untuk mendaftar ke Athena dan menanyakan tabel.
**Konfigurasikan lokasi Amazon S3 selama evaluasi kualitas data::**
Saat menjalankan tugas kualitas data di AWS Glue Data Catalog atau AWS Glue ETL, Anda dapat memberikan lokasi Amazon S3 untuk menulis hasil kualitas data ke Amazon S3. Anda dapat menggunakan sintaks di bawah ini untuk membuat tabel dengan mereferensikan target untuk membaca hasil kualitas data.
Perhatikan bahwa Anda harus menjalankan `MSCK REPAIR TABLE` kueri `CREATE EXTERNAL TABLE` dan secara terpisah.
```
CREATE EXTERNAL TABLE (
catalogid string,
databasename string,
tablename string,
dqrunid string,
evaluationstartedon timestamp,
evaluationcompletedon timestamp,
rule string,
outcome string,
failurereason string,
evaluatedmetrics string)
PARTITIONED BY (
`year` string,
`month` string,
`day` string)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES (
'paths'='catalogId,databaseName,dqRunId,evaluatedMetrics,evaluationCompletedOn,evaluationStartedOn,failureReason,outcome,rule,tableName')
STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://glue-s3-dq-bucket-us-east-2-results/'
TBLPROPERTIES (
'classification'='json',
'compressionType'='none',
'typeOfData'='file');
```
```
MSCK REPAIR TABLE ;
```
Setelah Anda membuat tabel di atas, Anda dapat menjalankan kueri analitik menggunakan Amazon Athena.
## Menerapkan aturan kualitas data menggunakan AWS CloudFormation
Anda dapat menggunakan AWS CloudFormation untuk membuat aturan kualitas data. Untuk informasi lebih lanjut, lihat [AWS CloudFormation untuk AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/populate-with-cloudformation-templates.html).
## Menjadwalkan aturan kualitas data
Anda dapat menjadwalkan aturan kualitas data menggunakan metode berikut:
+ Jadwalkan aturan kualitas data dari Katalog Data: tidak ada pengguna kode yang dapat menggunakan opsi ini untuk dengan mudah menjadwalkan pemindaian kualitas data mereka. AWS Glue Data Quality akan membuat jadwal di Amazon EventBridge. Untuk menjadwalkan aturan kualitas data:
+ **Arahkan ke ruleset dan klik Run.**
+ Dalam **frekuensi Jalankan**, pilih jadwal yang diinginkan dan berikan **Nama Tugas**. Nama Tugas ini adalah nama jadwal Anda di EventBridge.
+ Gunakan Amazon EventBridge dan AWS Step Functions untuk mengatur evaluasi dan rekomendasi untuk aturan kualitas data.
# Enkripsi data saat istirahat untuk AWS Glue Data Quality
AWS Glue Data Qualitymenyediakan enkripsi secara default untuk melindungi data pelanggan sensitif saat istirahat menggunakan kunci enkripsi yang AWS dimiliki.
## AWS kunci yang dimiliki
AWS Glue Data Quality menggunakan kunci ini untuk secara otomatis mengenkripsi aset Kualitas Data pelanggan. Anda tidak dapat melihat, mengelola, atau menggunakan kunci yang AWS dimiliki, atau mengaudit penggunaannya. Namun, Anda tidak perlu mengambil tindakan apa pun atau mengubah program apa pun untuk melindungi kunci yang mengenkripsi data Anda. Untuk informasi selengkapnya, lihat [kunci yang AWS dimiliki](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk) di Panduan AWS KMS Pengembang.
Enkripsi data saat istirahat secara default membantu mengurangi overhead operasional dan kompleksitas yang terlibat dalam melindungi data sensitif. Pada saat yang sama, ini memungkinkan Anda untuk membangun aplikasi aman yang memenuhi kepatuhan enkripsi yang ketat dan persyaratan peraturan.
Meskipun Anda tidak dapat menonaktifkan lapisan enkripsi ini atau memilih jenis enkripsi alternatif, Anda dapat menambahkan lapisan enkripsi kedua di atas kunci enkripsi yang ada AWS dengan memilih kunci yang dikelola pelanggan saat Anda membuat sumber daya Kualitas Data.
## Kunci yang dikelola pelanggan
**Kunci AWS terkelola pelanggan**: Glue Data Quality mendukung penggunaan kunci yang dikelola pelanggan simetris yang Anda buat, miliki, dan kelola. Ini menambahkan lapisan enkripsi kedua di atas enkripsi yang AWS dimiliki yang ada. Karena Anda memiliki kontrol penuh atas lapisan enkripsi ini, Anda dapat melakukan tugas-tugas seperti:
+ Menetapkan dan memelihara kebijakan utama
+ Menetapkan dan memelihara kebijakan IAM
+ Mengaktifkan dan menonaktifkan kebijakan utama
+ Memutar bahan kriptografi kunci
+ Menambahkan tanda
+ Membuat alias kunci
+ Kunci penjadwalan untuk penghapusan
Untuk informasi selengkapnya, lihat [Kunci terkelola pelanggan](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) di Panduan AWS KMS Pengembang.
Tabel berikut merangkum bagaimana AWS Glue Data Quality mengenkripsi aset Kualitas Data yang berbeda.
| Jenis data | AWS enkripsi kunci yang dimiliki | Enkripsi kunci yang dikelola pelanggan |
| --- | --- | --- |
| **Aturan Kualitas Data** String ruleset DQDL yang direferensikan oleh set aturan DQ yang bertahan. Set aturan yang bertahan ini hanya digunakan dalam pengalaman AWS Glue Data Catalog untuk saat ini. | Diaktifkan | Diaktifkan |
| ** Rule/Analyzer Hasil Kualitas Data** Hasil artefak yang berisi pass/fail status setiap aturan dalam kumpulan aturan serta metrik yang dikumpulkan oleh aturan dan penganalisis. | Diaktifkan | Diaktifkan |
| **Pengamatan** Pengamatan dihasilkan ketika anomali terdeteksi dalam data. Ini berisi informasi tentang batas atas dan bawah yang diharapkan dan aturan yang disarankan berdasarkan batas-batas ini. Jika dihasilkan, mereka ditampilkan dengan Hasil Kualitas Data. | Diaktifkan | Diaktifkan |
| **Statistik** Berisi informasi tentang metrik yang dikumpulkan setelah mengevaluasi data yang diberikan kumpulan aturan, seperti nilai metrik (misalnya, Kelengkapan), nama kolom RowCount, dan metadata lainnya. | Diaktifkan | Diaktifkan |
| **Model Statistik Deteksi Anomali** Model statistik berisi deret waktu batas atas dan bawah untuk metrik tertentu yang dihasilkan berdasarkan evaluasi sebelumnya dari data pelanggan. | Diaktifkan | Diaktifkan |
**catatan**
AWS Kualitas Data secara otomatis memungkinkan enkripsi saat istirahat menggunakan kunci yang AWS dimiliki untuk melindungi data yang dapat diidentifikasi secara pribadi tanpa biaya. Namun, AWS KMS biaya berlaku untuk menggunakan kunci yang dikelola pelanggan. Untuk informasi lebih lanjut tentang harga, lihat [AWS KMS Harga](https://aws.amazon.com/kms/pricing/).
Untuk informasi lebih lanjut tentang AWS KMS, lihat [AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
## Buat Kunci yang Dikelola Pelanggan
Anda dapat membuat kunci yang dikelola pelanggan simetris dengan menggunakan Konsol Manajemen AWS, atau. AWS KMS APIs
**Untuk membuat kunci terkelola pelanggan simetris:**
+ Ikuti langkah-langkah untuk [Membuat AWS KMS kunci enkripsi simetris](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) di Panduan AWS Key Management Service Pengembang.
### Kebijakan kunci
Kebijakan utama mengontrol akses ke kunci yang dikelola pelanggan Anda. Setiap kunci yang dikelola pelanggan harus memiliki persis satu kebijakan utama, yang berisi pernyataan yang menentukan siapa yang dapat menggunakan kunci dan bagaimana mereka dapat menggunakannya. Saat membuat kunci terkelola pelanggan, Anda dapat menentukan kebijakan kunci. Untuk informasi selengkapnya, lihat [Kebijakan kunci dalam AWS KMS kunci](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) di Panduan AWS Key Management Service Pengembang.
Untuk menggunakan kunci yang dikelola pelanggan dengan sumber daya Kualitas Data Anda, operasi API berikut harus diizinkan dalam kebijakan kunci:
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)— Mendekripsi ciphertext yang dienkripsi oleh kunci menggunakan AWS KMS `GenerateDataKeyWithoutPlaintext`
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html)— Memberikan detail kunci yang dikelola pelanggan untuk memungkinkan Lokasi Amazon memvalidasi kunci.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html)— Mengembalikan kunci data simetris yang unik untuk digunakan di luar. AWS KMS Operasi ini mengembalikan kunci data yang dienkripsi di bawah kunci KMS enkripsi simetris yang Anda tentukan. Byte dalam kunci adalah acak; mereka tidak terkait dengan penelepon atau ke kunci KMS. Digunakan untuk mengurangi panggilan KMS yang harus dilakukan pelanggan.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html)— Mendekripsi ciphertext dan kemudian mengenkripsi ulang sepenuhnya di dalam. AWS KMS Anda dapat menggunakan operasi ini untuk mengubah kunci KMS di mana data dienkripsi, seperti ketika Anda [memutar kunci KMS secara manual](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html#rotate-keys-manually) atau mengubah kunci KMS yang melindungi ciphertext. Anda juga dapat menggunakannya untuk mengenkripsi ulang ciphertext di bawah kunci KMS yang sama, seperti untuk mengubah konteks [enkripsi](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) ciphertext.
Berikut ini adalah contoh pernyataan kebijakan yang dapat Anda tambahkan untuk Lokasi Amazon:
```
"Statement" : [
{
"Sid" : "Allow access to principals authorized to use AWS Glue Data Quality",
"Effect" : "Allow",
"Principal" : {
"AWS": "arn:aws:iam:::role/ExampleRole"
},
"Action" : [
"kms:Decrypt",
"kms:DescribeKey",
"kms:GenerateDataKeyWithoutPlaintext",
"kms:ReEncrypt*"
],
"Resource" : "*",
"Condition" : {
"StringEquals" : {
"kms:ViaService" : "glue.amazonaws.com",
"kms:CallerAccount" : "111122223333"
}
},
{
"Sid": "Allow access for key administrators",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action" : [
"kms:*"
],
"Resource": "arn:aws:kms:region:111122223333:key/key_ID"
},
{
"Sid" : "Allow read-only access to key metadata to the account",
"Effect" : "Allow",
"Principal" : {
"AWS" : "arn:aws:iam::111122223333:root"
},
"Action" : [
"kms:Describe*",
"kms:Get*",
"kms:List*",
],
"Resource" : "*"
}
]
```
### Catatan tentang menggunakan Kunci KMS dalam Kualitas Data AWS Glue
AWS Glue Data Quality tidak mendukung transisi kunci. Ini berarti bahwa jika Anda mengenkripsi aset Kualitas Data Anda dengan Kunci A dan memutuskan untuk beralih ke Kunci B, kami tidak akan mengenkripsi ulang data yang dienkripsi dengan Kunci A untuk menggunakan Kunci B. Anda masih dapat beralih ke Kunci B, tetapi perlu mempertahankan akses ke Kunci A untuk mengakses data yang sebelumnya dienkripsi dengan Kunci A.
Untuk informasi selengkapnya tentang menentukan izin dalam kebijakan, lihat [Izin untuk AWS layanan dalam kebijakan utama di Panduan Pengembang](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-services.html) AWS Key Management Service .
Untuk informasi selengkapnya tentang akses kunci pemecahan masalah, lihat [Memecahkan masalah akses kunci](https://docs.aws.amazon.com/kms/latest/developerguide/policy-evaluation.html) di Panduan Pengembang. AWS Key Management Service
## Membuat konfigurasi keamanan
Di AWS Glue, [sumber daya Konfigurasi Keamanan](encryption-security-configuration.md) berisi properti yang diperlukan saat Anda menulis data terenkripsi.
**Untuk mengenkripsi aset kualitas data Anda:**
1. Di **Pengaturan enkripsi**, di bawah **Pengaturan lanjutan**, pilih **Aktifkan Enkripsi Kualitas Data**
1. Pilih tombol KMS Anda atau pilih **Buat AWS KMS ** kunci
![\[Tangkapan layar menunjukkan halaman Tambahkan konfigurasi keamanan. Opsi DataQuality Enkripsi Aktifkan dipilih.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/data-quality-add-security-configuration.png)
## AWS Konteks enkripsi Kualitas Data Glue
[Konteks enkripsi](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) adalah kumpulan opsional pasangan kunci-nilai yang berisi informasi kontekstual tambahan tentang data.
AWS KMS menggunakan konteks enkripsi sebagai [data otentikasi tambahan](https://docs.aws.amazon.com/crypto/latest/userguide/cryptography-concepts.html#term-aad) untuk mendukung enkripsi yang [diautentikasi.](https://docs.aws.amazon.com/crypto/latest/userguide/cryptography-concepts.html#term-aad) Bila Anda menyertakan konteks enkripsi dalam permintaan untuk mengenkripsi data, AWS KMS mengikat konteks enkripsi ke data terenkripsi. Untuk mendekripsi data, Anda menyertakan konteks enkripsi yang sama dalam permintaan.
### AWS Contoh konteks enkripsi Glue Data Quality
```
"encryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "beacon:ACTIVE"
}
```
### Menggunakan konteks enkripsi untuk pemantauan
Saat Anda menggunakan kunci terkelola pelanggan simetris untuk mengenkripsi pelacak atau koleksi geofence, Anda juga dapat menggunakan konteks enkripsi dalam catatan audit dan log untuk mengidentifikasi bagaimana kunci yang dikelola pelanggan digunakan. Konteks enkripsi juga muncul di log yang dihasilkan oleh AWS CloudTrail atau Amazon CloudWatch Logs.
## Memantau kunci enkripsi Anda untuk AWS Glue Data Quality
Saat Anda menggunakan kunci yang dikelola AWS KMS pelanggan dengan sumber daya Kualitas Data AWS Glue Anda, Anda dapat menggunakan AWS CloudTrail atau Amazon CloudWatch Logs melacak permintaan yang AWS dikirimkan oleh Glue Data Quality AWS KMS.
Contoh berikut adalah AWS CloudTrail peristiwa untuk `GenerateDataKeyWithoutPlainText` dan `Decrypt` untuk memantau operasi KMS yang dipanggil oleh AWS Glue Data Quality untuk mengakses data yang dienkripsi oleh kunci yang dikelola pelanggan Anda.
**Dekripsi**
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"arn": "arn:aws:sts::111122223333:role/CustomerRole",
"accountId": "111122223333",
"invokedBy": "glue.amazonaws.com"
},
"eventTime": "2024-07-02T20:03:10Z",
"eventSource": "kms.amazonaws.com",
"eventName": "Decrypt",
"awsRegion": "us-east-1",
"sourceIPAddress": "glue.amazonaws.com",
"userAgent": "glue.amazonaws.com",
"requestParameters": {
"keyId": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"encryptionAlgorithm": "SYMMETRIC_DEFAULT",
"encryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:ACTIVE",
"version": "branch:version:ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE"
}
},
"responseElements": null,
"requestID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"eventID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"eventCategory": "Management"
}
```
**GenerateDataKeyWithoutPlaintext**
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"arn": "arn:aws:sts::111122223333:role/CustomerRole",
"accountId": "111122223333",
"invokedBy": "glue.amazonaws.com"
},
"eventTime": "2024-07-02T20:03:10Z",
"eventSource": "kms.amazonaws.com",
"eventName": "GenerateDataKeyWithoutPlaintext",
"awsRegion": "us-east-1",
"sourceIPAddress": "glue.amazonaws.com",
"userAgent": "glue.amazonaws.com",
"requestParameters": {
"keyId": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"encryptionAlgorithm": "SYMMETRIC_DEFAULT",
"encryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:version:ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE"
}
},
"responseElements": null,
"requestID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"eventID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"eventCategory": "Management"
}
```
**ReEncyrpt**
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"arn": "arn:aws:sts::111122223333:role/CustomerRole",
"accountId": "111122223333",
"invokedBy": "glue.amazonaws.com"
},
"eventTime": "2024-07-17T21:34:41Z",
"eventSource": "kms.amazonaws.com",
"eventName": "ReEncrypt",
"awsRegion": "us-east-1",
"sourceIPAddress": "glue.amazonaws.com",
"userAgent": "glue.amazonaws.com",
"requestParameters": {
"destinationEncryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:ACTIVE"
"version": "branch:version:12345678-SAMPLE"
},
"destinationKeyId": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"sourceAAD": "1234567890-SAMPLE+Z+lqoYOHj7VtWxJLrvh+biUFbliYDAQkobM=",
"sourceKeyId": "arn:aws:kms:ap-southeast-2:585824196334:key/17ca05ca-a8c1-40d7-b7fd-30abb569a53a",
"destinationEncryptionAlgorithm": "SYMMETRIC_DEFAULT",
"sourceEncryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:version:ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE"
},
"destinationAAD": "1234567890-SAMPLE",
"sourceEncryptionAlgorithm": "SYMMETRIC_DEFAULT"
},
"responseElements": null,
"requestID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"eventID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
},
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"eventCategory": "Management"
}
```
## Pelajari selengkapnya
Sumber daya berikut memberikan informasi lebih lanjut tentang enkripsi data saat istirahat.
+ Untuk informasi selengkapnya tentang [konsep AWS Key Management Service dasar](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html), lihat Panduan AWS Key Management Service Pengembang.
+ Untuk informasi selengkapnya tentang [praktik terbaik Keamanan](https://docs.aws.amazon.com/kms/latest/developerguide/best-practices.html), AWS Key Management Service lihat Panduan AWS Key Management Service Pengembang.
# Memecahkan masalah kesalahan Kualitas Data AWS Glue
Jika Anda menemukan kesalahan dalam Kualitas Data AWS Glue, gunakan solusi berikut untuk membantu Anda menemukan sumber masalah dan memperbaikinya.
**Contents**
+ [
## Kesalahan: modul Kualitas Data AWS Glue hilang
](#data-quality-trouble-error-1)
+ [
## Kesalahan: izin AWS Lake Formation tidak mencukupi
](#data-quality-trouble-error-2)
+ [
## Kesalahan: rulesets tidak diberi nama unik
](#data-quality-trouble-error-3)
+ [
## Kesalahan: tabel dengan karakter khusus
](#data-quality-trouble-error-4)
+ [
## Kesalahan: kesalahan overflow dengan kumpulan aturan besar
](#data-quality-trouble-error-5)
+ [
## Kesalahan: status aturan keseluruhan gagal
](#data-quality-trouble-error-6)
+ [
## AnalysisException: Tidak dapat memverifikasi keberadaan basis data default
](#data-quality-trouble-error-7)
+ [
## Pesan Kesalahan: Peta kunci yang disediakan tidak cocok untuk bingkai data yang diberikan
](#data-quality-trouble-error-8)
+ [
## Pengecualian di Kelas Pengguna: java.lang. RuntimeException : Gagal mengambil data. Periksa log masuk CloudWatch untuk mendapatkan detail lebih lanjut
](#data-quality-trouble-error-9)
+ [
## LAUNCH ERROR: Kesalahan mengunduh dari S3 untuk ember
](#data-quality-trouble-error-10)
+ [
## InvalidInputException (status: 400): DataQuality aturan tidak dapat diuraikan
](#data-quality-trouble-error-11)
+ [
## Kesalahan: Eventbridge tidak memicu pekerjaan Glue DQ berdasarkan jadwal yang saya siapkan
](#data-quality-trouble-error-12)
+ [
## Kesalahan CustomSQL
](#data-quality-trouble-error-13)
+ [
## Aturan Dinamis
](#data-quality-trouble-error-14)
+ [
## Pengecualian di Kelas Pengguna: org.apache.spark.sql. AnalysisException: org.apache.hadoop.hive.ql.metadata. HiveException
](#data-quality-trouble-error-15)
+ [
## UNCLASSIFIED\$1ERROR; IllegalArgumentException: Kesalahan Penguraian: Tidak ada aturan atau penganalisis yang disediakan., tidak ada alternatif yang layak pada input
](#data-quality-trouble-error-16)
## Kesalahan: modul Kualitas Data AWS Glue hilang
**Pesan kesalahan**: Tidak ada modul bernama 'awsgluedq'.
**Resolusi**: Kesalahan ini terjadi ketika Anda menjalankan AWS Glue Data Quality dalam versi yang tidak didukung. AWS Glue Data Quality hanya didukung di Glue versi 3.0 dan yang lebih baru.
## Kesalahan: izin AWS Lake Formation tidak mencukupi
**Pesan kesalahan**: Pengecualian di Kelas Pengguna:: Izin Lake Formation tidak mencukupi pada impact\$1sdg\$1involvement (Layanan`com.amazonaws.services.glue.model.AccessDeniedException`:; Kode Status: 400; Kode Kesalahan:AWS Glue; ID Permintaan: 465ae693-b7ba-4df0-a4e4-6b17xxxxxxxx AccessDeniedException; Proxy: null).
**Resolusi**: Anda harus memberikan izin yang cukup di AWS Lake Formation.
## Kesalahan: rulesets tidak diberi nama unik
**Pesan kesalahan**: Pengecualian di Kelas Pengguna:... services.glue.model. AlreadyExistsException: Aturan lain dengan nama yang sama sudah ada.
**Resolusi**: Aturan bersifat global dan harus unik.
## Kesalahan: tabel dengan karakter khusus
**Pesan galat**: Pengecualian di Kelas Pengguna: org.apache.spark.sql. AnalysisException: tidak dapat menyelesaikan kolom masukan “C” yang diberikan: [primary.data\$1end\$1time, primary.data\$1start\$1time, primary.end\$1time, primary.last\$1updated, primary.message, primary.process\$1date, primary.rowhash, primary.run\$1by, primary.run\$1id, primary.start\$1time, primary.status]; baris 1 pos 44;.
**Resolusi**: Ada batasan saat ini bahwa AWS Glue Data Quality tidak dapat dijalankan pada tabel yang memiliki karakter khusus seperti “.”.
## Kesalahan: kesalahan overflow dengan kumpulan aturan besar
**Pesan galat**: Pengecualian di Kelas Pengguna: java.lang. StackOverflowError.
**Resolusi**: Jika Anda memiliki aturan besar lebih dari aturan 2K, Anda mungkin mengalami masalah ini. Pecahkan aturan Anda menjadi beberapa aturan.
## Kesalahan: status aturan keseluruhan gagal
**Kondisi kesalahan**: Set Aturan Saya berhasil, tetapi status aturan keseluruhan saya gagal.
**Resolusi**: Kesalahan ini kemungkinan besar terjadi karena Anda memilih opsi untuk menerbitkan metrik ke Amazon CloudWatch saat menerbitkan. Jika kumpulan data Anda ada dalam VPC, VPC Anda mungkin tidak mengizinkan AWS Glue mempublikasikan metrik ke Amazon. CloudWatch Dalam hal ini, Anda> harus menyiapkan titik akhir untuk VPC Anda untuk mengakses Amazon. CloudWatch
## AnalysisException: Tidak dapat memverifikasi keberadaan basis data default
**Kondisi kesalahan**: AnalysisException: Tidak dapat memverifikasi keberadaan database default: com.amazonaws.services.glue.model. AccessDeniedException: Izin Lake Formation tidak mencukupi secara default (Layanan:AWS Glue; Kode Status: 400; Kode Kesalahan:; ID Permintaan: XXXXXXXX-XXXX-XXXX-XXXX -XXXXXXXXXXXX AccessDeniedException; Proxy: null)
**Resolusi**: Dalam integrasi katalog AWS Glue pekerjaan, AWS Glue selalu mencoba untuk memeriksa apakah database default ada atau tidak menggunakan AWS Glue`GetDatabase API`. Ketika izin `DESCRIBE` Lake Formation tidak diberikan, atau `GetDatabase IAM` izin diberikan, maka pekerjaan gagal saat memverifikasi keberadaan database default.
Untuk menyelesaikan:
1. Tambahkan `DESCRIBE` izin di Lake Formation untuk database default.
1. Konfigurasikan peran IAM yang dilampirkan ke AWS Glue pekerjaan sebagai Pembuat Database di Lake Formation. Ini akan secara otomatis membuat database default dan memberikan izin Lake Formation yang diperlukan untuk peran tersebut.
1. Nonaktifkan `--enable-data-catalog` opsi. (Ini ditampilkan sebagai **Use Data Catalog as the Hive metastore** di). AWS Glue Studio
Jika Anda tidak memerlukan Data Catalog integrasi Spark SQL dalam pekerjaan, Anda dapat menonaktifkannya.
## Pesan Kesalahan: Peta kunci yang disediakan tidak cocok untuk bingkai data yang diberikan
**Kondisi kesalahan**: Peta kunci yang disediakan tidak cocok untuk bingkai data yang diberikan.
**Resolusi**: Anda menggunakan **DataSetMatch**ruletype dan tombol join memiliki duplikat. Kunci bergabung Anda harus unik dan tidak boleh NULL. Jika Anda tidak dapat memiliki kunci gabungan yang unik, pertimbangkan untuk menggunakan tipe aturan lain seperti **AggregateMatch**untuk mencocokkan data ringkasan.
## Pengecualian di Kelas Pengguna: java.lang. RuntimeException : Gagal mengambil data. Periksa log masuk CloudWatch untuk mendapatkan detail lebih lanjut
**Kondisi kesalahan**: Pengecualian di Kelas Pengguna: java.lang. RuntimeException : Gagal mengambil data. Periksa log masuk CloudWatch untuk mendapatkan detail lebih lanjut.
**Resolusi**: Ini terjadi ketika Anda membuat aturan DQ pada tabel berbasis Amazon S3 yang dibandingkan dengan Amazon RDS atau. Amazon Redshift Dalam kasus ini, AWS Glue tidak dapat memuat koneksi. Sebagai gantinya, cobalah untuk mengatur aturan DQ pada Amazon Redshift atau kumpulan data Amazon RDS. Ini adalah bug yang diketahui.
## LAUNCH ERROR: Kesalahan mengunduh dari S3 untuk ember
**Kondisi kesalahan**: LAUNCH ERROR: Kesalahan mengunduh dari S3 untuk ember:`aws-glue-ml-data-quality-assets-us-east-1, key: jars/aws-glue-ml-data-quality-etl.jar.Access Denied (Service: Amazon S3; Status Code: 403; Please refer logs for details) `.
**Resolusi**: Izin dalam peran yang diteruskan ke AWS Glue Data Quality harus mengizinkan pembacaan dari lokasi Amazon S3 sebelumnya. Kebijakan IAM ini harus dilampirkan pada peran:
```
{
"Sid": "allowS3",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::aws-glue-ml-data-quality-assets-/*"
}
```
Lihat [otorisasi Kualitas Data](https://docs.aws.amazon.com/glue/latest/dg/data-quality-authorization.html) untuk izin terperinci. Pustaka ini diperlukan untuk mengevaluasi kualitas data untuk kumpulan data Anda.
## InvalidInputException (status: 400): DataQuality aturan tidak dapat diuraikan
**Kondisi kesalahan**: InvalidInputException (status: 400): DataQuality aturan tidak dapat diuraikan.
**Resolusi**: Ada banyak kemungkinan untuk kesalahan ini. Salah satu kemungkinan adalah bahwa aturan Anda mungkin memiliki tanda kutip tunggal. Verifikasi bahwa mereka berada dalam tanda kutip ganda. Contoh:
```
Rules = [
ColumnValues "tipo_vinculo" in ["CODO", "DOCO", "COCO", "DODO"] AND "categoria" = 'ES"
AND "cod_bandera" = 'CEP'
```
Ubah ini menjadi:
```
Rules = [
(ColumnValues "tipovinculo" in [ "CODO", "DOCO", "COCO", "DODO"]) AND (ColumnValues "categoria" = "ES")
AND (ColumnValues "codbandera" = "CEP")
]
```
## Kesalahan: Eventbridge tidak memicu pekerjaan Glue DQ berdasarkan jadwal yang saya siapkan
**Kondisi kesalahan**: Eventbridge tidak AWS Glue Data Quality memicu pekerjaan berdasarkan jadwal yang saya siapkan.
**Resolusi**: Peran yang memicu pekerjaan mungkin tidak memiliki izin yang tepat. Pastikan bahwa peran yang Anda gunakan untuk memulai pekerjaan memiliki izin yang disebutkan dalam [penyiapan IAM yang diperlukan untuk evaluasi penjadwalan berjalan](https://docs.aws.amazon.com/glue/latest/dg/data-quality-authorization.html#data-quality-iam-setup-evaluation-runs).
## Kesalahan CustomSQL
**Kondisi kesalahan**:` The output from CustomSQL must contain at least one column that matches the input dataset for AWS Glue Data Quality to provide row level results. The SQL query is a valid query but no columns from the SQL result are present in the Input Dataset. Ensure that matching columns are returned from the SQL`.
**Resolusi**: Kueri SQL valid tetapi verifikasi bahwa Anda hanya memilih kolom dari tabel utama. Memilih fungsi agregat seperti jumlah, mengandalkan kolom dari primer dapat mengakibatkan kesalahan ini.
**Kondisi kesalahan**:` There was a problem when executing your SQL statement: cannot resolve "Col"`.
**Resolusi**: Kolom ini tidak ada di tabel utama.
**Kondisi kesalahan**:` The columns that are returned from the SQL statement should only belong to the primary table. "In this case, some columns ( Col ) belong to reference table"`.
**Resolusi**: Dalam kueri SQL saat Anda bergabung dengan tabel primer dengan tabel referensi lainnya, verifikasi bahwa pernyataan pilih Anda hanya memiliki nama kolom dari tabel utama Anda untuk menghasilkan hasil tingkat baris untuk tabel utama.
## Aturan Dinamis
**Kondisi kesalahan**`: Dynamic rules require job context, and cannot be evaluated in interactive session or data preview.`.
**Penyebab:** Pesan galat ini mungkin muncul di hasil pratinjau data Anda, atau di sesi interaktif lainnya, saat aturan DQ dinamis ada di kumpulan aturan Anda. Aturan dinamis mengacu pada metrik historis yang terkait dengan nama pekerjaan dan konteks evaluasi tertentu, sehingga tidak dapat dievaluasi dalam sesi interaktif.
**Resolusi**: Menjalankan AWS Glue pekerjaan Anda akan menghasilkan metrik historis, yang dapat direferensikan dalam pekerjaan selanjutnya untuk pekerjaan yang sama.
**Kondisi kesalahan**:
+ ` [RuleType] rule only supports simple atomic operands in thresholds.`.
+ `Function last not yet implemented for [RuleType] rule.`
**Resolusi**[: Aturan dinamis umumnya didukung untuk semua tipe aturan DQDL dalam ekspresi numerik (lihat Referensi DQDL).](dqdl.md) Namun, beberapa aturan yang menghasilkan beberapa metrik, ColumnValues dan ColumnLength, belum didukung.
**Kondisi kesalahan**:` Binary expression operands must resolve to a single number.`.
**Penyebab**: Aturan dinamis mendukung ekspresi biner, seperti`RowCount > avg(last(5)) * 0.9`. Di sini, ekspresi biner adalah`avg(last(5)) * 0.9`. Aturan ini valid karena kedua operan `avg(last(5))` dan `0.9` penyelesaian ke nomor tunggal. Contoh yang salah adalah`RowCount > last(5) * 0.9`, karena `last(5)` akan menghasilkan daftar yang tidak dapat dibandingkan secara bermakna dengan jumlah baris saat ini.
**Resolusi**: Gunakan fungsi agregasi untuk mengurangi operan bernilai daftar menjadi satu nomor.
**Kondisi kesalahan**:
+ `Rule threshold results in list, and a single value is expected. Use aggregation functions to produce a single value. Valid example: sum(last(10)), avg(last(10)).`
+ `Rule threshold results in empty list, and a single value is expected.`
**Penyebab**: Aturan dinamis dapat digunakan untuk membandingkan beberapa fitur kumpulan data Anda dengan nilai historisnya. Fungsi terakhir memungkinkan untuk pengambilan beberapa nilai historis, jika argumen integer positif disediakan. Misalnya, `last(5)` akan mengambil lima nilai terbaru terakhir yang diamati dalam menjalankan pekerjaan untuk aturan Anda.
**Resolusi**: Fungsi agregasi harus digunakan untuk mengurangi nilai-nilai ini menjadi satu angka untuk membuat perbandingan yang berarti dengan nilai yang diamati dalam menjalankan pekerjaan saat ini.
Contoh yang valid:
+ `RowCount >= avg(last(5))`
+ `RowCount > last(1)`
+ `RowCount < last()`
Contoh tidak valid:. `RowCount > last(5)`
**Kondisi kesalahan**:
+ `Function index used in threshold requires positive integer argument.`
+ `Index argument must be an integer. Valid syntax example: RowCount > index(last(10, 2)), which means RowCount must be greater than third most recent execution from last 10 job runs.`
**Resolusi**: Saat membuat aturan dinamis, Anda dapat menggunakan fungsi `index` agregasi untuk memilih satu nilai historis dari daftar. Misalnya`RowCount > index(last(5)`, 1) akan memeriksa apakah jumlah baris yang diamati dalam pekerjaan saat ini benar-benar lebih besar daripada jumlah baris terbaru kedua yang diamati untuk pekerjaan Anda. `index`diindeks nol.
**Kondisi kesalahan**:` IllegalArgumentException: Parsing Error: Rule Type: DetectAnomalies is not valid`.
**Resolusi**: Deteksi anomali hanya tersedia di AWS Glue 4.0.
**Kondisi kesalahan**:` IllegalArgumentException: Parsing Error: Unexpected condition for rule of type ... no viable alternative at input ...`.
Catatan: `...` dinamis. Contoh:`IllegalArgumentException: Parsing Error: Unexpected condition for rule of type RowCount with number return type, line 4:19 no viable alternative at input '>last'`.
**Resolusi**: Deteksi anomali hanya tersedia di AWS Glue 4.0.
## Pengecualian di Kelas Pengguna: org.apache.spark.sql. AnalysisException: org.apache.hadoop.hive.ql.metadata. HiveException
**Kondisi kesalahan** `: Exception in User Class: org.apache.spark.sql.AnalysisException: org.apache.hadoop.hive.ql.metadata.HiveException: Unable to fetch table mailpiece_submitted. StorageDescriptor#InputFormat cannot be null for table: mailpiece_submitted (Service: null; Status Code: 0; Error Code: null; Request ID: null; Proxy: null)`
**Penyebab:** Anda menggunakan Apache Iceberg di AWS Glue Data Catalog dan atribut Format Input di AWS Glue Data Catalog kosong.
**Resolusi**: Masalah ini terjadi ketika Anda menggunakan CustomSQL ruletype dalam aturan DQ Anda. Salah satu cara untuk memperbaikinya adalah dengan menggunakan “primer “atau menambahkan nama katalog `glue_catalog.` ke`. in Custom ruletype`.
## UNCLASSIFIED\$1ERROR; IllegalArgumentException: Kesalahan Penguraian: Tidak ada aturan atau penganalisis yang disediakan., tidak ada alternatif yang layak pada input
**Kondisi kesalahan** `: UNCLASSIFIED_ERROR; IllegalArgumentException: Parsing Error: No rules or analyzers provided., no viable alternative at input`
**Resolusi**: DQDL tidak dapat diurai. Ada beberapa contoh di mana ini bisa terjadi. Jika Anda menggunakan aturan komposit, pastikan mereka memiliki tanda kurung yang tepat.
```
(RowCount >= avg(last(10)) * 0.6) and (RowCount <= avg(last(10)) * 1.4) instead of
RowCount >= avg(last(10)) * 0.6 and RowCount <= avg(last(10)) * 1.4
```