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