Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan kerangka kerja data lake dengan pekerjaan AWS Glue ETL
Kerangka kerja data lake sumber terbuka menyederhanakan pemrosesan data tambahan untuk file yang Anda simpan di danau data yang dibangun di Amazon S3. AWS Glue 3.0 dan yang lebih baru mendukung kerangka kerja data lake sumber terbuka berikut:
+ Apache Hudi
+ Yayasan Linux Delta Lake
+ Gunung Es Apache
Kami menyediakan dukungan asli untuk kerangka kerja ini sehingga Anda dapat membaca dan menulis data yang Anda simpan di Amazon S3 dengan cara yang konsisten secara transaksional. Tidak perlu menginstal konektor terpisah atau menyelesaikan langkah konfigurasi tambahan untuk menggunakan kerangka kerja ini dalam pekerjaan AWS Glue ETL.
Saat Anda mengelola kumpulan data melalui AWS Glue Data Catalog, Anda dapat menggunakan AWS Glue metode untuk membaca dan menulis tabel danau data dengan Spark. DataFrames Anda juga dapat membaca dan menulis data Amazon S3 menggunakan Spark API DataFrame .
Dalam video ini, Anda dapat mempelajari dasar-dasar cara kerja Apache Hudi, Apache Iceberg, dan Delta Lake. Anda akan melihat cara menyisipkan, memperbarui, dan menghapus data di danau data Anda dan cara kerja masing-masing kerangka kerja ini.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/fryfx0Zg7KA)
**Topics**
+ [Batasan](aws-glue-programming-etl-datalake-native-frameworks-limitations.md)
+ [Menggunakan kerangka Hudi di Glue AWS](aws-glue-programming-etl-format-hudi.md)
+ [Menggunakan kerangka Delta Lake di AWS Glue](aws-glue-programming-etl-format-delta-lake.md)
+ [Menggunakan kerangka Iceberg di Glue AWS](aws-glue-programming-etl-format-iceberg.md)
# Batasan
Pertimbangkan batasan berikut sebelum Anda menggunakan kerangka kerja data lake dengan AWS Glue.
+ AWS Glue `GlueContext`Metode berikut untuk DynamicFrame tidak mendukung membaca dan menulis tabel kerangka data lake. Gunakan `GlueContext` metode untuk DataFrame atau Spark DataFrame API sebagai gantinya.
+ `create_dynamic_frame.from_catalog`
+ `write_dynamic_frame.from_catalog`
+ `getDynamicFrame`
+ `writeDynamicFrame`
+ `GlueContext`Metode berikut ini DataFrame didukung dengan kontrol izin Lake Formation:
+ `create_data_frame.from_catalog`
+ `write_data_frame.from_catalog`
+ `getDataFrame`
+ `writeDataFrame`
+ [Pengelompokan file kecil](grouping-input-files.md) tidak didukung.
+ [Bookmark Job](monitor-continuations.md) tidak didukung.
+ Apache Hudi 0.10.1 untuk AWS Glue 3.0 tidak mendukung tabel Hudi Merge on Read (MoR).
+ `ALTER TABLE … RENAME TO`tidak tersedia untuk Apache Iceberg 0.13.1 untuk 3.0. AWS Glue
## Batasan untuk tabel format danau data yang dikelola oleh izin Lake Formation
Format data lake terintegrasi dengan AWS Glue ETL melalui izin Lake Formation. Membuat DynamicFrame penggunaan `create_dynamic_frame` tidak didukung. Untuk informasi selengkapnya, lihat contoh berikut ini:
+ [Contoh: Membaca dan menulis tabel Gunung Es dengan kontrol izin Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-iceberg.html#aws-glue-programming-etl-format-iceberg-read-write-lake-formation-tables)
+ [Contoh: Membaca dan menulis tabel Hudi dengan kontrol izin Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-hudi.html#aws-glue-programming-etl-format-hudi-read-write-lake-formation-tables)
+ [Contoh: Membaca dan menulis tabel Delta Lake dengan kontrol izin Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-delta-lake.html#aws-glue-programming-etl-format-delta-lake-read-write-lake-formation-tables)
**catatan**
Integrasi dengan AWS Glue ETL melalui izin Lake Formation untuk Apache Hudi, Apache Iceberg, dan Delta Lake hanya didukung di versi 4.0. AWS Glue
Apache Iceberg memiliki integrasi terbaik dengan AWS Glue ETL melalui izin Lake Formation. Ini mendukung hampir semua operasi dan termasuk dukungan SQL.
Hudi mendukung sebagian besar operasi dasar dengan pengecualian operasi administratif. Hal ini karena pilihan ini umumnya dilakukan melalui penulisan dataframes dan ditentukan melalui. `additional_options` Anda perlu menggunakan AWS Glue APIs DataFrames untuk membuat operasi Anda karena SparkSQL tidak didukung.
Delta Lake hanya mendukung pembacaan dan penambahan dan penimpaan data tabel. Delta Lake membutuhkan penggunaan perpustakaan mereka sendiri untuk dapat melakukan berbagai tugas seperti pembaruan.
Fitur berikut tidak tersedia untuk tabel Iceberg yang dikelola oleh izin Lake Formation.
+ Pemadatan menggunakan AWS Glue ETL
+ Dukungan Spark SQL melalui ETL AWS Glue
Berikut ini adalah batasan tabel Hudi yang dikelola oleh izin Lake Formation:
+ Penghapusan file yatim piatu
Berikut ini adalah batasan tabel Delta Lake yang dikelola oleh izin Lake Formation:
+ Semua fitur selain memasukkan dan membaca dari tabel Delta Lake.
# Menggunakan kerangka Hudi di Glue AWS
AWS Glue 3.0 dan yang lebih baru mendukung kerangka Apache Hudi untuk data lake. Hudi adalah kerangka penyimpanan data lake sumber terbuka yang menyederhanakan pemrosesan data tambahan dan pengembangan pipa data. Topik ini mencakup fitur yang tersedia untuk menggunakan data Anda di AWS Glue saat Anda mengangkut atau menyimpan data Anda dalam tabel Hudi. Untuk mempelajari lebih lanjut tentang Hudi, lihat dokumentasi resmi [Apache Hudi](https://hudi.apache.org/docs/overview/).
Anda dapat menggunakan AWS Glue untuk melakukan operasi baca dan tulis pada tabel Hudi di Amazon S3, atau bekerja dengan tabel Hudi menggunakan Katalog Data AWS Glue. Operasi tambahan termasuk insert, update, dan semua [operasi Apache Spark](https://hudi.apache.org/docs/quick-start-guide/) juga didukung.
**catatan**
[Implementasi Apache Hudi 0.15.0 di AWS Glue 5.0 secara internal mengembalikan HUDI-7001.](https://github.com/apache/hudi/pull/9936) Itu tidak menunjukkan regresi yang terkait dengan gen Kunci Kompleks ketika kunci catatan terdiri dari satu bidang. Namun perilaku ini berbeda dari OSS Apache Hudi 0.15.0.
Apache Hudi 0.10.1 untuk AWS Glue 3.0 tidak mendukung tabel Hudi Merge on Read (MoR).
Tabel berikut mencantumkan versi Hudi yang disertakan dalam setiap versi AWS Glue.
****
| AWS Versi Glue | Versi Hudi yang didukung |
| --- | --- |
| 5.1 | 1.0.2 |
| 5.0 | 0.15.0 |
| 4.0 | 0.12.1 |
| 3.0 | 0.10.1 |
Untuk mempelajari lebih lanjut tentang framework data lake yang didukung AWS Glue, lihat[Menggunakan kerangka kerja data lake dengan pekerjaan AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
## Mengaktifkan Hudi
Untuk mengaktifkan Hudi for AWS Glue, selesaikan tugas-tugas berikut:
+ Tentukan `hudi` sebagai nilai untuk parameter `--datalake-formats` pekerjaan. Untuk informasi selengkapnya, lihat [Menggunakan parameter pekerjaan dalam pekerjaan AWS Glue](aws-glue-programming-etl-glue-arguments.md).
+ Buat kunci bernama `--conf` untuk pekerjaan AWS Glue Anda, dan atur ke nilai berikut. Atau, Anda dapat mengatur konfigurasi berikut menggunakan `SparkConf` skrip Anda. Pengaturan ini membantu Apache Spark menangani tabel Hudi dengan benar.
```
spark.serializer=org.apache.spark.serializer.KryoSerializer
```
+ Dukungan izin Lake Formation untuk Hudi diaktifkan secara default untuk AWS Glue 4.0. Tidak diperlukan konfigurasi tambahan reading/writing untuk tabel Hudi yang terdaftar di Lake Formation. Untuk membaca tabel Hudi terdaftar, peran IAM AWS Glue job harus memiliki izin SELECT. Untuk menulis ke tabel Hudi terdaftar, peran IAM pekerjaan AWS Glue harus memiliki izin SUPER. Untuk mempelajari lebih lanjut tentang mengelola izin Lake Formation, lihat [Memberikan dan mencabut izin](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html) pada sumber daya Katalog Data.
**Menggunakan versi Hudi yang berbeda**
Untuk menggunakan versi Hudi yang tidak didukung AWS Glue, tentukan file Hudi JAR Anda sendiri menggunakan parameter `--extra-jars` pekerjaan. Jangan sertakan `hudi` sebagai nilai untuk parameter `--datalake-formats` pekerjaan. Jika Anda menggunakan AWS Glue 5.0 atau lebih tinggi, Anda harus mengatur parameter `--user-jars-first true` pekerjaan.
## Contoh: Tulis tabel Hudi ke Amazon S3 dan daftarkan di Katalog Data AWS Glue
Contoh skrip ini menunjukkan cara menulis tabel Hudi ke Amazon S3 dan mendaftarkan tabel ke Katalog Data AWS Glue. Contoh menggunakan [alat Hudi Hive Sync](https://hudi.apache.org/docs/syncing_metastore/) untuk mendaftarkan tabel.
**catatan**
Contoh ini mengharuskan Anda untuk mengatur parameter `--enable-glue-datacatalog` pekerjaan untuk menggunakan Katalog Data AWS Glue sebagai metastore Apache Spark Hive. Untuk mempelajari selengkapnya, lihat [Menggunakan parameter pekerjaan dalam pekerjaan AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
```
# Example: Create a Hudi table from a DataFrame
# and register the table to Glue Data Catalog
additional_options={
"hoodie.table.name": "",
"hoodie.database.name": "",
"hoodie.datasource.write.storage.type": "COPY_ON_WRITE",
"hoodie.datasource.write.operation": "upsert",
"hoodie.datasource.write.recordkey.field": "",
"hoodie.datasource.write.precombine.field": "",
"hoodie.datasource.write.partitionpath.field": "",
"hoodie.datasource.write.hive_style_partitioning": "true",
"hoodie.datasource.hive_sync.enable": "true",
"hoodie.datasource.hive_sync.database": "",
"hoodie.datasource.hive_sync.table": "",
"hoodie.datasource.hive_sync.partition_fields": "",
"hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc": "false",
"hoodie.datasource.hive_sync.mode": "hms",
"path": "s3://"
}
dataFrame.write.format("hudi") \
.options(**additional_options) \
.mode("overwrite") \
.save()
```
------
#### [ Scala ]
```
// Example: Example: Create a Hudi table from a DataFrame
// and register the table to Glue Data Catalog
val additionalOptions = Map(
"hoodie.table.name" -> "",
"hoodie.database.name" -> "",
"hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE",
"hoodie.datasource.write.operation" -> "upsert",
"hoodie.datasource.write.recordkey.field" -> "",
"hoodie.datasource.write.precombine.field" -> "",
"hoodie.datasource.write.partitionpath.field" -> "",
"hoodie.datasource.write.hive_style_partitioning" -> "true",
"hoodie.datasource.hive_sync.enable" -> "true",
"hoodie.datasource.hive_sync.database" -> "",
"hoodie.datasource.hive_sync.table" -> "",
"hoodie.datasource.hive_sync.partition_fields" -> "",
"hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc" -> "false",
"hoodie.datasource.hive_sync.mode" -> "hms",
"path" -> "s3://")
dataFrame.write.format("hudi")
.options(additionalOptions)
.mode("append")
.save()
```
------
## Contoh: Membaca tabel Hudi dari Amazon S3 menggunakan Katalog Data AWS Glue
Contoh ini membaca tabel Hudi yang Anda buat [Contoh: Tulis tabel Hudi ke Amazon S3 dan daftarkan di Katalog Data AWS Glue](#aws-glue-programming-etl-format-hudi-write) dari Amazon S3.
**catatan**
Contoh ini mengharuskan Anda untuk mengatur parameter `--enable-glue-datacatalog` pekerjaan untuk menggunakan Katalog Data AWS Glue sebagai metastore Apache Spark Hive. Untuk mempelajari selengkapnya, lihat [Menggunakan parameter pekerjaan dalam pekerjaan AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Untuk contoh ini, gunakan `GlueContext.create\$1data\$1frame.from\$1catalog()` metode ini.
```
# Example: Read a Hudi table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
dataFrame = glueContext.create_data_frame.from_catalog(
database = "",
table_name = ""
)
```
------
#### [ Scala ]
Untuk contoh ini, gunakan [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource)metode ini.
```
// Example: Read a Hudi table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dataFrame = glueContext.getCatalogSource(
database = "",
tableName = ""
).getDataFrame()
}
}
```
------
## Contoh: Perbarui dan masukkan `DataFrame` ke dalam tabel Hudi di Amazon S3
Contoh ini menggunakan AWS Glue Data Catalog untuk menyisipkan DataFrame ke dalam tabel Hudi yang Anda buat. [Contoh: Tulis tabel Hudi ke Amazon S3 dan daftarkan di Katalog Data AWS Glue](#aws-glue-programming-etl-format-hudi-write)
**catatan**
Contoh ini mengharuskan Anda untuk mengatur parameter `--enable-glue-datacatalog` pekerjaan untuk menggunakan Katalog Data AWS Glue sebagai metastore Apache Spark Hive. Untuk mempelajari selengkapnya, lihat [Menggunakan parameter pekerjaan dalam pekerjaan AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Untuk contoh ini, gunakan `GlueContext.write\$1data\$1frame.from\$1catalog()` metode ini.
```
# Example: Upsert a Hudi table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
glueContext.write_data_frame.from_catalog(
frame = dataFrame,
database = "",
table_name = "",
additional_options={
"hoodie.table.name": "",
"hoodie.database.name": "",
"hoodie.datasource.write.storage.type": "COPY_ON_WRITE",
"hoodie.datasource.write.operation": "upsert",
"hoodie.datasource.write.recordkey.field": "",
"hoodie.datasource.write.precombine.field": "",
"hoodie.datasource.write.partitionpath.field": "",
"hoodie.datasource.write.hive_style_partitioning": "true",
"hoodie.datasource.hive_sync.enable": "true",
"hoodie.datasource.hive_sync.database": "",
"hoodie.datasource.hive_sync.table": "",
"hoodie.datasource.hive_sync.partition_fields": "",
"hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc": "false",
"hoodie.datasource.hive_sync.mode": "hms"
}
)
```
------
#### [ Scala ]
Untuk contoh ini, gunakan [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink)metode ini.
```
// Example: Upsert a Hudi table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.JsonOptions
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getCatalogSink("", "",
additionalOptions = JsonOptions(Map(
"hoodie.table.name" -> "",
"hoodie.database.name" -> "",
"hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE",
"hoodie.datasource.write.operation" -> "upsert",
"hoodie.datasource.write.recordkey.field" -> "",
"hoodie.datasource.write.precombine.field" -> "",
"hoodie.datasource.write.partitionpath.field" -> "",
"hoodie.datasource.write.hive_style_partitioning" -> "true",
"hoodie.datasource.hive_sync.enable" -> "true",
"hoodie.datasource.hive_sync.database" -> "",
"hoodie.datasource.hive_sync.table" -> "",
"hoodie.datasource.hive_sync.partition_fields" -> "",
"hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc" -> "false",
"hoodie.datasource.hive_sync.mode" -> "hms"
)))
.writeDataFrame(dataFrame, glueContext)
}
}
```
------
## Contoh: Baca tabel Hudi dari Amazon S3 menggunakan Spark
Contoh ini membaca tabel Hudi dari Amazon S3 menggunakan Spark API. DataFrame
------
#### [ Python ]
```
# Example: Read a Hudi table from S3 using a Spark DataFrame
dataFrame = spark.read.format("hudi").load("s3://")
```
------
#### [ Scala ]
```
// Example: Read a Hudi table from S3 using a Spark DataFrame
val dataFrame = spark.read.format("hudi").load("s3://")
```
------
## Contoh: Tulis tabel Hudi ke Amazon S3 menggunakan Spark
Contoh ini menulis tabel Hudi ke Amazon S3 menggunakan Spark.
------
#### [ Python ]
```
# Example: Write a Hudi table to S3 using a Spark DataFrame
dataFrame.write.format("hudi") \
.options(**additional_options) \
.mode("overwrite") \
.save("s3://)
```
------
#### [ Scala ]
```
// Example: Write a Hudi table to S3 using a Spark DataFrame
dataFrame.write.format("hudi")
.options(additionalOptions)
.mode("overwrite")
.save("s3://")
```
------
## Contoh: Membaca dan menulis tabel Hudi dengan kontrol izin Lake Formation
Contoh ini membaca dan menulis tabel Hudi dengan kontrol izin Lake Formation.
1. Buat tabel Hudi dan daftarkan di Lake Formation.
1. Untuk mengaktifkan kontrol izin Lake Formation, Anda harus terlebih dahulu mendaftarkan tabel jalur Amazon S3 di Lake Formation. Untuk informasi selengkapnya, lihat [Mendaftarkan lokasi Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html). Anda dapat mendaftarkannya baik dari konsol Lake Formation atau dengan menggunakan AWS CLI:
```
aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region
```
Setelah Anda mendaftarkan lokasi Amazon S3, tabel AWS Glue apa pun yang menunjuk ke lokasi (atau lokasi turunannya) akan mengembalikan nilai `IsRegisteredWithLakeFormation` parameter sebagai true dalam panggilan. `GetTable`
1. Buat tabel Hudi yang menunjuk ke jalur Amazon S3 terdaftar melalui API kerangka data Spark:
```
hudi_options = {
'hoodie.table.name': table_name,
'hoodie.database.name': database_name,
'hoodie.datasource.write.storage.type': 'COPY_ON_WRITE',
'hoodie.datasource.write.recordkey.field': 'product_id',
'hoodie.datasource.write.table.name': table_name,
'hoodie.datasource.write.operation': 'upsert',
'hoodie.datasource.write.precombine.field': 'updated_at',
'hoodie.datasource.write.hive_style_partitioning': 'true',
'hoodie.upsert.shuffle.parallelism': 2,
'hoodie.insert.shuffle.parallelism': 2,
'path': ,
'hoodie.datasource.hive_sync.enable': 'true',
'hoodie.datasource.hive_sync.database': database_name,
'hoodie.datasource.hive_sync.table': table_name,
'hoodie.datasource.hive_sync.use_jdbc': 'false',
'hoodie.datasource.hive_sync.mode': 'hms'
}
df_products.write.format("hudi") \
.options(**hudi_options) \
.mode("overwrite") \
.save()
```
1. Berikan izin Formasi Lake untuk peran IAM pekerjaan AWS Glue. Anda dapat memberikan izin dari konsol Lake Formation, atau menggunakan AWS CLI. Untuk informasi selengkapnya, lihat [Memberikan izin tabel menggunakan konsol Lake Formation dan metode sumber daya bernama](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html)
1. Baca tabel Hudi yang terdaftar di Lake Formation. Kodenya sama dengan membaca tabel Hudi yang tidak terdaftar. Perhatikan bahwa peran IAM AWS Glue job harus memiliki izin SELECT agar pembacaan berhasil.
```
val dataFrame = glueContext.getCatalogSource(
database = "",
tableName = ""
).getDataFrame()
```
1. Tulis ke tabel Hudi yang terdaftar di Lake Formation. Kode ini sama dengan menulis ke tabel Hudi yang tidak terdaftar. Perhatikan bahwa peran IAM AWS Glue job harus memiliki izin SUPER agar penulisan berhasil.
```
glueContext.getCatalogSink("", "",
additionalOptions = JsonOptions(Map(
"hoodie.table.name" -> "",
"hoodie.database.name" -> "",
"hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE",
"hoodie.datasource.write.operation" -> "",
"hoodie.datasource.write.recordkey.field" -> "",
"hoodie.datasource.write.precombine.field" -> "",
"hoodie.datasource.write.partitionpath.field" -> "",
"hoodie.datasource.write.hive_style_partitioning" -> "true",
"hoodie.datasource.hive_sync.enable" -> "true",
"hoodie.datasource.hive_sync.database" -> "",
"hoodie.datasource.hive_sync.table" -> "",
"hoodie.datasource.hive_sync.partition_fields" -> "",
"hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc" -> "false",
"hoodie.datasource.hive_sync.mode" -> "hms"
)))
.writeDataFrame(dataFrame, glueContext)
```
# Menggunakan kerangka Delta Lake di AWS Glue
AWS Glue 3.0 dan yang lebih baru mendukung kerangka Linux Foundation Delta Lake. Delta Lake adalah kerangka penyimpanan data lake sumber terbuka yang membantu Anda melakukan transaksi ACID, menskalakan penanganan metadata, dan menyatukan streaming dan pemrosesan data batch. Topik ini mencakup fitur yang tersedia untuk menggunakan data Anda di AWS Glue saat Anda mengangkut atau menyimpan data Anda di tabel Delta Lake. Untuk mempelajari lebih lanjut tentang Danau Delta, lihat dokumentasi resmi [Danau Delta](https://docs.delta.io/latest/delta-intro.html).
Anda dapat menggunakan AWS Glue untuk melakukan operasi baca dan tulis pada tabel Delta Lake di Amazon S3, atau bekerja dengan tabel Delta Lake menggunakan AWS Glue Data Catalog. Operasi tambahan seperti insert, update, dan [Table batch read and write](https://docs.delta.io/0.7.0/api/python/index.html) juga didukung. Saat Anda menggunakan tabel Delta Lake, Anda juga memiliki opsi untuk menggunakan metode dari perpustakaan Delta Lake Python seperti. `DeltaTable.forPath` Untuk informasi lebih lanjut tentang perpustakaan Delta Lake Python, lihat dokumentasi Python Delta Lake.
Tabel berikut mencantumkan versi Delta Lake yang disertakan dalam setiap versi AWS Glue.
****
| AWS Versi Glue | Versi Delta Lake yang didukung |
| --- | --- |
| 5.1 | 3.3.2 |
| 5.0 | 3.3.0 |
| 4.0 | 2.1.0 |
| 3.0 | 1.0.0 |
Untuk mempelajari lebih lanjut tentang framework data lake yang didukung AWS Glue, lihat[Menggunakan kerangka kerja data lake dengan pekerjaan AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
## Mengaktifkan Delta Lake untuk Glue AWS
Untuk mengaktifkan Delta Lake for AWS Glue, selesaikan tugas-tugas berikut:
+ Tentukan `delta` sebagai nilai untuk parameter `--datalake-formats` pekerjaan. Untuk informasi selengkapnya, lihat [Menggunakan parameter pekerjaan dalam pekerjaan AWS Glue](aws-glue-programming-etl-glue-arguments.md).
+ Buat kunci bernama `--conf` untuk pekerjaan AWS Glue Anda, dan atur ke nilai berikut. Atau, Anda dapat mengatur konfigurasi berikut menggunakan `SparkConf` skrip Anda. Pengaturan ini membantu Apache Spark menangani tabel Delta Lake dengan benar.
```
spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension --conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog --conf spark.delta.logStore.class=org.apache.spark.sql.delta.storage.S3SingleDriverLogStore
```
+ Dukungan izin Lake Formation untuk tabel Delta diaktifkan secara default untuk AWS Glue 4.0. Tidak diperlukan konfigurasi tambahan reading/writing untuk tabel Delta yang terdaftar di Lake Formation. Untuk membaca tabel Delta terdaftar, peran IAM AWS Glue job harus memiliki izin SELECT. Untuk menulis ke tabel Delta terdaftar, peran IAM AWS Glue job harus memiliki izin SUPER. Untuk mempelajari lebih lanjut tentang mengelola izin Lake Formation, lihat [Memberikan dan mencabut izin](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html) pada sumber daya Katalog Data.
**Menggunakan versi Delta Lake yang berbeda**
Untuk menggunakan versi danau Delta yang tidak didukung AWS Glue, tentukan file JAR Delta Lake Anda sendiri menggunakan parameter `--extra-jars` pekerjaan. Jangan sertakan `delta` sebagai nilai untuk parameter `--datalake-formats` pekerjaan. Jika Anda menggunakan AWS Glue 5.0 atau lebih tinggi, Anda harus mengatur parameter `--user-jars-first true` pekerjaan. Untuk menggunakan pustaka Delta Lake Python dalam kasus ini, Anda harus menentukan file JAR perpustakaan menggunakan parameter pekerjaan`--extra-py-files`. Pustaka Python dikemas dalam file JAR Delta Lake.
## Contoh: Tulis tabel Delta Lake ke Amazon S3 dan daftarkan ke Katalog Data AWS Glue
Skrip AWS Glue ETL berikut menunjukkan cara menulis tabel Delta Lake ke Amazon S3 dan mendaftarkan tabel ke Katalog Data Glue. AWS
------
#### [ Python ]
```
# Example: Create a Delta Lake table from a DataFrame
# and register the table to Glue Data Catalog
additional_options = {
"path": "s3://"
}
dataFrame.write \
.format("delta") \
.options(**additional_options) \
.mode("append") \
.partitionBy("") \
.saveAsTable(".")
```
------
#### [ Scala ]
```
// Example: Example: Create a Delta Lake table from a DataFrame
// and register the table to Glue Data Catalog
val additional_options = Map(
"path" -> "s3://"
)
dataFrame.write.format("delta")
.options(additional_options)
.mode("append")
.partitionBy("")
.saveAsTable(".")
```
------
## Contoh: Baca tabel Delta Lake dari Amazon S3 menggunakan Katalog Data AWS Glue
Skrip AWS Glue ETL berikut membaca tabel Delta Lake yang Anda buat. [Contoh: Tulis tabel Delta Lake ke Amazon S3 dan daftarkan ke Katalog Data AWS Glue](#aws-glue-programming-etl-format-delta-lake-write)
------
#### [ Python ]
Untuk contoh ini, gunakan metode [create\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog).
```
# Example: Read a Delta Lake table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
Untuk contoh ini, gunakan [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource)metode ini.
```
// Example: Read a Delta Lake table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val df = glueContext.getCatalogSource("", "",
additionalOptions = additionalOptions)
.getDataFrame()
}
}
```
------
## Contoh: Masukkan `DataFrame` ke dalam tabel Delta Lake di Amazon S3 menggunakan AWS Glue Data Catalog
Contoh ini menyisipkan data ke dalam tabel Delta Lake yang Anda buat. [Contoh: Tulis tabel Delta Lake ke Amazon S3 dan daftarkan ke Katalog Data AWS Glue](#aws-glue-programming-etl-format-delta-lake-write)
**catatan**
Contoh ini mengharuskan Anda untuk mengatur parameter `--enable-glue-datacatalog` pekerjaan untuk menggunakan Katalog Data AWS Glue sebagai metastore Apache Spark Hive. Untuk mempelajari selengkapnya, lihat [Menggunakan parameter pekerjaan dalam pekerjaan AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Untuk contoh ini, gunakan metode [write\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_data_frame_from_catalog).
```
# Example: Insert into a Delta Lake table in S3 using Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
Untuk contoh ini, gunakan [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink)metode ini.
```
// Example: Insert into a Delta Lake table in S3 using Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getCatalogSink("", "",
additionalOptions = additionalOptions)
.writeDataFrame(dataFrame, glueContext)
}
}
```
------
## Contoh: Membaca tabel Delta Lake dari Amazon S3 menggunakan Spark API
Contoh ini membaca tabel Delta Lake dari Amazon S3 menggunakan Spark API.
------
#### [ Python ]
```
# Example: Read a Delta Lake table from S3 using a Spark DataFrame
dataFrame = spark.read.format("delta").load("s3://")
```
------
#### [ Scala ]
```
// Example: Read a Delta Lake table from S3 using a Spark DataFrame
val dataFrame = spark.read.format("delta").load("s3://")
```
------
## Contoh: Tulis tabel Delta Lake ke Amazon S3 menggunakan Spark
Contoh ini menulis tabel Delta Lake ke Amazon S3 menggunakan Spark.
------
#### [ Python ]
```
# Example: Write a Delta Lake table to S3 using a Spark DataFrame
dataFrame.write.format("delta") \
.options(**additional_options) \
.mode("overwrite") \
.partitionBy("")
.save("s3://")
```
------
#### [ Scala ]
```
// Example: Write a Delta Lake table to S3 using a Spark DataFrame
dataFrame.write.format("delta")
.options(additionalOptions)
.mode("overwrite")
.partitionBy("")
.save("s3://")
```
------
## Contoh: Membaca dan menulis tabel Delta Lake dengan kontrol izin Lake Formation
Contoh ini membaca dan menulis tabel Danau Delta dengan kontrol izin Lake Formation.
1. Buat tabel Delta dan daftarkan di Lake Formation
1. Untuk mengaktifkan kontrol izin Lake Formation, Anda harus terlebih dahulu mendaftarkan tabel jalur Amazon S3 di Lake Formation. Untuk informasi selengkapnya, lihat [Mendaftarkan lokasi Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html). Anda dapat mendaftarkannya baik dari konsol Lake Formation atau dengan menggunakan AWS CLI:
```
aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region
```
Setelah Anda mendaftarkan lokasi Amazon S3, tabel AWS Glue apa pun yang menunjuk ke lokasi (atau lokasi turunannya) akan mengembalikan nilai `IsRegisteredWithLakeFormation` parameter sebagai true dalam panggilan. `GetTable`
1. Buat tabel Delta yang menunjuk ke jalur Amazon S3 terdaftar melalui Spark:
**catatan**
Berikut ini adalah contoh Python.
```
dataFrame.write \
.format("delta") \
.mode("overwrite") \
.partitionBy("") \
.save("s3://")
```
Setelah data ditulis ke Amazon S3, gunakan crawler AWS Glue untuk membuat tabel katalog Delta baru. Untuk informasi selengkapnya, lihat [Memperkenalkan dukungan tabel Delta Lake asli dengan crawler AWS Glue](https://aws.amazon.com/blogs/big-data/introducing-native-delta-lake-table-support-with-aws-glue-crawlers/).
Anda juga dapat membuat tabel secara manual melalui AWS Glue `CreateTable` API.
1. Berikan izin Formasi Lake untuk peran IAM pekerjaan AWS Glue. Anda dapat memberikan izin dari konsol Lake Formation, atau menggunakan AWS CLI. Untuk informasi selengkapnya, lihat [Memberikan izin tabel menggunakan konsol Lake Formation dan metode sumber daya bernama](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html)
1. Baca tabel Delta yang terdaftar di Lake Formation. Kodenya sama dengan membaca tabel Delta yang tidak terdaftar. Perhatikan bahwa peran IAM AWS Glue job harus memiliki izin SELECT agar pembacaan berhasil.
```
# Example: Read a Delta Lake table from Glue Data Catalog
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
1. Tulis ke tabel Delta yang terdaftar di Lake Formation. Kode ini sama dengan menulis ke tabel Delta yang tidak terdaftar. Perhatikan bahwa peran IAM AWS Glue job harus memiliki izin SUPER agar penulisan berhasil.
Secara default AWS Glue menggunakan `Append` sebagai SaveMode. Anda dapat mengubahnya dengan mengatur opsi SaveMode di. `additional_options` Untuk informasi tentang dukungan SaveMode di tabel Delta, lihat [Menulis ke](https://docs.delta.io/latest/delta-batch.html#write-to-a-table) tabel.
```
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```
# Menggunakan kerangka Iceberg di Glue AWS
AWS Glue 3.0 dan yang lebih baru mendukung kerangka Apache Iceberg untuk data lake. Iceberg menyediakan format tabel kinerja tinggi yang bekerja seperti tabel SQL. Topik ini mencakup fitur yang tersedia untuk menggunakan data Anda di AWS Glue saat Anda mengangkut atau menyimpan data Anda dalam tabel Gunung Es. Untuk mempelajari lebih lanjut tentang Iceberg, lihat dokumentasi resmi [Apache](https://iceberg.apache.org/docs/latest/) Iceberg.
Anda dapat menggunakan AWS Glue untuk melakukan operasi baca dan tulis pada tabel Iceberg di Amazon S3, atau bekerja dengan tabel Iceberg menggunakan AWS Glue Data Catalog. Operasi tambahan termasuk insert dan semua [Spark Queries](https://iceberg.apache.org/docs/latest/spark-queries/) [Spark Writes juga didukung](https://iceberg.apache.org/docs/latest/spark-writes/). Pembaruan tidak didukung untuk tabel Iceberg.
**catatan**
`ALTER TABLE … RENAME TO`tidak tersedia untuk Apache Iceberg 0.13.1 untuk Glue 3.0. AWS
Tabel berikut mencantumkan versi Iceberg yang disertakan dalam setiap versi AWS Glue.
****
| AWS Versi Glue | Versi Iceberg yang didukung |
| --- | --- |
| 5.1 | 1.10.0 |
| 5.0 | 1.7.1 |
| 4.0 | 1.0.0 |
| 3.0 | 0.13.1 |
Untuk mempelajari lebih lanjut tentang framework data lake yang didukung AWS Glue, lihat[Menggunakan kerangka kerja data lake dengan pekerjaan AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
## Mengaktifkan kerangka Iceberg
Untuk mengaktifkan Iceberg for AWS Glue, selesaikan tugas-tugas berikut:
+ Tentukan `iceberg` sebagai nilai untuk parameter `--datalake-formats` pekerjaan. Untuk informasi selengkapnya, lihat [Menggunakan parameter pekerjaan dalam pekerjaan AWS Glue](aws-glue-programming-etl-glue-arguments.md).
+ Buat kunci bernama `--conf` untuk pekerjaan AWS Glue Anda, dan atur ke nilai berikut. Atau, Anda dapat mengatur konfigurasi berikut menggunakan `SparkConf` skrip Anda. Pengaturan ini membantu Apache Spark menangani tabel Iceberg dengan benar.
```
spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog
--conf spark.sql.catalog.glue_catalog.warehouse=s3:///
--conf spark.sql.catalog.glue_catalog.catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog
--conf spark.sql.catalog.glue_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO
```
Jika Anda membaca atau menulis ke tabel Gunung Es yang terdaftar di Lake Formation, ikuti panduan di [Menggunakan AWS Glue dengan AWS Lake Formation kontrol akses berbutir halus](security-lf-enable.md) AWS Glue 5.0 dan yang lebih baru. Di AWS Glue 4.0, tambahkan konfigurasi berikut untuk mengaktifkan dukungan Lake Formation.
```
--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true
--conf spark.sql.catalog.glue_catalog.glue.id=
```
Jika Anda menggunakan AWS Glue 3.0 dengan Iceberg 0.13.1, Anda harus mengatur konfigurasi tambahan berikut untuk menggunakan pengelola kunci Amazon DynamoDB untuk memastikan transaksi atom. AWS Glue 4.0 atau yang lebih baru menggunakan penguncian optimis secara default. Untuk informasi selengkapnya, lihat [AWS Integrasi Gunung Es dalam dokumentasi resmi Apache Iceberg](https://iceberg.apache.org/docs/latest/aws/#dynamodb-lock-manager).
```
--conf spark.sql.catalog.glue_catalog.lock-impl=org.apache.iceberg.aws.glue.DynamoLockManager
--conf spark.sql.catalog.glue_catalog.lock.table=
```
**Menggunakan versi Iceberg yang berbeda**
Untuk menggunakan versi Iceberg yang tidak didukung AWS Glue, tentukan file Iceberg JAR Anda sendiri menggunakan parameter pekerjaan. `--extra-jars` Jangan sertakan `iceberg` sebagai nilai untuk `--datalake-formats` parameter. Jika Anda menggunakan AWS Glue 5.0 atau lebih tinggi, Anda harus mengatur parameter `--user-jars-first true` pekerjaan.
**Mengaktifkan enkripsi untuk tabel Iceberg**
**catatan**
Tabel gunung es memiliki mekanisme sendiri untuk mengaktifkan enkripsi sisi server. Anda harus mengaktifkan konfigurasi ini selain konfigurasi keamanan AWS Glue.
[Untuk mengaktifkan enkripsi sisi server pada tabel Iceberg, tinjau panduan dari dokumentasi Iceberg.](https://iceberg.apache.org/docs/latest/aws/#s3-server-side-encryption)
**Tambahkan konfigurasi Spark untuk lintas wilayah Iceberg**
Untuk menambahkan konfigurasi percikan tambahan untuk akses tabel lintas wilayah Iceberg dengan AWS Glue Data Catalog dan AWS Lake Formation, ikuti langkah-langkah di bawah ini:
1. Buat [titik akses Multi-wilayah](https://docs.aws.amazon.com/AmazonS3/latest/userguide/multi-region-access-point-create-examples.html).
1. Mengatur properti Spark berikut:
```
-----
--conf spark.sql.catalog.my_catalog.s3.use-arn-region-enabled=true \
--conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket1", "arn:aws:s3:::accesspoint/.mrap \
--conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket2", "arn:aws:s3:::accesspoint/.mrap
-----
```
## Contoh: Tulis tabel Gunung Es ke Amazon S3 dan daftarkan ke Katalog Data Glue AWS
Contoh skrip ini menunjukkan cara menulis tabel Iceberg ke Amazon S3. Contoh menggunakan [Iceberg AWS Integrations](https://iceberg.apache.org/docs/latest/aws/) untuk mendaftarkan tabel ke AWS Glue Data Catalog.
------
#### [ Python ]
```
# Example: Create an Iceberg table from a DataFrame
# and register the table to Glue Data Catalog
dataFrame.createOrReplaceTempView("tmp_")
query = f"""
CREATE TABLE glue_catalog..
USING iceberg
TBLPROPERTIES ("format-version"="2")
AS SELECT * FROM tmp_
"""
spark.sql(query)
```
------
#### [ Scala ]
```
// Example: Example: Create an Iceberg table from a DataFrame
// and register the table to Glue Data Catalog
dataFrame.createOrReplaceTempView("tmp_")
val query = """CREATE TABLE glue_catalog..
USING iceberg
TBLPROPERTIES ("format-version"="2")
AS SELECT * FROM tmp_
"""
spark.sql(query)
```
------
Atau, Anda dapat menulis tabel Iceberg ke Amazon S3 dan Katalog Data menggunakan metode Spark.
Prasyarat: Anda perlu menyediakan katalog untuk perpustakaan Iceberg untuk digunakan. Saat menggunakan AWS Glue Data Catalog, AWS Glue membuatnya mudah. Katalog Data AWS Glue sudah dikonfigurasi sebelumnya untuk digunakan oleh pustaka Spark sebagai. `glue_catalog` Tabel Katalog Data diidentifikasi oleh a *databaseName* dan a*tableName*. Untuk informasi selengkapnya tentang Katalog Data AWS Glue, lihat[Penemuan dan katalogisasi data di AWS Glue](catalog-and-crawler.md).
Jika Anda tidak menggunakan Katalog Data AWS Glue, Anda harus menyediakan katalog melalui Spark APIs. Untuk informasi selengkapnya, lihat [Spark Configuration](https://iceberg.apache.org/docs/latest/spark-configuration/) di dokumentasi Iceberg.
Contoh ini menulis tabel Iceberg ke Amazon S3 dan Katalog Data menggunakan Spark.
------
#### [ Python ]
```
# Example: Write an Iceberg table to S3 on the Glue Data Catalog
# Create (equivalent to CREATE TABLE AS SELECT)
dataFrame.writeTo("glue_catalog.databaseName.tableName") \
.tableProperty("format-version", "2") \
.create()
# Append (equivalent to INSERT INTO)
dataFrame.writeTo("glue_catalog.databaseName.tableName") \
.tableProperty("format-version", "2") \
.append()
```
------
#### [ Scala ]
```
// Example: Write an Iceberg table to S3 on the Glue Data Catalog
// Create (equivalent to CREATE TABLE AS SELECT)
dataFrame.writeTo("glue_catalog.databaseName.tableName")
.tableProperty("format-version", "2")
.create()
// Append (equivalent to INSERT INTO)
dataFrame.writeTo("glue_catalog.databaseName.tableName")
.tableProperty("format-version", "2")
.append()
```
------
## Contoh: Membaca tabel Gunung Es dari Amazon S3 menggunakan Katalog Data Glue AWS
Contoh ini membaca tabel Iceberg yang Anda buat. [Contoh: Tulis tabel Gunung Es ke Amazon S3 dan daftarkan ke Katalog Data Glue AWS](#aws-glue-programming-etl-format-iceberg-write)
------
#### [ Python ]
Untuk contoh ini, gunakan `GlueContext.create\$1data\$1frame.from\$1catalog()` metode ini.
```
# Example: Read an Iceberg table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
Untuk contoh ini, gunakan [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource)metode ini.
```
// Example: Read an Iceberg table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val df = glueContext.getCatalogSource("", "",
additionalOptions = additionalOptions)
.getDataFrame()
}
}
```
------
## Contoh: Masukkan `DataFrame` ke dalam tabel Iceberg di Amazon S3 menggunakan Glue Data Catalog AWS
Contoh ini menyisipkan data ke dalam tabel Iceberg yang Anda buat. [Contoh: Tulis tabel Gunung Es ke Amazon S3 dan daftarkan ke Katalog Data Glue AWS](#aws-glue-programming-etl-format-iceberg-write)
**catatan**
Contoh ini mengharuskan Anda untuk mengatur parameter `--enable-glue-datacatalog` pekerjaan untuk menggunakan Katalog Data AWS Glue sebagai metastore Apache Spark Hive. Untuk mempelajari selengkapnya, lihat [Menggunakan parameter pekerjaan dalam pekerjaan AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Untuk contoh ini, gunakan `GlueContext.write\$1data\$1frame.from\$1catalog()` metode ini.
```
# Example: Insert into an Iceberg table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
Untuk contoh ini, gunakan [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink)metode ini.
```
// Example: Insert into an Iceberg table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getCatalogSink("", "",
additionalOptions = additionalOptions)
.writeDataFrame(dataFrame, glueContext)
}
}
```
------
## Contoh: Membaca tabel Iceberg dari Amazon S3 menggunakan Spark
Prasyarat: Anda perlu menyediakan katalog untuk perpustakaan Iceberg untuk digunakan. Saat menggunakan AWS Glue Data Catalog, AWS Glue membuatnya mudah. Katalog Data AWS Glue sudah dikonfigurasi sebelumnya untuk digunakan oleh pustaka Spark sebagai. `glue_catalog` Tabel Katalog Data diidentifikasi oleh a *databaseName* dan a*tableName*. Untuk informasi selengkapnya tentang Katalog Data AWS Glue, lihat[Penemuan dan katalogisasi data di AWS Glue](catalog-and-crawler.md).
Jika Anda tidak menggunakan Katalog Data AWS Glue, Anda harus menyediakan katalog melalui Spark APIs. Untuk informasi selengkapnya, lihat [Spark Configuration](https://iceberg.apache.org/docs/latest/spark-configuration/) di dokumentasi Iceberg.
Contoh ini membaca tabel Iceberg di Amazon S3 dari Katalog Data menggunakan Spark.
------
#### [ Python ]
```
# Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog
dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName")
```
------
#### [ Scala ]
```
// Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog
val dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName")
```
------
## Contoh: Membaca dan menulis tabel Gunung Es dengan kontrol izin Lake Formation
Contoh ini membaca dan menulis tabel Gunung Es dengan kontrol izin Lake Formation.
**catatan**
Contoh ini hanya berfungsi di AWS Glue 4.0. Di AWS Glue 5.0 dan yang lebih baru, ikuti panduan di[Menggunakan AWS Glue dengan AWS Lake Formation kontrol akses berbutir halus](security-lf-enable.md).
1. Buat tabel Gunung Es dan daftarkan di Lake Formation:
1. Untuk mengaktifkan kontrol izin Lake Formation, Anda harus terlebih dahulu mendaftarkan tabel jalur Amazon S3 di Lake Formation. Untuk informasi selengkapnya, lihat [Mendaftarkan lokasi Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html). Anda dapat mendaftarkannya baik dari konsol Lake Formation atau dengan menggunakan AWS CLI:
```
aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region
```
Setelah Anda mendaftarkan lokasi Amazon S3, tabel AWS Glue apa pun yang menunjuk ke lokasi (atau lokasi turunannya) akan mengembalikan nilai `IsRegisteredWithLakeFormation` parameter sebagai true dalam panggilan. `GetTable`
1. Buat tabel Iceberg yang menunjuk ke jalur terdaftar melalui Spark SQL:
**catatan**
Berikut ini adalah contoh Python.
```
dataFrame.createOrReplaceTempView("tmp_")
query = f"""
CREATE TABLE glue_catalog..
USING iceberg
AS SELECT * FROM tmp_
"""
spark.sql(query)
```
Anda juga dapat membuat tabel secara manual melalui AWS Glue `CreateTable` API. Untuk informasi selengkapnya, lihat [Membuat tabel Apache Iceberg](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-iceberg-tables.html).
**catatan**
`UpdateTable`API saat ini tidak mendukung format tabel Iceberg sebagai masukan untuk operasi.
1. Berikan izin Formasi Danau untuk peran IAM pekerjaan. Anda dapat memberikan izin dari konsol Lake Formation, atau menggunakan AWS CLI. Untuk informasi lebih lanjut, lihat: https://docs.aws.amazon.com/lake-formation/ latest/dg/granting -table-permissions.html
1. Baca tabel Gunung Es yang terdaftar di Lake Formation. Kodenya sama dengan membaca tabel Iceberg yang tidak terdaftar. Perhatikan bahwa peran IAM AWS Glue job Anda harus memiliki izin SELECT agar pembacaan berhasil.
```
# Example: Read an Iceberg table from the AWS Glue Data Catalog
from awsglue.context import GlueContextfrom pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
1. Tulis ke meja Gunung Es yang terdaftar di Lake Formation. Kode ini sama dengan menulis ke tabel Iceberg yang tidak terdaftar. Perhatikan bahwa peran IAM AWS Glue job Anda harus memiliki izin SUPER agar penulisan berhasil.
```
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```