Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Koneksi Amazon S3
Anda dapat menggunakan AWS Glue for Spark untuk membaca dan menulis file di Amazon S3. AWS Glue for Spark mendukung banyak format data umum yang disimpan di Amazon S3 di luar kotak, termasuk CSV, Avro, JSON, Orc, dan Parket. Untuk informasi selengkapnya tentang format data yang didukung, lihat[Opsi format data untuk input dan output untuk Spark AWS Glue](aws-glue-programming-etl-format.md). Setiap format data dapat mendukung serangkaian fitur AWS Glue yang berbeda. Konsultasikan halaman untuk format data Anda untuk spesifikasi dukungan fitur. Selain itu, Anda dapat membaca dan menulis file berversi yang disimpan dalam kerangka data lake Hudi, Iceberg, dan Delta Lake. Untuk informasi selengkapnya tentang kerangka data lake, lihat[Menggunakan kerangka kerja data lake dengan pekerjaan AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
Dengan AWS Glue Anda dapat mempartisi objek Amazon S3 Anda ke dalam struktur folder saat menulis, lalu mengambilnya dengan partisi untuk meningkatkan kinerja menggunakan konfigurasi sederhana. Anda juga dapat mengatur konfigurasi untuk mengelompokkan file kecil bersama-sama saat mengubah data Anda untuk meningkatkan kinerja. Anda dapat membaca dan menulis `bzip2` dan `gzip` mengarsipkan di Amazon S3.
**Topics**
+ [Mengkonfigurasi koneksi S3](#aws-glue-programming-etl-connect-s3-configure)
+ [Referensi opsi koneksi Amazon S3](#aws-glue-programming-etl-connect-s3)
+ [Sintaks koneksi usang untuk format data](#aws-glue-programming-etl-connect-legacy-format)
+ [Tidak termasuk kelas penyimpanan Amazon S3](aws-glue-programming-etl-storage-classes.md)
+ [Mengelola partisi untuk output ETL di AWS Glue](aws-glue-programming-etl-partitions.md)
+ [Membaca file input dalam kelompok yang lebih besar](grouping-input-files.md)
+ [Amazon VPC endpoint untuk Amazon S3](vpc-endpoints-s3.md)
## Mengkonfigurasi koneksi S3
Untuk terhubung ke Amazon S3 dalam pekerjaan AWS Glue with Spark, Anda memerlukan beberapa prasyarat:
+ Pekerjaan AWS Glue harus memiliki izin IAM untuk bucket Amazon S3 yang relevan.
Dalam kasus tertentu, Anda perlu mengkonfigurasi prasyarat tambahan:
+ Saat mengonfigurasi akses lintas akun, kontrol akses yang sesuai pada bucket Amazon S3.
+ Untuk alasan keamanan, Anda dapat memilih untuk merutekan permintaan Amazon S3 Anda melalui Amazon VPC. Pendekatan ini dapat memperkenalkan tantangan bandwidth dan ketersediaan. Untuk informasi selengkapnya, lihat [Amazon VPC endpoint untuk Amazon S3](vpc-endpoints-s3.md).
## Referensi opsi koneksi Amazon S3
Mengkhususkan koneksi ke Amazon S3.
Karena Amazon S3 mengelola file daripada tabel, selain menentukan properti koneksi yang disediakan dalam dokumen ini, Anda perlu menentukan konfigurasi tambahan tentang jenis file Anda. Anda menentukan informasi ini melalui opsi format data. Untuk informasi selengkapnya tentang opsi format, lihat[Opsi format data untuk input dan output untuk Spark AWS Glue](aws-glue-programming-etl-format.md). Anda juga dapat menentukan informasi ini dengan mengintegrasikan dengan Katalog Data AWS Glue.
Untuk contoh perbedaan antara opsi koneksi dan opsi format, pertimbangkan bagaimana [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) metode ini mengambil`connection_type`,`connection_options`, `format` dan`format_options`. Bagian ini secara khusus membahas parameter yang disediakan untuk`connection_options`.
Gunakan opsi koneksi berikut dengan `"connectionType": "s3"`:
+ `"paths"`: (Wajib) Daftar path Amazon S3 tempat untuk membaca.
+ `"exclusions"`: (Opsional) Sebuah string yang berisi daftar JSON pola glob dengan gaya Unix untuk mengecualikan. Misalnya, `"[\"**.pdf\"]"` mengecualikan semua file PDF. Untuk informasi selengkapnya tentang sintaks glob yang AWS Glue mendukung, lihat [Sertakan dan Kecualikan](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude) Pola.
+ `"compressionType"`: atau "`compression`": (Opsional) Menentukan cara kompresi data. Gunakan `"compressionType"` untuk sumber Amazon S3 dan `"compression"` untuk target Amazon S3. Hal ini umumnya tidak diperlukan jika data memiliki sebuah ekstensi file standar. Nilai yang mungkin adalah `"gzip"` dan`"bzip2"`). Format kompresi tambahan dapat didukung untuk format tertentu. Untuk spesifikasi dukungan fitur, lihat halaman format data.
+ `"groupFiles"`: (Opsional) Pengelompokan file dalam grup diaktifkan secara default ketika input berisi lebih dari 50.000 file. Untuk mengaktifkan pengelompokan dalam grup dengan jumlah file kurang dari 50.000, tetapkan parameter ini ke `"inPartition"`. Untuk menonaktifkan pengelompokan dalam grup ketika ada lebih dari 50.000 file, tetapkan parameter ini ke `"none"`.
+ `"groupSize"`: (Opsional) Ukuran grup target dalam byte. Default-nya dihitung berdasarkan ukuran input data dan ukuran klaster Anda. Ketika ada kurang dari 50.000 file input, `"groupFiles"` harus diatur ke `"inPartition"` agar ini berlaku.
+ `"recurse"`: (Opsional) Jika diatur ke BETUL, secara rekursif akan membaca file di semua subdirektori pada path yang ditentukan.
+ `"maxBand"`: (Opsional, lanjutan) Opsi ini mengontrol durasi dalam milidetik yang setelahnya pencantuman `s3` kemungkinan akan konsisten. File dengan stempel waktu modifikasi berada dalam `maxBand` milidetik terakhir dilacak secara khusus ketika menggunakan `JobBookmarks` untuk memperhitungkan eventual consistency Amazon S3. Sebagian besar pengguna tidak perlu mengatur opsi ini. Default-nya adalah 900000 milidetik, atau 15 menit.
+ `"maxFilesInBand"`: (Opsional, lanjutan) Opsi ini menentukan jumlah maksimum file yang akan disimpan dari `maxBand` detik terakhir. Jika jumlah ini terlampaui, file tambahan akan dilewati dan hanya diproses dalam eksekusi tugas berikutnya. Sebagian besar pengguna tidak perlu mengatur opsi ini.
+ `"isFailFast"`: (Opsional) Opsi ini menentukan apakah pekerjaan AWS Glue ETL melempar pengecualian penguraian pembaca. Jika diatur ke `true`, maka tugas akan di fail-fast jika empat kali percobaan tugas Spark gagal untuk mengurai data dengan benar.
+ `"catalogPartitionPredicate"`: (Opsional) Digunakan untuk Baca. Isi dari `WHERE` klausa SQL. Digunakan saat membaca dari tabel Katalog Data dengan jumlah partisi yang sangat besar. Mengambil partisi yang cocok dari indeks Katalog Data. Digunakan dengan`push_down_predicate`, opsi pada [create\$1dynamic\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog) metode (dan metode serupa lainnya). Untuk informasi selengkapnya, lihat [Pemfilteran sisi server menggunakan predikat partisi katalog](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-cat-predicates).
+ `"partitionKeys"`: (Opsional) Digunakan untuk Menulis. Sebuah array string label kolom. AWS Glue akan mempartisi data Anda seperti yang ditentukan oleh konfigurasi ini. Untuk informasi selengkapnya, lihat [Menulis partisi](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-writing).
+ `"excludeStorageClasses"`: (Opsional) Digunakan untuk Baca. Array string yang menentukan kelas penyimpanan Amazon S3. AWS Glue akan mengecualikan objek Amazon S3 berdasarkan konfigurasi ini. Untuk informasi selengkapnya, lihat [Tidak termasuk kelas penyimpanan Amazon S3](aws-glue-programming-etl-storage-classes.md).
## Sintaks koneksi usang untuk format data
Format data tertentu dapat diakses menggunakan sintaks jenis koneksi tertentu. Sintaks ini sudah usang. Kami menyarankan Anda menentukan format Anda menggunakan jenis `s3` koneksi dan opsi format yang disediakan [Opsi format data untuk input dan output untuk Spark AWS Glue](aws-glue-programming-etl-format.md) sebagai gantinya.
### “ConnectionType”: “ConnectionType”
Mengkhususkan koneksi ke file yang disimpan di Amazon S3 dalam format file [Apache Hive Optimized Row Columnar (ORC)](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+ORC).
Gunakan opsi koneksi berikut dengan `"connectionType": "orc"`:
+ `paths`: (Wajib) Daftar path Amazon S3 tempat untuk membaca.
+ *( name/value Pasangan opsi lainnya)*: Opsi tambahan apa pun, termasuk opsi pemformatan, diteruskan langsung ke `DataSource` SparkSQL.
### "connectionType": "parquet"
Mengkhususkan koneksi ke file yang disimpan di Amazon S3 dalam format file [Apache Parquet](https://parquet.apache.org/docs/).
Gunakan opsi koneksi berikut dengan `"connectionType": "parquet"`:
+ `paths`: (Wajib) Daftar path Amazon S3 tempat untuk membaca.
+ *( name/value Pasangan opsi lainnya)*: Opsi tambahan apa pun, termasuk opsi pemformatan, diteruskan langsung ke `DataSource` SparkSQL.
# Tidak termasuk kelas penyimpanan Amazon S3
Jika Anda menjalankan tugas AWS Glue ETL yang membaca file atau partisi dari Amazon Simple Storage Service (Amazon S3), Anda dapat mengecualikan beberapa jenis kelas penyimpanan Amazon S3.
Kelas penyimpanan berikut tersedia di Amazon S3:
+ `STANDARD` — Untuk penyimpanan data yang sering diakses untuk tujuan umum.
+ `INTELLIGENT_TIERING` — Untuk data dengan pola akses yang berubah-ubah atau tidak diketahui.
+ `STANDARD_IA` dan `ONEZONE_IA` — Untuk data yang tahan lama, namun tidak banyak diakses.
+ `GLACIER`, `DEEP_ARCHIVE`, dan `REDUCED_REDUNDANCY` — Untuk arsip jangka panjang dan pelestarian digital.
Untuk informasi selengkapnya, lihat [Kelas Penyimpanan Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html) dalam *Panduan Developer Amazon S3*.
Contoh dalam bagian ini menunjukkan cara mengecualikan kelas penyimpanan `GLACIER` dan `DEEP_ARCHIVE`. Kelas-kelas ini memungkinkan Anda untuk mencantumkan file, tetapi tidak akan membiarkan Anda membaca file kecuali mereka dipulihkan. (Untuk informasi lebih lanjut, lihat [Mengembalikan Objek yang Diarsipkan](https://docs.aws.amazon.com/AmazonS3/latest/dev/restoring-objects.html) di *Panduan Developer Amazon S3*.)
Dengan menggunakan pengecualian kelas penyimpanan, Anda dapat memastikan bahwa AWS Glue pekerjaan Anda akan bekerja pada tabel yang memiliki partisi di seluruh tingkatan kelas penyimpanan ini. Tanpa pengecualian, tugas yang membaca data dari tingkatan ini gagal dengan kesalahan berikut: Amazons3Exception: operasi ini tidak berlaku untuk kelas penyimpanan objek.
Ada berbagai cara agar Anda dapat memfilter kelas penyimpanan Amazon S3. AWS Glue
**Topics**
+ [Tidak termasuk kelas penyimpanan Amazon S3 saat membuat Bingkai Dinamis](#aws-glue-programming-etl-storage-classes-dynamic-frame)
+ [Tidak termasuk kelas penyimpanan Amazon S3 pada tabel Katalog Data](#aws-glue-programming-etl-storage-classes-table)
## Tidak termasuk kelas penyimpanan Amazon S3 saat membuat Bingkai Dinamis
Untuk mengecualikan kelas penyimpanan Amazon S3 saat membuat bingkai dinamis, gunakan `excludeStorageClasses` di. `additionalOptions` AWS Gluesecara otomatis menggunakan `Lister` implementasi Amazon S3 sendiri untuk membuat daftar dan mengecualikan file yang sesuai dengan kelas penyimpanan yang ditentukan.
Contoh Python dan Scala berikut menunjukkan bagaimana cara untuk mengecualikan kelas penyimpanan `GLACIER` dan `DEEP_ARCHIVE` saat membuat sebuah bingkai dinamis.
Contoh Python:
```
glueContext.create_dynamic_frame.from_catalog(
database = "my_database",
tableName = "my_table_name",
redshift_tmp_dir = "",
transformation_ctx = "my_transformation_context",
additional_options = {
"excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"]
}
)
```
Contoh scala:
```
val* *df = glueContext.getCatalogSource(
nameSpace, tableName, "", "my_transformation_context",
additionalOptions = JsonOptions(
Map("excludeStorageClasses" -> List("GLACIER", "DEEP_ARCHIVE"))
)
).getDynamicFrame()
```
## Tidak termasuk kelas penyimpanan Amazon S3 pada tabel Katalog Data
Anda dapat menentukan pengecualian kelas penyimpanan yang akan digunakan oleh pekerjaan AWS Glue ETL sebagai parameter tabel di AWS Glue Data Catalog. Anda dapat menyertakan parameter ini dalam `CreateTable` operasi menggunakan AWS Command Line Interface (AWS CLI) atau menggunakan API secara terprogram. Untuk informasi lebih lanjut, lihat [Struktur Tabel](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-Table) dan [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html).
Anda juga dapat menentukan kelas penyimpanan yang dikecualikan di AWS Glue konsol.
**Untuk mengecualikan kelas penyimpanan Amazon S3 (konsol)**
1. Masuk ke Konsol Manajemen AWS dan buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Pada panel navigasi di sebelah kiri, pilih **Tabel**.
1. Pilih nama tabel dalam daftar, kemudian pilih **Edit tabel**.
1. Di **Properti tabel**, tambahkan **excludeStorageClasses** sebagai kunci dan **[\$1"GLACIER\$1",\$1"DEEP\$1ARCHIVE\$1"]** sebagai nilai.
1. Pilih **Terapkan**.
# Mengelola partisi untuk output ETL di AWS Glue
Pemartisian merupakan teknik penting untuk mengatur set data sehingga mereka dapat di-kueri secara efisien. Ia mengatur data dalam sebuah struktur direktori hirarkis berdasarkan nilai-nilai yang berbeda dari satu atau beberapa kolom.
Misalnya, Anda dapat memutuskan untuk melakukan partisi pada log aplikasi Anda di Amazon Simple Storage Service (Amazon S3) berdasarkan tanggal, dirinci berdasarkan tahun, bulan, dan hari. File yang sesuai dengan data satu hari, kemudian ditempatkan dengan prefiks seperti `s3://my_bucket/logs/year=2018/month=01/day=23/`. Sistem seperti Amazon Athena, Amazon Redshift Spectrum, dan AWS Glue sekarang dapat menggunakan partisi ini untuk memfilter data berdasarkan nilai partisi tanpa harus membaca semua data yang mendasarinya dari Amazon S3.
Crawler tidak hanya menyimpulkan jenis dan skema file, mereka juga secara otomatis mengidentifikasi struktur partisi kumpulan data Anda saat mereka mengisi Katalog Data Glue. AWS Kolom partisi yang dihasilkan tersedia untuk kueri dalam pekerjaan AWS Glue ETL atau mesin kueri seperti Amazon Athena.
Setelah melakukan perayapan pada tabel, Anda dapat melihat partisi yang dibuat crawler. Di AWS Glue konsol, pilih **Tabel** di panel navigasi kiri. Pilih tabel yang dibuat oleh crawler, lalu pilih **Lihat partisi**.
Untuk path yang dipartisi dengan gaya Apache Hive di `key=val`, crawler secara otomatis mengisi nama kolom menggunakan nama kunci. Jika tidak, ia menggunakan nama default seperti `partition_0`, `partition_1`, dan sebagainya. Anda dapat mengubah nama default di konsol. Untuk melakukannya, navigasikan ke tabel. Periksa apakah indeks ada di bawah tab **Indeks**. Jika itu masalahnya, Anda perlu menghapusnya untuk melanjutkan (Anda dapat membuatnya kembali menggunakan nama kolom baru setelahnya). Kemudian, pilih **Edit Skema**, dan ubah nama kolom partisi di sana.
Dalam skrip ETL Anda, Anda kemudian dapat mem-filter pada kolom partisi. Karena informasi partisi disimpan dalam Katalog Data, gunakan panggilan API `from_catalog` untuk menyertakan kolom partisi di `DynamicFrame`. Misalnya, gunakan `create_dynamic_frame.from_catalog` sebagai ganti dari `create_dynamic_frame.from_options`.
Partisi adalah teknik optimasi yang mengurangi pemindaian data. Untuk informasi lebih lanjut tentang proses mengidentifikasi kapan teknik ini tepat, lihat [Mengurangi jumlah pemindaian data](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/reduce-data-scan.html) dalam Panduan *Pekerjaan AWS Glue for Apache Spark Praktik Terbaik untuk Penyetelan Kinerja* di AWS Panduan Preskriptif.
## Pra-penyaringan menggunakan predikat pushdown
Dalam banyak kasus, Anda dapat menggunakan predikat pushdown untuk mem-filter pada partisi tanpa harus mencantumkan dan membaca semua file dalam set data Anda. Alih-alih membaca seluruh kumpulan data dan kemudian memfilter di a DynamicFrame, Anda dapat menerapkan filter langsung pada metadata partisi di Katalog Data. Kemudian Anda hanya membuat daftar dan membaca apa yang sebenarnya Anda butuhkan ke dalam DynamicFrame.
Misalnya, dengan Python, Anda bisa menulis yang berikut ini.
```
glue_context.create_dynamic_frame.from_catalog(
database = "my_S3_data_set",
table_name = "catalog_data_table",
push_down_predicate = my_partition_predicate)
```
Ini menciptakan sebuah DynamicFrame yang memuat hanya partisi dalam Katalog Data yang memenuhi ekspresi predikat. Tergantung pada seberapa kecil subset data yang Anda muat, hal ini dapat menghemat banyak waktu pemrosesan.
Ekspresi predikat dapat berupa ekspresi Boolean yang didukung oleh Spark SQL. Apa pun yang Anda bisa masukkan ke dalam klausul `WHERE` dalam kueri Spark SQL akan bisa digunakan. Misalnya, ekspresi predikat `pushDownPredicate = "(year=='2017' and month=='04')"` memuat hanya partisi dalam Katalog Data yang memiliki `year` sama dengan 2017 dan `month` sama dengan 04. Untuk informasi lebih lanjut, lihat [dokumentasi Apache Spark SQL](https://spark.apache.org/docs/2.1.1/sql-programming-guide.html), dan khususnya, [referensi fungsi Scala SQL](https://spark.apache.org/docs/2.1.1/api/scala/index.html#org.apache.spark.sql.functions$).
## Pemfilteran sisi server menggunakan predikat partisi katalog
`push_down_predicate`Opsi ini diterapkan setelah mencantumkan semua partisi dari katalog dan sebelum mencantumkan file dari Amazon S3 untuk partisi tersebut. Jika Anda memiliki banyak partisi untuk sebuah tabel, daftar partisi katalog masih dapat menimbulkan overhead waktu tambahan. Untuk mengatasi overhead ini, Anda dapat menggunakan pemangkasan partisi sisi server dengan `catalogPartitionPredicate` opsi yang menggunakan [indeks partisi](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html) di Katalog Data Glue. AWS Ini membuat pemfilteran partisi jauh lebih cepat ketika Anda memiliki jutaan partisi dalam satu tabel. Anda dapat menggunakan keduanya `push_down_predicate` dan `catalogPartitionPredicate` `additional_options` bersama-sama jika Anda `catalogPartitionPredicate` memerlukan sintaks predikat yang belum didukung dengan indeks partisi katalog.
Python:
```
dynamic_frame = glueContext.create_dynamic_frame.from_catalog(
database=dbname,
table_name=tablename,
transformation_ctx="datasource0",
push_down_predicate="day>=10 and customer_id like '10%'",
additional_options={"catalogPartitionPredicate":"year='2021' and month='06'"}
)
```
Scala:
```
val dynamicFrame = glueContext.getCatalogSource(
database = dbname,
tableName = tablename,
transformationContext = "datasource0",
pushDownPredicate="day>=10 and customer_id like '10%'",
additionalOptions = JsonOptions("""{
"catalogPartitionPredicate": "year='2021' and month='06'"}""")
).getDynamicFrame()
```
**catatan**
`push_down_predicate`Dan `catalogPartitionPredicate` menggunakan sintaks yang berbeda. Yang pertama menggunakan sintaks standar Spark SQL dan yang kemudian menggunakan parser JSQL.
## Menulis partisi
Secara default, a tidak DynamicFrame dipartisi saat ditulis. Semua file output ditulis di tingkat atas dari path output yang ditentukan. Sampai saat ini, satu-satunya cara untuk menulis DynamicFrame menjadi partisi adalah mengubahnya menjadi Spark SQL DataFrame sebelum menulis.
Namun, DynamicFrames sekarang mendukung partisi asli menggunakan urutan kunci, menggunakan `partitionKeys` opsi saat Anda membuat wastafel. Sebagai contoh, kode Python berikut menuliskan set data ke Amazon S3 dalam format Parquet, ke direktori yang dipartisi oleh bidang jenis. Dari sana, Anda dapat memproses partisi ini dengan menggunakan sistem lain, seperti Amazon Athena.
```
glue_context.write_dynamic_frame.from_options(
frame = projectedEvents,
connection_type = "s3",
connection_options = {"path": "$outpath", "partitionKeys": ["type"]},
format = "parquet")
```
# Membaca file input dalam kelompok yang lebih besar
Anda dapat mengatur properti tabel Anda untuk memungkinkan tugas ETL AWS Glue untuk mengelompokkan file ketika dibaca dari penyimpanan data Amazon S3. Properti ini memungkinkan setiap tugas ETL untuk membaca sekelompok file input ke dalam partisi di memori tunggal, ini sangat berguna ketika ada sejumlah besar file kecil di Penyimpanan data Amazon S3 Anda. Ketika Anda mengatur properti tertentu, Anda menginstruksikan AWS Glue untuk mengelompokkan file dalam partisi data Amazon S3 dan mengatur ukuran grup yang akan dibaca. Anda juga dapat mengatur pilihan ini ketika membaca dari penyimpanan data Amazon S3 dengan metode `create_dynamic_frame.from_options`.
Untuk mengaktifkan pengelompokan file untuk sebuah tabel, Anda mengatur pasangan nilai-kunci di bidang parameter struktur tabel Anda. Gunakan notasi JSON untuk menetapkan nilai untuk bidang parameter tabel Anda. Untuk informasi lebih lanjut tentang mengedit properti tabel, lihat [Melihat dan mengelola detail tabel](tables-described.md#console-tables-details).
Anda dapat menggunakan metode ini untuk mengaktifkan pengelompokan untuk tabel di Katalog Data dengan menyimpan data Amazon S3.
**groupFiles**
Atur **groupFiles** ke `inPartition` untuk mengaktifkan pengelompokan file dalam partisi data Amazon S3. AWS Glue secara otomatis memungkinkan pengelompokan jika ada lebih dari 50.000 file input, seperti dalam contoh berikut.
```
'groupFiles': 'inPartition'
```
**groupSize**
Atur **groupSize** untuk ukuran target grup dalam byte. Properti **groupSize** bersifat opsional, jika tidak disediakan, AWS Glue menghitung ukuran untuk menggunakan semua core CPU di klaster sekaligus masih mengurangi jumlah keseluruhan tugas ETL dan partisi di memori.
Sebagai contoh, berikut ini menetapkan ukuran grup ke 1 MB.
```
'groupSize': '1048576'
```
Perhatikan bahwa `groupsize` harus diatur dengan hasil perhitungan. Sebagai contoh 1024 \$1 1024 = 1048576.
**rekursi**
Atur **rekursi** ke `True` untuk secara rekursif membaca file di semua subdirektori saat menentukan `paths` sebagai array path. Anda tidak perlu mengatur **recurse** if `paths` adalah array kunci objek di Amazon S3, atau jika format input parquet/orc, seperti pada contoh berikut.
```
'recurse':True
```
Jika Anda membaca dari Amazon S3 secara langsung menggunakan metode `create_dynamic_frame.from_options`, tambahkan opsi koneksi ini. Sebagai contoh, upaya berikut untuk mengelompokkan file ke dalam grup 1 MB.
```
df = glueContext.create_dynamic_frame.from_options("s3", {'paths': ["s3://s3path/"], 'recurse':True, 'groupFiles': 'inPartition', 'groupSize': '1048576'}, format="json")
```
**catatan**
`groupFiles`didukung untuk DynamicFrames dibuat dari format data berikut: csv, ion, GrokLog, json, dan xml. Opsi ini tidak didukung untuk avro, parket, dan orc.
# Amazon VPC endpoint untuk Amazon S3
Untuk alasan keamanan, banyak AWS pelanggan menjalankan aplikasi mereka dalam lingkungan Amazon Virtual Private Cloud (Amazon VPC). Dengan Amazon VPC, Anda dapat meluncurkan EC2 instans Amazon ke cloud pribadi virtual, yang secara logis terisolasi dari jaringan lain—termasuk internet publik. Dengan Amazon VPC, Anda dapat mengontrol rentang alamat IP, subnet, tabel perutean, gateway jaringan, dan pengaturan keamanan.
**catatan**
Jika Anda membuat AWS akun setelah 2013-12-04, Anda sudah memiliki VPC default di setiap Wilayah. AWS Anda dapat segera mulai menggunakan VPC default Anda tanpa perlu konfigurasi tambahan.
Untuk informasi lebih lanjut, lihat [VPC dan Subnet Default Anda](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html) di Panduan Pengguna Amazon VPC.
Banyak pelanggan memiliki kekhawatiran yang sah mengenai privasi dan keamanan saat mengirim dan menerima data melalui internet publik. Para pelanggan dapat mengatasi masalah ini dengan menggunakan virtual private network (VPN) untuk merutekan semua lalu lintas jaringan Amazon S3 melalui infrastruktur jaringan perusahaan mereka sendiri. Namun, pendekatan ini dapat menimbulkan tantangan bandwidth dan ketersediaan.
VPC endpoint untuk Amazon S3 dapat meringankan tantangan ini. Sebuah VPC endpoint untuk Amazon S3 memungkinkan AWS Glue untuk menggunakan alamat IP privat guna mengakses Amazon S3 tanpa terbuka ke internet publik. AWS Glue tidak memerlukan alamat IP privat, dan Anda tidak memerlukan sebuah gateway internet, perangkat NAT, atau virtual private gateway di VPC Anda. Anda menggunakan kebijakan titik akhir guna mengendalikan akses ke Amazon S3. Lalu lintas antara VPC Anda dan AWS layanan tidak meninggalkan jaringan Amazon.
Ketika Anda membuat VPC endpoint untuk Amazon S3, setiap permintaan untuk titik akhir Amazon S3 dalam Wilayah (misalnya, *s3.us-west-2.amazonaws.com*) dirutekan ke titik akhir Amazon S3 privat dalam jaringan Amazon. Anda tidak perlu memodifikasi aplikasi yang berjalan di EC2 instans Amazon di VPC Anda—nama endpoint tetap sama, tetapi rute ke Amazon S3 tetap sepenuhnya berada dalam jaringan Amazon, dan tidak mengakses internet publik.
Untuk informasi selengkapnya tentang VPC endpoint, lihat [VPC Endpoint](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html) dalam Panduan Pengguna Amazon VPC.
Diagram berikut menunjukkan bagaimana AWS Glue dapat menggunakan VPC endpoint untuk mengakses Amazon S3.
![\[Alur lalu lintas jaringan menunjukkan koneksi VPC ke Amazon S3.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/PopulateCatalog-vpc-endpoint.png)
**Untuk menyiapkan akses untuk Amazon S3**
1. Masuk ke Konsol Manajemen AWS dan buka konsol VPC Amazon di. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)
1. Pada panel navigasi kiri, pilih **Titik Akhir**.
1. Pilih **Buat titik akhir**, dan ikuti langkah-langkah untuk membuat VPC endpoint akhir Amazon S3 jenis Gateway.