Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Opsi format data untuk input dan output untuk Spark AWS Glue
Halaman ini menawarkan informasi tentang dukungan fitur dan parameter konfigurasi untuk format data yang didukung oleh AWS Glue for Spark. Lihat berikut ini untuk deskripsi penggunaan dan penerapan informasi ini.
## Dukungan fitur di seluruh format data di AWS Glue
Setiap format data dapat mendukung fitur AWS Glue yang berbeda. Fitur umum berikut mungkin atau mungkin tidak didukung berdasarkan jenis format Anda. Lihat dokumentasi untuk format data Anda untuk memahami cara memanfaatkan fitur kami untuk memenuhi kebutuhan Anda.
| | |
| --- |--- |
| Baca | AWS Glue dapat mengenali dan menafsirkan format data ini tanpa sumber daya tambahan, seperti konektor. |
| Tulis | AWS Glue dapat menulis data dalam format ini tanpa sumber daya tambahan. Anda dapat menyertakan pustaka pihak ketiga dalam pekerjaan Anda dan menggunakan fungsi Apache Spark standar untuk menulis data, seperti yang Anda lakukan di lingkungan Spark lainnya. Untuk informasi selengkapnya tentang menyertakan pustaka, lihat[Menggunakan pustaka Python dengan Glue AWS](aws-glue-programming-python-libraries.md). |
| Streaming dibaca | AWS Glue dapat mengenali dan menafsirkan format data ini dari Apache Kafka, Amazon Managed Streaming for Apache Kafka atau aliran pesan Amazon Kinesis. Kami mengharapkan aliran untuk menyajikan data dalam format yang konsisten, sehingga mereka dibaca sebagaiDataFrames. |
| Kelompokkan file kecil | AWS Glue dapat mengelompokkan file bersama-sama untuk pekerjaan batch yang dikirim ke setiap node saat melakukan transformasi AWS Glue. Ini secara signifikan dapat meningkatkan kinerja untuk beban kerja yang melibatkan sejumlah besar file kecil. Untuk informasi selengkapnya, lihat [Membaca file input dalam kelompok yang lebih besar](grouping-input-files.md). |
| Bookmark tugas | AWS Glue dapat melacak kemajuan transformasi yang melakukan pekerjaan yang sama pada kumpulan data yang sama di seluruh pekerjaan yang dijalankan dengan bookmark pekerjaan. Ini dapat meningkatkan kinerja untuk beban kerja yang melibatkan kumpulan data di mana pekerjaan hanya perlu dilakukan pada data baru sejak pekerjaan terakhir dijalankan. Untuk informasi selengkapnya, lihat [Melacak data yang diproses menggunakan bookmark pekerjaan](monitor-continuations.md). |
## Parameter yang digunakan untuk berinteraksi dengan format data di AWS Glue
Jenis koneksi AWS Glue tertentu mendukung beberapa `format` jenis, mengharuskan Anda menentukan informasi tentang format data Anda dengan `format_options` objek saat menggunakan metode seperti`GlueContext.write_dynamic_frame.from_options`.
+ `s3`— Untuk informasi selengkapnya, lihat Jenis dan opsi koneksi untuk ETL di AWS Glue:[Parameter koneksi S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Anda juga dapat melihat dokumentasi untuk metode yang memfasilitasi jenis koneksi ini: [create\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options) dan dengan Python dan [write\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options) metode [Format def getSourceWith](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat) Scala yang sesuai dan. [Format def getSinkWith](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat)
+ `kinesis`— Untuk informasi selengkapnya, lihat Jenis dan opsi koneksi untuk ETL di AWS Glue:[Parameter koneksi Kinesis](aws-glue-programming-etl-connect-kinesis-home.md#aws-glue-programming-etl-connect-kinesis). Anda juga dapat melihat dokumentasi untuk metode yang memfasilitasi jenis koneksi ini: [create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) dan metode Scala yang sesuai. [def createDataFrame FromOptions](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions)
+ `kafka`— Untuk informasi selengkapnya, lihat Jenis dan opsi koneksi untuk ETL di AWS Glue:[Parameter koneksi Kafka](aws-glue-programming-etl-connect-kafka-home.md#aws-glue-programming-etl-connect-kafka). Anda juga dapat melihat dokumentasi untuk metode yang memfasilitasi jenis koneksi ini: [create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) dan metode Scala yang sesuai. [def createDataFrame FromOptions](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions)
Beberapa jenis koneksi tidak memerlukan`format_options`. Misalnya, dalam penggunaan normal, koneksi JDBC ke database relasional mengambil data dalam format data tabular yang konsisten. Oleh karena itu, membaca dari koneksi JDBC tidak memerlukan. `format_options`
Beberapa metode untuk membaca dan menulis data dalam lem tidak diperlukan`format_options`. Misalnya, menggunakan `GlueContext.create_dynamic_frame.from_catalog` dengan AWS Glue crawler. Crawler menentukan bentuk data Anda. Saat menggunakan crawler, pengklasifikasi AWS Glue akan memeriksa data Anda untuk membuat keputusan cerdas tentang cara merepresentasikan format data Anda. Kemudian akan menyimpan representasi data Anda di AWS Glue Data Catalog, yang dapat digunakan dalam skrip AWS Glue ETL untuk mengambil data Anda dengan metode tersebut`GlueContext.create_dynamic_frame.from_catalog`. Crawler menghapus kebutuhan untuk menentukan informasi secara manual tentang format data Anda.
Untuk pekerjaan yang mengakses tabel yang AWS Lake Formation diatur, AWS Glue mendukung membaca dan menulis semua format yang didukung oleh tabel yang diatur Lake Formation. Untuk daftar format yang didukung saat ini untuk tabel yang AWS Lake Formation diatur, lihat [Catatan dan Pembatasan untuk Tabel yang Diatur](https://docs.aws.amazon.com/lake-formation/latest/dg/governed-table-restrictions.html) dalam Panduan *AWS Lake Formation Pengembang*.
**catatan**
Untuk menulis Apache Parquet, AWS Glue ETL hanya mendukung penulisan ke tabel yang diatur dengan menentukan opsi untuk jenis penulis Parket kustom yang dioptimalkan untuk Dynamic Frames. Saat menulis ke tabel yang diatur dengan `parquet` format, Anda harus menambahkan kunci `useGlueParquetWriter` dengan nilai `true` dalam parameter tabel.
**Topics**
+ [Dukungan fitur di seluruh format data di AWS Glue](#aws-glue-programming-etl-format-features)
+ [Parameter yang digunakan untuk berinteraksi dengan format data di AWS Glue](#aws-glue-programming-etl-format-parameters)
+ [Menggunakan format CSV di AWS Glue](aws-glue-programming-etl-format-csv-home.md)
+ [Menggunakan format Parket di AWS Glue](aws-glue-programming-etl-format-parquet-home.md)
+ [Menggunakan format XHTML di AWS Glue](aws-glue-programming-etl-format-xml-home.md)
+ [Menggunakan format Avro di AWS Glue](aws-glue-programming-etl-format-avro-home.md)
+ [Menggunakan format GrokLog di Glue AWS](aws-glue-programming-etl-format-grokLog-home.md)
+ [Menggunakan format Ion di AWS Glue](aws-glue-programming-etl-format-ion-home.md)
+ [Menggunakan format JSON di AWS Glue](aws-glue-programming-etl-format-json-home.md)
+ [Menggunakan format ORC di AWS Glue](aws-glue-programming-etl-format-orc-home.md)
+ [Menggunakan kerangka kerja data lake dengan pekerjaan AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md)
+ [Referensi konfigurasi bersama](#aws-glue-programming-etl-format-shared-reference)
# Menggunakan format CSV di AWS Glue
AWS Glue mengambil data dari sumber dan menulis data ke target yang disimpan dan diangkut dalam berbagai format data. Jika data Anda disimpan atau diangkut dalam format data CSV, dokumen ini memperkenalkan fitur yang tersedia untuk menggunakan data Anda di Glue. AWS
AWS Glue mendukung penggunaan format comma-separated value (CSV). Format ini adalah format data berbasis baris minimal. CSVs sering tidak sepenuhnya sesuai dengan standar, tetapi Anda dapat merujuk ke [RFC 4180 dan RFC](https://tools.ietf.org/html/rfc4180) [7111](https://tools.ietf.org/html/rfc7111) untuk informasi lebih lanjut.
Anda dapat menggunakan AWS Glue untuk membaca CSVs dari Amazon S3 dan dari sumber streaming serta menulis CSVs ke Amazon S3. Anda dapat membaca dan menulis `bzip` dan `gzip` mengarsipkan yang berisi file CSV dari S3. Anda mengonfigurasi perilaku kompresi pada [Parameter koneksi S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) alih-alih dalam konfigurasi yang dibahas di halaman ini.
Tabel berikut menunjukkan fitur AWS Glue umum mana yang mendukung opsi format CSV.
| Baca | Tulis | Streaming dibaca | Kelompokkan file kecil | Bookmark tugas |
| --- | --- | --- | --- | --- |
| Didukung | Didukung | Didukung | Didukung | Didukung |
## Contoh: Baca file CSV atau folder dari S3
**Prasyarat:** Anda akan memerlukan jalur S3 (`s3path`) ke file CSV atau folder yang ingin Anda baca.
**Konfigurasi:** Dalam opsi fungsi Anda, tentukan`format="csv"`. Dalam Anda`connection_options`, gunakan `paths` kunci untuk menentukan`s3path`. Anda dapat mengonfigurasi bagaimana pembaca berinteraksi dengan S3 di. `connection_options` Untuk detailnya, lihat Jenis dan opsi koneksi untuk ETL di AWS Glue:[Parameter koneksi S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Anda dapat mengonfigurasi bagaimana pembaca menafsirkan file CSV di file Anda. `format_options` Untuk detailnya, lihat [Referensi Konfigurasi CSV](#aws-glue-programming-etl-format-csv-reference).
Berikut skrip AWS Glue ETL menunjukkan proses membaca file CSV atau folder dari S3.
Kami menyediakan pembaca CSV khusus dengan pengoptimalan kinerja untuk alur kerja umum melalui kunci konfigurasi. `optimizePerformance` Untuk menentukan apakah pembaca ini tepat untuk beban kerja Anda, lihat[Optimalkan kinerja baca dengan pembaca SIMD CSV vektor](#aws-glue-programming-etl-format-simd-csv-reader).
------
#### [ Python ]
Untuk contoh ini, gunakan metode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read CSV from S3
# For show, we handle a CSV with a header row. Set the withHeader option.
# Consider whether optimizePerformance is right for your workflow.
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="csv",
format_options={
"withHeader": True,
# "optimizePerformance": True,
},
)
```
Anda juga dapat menggunakan DataFrames dalam script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read\
.format("csv")\
.option("header", "true")\
.load("s3://s3path")
```
------
#### [ Scala ]
Untuk contoh ini, gunakan operasi [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read CSV from S3
// For show, we handle a CSV with a header row. Set the withHeader option.
// Consider whether optimizePerformance is right for your workflow.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, 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 dynamicFrame = glueContext.getSourceWithFormat(
formatOptions=JsonOptions("""{"withHeader": true}"""),
connectionType="s3",
format="csv",
options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
).getDynamicFrame()
}
}
```
Anda juga dapat menggunakan DataFrames dalam script (`org.apache.spark.sql.DataFrame`).
```
val dataFrame = spark.read
.option("header","true")
.format("csv")
.load("s3://s3path“)
```
------
## Contoh: Tulis file dan folder CSV ke S3
**Prasyarat:** Anda akan memerlukan initialized DataFrame (`dataFrame`) atau a (). DynamicFrame `dynamicFrame` Anda juga akan membutuhkan jalur output S3 yang Anda harapkan,`s3path`.
**Konfigurasi:** Dalam opsi fungsi Anda, tentukan`format="csv"`. Dalam Anda`connection_options`, gunakan `paths` kunci untuk menentukan`s3path`. Anda dapat mengonfigurasi bagaimana penulis berinteraksi dengan S3 di. `connection_options` Untuk detailnya, lihat Jenis dan opsi koneksi untuk ETL di AWS Glue:[Parameter koneksi S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Anda dapat mengonfigurasi bagaimana operasi Anda menulis konten file Anda`format_options`. Untuk detailnya, lihat [Referensi Konfigurasi CSV](#aws-glue-programming-etl-format-csv-reference). Skrip AWS Glue ETL berikut menunjukkan proses penulisan file CSV dan folder ke S3.
------
#### [ Python ]
Untuk contoh ini, gunakan metode [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
# Example: Write CSV to S3
# For show, customize how we write string type values. Set quoteChar to -1 so our values are not quoted.
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
connection_options={"path": "s3://s3path"},
format="csv",
format_options={
"quoteChar": -1,
},
)
```
Anda juga dapat menggunakan DataFrames dalam script (`pyspark.sql.DataFrame`).
```
dataFrame.write\
.format("csv")\
.option("quote", None)\
.mode("append")\
.save("s3://s3path")
```
------
#### [ Scala ]
Untuk contoh ini, gunakan metode [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
// Example: Write CSV to S3
// For show, customize how we write string type values. Set quoteChar to -1 so our values are not quoted.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, 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)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="csv"
).writeDynamicFrame(dynamicFrame)
}
}
```
Anda juga dapat menggunakan DataFrames dalam script (`org.apache.spark.sql.DataFrame`).
```
dataFrame.write
.format("csv")
.option("quote", null)
.mode("Append")
.save("s3://s3path")
```
------
## Referensi konfigurasi CSV
Anda dapat menggunakan yang berikut ini di `format_options` mana pun pustaka AWS Glue menentukan`format="csv"`:
+ `separator`—Menentukan karakter pembatas. Defaultnya adalah koma, tetapi karakter lain dapat ditentukan.
+ **Jenis:** Teks, **Default:** `","`
+ `escaper`- Menentukan karakter yang akan digunakan untuk melarikan diri. Opsi ini hanya digunakan saat membaca file CSV, bukan menulis. Jika diaktifkan, karakter yang segera mengikuti digunakan apa adanya, kecuali untuk satu set kecil pelarian terkenal (`\n`,, `\r``\t`, dan`\0`).
+ **Jenis:** Teks, **Default:** tidak ada
+ `quoteChar`- Menentukan karakter yang akan digunakan untuk mengutip. Defaultnya adalah kutipan ganda. Atur ini ke `-1` untuk menonaktifkan pengutipan seluruhnya.
+ **Jenis:** Teks, **Default:** `'"'`
+ `multiLine`- Menentukan apakah catatan tunggal dapat menjangkau beberapa baris. Hal ini dapat terjadi ketika bidang berisi karakter baris baru yang dikutip. Anda harus menetapkan opsi ini ke `True` jika ada catatan yang mencakup beberapa baris. Mengaktifkan `multiLine` dapat menurunkan kinerja karena membutuhkan pemisahan file yang lebih hati-hati saat mengurai.
+ **Jenis:** Boolean, **Default**: `false`
+ `withHeader`- Menentukan apakah untuk memperlakukan baris pertama sebagai header. Opsi ini dapat digunakan dalam kelas `DynamicFrameReader`.
+ **Jenis:** Boolean, **Default**: `false`
+ `writeHeader`- Menentukan apakah akan menulis header untuk output. Opsi ini dapat digunakan dalam kelas `DynamicFrameWriter`.
+ **Jenis:** Boolean, **Default**: `true`
+ `skipFirst`- Menentukan apakah akan melewati baris data pertama.
+ **Jenis:** Boolean, **Default**: `false`
+ `optimizePerformance`— Menentukan apakah akan menggunakan pembaca CSV SIMD canggih bersama dengan format memori kolumnar berbasis Apache Arrow. Hanya tersedia dalam AWS Glue 3.0\$1.
+ **Jenis:** Boolean, **Default**: `false`
+ `strictCheckForQuoting`— Saat menulis CSVs, Glue dapat menambahkan tanda kutip ke nilai yang ditafsirkan sebagai string. Hal ini dilakukan untuk mencegah ambiguitas dalam apa yang tertulis. Untuk menghemat waktu ketika memutuskan apa yang akan ditulis, Glue dapat mengutip dalam situasi tertentu di mana kutipan tidak diperlukan. Mengaktifkan pemeriksaan ketat akan melakukan perhitungan yang lebih intensif dan hanya akan mengutip jika benar-benar diperlukan. Hanya tersedia dalam AWS Glue 3.0\$1.
+ **Jenis:** Boolean, **Default**: `false`
## Optimalkan kinerja baca dengan pembaca SIMD CSV vektor
AWS Glueversi 3.0 menambahkan pembaca CSV yang dioptimalkan yang secara signifikan dapat mempercepat kinerja pekerjaan secara keseluruhan dibandingkan dengan pembaca CSV berbasis baris.
Pembaca yang dioptimalkan:
+ Menggunakan instruksi CPU SIMD untuk membaca dari disk
+ Segera menulis catatan ke memori dalam format kolom (Apache Arrow)
+ Membagi catatan menjadi batch
Ini menghemat waktu pemrosesan ketika catatan akan di-batch atau dikonversi ke format kolumnar nanti. Beberapa contoh adalah ketika mengubah skema atau mengambil data berdasarkan kolom.
Untuk menggunakan pembaca yang dioptimalkan, atur `"optimizePerformance"` ke `true` dalam properti `format_options` or table.
```
glueContext.create_dynamic_frame.from_options(
frame = datasource1,
connection_type = "s3",
connection_options = {"paths": ["s3://s3path"]},
format = "csv",
format_options={
"optimizePerformance": True,
"separator": ","
},
transformation_ctx = "datasink2")
```
**Keterbatasan untuk pembaca CSV vektor**
Perhatikan batasan berikut dari pembaca CSV vektor:
+ Itu tidak mendukung opsi `multiLine` dan `escaper` format. Ini menggunakan default `escaper` karakter kutipan ganda. `'"'` Ketika opsi ini diatur, AWS Glue secara otomatis kembali menggunakan pembaca CSV berbasis baris.
+ Itu tidak mendukung pembuatan DynamicFrame dengan [ChoiceType](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-extensions-types.html#aws-glue-api-crawler-pyspark-extensions-types-awsglue-choicetype).
+ Itu tidak mendukung pembuatan [catatan kesalahan DynamicFrame ](https://docs.aws.amazon.com/glue/latest/dg/glue-etl-scala-apis-glue-dynamicframe-class.html#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame) dengan.
+ Itu tidak mendukung membaca file CSV dengan karakter multibyte seperti karakter Jepang atau China.
# Menggunakan format Parket di AWS Glue
AWS Glue mengambil data dari sumber dan menulis data ke target yang disimpan dan diangkut dalam berbagai format data. Jika data Anda disimpan atau diangkut dalam format data Parket, dokumen ini memperkenalkan fitur yang tersedia untuk menggunakan data Anda di Glue. AWS
AWS Glue mendukung menggunakan format Parket. Format ini adalah format data berbasis kolom yang berorientasi kinerja. Untuk pengenalan format oleh otoritas standar lihat, [Apache Parquet Documentation](https://parquet.apache.org/docs/overview/) Overview.
Anda dapat menggunakan AWS Glue untuk membaca file Parket dari Amazon S3 dan dari sumber streaming serta menulis file Parket ke Amazon S3. Anda dapat membaca dan menulis `bzip` dan `gzip` mengarsipkan yang berisi file Parket dari S3. Anda mengonfigurasi perilaku kompresi pada [Parameter koneksi S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) alih-alih dalam konfigurasi yang dibahas di halaman ini.
Tabel berikut menunjukkan fitur AWS Glue umum mana yang mendukung opsi format Parket.
| Baca | Tulis | Streaming dibaca | Kelompokkan file kecil | Bookmark tugas |
| --- | --- | --- | --- | --- |
| Didukung | Didukung | Didukung | Tidak didukung | Didukung \$1 |
\$1 Didukung dalam AWS Glue versi 1.0\$1
## Contoh: Baca file atau folder Parket dari S3
**Prasyarat:** Anda akan memerlukan jalur S3 (`s3path`) ke file atau folder Parket yang ingin Anda baca.
**Konfigurasi:** Dalam opsi fungsi Anda, tentukan`format="parquet"`. Dalam Anda`connection_options`, gunakan `paths` kunci untuk menentukan Anda`s3path`.
Anda dapat mengonfigurasi bagaimana pembaca berinteraksi dengan S3 di file. `connection_options` Untuk detailnya, lihat Jenis dan opsi koneksi untuk ETL di AWS Glue:[Parameter koneksi S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3).
Anda dapat mengonfigurasi bagaimana pembaca menafsirkan file Parket di file Anda. `format_options` Untuk detailnya, lihat [Referensi Konfigurasi Parket](#aws-glue-programming-etl-format-parquet-reference).
Skrip AWS Glue ETL berikut menunjukkan proses membaca file Parket atau folder dari S3:
------
#### [ Python ]
Untuk contoh ini, gunakan metode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read Parquet from S3
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type = "s3",
connection_options = {"paths": ["s3://s3path/"]},
format = "parquet"
)
```
Anda juga dapat menggunakan DataFrames dalam script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read.parquet("s3://s3path/")
```
------
#### [ Scala ]
Untuk contoh ini, gunakan metode [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read Parquet from S3
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, 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 dynamicFrame = glueContext.getSourceWithFormat(
connectionType="s3",
format="parquet",
options=JsonOptions("""{"paths": ["s3://s3path"]}""")
).getDynamicFrame()
}
}
```
Anda juga dapat menggunakan DataFrames dalam script (`org.apache.spark.sql.DataFrame`).
```
spark.read.parquet("s3://s3path/")
```
------
## Contoh: Tulis file dan folder Parket ke S3
**Prasyarat:** Anda akan memerlukan initialized DataFrame () atau ()`dataFrame`. DynamicFrame `dynamicFrame` Anda juga akan membutuhkan jalur output S3 yang Anda harapkan,`s3path`.
**Konfigurasi:** Dalam opsi fungsi Anda, tentukan`format="parquet"`. Dalam Anda`connection_options`, gunakan `paths` kunci untuk menentukan`s3path`.
Anda selanjutnya dapat mengubah cara penulis berinteraksi dengan S3 di. `connection_options` Untuk detailnya, lihat Jenis dan opsi koneksi untuk ETL di AWS Glue:[Parameter koneksi S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Anda dapat mengonfigurasi bagaimana operasi Anda menulis konten file Anda`format_options`. Untuk detailnya, lihat [Referensi Konfigurasi Parket](#aws-glue-programming-etl-format-parquet-reference).
Skrip AWS Glue ETL berikut menunjukkan proses penulisan file dan folder Parket ke S3.
Kami menyediakan penulis Parket khusus dengan pengoptimalan kinerja untuk DynamicFrames, melalui kunci konfigurasi. `useGlueParquetWriter` Untuk menentukan apakah penulis ini tepat untuk beban kerja Anda, lihat [Glue Parquet](#aws-glue-programming-etl-format-glue-parquet-writer) Writer.
------
#### [ Python ]
Untuk contoh ini, gunakan metode [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
# Example: Write Parquet to S3
# Consider whether useGlueParquetWriter is right for your workflow.
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
format="parquet",
connection_options={
"path": "s3://s3path",
},
format_options={
# "useGlueParquetWriter": True,
},
)
```
Anda juga dapat menggunakan DataFrames dalam script (`pyspark.sql.DataFrame`).
```
df.write.parquet("s3://s3path/")
```
------
#### [ Scala ]
Untuk contoh ini, gunakan metode [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
// Example: Write Parquet to S3
// Consider whether useGlueParquetWriter is right for your workflow.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, 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)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="parquet"
).writeDynamicFrame(dynamicFrame)
}
}
```
Anda juga dapat menggunakan DataFrames dalam script (`org.apache.spark.sql.DataFrame`).
```
df.write.parquet("s3://s3path/")
```
------
## Referensi konfigurasi parket
Anda dapat menggunakan yang berikut ini di `format_options` mana pun pustaka AWS Glue menentukan`format="parquet"`:
+ `useGlueParquetWriter`— Menentukan penggunaan penulis Parket kustom yang memiliki optimasi kinerja untuk alur kerja. DynamicFrame Untuk detail penggunaan, lihat [Glue Parquet Writer](#aws-glue-programming-etl-format-glue-parquet-writer).
+ **Jenis:** Boolean, **Default**: `false`
+ `compression`- Menentukan codec kompresi yang digunakan. Nilai sepenuhnya kompatibel dengan`org.apache.parquet.hadoop.metadata.CompressionCodecName`.
+ **Jenis:** **Teks Terhitung, Default:** `"snappy"`
+ Nilai:`"uncompressed"`,`"snappy"`,`"gzip"`, dan `"lzo"`
+ `blockSize`- Menentukan ukuran dalam byte dari kelompok baris yang disangga dalam memori. Anda menggunakan ini untuk tuning kinerja. Ukuran harus dibagi persis menjadi sejumlah megabyte.
+ **Jenis:** Numerik, **Default**: `134217728`
+ Nilai default sama dengan 128 MB.
+ `pageSize`- Menentukan ukuran dalam byte halaman. Anda menggunakan ini untuk tuning kinerja. Halaman adalah unit terkecil yang harus dibaca sepenuhnya untuk mengakses satu catatan.
+ **Jenis:** Numerik, **Default**: `1048576`
+ Nilai default sama dengan 1 MB.
**catatan**
Selain itu, opsi apa pun yang diterima oleh kode SparkSQL yang mendasarinya dapat diteruskan ke format ini melalui parameter peta. `connection_options` Misalnya, Anda dapat mengatur konfigurasi Spark seperti [MergeSchema](https://spark.apache.org/docs/latest/sql-data-sources-parquet.html#schema-merging) untuk pembaca AWS Glue Spark untuk menggabungkan skema untuk semua file.
## Optimalkan kinerja menulis dengan AWS Glue Parquet writer
**catatan**
Penulis AWS Glue Parquet secara historis telah diakses melalui jenis `glueparquet` format. Pola akses ini tidak lagi dianjurkan. Sebagai gantinya, gunakan `parquet` tipe dengan `useGlueParquetWriter` diaktifkan.
Penulis AWS Glue Parquet memiliki peningkatan kinerja yang memungkinkan penulisan file Parket lebih cepat. Penulis tradisional menghitung skema sebelum menulis. Format Parket tidak menyimpan skema dengan cara yang dapat diambil dengan cepat, jadi ini mungkin memakan waktu. Dengan penulis AWS Glue Parquet, skema pra-komputasi tidak diperlukan. Penulis menghitung dan memodifikasi skema secara dinamis, saat data masuk.
Perhatikan batasan berikut saat Anda menentukan`useGlueParquetWriter`:
+ Penulis hanya mendukung evolusi skema (seperti menambahkan atau menghapus kolom), tetapi tidak mengubah jenis kolom, seperti dengan`ResolveChoice`.
+ Penulis tidak mendukung penulisan kosong DataFrames —misalnya, untuk menulis file khusus skema. Saat mengintegrasikan dengan Katalog Data AWS Glue dengan pengaturan`enableUpdateCatalog=True`, mencoba menulis kosong tidak DataFrame akan memperbarui Katalog Data. Ini akan menghasilkan pembuatan tabel di Katalog Data tanpa skema.
Jika transformasi Anda tidak memerlukan batasan ini, menyalakan penulis AWS Glue Parquet akan meningkatkan kinerja.
# Menggunakan format XHTML di AWS Glue
AWS Glue mengambil data dari sumber dan menulis data ke target yang disimpan dan diangkut dalam berbagai format data. Jika data Anda disimpan atau diangkut dalam format data XHTML, dokumen ini memperkenalkan fitur yang tersedia untuk menggunakan data Anda di Glue. AWS
AWS Glue mendukung menggunakan format XHTML. Format ini mewakili struktur data yang sangat dapat dikonfigurasi dan didefinisikan secara kaku yang tidak berbasis baris atau kolom. XML-nya sangat terstandarisasi. Untuk pengenalan format oleh otoritas standar, lihat [XMLEssentials](https://www.w3.org/standards/xml/core).
Anda dapat menggunakan AWS Glue untuk membaca file XHTML dari Amazon S3, `bzip` serta `gzip` dan arsip yang berisi file XHTML. Anda mengonfigurasi perilaku kompresi pada [Parameter koneksi S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) alih-alih dalam konfigurasi yang dibahas di halaman ini.
Tabel berikut menunjukkan fitur AWS Glue umum mana yang mendukung opsi format XHTML.
| Baca | Tulis | Streaming dibaca | Kelompokkan file kecil | Bookmark tugas |
| --- | --- | --- | --- | --- |
| Didukung | Tidak didukung | Tidak didukung | Didukung | Didukung |
## Contoh: Baca XMLdari S3
Pembaca XHTML mengambil nama tag XHTML. Ini memeriksa elemen dengan tag itu dalam inputnya untuk menyimpulkan skema dan mengisi a dengan nilai yang DynamicFrame sesuai. Fungsionalitas AWS Glue XMLberperilaku mirip dengan [Sumber Data XMLuntuk](https://github.com/databricks/spark-xml) Apache Spark. Anda mungkin bisa mendapatkan wawasan seputar perilaku dasar dengan membandingkan pembaca ini dengan dokumentasi proyek itu.
**Prasyarat:** Anda akan memerlukan jalur S3 (`s3path`) ke file atau folder XHTML yang ingin Anda baca, dan beberapa informasi tentang file XMLmu. Anda juga akan memerlukan tag untuk elemen XHTML yang ingin Anda baca,`xmlTag`.
**Konfigurasi:** Dalam opsi fungsi Anda, tentukan`format="xml"`. Dalam Anda`connection_options`, gunakan `paths` kunci untuk menentukan`s3path`. Anda dapat mengonfigurasi lebih lanjut bagaimana pembaca berinteraksi dengan S3 di file. `connection_options` Untuk detailnya, lihat Jenis dan opsi koneksi untuk ETL di AWS Glue:[Parameter koneksi S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Dalam Anda`format_options`, gunakan `rowTag` kunci untuk menentukan`xmlTag`. Anda dapat mengkonfigurasi lebih lanjut bagaimana pembaca menafsirkan file XHTML di file Anda. `format_options` Untuk detailnya, lihat [Referensi Konfigurasi XHTML](#aws-glue-programming-etl-format-xml-reference).
Berikut skrip AWS Glue ETL menunjukkan proses membaca file XHTML atau folder dari S3.
------
#### [ Python ]
Untuk contoh ini, gunakan metode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read XML from S3
# Set the rowTag option to configure the reader.
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="xml",
format_options={"rowTag": "xmlTag"},
)
```
Anda juga dapat menggunakan DataFrames dalam script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read\
.format("xml")\
.option("rowTag", "xmlTag")\
.load("s3://s3path")
```
------
#### [ Scala ]
Untuk contoh ini, gunakan operasi [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read XML from S3
// Set the rowTag option to configure the reader.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.sql.SparkSession
val glueContext = new GlueContext(SparkContext.getOrCreate())
val sparkSession: SparkSession = glueContext.getSparkSession
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val dynamicFrame = glueContext.getSourceWithFormat(
formatOptions=JsonOptions("""{"rowTag": "xmlTag"}"""),
connectionType="s3",
format="xml",
options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
).getDynamicFrame()
}
```
Anda juga dapat menggunakan DataFrames dalam script (`org.apache.spark.sql.DataFrame`).
```
val dataFrame = spark.read
.option("rowTag", "xmlTag")
.format("xml")
.load("s3://s3path“)
```
------
## Referensi konfigurasi XML
Anda dapat menggunakan yang berikut ini di `format_options` mana pun pustaka AWS Glue menentukan`format="xml"`:
+ `rowTag`- Menentukan tag XMLdalam file untuk memperlakukan sebagai baris. Tag baris tidak dapat berupa penutupan-sendiri.
+ **Jenis:** Teks, **Diperlukan**
+ `encoding`- Menentukan pengkodean karakter. Ini bisa berupa nama atau alias [Charset](https://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html) yang didukung oleh lingkungan runtime kami. Kami tidak membuat jaminan khusus seputar dukungan pengkodean, tetapi pengkodean utama harus berfungsi.
+ **Jenis:** Teks, **Default:** `"UTF-8"`
+ `excludeAttribute`- Menentukan apakah Anda ingin mengecualikan atribut dalam elemen atau tidak.
+ **Jenis:** Boolean, **Default**: `false`
+ `treatEmptyValuesAsNulls`- Menentukan apakah untuk memperlakukan ruang putih sebagai nilai null.
+ **Jenis:** Boolean, **Default**: `false`
+ `attributePrefix`— Awalan untuk atribut untuk membedakannya dari teks elemen anak. Prefiks ini digunakan untuk nama bidang.
+ **Jenis:** Teks, **Default:** `"_"`
+ `valueTag`— Tag yang digunakan untuk nilai ketika ada atribut dalam elemen yang tidak memiliki anak.
+ **Jenis:** Teks, **Default:** `"_VALUE"`
+ `ignoreSurroundingSpaces`- Menentukan apakah ruang putih yang mengelilingi nilai-nilai harus diabaikan.
+ **Jenis:** Boolean, **Default**: `false`
+ `withSchema`— Berisi skema yang diharapkan, dalam situasi di mana Anda ingin mengganti skema yang disimpulkan. Jika Anda tidak menggunakan opsi ini, AWS Glue simpulkan skema dari data XHTML.
+ **Jenis:** Teks, **Default:** Tidak berlaku
+ Nilainya harus berupa objek JSON yang mewakili a`StructType`.
## Tentukan skema XMLnya secara manual
**Contoh skema XHTML manual**
Ini adalah contoh penggunaan pilihan format `withSchema` untuk menentukan skema untuk data XML.
```
from awsglue.gluetypes import *
schema = StructType([
Field("id", IntegerType()),
Field("name", StringType()),
Field("nested", StructType([
Field("x", IntegerType()),
Field("y", StringType()),
Field("z", ChoiceType([IntegerType(), StringType()]))
]))
])
datasource0 = create_dynamic_frame_from_options(
connection_type,
connection_options={"paths": ["s3://xml_bucket/someprefix"]},
format="xml",
format_options={"withSchema": json.dumps(schema.jsonValue())},
transformation_ctx = ""
)
```
# Menggunakan format Avro di AWS Glue
AWS Glue mengambil data dari sumber dan menulis data ke target yang disimpan dan diangkut dalam berbagai format data. Jika data Anda disimpan atau diangkut dalam format data Avro, dokumen ini memperkenalkan fitur yang tersedia untuk menggunakan data Anda di Glue. AWS
AWS Glue mendukung menggunakan format Avro. Format ini adalah format data berbasis baris yang berorientasi kinerja. Untuk pengenalan format oleh otoritas standar lihat, [Apache Avro 1.8.2](https://avro.apache.org/docs/1.8.2/) Dokumentasi.
Anda dapat menggunakan AWS Glue untuk membaca file Avro dari Amazon S3 dan dari sumber streaming serta menulis file Avro ke Amazon S3. Anda dapat membaca dan menulis `bzip2` dan `gzip` mengarsipkan yang berisi file Avro dari S3. Selain itu, Anda dapat menulis`deflate`,`snappy`, dan `xz` arsip yang berisi file Avro. Anda mengonfigurasi perilaku kompresi pada [Parameter koneksi S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) alih-alih dalam konfigurasi yang dibahas di halaman ini.
Tabel berikut menunjukkan operasi AWS Glue umum mana yang mendukung opsi format Avro.
| Baca | Tulis | Streaming dibaca | Kelompokkan file kecil | Bookmark tugas |
| --- | --- | --- | --- | --- |
| Didukung | Didukung | Didukung \$1 | Tidak didukung | Didukung |
\$1 Didukung dengan batasan. Untuk informasi selengkapnya, lihat [Catatan dan batasan untuk sumber streaming Avro](add-job-streaming.md#streaming-avro-notes).
## Contoh: Baca file atau folder Avro dari S3
**Prasyarat:** Anda akan memerlukan jalur S3 (`s3path`) ke file atau folder Avro yang ingin Anda baca.
**Konfigurasi:** Dalam opsi fungsi Anda, tentukan`format="avro"`. Dalam Anda`connection_options`, gunakan `paths` kunci untuk menentukan`s3path`. Anda dapat mengonfigurasi bagaimana pembaca berinteraksi dengan S3 di file. `connection_options` Untuk detailnya, lihat Opsi format data untuk input dan output ETL di Glue AWS :. [Referensi opsi koneksi Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) Anda dapat mengonfigurasi bagaimana pembaca menafsirkan file Avro di file Anda. `format_options` Untuk detailnya, lihat [Referensi Konfigurasi Avro](#aws-glue-programming-etl-format-avro-reference).
Skrip AWS Glue ETL berikut menunjukkan proses membaca file atau folder Avro dari S3:
------
#### [ Python ]
Untuk contoh ini, gunakan metode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="avro"
)
```
------
#### [ Scala ]
Untuk contoh ini, gunakan operasi [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.sql.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType="s3",
format="avro",
options=JsonOptions("""{"paths": ["s3://s3path"]}""")
).getDynamicFrame()
}
```
------
## Contoh: Tulis file dan folder Avro ke S3
**Prasyarat:** Anda akan memerlukan initialized DataFrame () atau ()`dataFrame`. DynamicFrame `dynamicFrame` Anda juga akan membutuhkan jalur output S3 yang Anda harapkan,`s3path`.
**Konfigurasi:** Dalam opsi fungsi Anda, tentukan`format="avro"`. Dalam Anda`connection_options`, gunakan `paths` kunci untuk menentukan Anda`s3path`. Anda selanjutnya dapat mengubah cara penulis berinteraksi dengan S3 di. `connection_options` Untuk detailnya, lihat Opsi format data untuk input dan output ETL di Glue AWS :. [Referensi opsi koneksi Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) Anda dapat mengubah cara penulis menafsirkan file Avro di file Anda. `format_options` Untuk detailnya, lihat [Referensi Konfigurasi Avro](#aws-glue-programming-etl-format-avro-reference).
Skrip AWS Glue ETL berikut menunjukkan proses penulisan file Avro atau folder ke S3.
------
#### [ Python ]
Untuk contoh ini, gunakan metode [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
format="avro",
connection_options={
"path": "s3://s3path"
}
)
```
------
#### [ Scala ]
Untuk contoh ini, gunakan metode [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, 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)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="avro"
).writeDynamicFrame(dynamicFrame)
}
}
```
------
## Referensi konfigurasi Avro
Anda dapat menggunakan `format_options` nilai-nilai berikut di mana pun pustaka AWS Glue menentukan`format="avro"`:
+ `version`- Menentukan versi reader/writer format Apache Avro untuk mendukung. Default-nya adalah "1.7". Anda dapat menentukan `format_options={"version": “1.8”}` untuk mengaktifkan jenis membaca dan menulis logis Avro. Untuk informasi lebih lanjut, lihat [Spesifikasi Apache Avro 1.7.7](https://avro.apache.org/docs/1.7.7/spec.html) dan [Spesifikasi Apache Avro 1.8.2](https://avro.apache.org/docs/1.8.2/spec.html).
Konektor Apache Avro 1.8 mendukung konversi tipe logis berikut:
Untuk pembaca: tabel ini menunjukkan konversi antara tipe data Avro (tipe logis dan tipe primitif Avro) dan tipe AWS Glue `DynamicFrame` data untuk pembaca Avro 1.7 dan 1.8.
| Tipe Data Avro: Tipe Logis | Tipe Data Avro: Jenis Primitif Avro | GlueDynamicFrame Tipe Data:Pembaca Avro 1.7 | GlueDynamicFrame Tipe Data: Pembaca Avro 1.8 |
| --- | --- | --- | --- |
| Decimal | byte | BINARY | Decimal |
| Decimal | tetap | BINARY | Decimal |
| Date | int | INT | Date |
| Waktu (milidetik) | int | INT | INT |
| Waktu (mikrodetik) | long | LONG | LONG |
| Timestamp (milidetik) | long | LONG | Timestamp |
| Timestamp (mikrodetik) | long | LONG | LONG |
| Durasi (bukan tipe logis) | tetap 12 | BINARY | BINARY |
Untuk penulis: tabel ini menunjukkan konversi antara tipe AWS Glue `DynamicFrame` data dan tipe data Avro untuk Avro writer 1.7 dan 1.8.
| AWS Glue`DynamicFrame`Tipe Data | Tipe Data Avro:Penulis Avro 1.7 | Tipe Data Avro:Penulis Avro 1.8 |
| --- | --- | --- |
| Decimal | String | decimal |
| Date | String | tanggal |
| Stempel waktu | String | timestamp-micros |
## Dukungan Avro Spark DataFrame
Untuk menggunakan Avro dari Spark DataFrame API, Anda perlu menginstal plugin Spark Avro untuk versi Spark yang sesuai. Versi Spark yang tersedia di pekerjaan Anda ditentukan oleh versi AWS Glue Anda. Untuk informasi selengkapnya tentang versi Spark, lihat[AWS Glue versi](release-notes.md). Plugin ini dikelola oleh Apache, kami tidak membuat jaminan dukungan khusus.
Di AWS Glue 2.0 - gunakan versi 2.4.3 dari plugin Spark Avro. Anda dapat menemukan JAR ini di Maven Central, lihat [org.apache.spark:spark-avro\$12. 12:2.4 .3](https://search.maven.org/artifact/org.apache.spark/spark-avro_2.12/3.1.1/jar).
Di AWS Glue 3.0 - gunakan versi 3.1.1 dari plugin Spark Avro. Anda dapat menemukan JAR ini di Maven Central, lihat [org.apache.spark:spark-avro\$12. 12:3.1 .1](https://search.maven.org/artifact/org.apache.spark/spark-avro_2.12/3.1.1/jar).
Untuk memasukkan ekstra JARs dalam pekerjaan AWS Glue ETL, gunakan parameter `--extra-jars` pekerjaan. Untuk informasi selengkapnya tentang parameter pekerjaan, lihat[Menggunakan parameter pekerjaan dalam pekerjaan AWS Glue](aws-glue-programming-etl-glue-arguments.md). Anda juga dapat mengonfigurasi parameter ini di file Konsol Manajemen AWS.
# Menggunakan format GrokLog di Glue AWS
AWS Glue mengambil data dari sumber dan menulis data ke target yang disimpan dan diangkut dalam berbagai format data. Jika data Anda disimpan atau diangkut dalam format plaintext yang terstruktur secara longgar, dokumen ini memperkenalkan fitur yang tersedia untuk menggunakan data Anda dalam pola Glue AWS through Grok.
AWS Glue mendukung menggunakan pola Grok. Pola Grok mirip dengan grup pengambilan ekspresi reguler. Mereka mengenali pola urutan karakter dalam file plaintext dan memberi mereka jenis dan tujuan. Di AWS Glue, tujuan utamanya adalah membaca log. Untuk pengenalan Grok oleh penulis, lihat [Referensi Logstash: Plugin filter Grok](https://www.elastic.co/guide/en/logstash/current/plugins-filters-grok.html).
| Baca | Tulis | Streaming dibaca | Kelompokkan file kecil | Bookmark tugas |
| --- | --- | --- | --- | --- |
| Didukung | Tidak Berlaku | Didukung | Didukung | Tidak didukung |
## Referensi konfigurasi GrokLog
Anda dapat menggunakan nilai `format_options` berikut dengan `format="grokLog"`:
+ `logFormat` — Menentukan pola Grok yang cocok dengan format log.
+ `customPatterns` — Menentukan pola Grok tambahan yang digunakan di sini.
+ `MISSING` — Menentukan sinyal untuk digunakan dalam mengidentifikasi nilai-nilai yang hilang. Nilai default-nya `'-'`.
+ `LineCount` — Menentukan jumlah baris dalam setiap catatan log. Default-nya adalah `'1'`, dan saat ini hanya catatan baris-tunggal yang didukung.
+ `StrictMode` — Nilai Boolean yang menentukan apakah mode ketat diaktifkan. Dalam mode ketat, pembaca tidak melakukan konversi jenis otomatis atau pemulihan. Nilai default-nya adalah `"false"`.
# Menggunakan format Ion di AWS Glue
AWS Glue mengambil data dari sumber dan menulis data ke target yang disimpan dan diangkut dalam berbagai format data. Jika data Anda disimpan atau diangkut dalam format data Ion, dokumen ini memperkenalkan fitur yang tersedia untuk menggunakan data Anda di Glue AWS .
AWS Glue mendukung menggunakan format Ion. Format ini mewakili struktur data (yang tidak berbasis baris atau kolom) dalam representasi biner dan teks biasa yang dapat dipertukarkan. Untuk pengantar format oleh penulis, lihat [Amazon Ion](https://amzn.github.io/ion-docs/). (Untuk informasi lebih lanjut, lihat [Spesifikasi Amazon Ion](https://amzn.github.io/ion-docs/spec.html).)
Anda dapat menggunakan AWS Glue untuk membaca file Ion dari Amazon S3. Anda dapat membaca `bzip` dan `gzip` mengarsipkan yang berisi file Ion dari S3. Anda mengonfigurasi perilaku kompresi pada [Parameter koneksi S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) alih-alih dalam konfigurasi yang dibahas di halaman ini.
Tabel berikut menunjukkan operasi AWS Glue umum mana yang mendukung opsi format Ion.
| Baca | Tulis | Streaming dibaca | Kelompokkan file kecil | Bookmark tugas |
| --- | --- | --- | --- | --- |
| Didukung | Tidak didukung | Tidak didukung | Didukung | Tidak didukung |
## Contoh: Baca file dan folder Ion dari S3
**Prasyarat:** Anda akan memerlukan jalur S3 (`s3path`) ke file Ion atau folder yang ingin Anda baca.
**Konfigurasi:** Dalam opsi fungsi Anda, tentukan`format="json"`. Dalam Anda`connection_options`, gunakan `paths` kunci untuk menentukan Anda`s3path`. Anda dapat mengonfigurasi bagaimana pembaca berinteraksi dengan S3 di file. `connection_options` Untuk detailnya, lihat Jenis dan opsi koneksi untuk ETL di AWS Glue:[Referensi opsi koneksi Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3).
Skrip AWS Glue ETL berikut menunjukkan proses membaca file Ion atau folder dari S3:
------
#### [ Python ]
Untuk contoh ini, gunakan metode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read ION from S3
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="ion"
)
```
------
#### [ Scala ]
Untuk contoh ini, gunakan operasi [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read ION from S3
import com.amazonaws.services.glue.util.JsonOptions
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 dynamicFrame = glueContext.getSourceWithFormat(
connectionType="s3",
format="ion",
options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
).getDynamicFrame()
}
}
```
------
## Referensi konfigurasi ion
Tidak ada nilai `format_options` untuk `format="ion"`.
# Menggunakan format JSON di AWS Glue
AWS Glue mengambil data dari sumber dan menulis data ke target yang disimpan dan diangkut dalam berbagai format data. Jika data Anda disimpan atau diangkut dalam format data JSON, dokumen ini memperkenalkan Anda ke fitur yang tersedia untuk menggunakan data Anda di Glue. AWS
AWS Glue mendukung menggunakan format JSON. Format ini mewakili struktur data dengan bentuk yang konsisten tetapi konten fleksibel, yang tidak berbasis baris atau kolom. JSON didefinisikan oleh standar paralel yang dikeluarkan oleh beberapa otoritas, salah satunya adalah ECMA-404. Untuk pengenalan format oleh sumber yang sering direferensikan, lihat [Memperkenalkan JSON](https://www.json.org/).
Anda dapat menggunakan AWS Glue untuk membaca file JSON dari Amazon S3, `bzip` serta file JSON `gzip` terkompresi. Anda mengonfigurasi perilaku kompresi pada [Parameter koneksi S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) alih-alih dalam konfigurasi yang dibahas di halaman ini.
| Baca | Tulis | Streaming dibaca | Kelompokkan file kecil | Bookmark tugas |
| --- | --- | --- | --- | --- |
| Didukung | Didukung | Didukung | Didukung | Didukung |
## Contoh: Baca file atau folder JSON dari S3
**Prasyarat:** Anda akan memerlukan jalur S3 (`s3path`) ke file atau folder JSON yang ingin Anda baca.
**Konfigurasi:** Dalam opsi fungsi Anda, tentukan`format="json"`. Dalam Anda`connection_options`, gunakan `paths` kunci untuk menentukan Anda`s3path`. Anda dapat lebih lanjut mengubah bagaimana operasi baca Anda akan melintasi s3 dalam opsi koneksi, berkonsultasi untuk detailnya. [Referensi opsi koneksi Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) Anda dapat mengonfigurasi bagaimana pembaca menafsirkan file JSON di file Anda. `format_options` Untuk detailnya, lihat [Referensi Konfigurasi JSON](#aws-glue-programming-etl-format-json-reference).
Berikut skrip AWS Glue ETL menunjukkan proses membaca file JSON atau folder dari S3:
------
#### [ Python ]
Untuk contoh ini, gunakan metode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read JSON from S3
# For show, we handle a nested JSON file that we can limit with the JsonPath parameter
# For show, we also handle a JSON where a single entry spans multiple lines
# Consider whether optimizePerformance is right for your workflow.
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="json",
format_options={
"jsonPath": "$.id",
"multiline": True,
# "optimizePerformance": True, -> not compatible with jsonPath, multiline
}
)
```
Anda juga dapat menggunakan DataFrames dalam script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read\
.option("multiline", "true")\
.json("s3://s3path")
```
------
#### [ Scala ]
Untuk contoh ini, gunakan operasi [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read JSON from S3
// For show, we handle a nested JSON file that we can limit with the JsonPath parameter
// For show, we also handle a JSON where a single entry spans multiple lines
// Consider whether optimizePerformance is right for your workflow.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, 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 dynamicFrame = glueContext.getSourceWithFormat(
formatOptions=JsonOptions("""{"jsonPath": "$.id", "multiline": true, "optimizePerformance":false}"""),
connectionType="s3",
format="json",
options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
).getDynamicFrame()
}
}
```
Anda juga dapat menggunakan DataFrames dalam script (`pyspark.sql.DataFrame`).
```
val dataFrame = spark.read
.option("multiline", "true")
.json("s3://s3path")
```
------
## Contoh: Tulis file dan folder JSON ke S3
**Prasyarat:** Anda akan memerlukan initialized DataFrame () atau ()`dataFrame`. DynamicFrame `dynamicFrame` Anda juga akan membutuhkan jalur output S3 yang Anda harapkan,`s3path`.
**Konfigurasi:** Dalam opsi fungsi Anda, tentukan`format="json"`. Dalam Anda`connection_options`, gunakan `paths` kunci untuk menentukan`s3path`. Anda selanjutnya dapat mengubah cara penulis berinteraksi dengan S3 di. `connection_options` Untuk detailnya, lihat Opsi format data untuk input dan output ETL di Glue AWS :. [Referensi opsi koneksi Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) Anda dapat mengonfigurasi bagaimana penulis menafsirkan file JSON di file Anda. `format_options` Untuk detailnya, lihat [Referensi Konfigurasi JSON](#aws-glue-programming-etl-format-json-reference).
Berikut skrip AWS Glue ETL menunjukkan proses penulisan file JSON atau folder dari S3:
------
#### [ Python ]
Untuk contoh ini, gunakan metode [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
# Example: Write JSON to S3
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
connection_options={"path": "s3://s3path"},
format="json"
)
```
Anda juga dapat menggunakan DataFrames dalam script (`pyspark.sql.DataFrame`).
```
df.write.json("s3://s3path/")
```
------
#### [ Scala ]
Untuk contoh ini, gunakan metode [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
// Example: Write JSON to S3
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, 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)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="json"
).writeDynamicFrame(dynamicFrame)
}
}
```
Anda juga dapat menggunakan DataFrames dalam script (`pyspark.sql.DataFrame`).
```
df.write.json("s3://s3path")
```
------
## Referensi konfigurasi Json
Anda dapat menggunakan nilai `format_options` berikut dengan `format="json"`:
+ `jsonPath`— [JsonPath](https://github.com/json-path/JsonPath)Ekspresi yang mengidentifikasi objek yang akan dibaca ke dalam catatan. Hal ini sangat berguna ketika sebuah file berisi catatan bersarang di dalam array luar. Misalnya, JsonPath ekspresi berikut menargetkan `id` bidang objek JSON.
```
format="json", format_options={"jsonPath": "$.id"}
```
+ `multiline` — Nilai Boolean yang menentukan apakah satu catatan dapat memiliki panjang hingga beberapa baris. Hal ini dapat terjadi ketika bidang berisi karakter baris baru yang dikutip. Anda harus menetapkan opsi ini ke `"true"` jika ada catatan yang mencakup beberapa baris. Nilai default-nya adalah `"false"`, yang memungkinkan untuk pemecahan file yang lebih agresif selama penguraian.
+ `optimizePerformance`— Nilai Boolean yang menentukan apakah akan menggunakan pembaca SIMD JSON tingkat lanjut bersama dengan format memori kolumnar berbasis Apache Arrow. Hanya tersedia di AWS Glue 3.0. Tidak kompatibel dengan `multiline` atau`jsonPath`. Menyediakan salah satu dari opsi tersebut akan menginstruksikan AWS Glue untuk kembali ke pembaca standar.
+ `withSchema`— Nilai String yang menentukan skema tabel dalam format yang dijelaskan dalam. [Tentukan skema XMLnya secara manual](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema) Hanya digunakan dengan `optimizePerformance` saat membaca dari koneksi non-Katalog.
## Menggunakan pembaca SIMD JSON vektor dengan format kolom Apache Arrow
AWS Glueversi 3.0 menambahkan pembaca vektor untuk data JSON. Ini melakukan 2x lebih cepat dalam kondisi tertentu, dibandingkan dengan pembaca standar. Pembaca ini dilengkapi dengan batasan tertentu yang harus diperhatikan pengguna sebelum digunakan, didokumentasikan di bagian ini.
Untuk menggunakan pembaca yang dioptimalkan, atur `"optimizePerformance"` ke True di properti `format_options` or table. Anda juga perlu menyediakan `withSchema` kecuali membaca dari katalog. `withSchema`mengharapkan masukan seperti yang dijelaskan dalam [Tentukan skema XMLnya secara manual](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema)
```
// Read from S3 data source
glueContext.create_dynamic_frame.from_options(
connection_type = "s3",
connection_options = {"paths": ["s3://s3path"]},
format = "json",
format_options={
"optimizePerformance": True,
"withSchema": SchemaString
})
// Read from catalog table
glueContext.create_dynamic_frame.from_catalog(
database = database,
table_name = table,
additional_options = {
// The vectorized reader for JSON can read your schema from a catalog table property.
"optimizePerformance": True,
})
```
Untuk informasi lebih lanjut tentang bangunan a *SchemaString* di perpustakaan AWS Glue, lihat[PySpark jenis ekstensi](aws-glue-api-crawler-pyspark-extensions-types.md).
**Keterbatasan untuk pembaca CSV vektor**
Perhatikan batasan berikut:
+ Elemen JSON dengan objek bersarang atau nilai array tidak didukung. Jika disediakan, AWS Glue akan kembali ke pembaca standar.
+ Skema harus disediakan, baik dari Katalog atau dengan`withSchema`.
+ Tidak kompatibel dengan `multiline` atau`jsonPath`. Menyediakan salah satu dari opsi tersebut akan menginstruksikan AWS Glue untuk kembali ke pembaca standar.
+ Menyediakan catatan masukan yang tidak sesuai dengan skema masukan akan menyebabkan pembaca gagal.
+ [Catatan kesalahan](https://docs.aws.amazon.com/glue/latest/dg/glue-etl-scala-apis-glue-dynamicframe-class.html#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame) tidak akan dibuat.
+ File JSON dengan karakter multi-byte (seperti karakter Jepang atau China) tidak didukung.
# Menggunakan format ORC di AWS Glue
AWS Glue mengambil data dari sumber dan menulis data ke target yang disimpan dan diangkut dalam berbagai format data. Jika data Anda disimpan atau diangkut dalam format data ORC, dokumen ini memperkenalkan fitur yang tersedia untuk menggunakan data Anda di Glue. AWS
AWS Glue mendukung menggunakan format ORC. Format ini adalah format data berbasis kolom yang berorientasi kinerja. Untuk pengenalan format oleh otoritas standar lihat, [Apache Orc](https://orc.apache.org/docs/).
Anda dapat menggunakan AWS Glue untuk membaca file ORC dari Amazon S3 dan dari sumber streaming serta menulis file ORC ke Amazon S3. Anda dapat membaca dan menulis `bzip` dan `gzip` mengarsipkan yang berisi file ORC dari S3. Anda mengonfigurasi perilaku kompresi pada [Parameter koneksi S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) alih-alih dalam konfigurasi yang dibahas di halaman ini.
Tabel berikut menunjukkan operasi AWS Glue umum mana yang mendukung opsi format ORC.
| Baca | Tulis | Streaming dibaca | Kelompokkan file kecil | Bookmark tugas |
| --- | --- | --- | --- | --- |
| Didukung | Didukung | Didukung | Tidak didukung | Didukung \$1 |
\$1 Didukung dalam AWS Glue versi 1.0 \$1
## Contoh: Baca file atau folder ORC dari S3
**Prasyarat:** Anda akan memerlukan jalur S3 (`s3path`) ke file atau folder ORC yang ingin Anda baca.
**Konfigurasi:** Dalam opsi fungsi Anda, tentukan`format="orc"`. Dalam Anda`connection_options`, gunakan `paths` kunci untuk menentukan Anda`s3path`. Anda dapat mengonfigurasi bagaimana pembaca berinteraksi dengan S3 di file. `connection_options` Untuk detailnya, lihat Jenis dan opsi koneksi untuk ETL di AWS Glue:[Referensi opsi koneksi Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3).
Berikut skrip AWS Glue ETL menunjukkan proses membaca file ORC atau folder dari S3:
------
#### [ Python ]
Untuk contoh ini, gunakan metode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="orc"
)
```
Anda juga dapat menggunakan DataFrames dalam script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read\
.orc("s3://s3path")
```
------
#### [ Scala ]
Untuk contoh ini, gunakan operasi [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.sql.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType="s3",
format="orc",
options=JsonOptions("""{"paths": ["s3://s3path"]}""")
).getDynamicFrame()
}
}
```
Anda juga dapat menggunakan DataFrames dalam script (`pyspark.sql.DataFrame`).
```
val dataFrame = spark.read
.orc("s3://s3path")
```
------
## Contoh: Tulis file dan folder ORC ke S3
**Prasyarat:** Anda akan memerlukan initialized DataFrame () atau ()`dataFrame`. DynamicFrame `dynamicFrame` Anda juga akan membutuhkan jalur output S3 yang Anda harapkan,`s3path`.
**Konfigurasi:** Dalam opsi fungsi Anda, tentukan`format="orc"`. Dalam opsi koneksi Anda, gunakan `paths` kunci untuk menentukan`s3path`. Anda selanjutnya dapat mengubah cara penulis berinteraksi dengan S3 di. `connection_options` Untuk detailnya, lihat Opsi format data untuk input dan output ETL di Glue AWS :. [Referensi opsi koneksi Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) Contoh kode berikut menunjukkan proses:
------
#### [ Python ]
Untuk contoh ini, gunakan metode [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
format="orc",
connection_options={
"path": "s3://s3path"
}
)
```
Anda juga dapat menggunakan DataFrames dalam script (`pyspark.sql.DataFrame`).
```
df.write.orc("s3://s3path/")
```
------
#### [ Scala ]
Untuk contoh ini, gunakan metode [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, 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)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="orc"
).writeDynamicFrame(dynamicFrame)
}
}
```
Anda juga dapat menggunakan DataFrames dalam script (`pyspark.sql.DataFrame`).
```
df.write.orc("s3://s3path/")
```
------
## Referensi konfigurasi ORC
Tidak ada nilai `format_options` untuk `format="orc"`. Namun demikian, setiap pilihan yang diterima oleh kode SparkSQL yang mendasari dapat diteruskan ke sana dengan cara parameter peta `connection_options`.
# 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
)
```
## Referensi konfigurasi bersama
Anda dapat menggunakan `format_options` nilai berikut dengan jenis format apa pun.
+ `attachFilename`— Sebuah string dalam format yang sesuai untuk digunakan sebagai nama kolom. Jika Anda memberikan opsi ini, nama file sumber untuk catatan akan ditambahkan ke catatan. Nilai parameter akan digunakan sebagai nama kolom.
+ `attachTimestamp`— Sebuah string dalam format yang sesuai untuk digunakan sebagai nama kolom. Jika Anda memberikan opsi ini, waktu modifikasi file sumber untuk catatan akan ditambahkan ke catatan. Nilai parameter akan digunakan sebagai nama kolom.