Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Koneksi JDBC Jenis database tertentu, biasanya relasional, mendukung koneksi melalui standar JDBC. Untuk informasi selengkapnya tentang JDBC, lihat dokumentasi [Java JDBC](https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/) API. AWS Glue secara native mendukung koneksi ke database tertentu melalui konektor JDBC mereka - perpustakaan JDBC disediakan dalam pekerjaan Glue Spark. AWS Saat menghubungkan ke tipe database ini menggunakan pustaka AWS Glue, Anda memiliki akses ke serangkaian opsi standar. Nilai ConnectionType JDBC meliputi yang berikut: + `"connectionType": "sqlserver"`: Mengkhususkan koneksi ke Microsoft SQL Server. + `"connectionType": "mysql"`: Mengkhususkan koneksi ke basis data MySQL. + `"connectionType": "oracle"`: Mengkhususkan koneksi ke basis data Oracle. + `"connectionType": "postgresql"`: Mengkhususkan koneksi ke basis data PostgreSQL. + `"connectionType": "redshift"`: Mengkhususkan koneksi ke basis data Amazon Redshift. Untuk informasi selengkapnya, lihat [Koneksi Redshift](aws-glue-programming-etl-connect-redshift-home.md). Tabel berikut mencantumkan versi driver JDBC yang didukung AWS Glue. | Produk | Versi driver JDBC untuk Glue 5.1 | Versi driver JDBC untuk Glue 5.0 | Versi driver JDBC untuk Glue 4.0 | Versi driver JDBC untuk Glue 3.0 | Versi driver JDBC untuk Glue 0.9, 1.0, 2.0 | | --- | --- | --- | --- | --- | --- | | Microsoft SQL Server | 10.2.0 | 10.2.0 | 9.4.0 | 7.x | 6.x | | MySQL | 8.0.33 | 8.0.33 | 8.0.23 | 8.0.23 | 5.1 | | Oracle Database | 23.3.0.23.09 | 23.3.0.23.09 | 21.7 | 21.1 | 11.2 | | PostgreSQL | 42.7.3 | 42.7.3 | 42.3.6 | 42.2.18 | 42.1.x | | Pergeseran Merah Amazon\$1 | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.16 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 | \$1 Untuk jenis koneksi Amazon Redshift, semua name/value pasangan opsi lain yang disertakan dalam opsi koneksi untuk koneksi JDBC, termasuk opsi pemformatan, diteruskan langsung ke SparkSQL yang mendasarinya. DataSource Dalam pekerjaan AWS Glue with Spark di AWS Glue 4.0 dan versi yang lebih baru, konektor asli AWS Glue untuk Amazon Redshift menggunakan integrasi Amazon Redshift untuk Apache Spark. Untuk informasi selengkapnya, lihat [integrasi Amazon Redshift untuk Apache](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) Spark. Di versi sebelumnya, lihat [Sumber data Amazon Redshift untuk Spark](https://github.com/databricks/spark-redshift). Untuk mengonfigurasi VPC Amazon agar tersambung ke penyimpanan data Amazon RDS menggunakan JDBC, lihat. [Menyiapkan Amazon VPC untuk koneksi JDBC ke penyimpanan data Amazon RDS dari AWS Glue](setup-vpc-for-glue-access.md) **catatan** AWS Glue jobs hanya dikaitkan dengan satu subnet selama menjalankan. Ini dapat memengaruhi kemampuan Anda untuk terhubung ke beberapa sumber data melalui pekerjaan yang sama. Perilaku ini tidak terbatas pada sumber JDBC. **Topics** + [Referensi opsi koneksi JDBC](#aws-glue-programming-etl-connect-jdbc) + [Gunakan SampleQuery](#aws-glue-programming-etl-jdbc-samplequery) + [Gunakan driver JDBC khusus](#aws-glue-programming-etl-jdbc-custom-driver) + [Membaca dari tabel JDBC secara paralel](run-jdbc-parallel-read-job.md) + [Menyiapkan Amazon VPC untuk koneksi JDBC ke penyimpanan data Amazon RDS dari AWS Glue](setup-vpc-for-glue-access.md) ## Referensi opsi koneksi JDBC Jika Anda sudah memiliki koneksi AWS Glue JDBC yang ditentukan, Anda dapat menggunakan kembali properti konfigurasi yang ditentukan di dalamnya, seperti: url, pengguna, dan kata sandi; jadi Anda tidak perlu menentukannya dalam kode sebagai opsi koneksi. Fitur ini tersedia dalam AWS Glue 3.0 dan versi yang lebih baru. Untuk melakukannya, gunakan properti koneksi berikut: + `"useConnectionProperties"`: Setel ke “true” untuk menunjukkan Anda ingin menggunakan konfigurasi dari koneksi. + `"connectionName"`: Masukkan nama koneksi untuk mengambil konfigurasi dari, koneksi harus ditentukan di wilayah yang sama dengan pekerjaan. Gunakan opsi koneksi ini dengan koneksi JDBC: + `"url"`: (Wajib) URL JDBC untuk basis data. + `"dbtable"`: (Wajib) Tabel database untuk dibaca. Untuk penyimpanan data JDBC yang mendukung skema dalam basis data, tentukan `schema.table-name`. Jika skema tidak disediakan, maka skema "publik" default digunakan. + `"user"`: (Wajib) Nama pengguna yang akan digunakan saat terhubung. + `"password"`: (Wajib) Kata sandi yang akan digunakan saat terhubung. + (Opsional) Opsi berikut memungkinkan Anda untuk memberikan driver JDBC kustom. Gunakan opsi ini jika Anda harus menggunakan driver yang AWS Glue tidak mendukung secara asli. Tugas ETL dapat menggunakan versi driver JDBC yang berbeda untuk sumber data dan target, bahkan jika sumber dan target adalah produk basis data yang sama. Hal ini memungkinkan Anda untuk memigrasi data antara sumber dan target basis data dengan versi yang berbeda. Untuk menggunakan opsi ini, Anda harus terlebih dahulu mengunggah file JAR dari driver JDBC ke Amazon S3. + `"customJdbcDriverS3Path"`: Jalur Amazon S3 dari driver JDBC khusus. + `"customJdbcDriverClassName"`: Nama kelas driver JDBC. + `"bulkSize"`: (Opsional) Digunakan untuk mengkonfigurasi sisipan paralel untuk mempercepat beban massal ke target JDBC. Tentukan nilai integer untuk tingkat paralelisme yang akan digunakan saat menulis atau memasukkan data. Opsi ini berguna untuk meningkatkan kinerja penulisan ke dalam database seperti Arch User Repository (AUR). + `"hashfield"`(Opsional) String, digunakan untuk menentukan nama kolom dalam tabel JDBC yang akan digunakan untuk membagi data menjadi partisi saat membaca dari tabel JDBC secara paralel. Berikan “hashfield” ATAU “hashexpression”. Untuk informasi selengkapnya, lihat [Membaca dari tabel JDBC secara paralel](run-jdbc-parallel-read-job.md). + `"hashexpression"`(Opsional) Klausa pilih SQL mengembalikan bilangan bulat. Digunakan untuk membagi data dalam tabel JDBC menjadi partisi saat membaca dari tabel JDBC secara paralel. Berikan “hashfield” ATAU “hashexpression”. Untuk informasi selengkapnya, lihat [Membaca dari tabel JDBC secara paralel](run-jdbc-parallel-read-job.md). + `"hashpartitions"`(Opsional) Sebuah bilangan bulat positif. Digunakan untuk menentukan jumlah pembacaan paralel dari tabel JDBC saat membaca dari tabel JDBC secara paralel. Default: 7. Untuk informasi selengkapnya, lihat [Membaca dari tabel JDBC secara paralel](run-jdbc-parallel-read-job.md). + `"sampleQuery"`: (Opsional) Pernyataan kueri SQL kustom. Digunakan untuk menentukan subset informasi dalam tabel untuk mengambil sampel isi tabel. **Ketika dikonfigurasi tanpa memperhatikan data Anda, itu bisa kurang efisien daripada DynamicFrame metode, menyebabkan batas waktu atau kehabisan kesalahan memori.** Untuk informasi selengkapnya, lihat [Gunakan SampleQuery](#aws-glue-programming-etl-jdbc-samplequery). + `"enablePartitioningForSampleQuery"`: (Opsional) Sebuah boolean. Default: false. Digunakan untuk mengaktifkan membaca dari tabel JDBC secara paralel saat menentukan. `sampleQuery` **Jika disetel ke true, `sampleQuery` harus diakhiri dengan “where” atau “and” agar AWS Glue menambahkan kondisi partisi.** Untuk informasi selengkapnya, lihat [Gunakan SampleQuery](#aws-glue-programming-etl-jdbc-samplequery). + `"sampleSize"`: (Opsional) Sebuah bilangan bulat positif. Membatasi jumlah baris yang dikembalikan oleh kueri sampel. Bekerja hanya ketika `enablePartitioningForSampleQuery` itu benar. Jika partisi tidak diaktifkan, Anda harus langsung menambahkan `"limit x"` `sampleQuery` untuk membatasi ukuran. Untuk informasi selengkapnya, lihat [Gunakan SampleQuery](#aws-glue-programming-etl-jdbc-samplequery). ## Gunakan SampleQuery Bagian ini menjelaskan cara menggunakan`sampleQuery`, `sampleSize` dan`enablePartitioningForSampleQuery`. `sampleQuery`dapat menjadi cara yang efisien untuk mengambil sampel beberapa baris dataset Anda. Secara default, query dijalankan oleh seorang eksekutor tunggal. Ketika dikonfigurasi tanpa memperhatikan data Anda, itu bisa kurang efisien daripada DynamicFrame metode, menyebabkan batas waktu atau kehabisan kesalahan memori. Menjalankan SQL pada database yang mendasarinya sebagai bagian dari pipeline ETL Anda umumnya hanya diperlukan untuk tujuan kinerja. Jika Anda mencoba untuk melihat pratinjau beberapa baris dataset Anda, pertimbangkan untuk menggunakan[show](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-show). Jika Anda mencoba untuk mengubah dataset Anda menggunakan SQL, pertimbangkan [toDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-toDF) untuk menggunakan untuk mendefinisikan transformasi SparkSQL terhadap data Anda dalam formulir. DataFrame Meskipun kueri Anda dapat memanipulasi berbagai tabel, `dbtable` tetap diperlukan. **Menggunakan SampleQuery untuk mengambil sampel tabel Anda** Saat menggunakan perilaku SampleQuery default untuk mengambil sampel data Anda, AWS Glue tidak mengharapkan throughput yang substansif, sehingga menjalankan kueri Anda pada satu eksekutor. Untuk membatasi data yang Anda berikan dan tidak menyebabkan masalah kinerja, kami sarankan Anda memberikan SQL dengan `LIMIT` klausa. **Example Gunakan SampleQuery tanpa partisi** Contoh kode berikut menunjukkan bagaimana menggunakan `sampleQuery` tanpa partisi. ``` //A full sql query statement. val query = "select name from $tableName where age > 0 limit 1" val connectionOptions = JsonOptions(Map( "url" -> url, "dbtable" -> tableName, "user" -> user, "password" -> password, "sampleQuery" -> query )) val dyf = glueContext.getSource("mysql", connectionOptions) .getDynamicFrame() ``` **Menggunakan SampleQuery terhadap kumpulan data yang lebih besar** Jika Anda membaca kumpulan data besar, Anda mungkin perlu mengaktifkan partisi JDBC untuk menanyakan tabel secara paralel. Untuk informasi selengkapnya, lihat [Membaca dari tabel JDBC secara paralel](run-jdbc-parallel-read-job.md). Untuk digunakan `sampleQuery` dengan partisi JDBC, atur ke true. `enablePartitioningForSampleQuery` Mengaktifkan fitur ini mengharuskan Anda untuk membuat beberapa perubahan pada Anda`sampleQuery`. Saat menggunakan partisi JDBC dengan`sampleQuery`, kueri Anda harus diakhiri dengan “where” atau “and” agar AWS Glue menambahkan kondisi partisi. Jika Anda ingin membatasi hasil SampleQuery Anda saat membaca dari tabel JDBC secara paralel, atur `"sampleSize"` parameter daripada menentukan klausa. `LIMIT` **Example Gunakan SampleQuery dengan partisi JDBC** Contoh kode berikut menunjukkan bagaimana menggunakan `sampleQuery` dengan partisi JDBC. ``` //note that the query should end with "where" or "and" if use with JDBC partitioning. val query = "select name from $tableName where age > 0 and" //Enable JDBC partitioning by setting hashfield. //to use sampleQuery with partitioning, set enablePartitioningForSampleQuery. //use sampleSize to limit the size of returned data. val connectionOptions = JsonOptions(Map( "url" -> url, "dbtable" -> tableName, "user" -> user, "password" -> password, "hashfield" -> primaryKey, "sampleQuery" -> query, "enablePartitioningForSampleQuery" -> true, "sampleSize" -> "1" )) val dyf = glueContext.getSource("mysql", connectionOptions) .getDynamicFrame() ``` **Catatan dan Pembatasan:** Contoh kueri tidak dapat digunakan bersama dengan bookmark pekerjaan. Status bookmark akan diabaikan ketika konfigurasi untuk keduanya disediakan. ## Gunakan driver JDBC khusus Contoh kode berikut ini menunjukkan cara membaca dan menulis ke basis data JDBC dengan driver JDBC kustom. Mereka menunjukkan membaca dari satu versi produk database, dan menulis ke versi yang lebih baru dari produk yang sama. ------ #### [ Python ] ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext, SparkConf from awsglue.context import GlueContext from awsglue.job import Job import time from pyspark.sql.types import StructType, StructField, IntegerType, StringType sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session # Construct JDBC connection options connection_mysql5_options = { "url": "jdbc:mysql://:3306/db", "dbtable": "test", "user": "admin", "password": "pwd"} connection_mysql8_options = { "url": "jdbc:mysql://:3306/db", "dbtable": "test", "user": "admin", "password": "pwd", "customJdbcDriverS3Path": "s3://amzn-s3-demo-bucket/mysql-connector-java-8.0.17.jar", "customJdbcDriverClassName": "com.mysql.cj.jdbc.Driver"} connection_oracle11_options = { "url": "jdbc:oracle:thin:@//:1521/ORCL", "dbtable": "test", "user": "admin", "password": "pwd"} connection_oracle18_options = { "url": "jdbc:oracle:thin:@//:1521/ORCL", "dbtable": "test", "user": "admin", "password": "pwd", "customJdbcDriverS3Path": "s3://amzn-s3-demo-bucket/ojdbc10.jar", "customJdbcDriverClassName": "oracle.jdbc.OracleDriver"} # Read from JDBC databases with custom driver df_mysql8 = glueContext.create_dynamic_frame.from_options(connection_type="mysql", connection_options=connection_mysql8_options) # Read DynamicFrame from MySQL 5 and write to MySQL 8 df_mysql5 = glueContext.create_dynamic_frame.from_options(connection_type="mysql", connection_options=connection_mysql5_options) glueContext.write_from_options(frame_or_dfc=df_mysql5, connection_type="mysql", connection_options=connection_mysql8_options) # Read DynamicFrame from Oracle 11 and write to Oracle 18 df_oracle11 = glueContext.create_dynamic_frame.from_options(connection_type="oracle", connection_options=connection_oracle11_options) glueContext.write_from_options(frame_or_dfc=df_oracle11, connection_type="oracle", connection_options=connection_oracle18_options) ``` ------ #### [ Scala ] ``` import com.amazonaws.services.glue.GlueContext import com.amazonaws.services.glue.MappingSpec import com.amazonaws.services.glue.errors.CallSite import com.amazonaws.services.glue.util.GlueArgParser import com.amazonaws.services.glue.util.Job import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.DynamicFrame import org.apache.spark.SparkContext import scala.collection.JavaConverters._ object GlueApp { val MYSQL_5_URI: String = "jdbc:mysql://:3306/db" val MYSQL_8_URI: String = "jdbc:mysql://:3306/db" val ORACLE_11_URI: String = "jdbc:oracle:thin:@//:1521/ORCL" val ORACLE_18_URI: String = "jdbc:oracle:thin:@//:1521/ORCL" // Construct JDBC connection options lazy val mysql5JsonOption = jsonOptions(MYSQL_5_URI) lazy val mysql8JsonOption = customJDBCDriverJsonOptions(MYSQL_8_URI, "s3://amzn-s3-demo-bucket/mysql-connector-java-8.0.17.jar", "com.mysql.cj.jdbc.Driver") lazy val oracle11JsonOption = jsonOptions(ORACLE_11_URI) lazy val oracle18JsonOption = customJDBCDriverJsonOptions(ORACLE_18_URI, "s3://amzn-s3-demo-bucket/ojdbc10.jar", "oracle.jdbc.OracleDriver") def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray) Job.init(args("JOB_NAME"), glueContext, args.asJava) // Read from JDBC database with custom driver val df_mysql8: DynamicFrame = glueContext.getSource("mysql", mysql8JsonOption).getDynamicFrame() // Read DynamicFrame from MySQL 5 and write to MySQL 8 val df_mysql5: DynamicFrame = glueContext.getSource("mysql", mysql5JsonOption).getDynamicFrame() glueContext.getSink("mysql", mysql8JsonOption).writeDynamicFrame(df_mysql5) // Read DynamicFrame from Oracle 11 and write to Oracle 18 val df_oracle11: DynamicFrame = glueContext.getSource("oracle", oracle11JsonOption).getDynamicFrame() glueContext.getSink("oracle", oracle18JsonOption).writeDynamicFrame(df_oracle11) Job.commit() } private def jsonOptions(url: String): JsonOptions = { new JsonOptions( s"""{"url": "${url}", |"dbtable":"test", |"user": "admin", |"password": "pwd"}""".stripMargin) } private def customJDBCDriverJsonOptions(url: String, customJdbcDriverS3Path: String, customJdbcDriverClassName: String): JsonOptions = { new JsonOptions( s"""{"url": "${url}", |"dbtable":"test", |"user": "admin", |"password": "pwd", |"customJdbcDriverS3Path": "${customJdbcDriverS3Path}", |"customJdbcDriverClassName" : "${customJdbcDriverClassName}"}""".stripMargin) } } ``` ------ # Membaca dari tabel JDBC secara paralel Anda dapat mengatur properti dari tabel JDBC Anda untuk memungkinkan AWS Glue membaca data secara paralel. Ketika Anda mengatur properti tertentu, Anda menginstruksikan AWS Glue untuk menjalankan kueri SQL paralel terhadap partisi logis data Anda. Anda dapat mengontrol pemartisian dengan menetapkan bidang hash atau ekspresi hash. Anda juga dapat mengontrol jumlah baca paralel yang digunakan untuk mengakses data Anda. Membaca dari tabel JDBC secara paralel adalah teknik optimasi yang dapat meningkatkan kinerja. Untuk informasi lebih lanjut tentang proses mengidentifikasi kapan teknik ini tepat, lihat [Kurangi jumlah pemindaian data](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/parallelize-tasks.html) dalam *Praktik terbaik untuk penyetelan AWS Glue kinerja untuk panduan pekerjaan Apache Spark* pada AWS Panduan Preskriptif. Untuk memungkinkan baca paralel, Anda dapat 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 juga dapat mengaktifkan baca paralel ketika Anda memanggil metode ETL (extract, transform, dan load) `create_dynamic_frame_from_options` dan `create_dynamic_frame_from_catalog`. Untuk informasi lebih lanjut tentang menentukan opsi dalam metode ini, lihat [from\$1options](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_options) dan [from\$1catalog](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_catalog). Anda dapat menggunakan metode ini untuk tabel JDBC, yaitu, sebagian besar tabel yang data dasar-nya merupakan penyimpanan data JDBC. Properti ini diabaikan saat membaca tabel Amazon Redshift dan tabel Amazon S3. **hashfield** Atur `hashfield` dengan nama kolom dalam tabel JDBC yang akan digunakan untuk membagi data menjadi partisi. Untuk hasil terbaik, kolom ini harus memiliki distribusi nilai yang genap untuk menyebarkan data antar partisi. Kolom ini dapat berupa tipe data apa pun. AWS Glue menghasilkan kueri yang tidak bertumpang tindih yang berjalan secara paralel untuk membaca data yang dipartisi oleh kolom ini. Misalnya, jika data Anda didistribusikan secara merata berdasarkan bulan, Anda dapat menggunakan kolom `month` untuk membaca setiap bulan data secara paralel. ``` 'hashfield': 'month' ``` AWS Glue membuat sebuah kueri untuk meng-hash nilai bidang ke nomor partisi dan menjalankan kueri untuk semua partisi secara paralel. Untuk menggunakan kueri Anda sendiri untuk melakukan partisi pada pembacaan tabel, berikan `hashexpression`, bukan sebuah `hashfield`. **hashexpression** Atur `hashexpression` dengan ekspresi SQL (sesuai dengan tata bahasa mesin basis data JDBC) yang mengembalikan bilangan bulat. Sebuah ekspresi sederhana adalah nama dari setiap kolom numerik dalam tabel. AWS Glue menghasilkan kueri SQL untuk membaca data JDBC secara paralel menggunakan `hashexpression` di `WHERE` untuk melakukan partisi data. Misalnya, gunakan kolom numerik `customerID` untuk membaca data yang dipartisi berdasarkan nomor pelanggan. ``` 'hashexpression': 'customerID' ``` Untuk membuat AWS Glue mengontrol partisi, berikan `hashfield`, bukan sebuah `hashexpression`. **hashpartitions** Atur `hashpartitions` dengan jumlah baca paralel tabel JDBC. Jika properti ini tidak diatur, maka nilai default 7 akan digunakan. Sebagai contoh, tetapkan jumlah baca paralel ke `5` sehingga AWS Glue membaca data Anda dengan lima kueri (atau lebih sedikit). ``` 'hashpartitions': '5' ``` # Menyiapkan Amazon VPC untuk koneksi JDBC ke penyimpanan data Amazon RDS dari AWS Glue Saat menggunakan JDBC untuk terhubung ke database di Amazon RDS, Anda perlu melakukan pengaturan tambahan. Untuk mengaktifkan AWS Glue komponen untuk berkomunikasi dengan Amazon RDS, Anda harus mengatur akses ke penyimpanan data Amazon RDS Anda di Amazon VPC. Untuk mengaktifkan AWS Glue untuk berkomunikasi antara komponen-komponennya, tentukan grup keamanan dengan aturan inbound self-referencing untuk semua port TCP. Dengan membuat aturan referensi diri, Anda dapat membatasi sumber ke grup keamanan yang sama di VPC. Aturan referensi diri tidak akan membuka VPC ke semua jaringan. Grup keamanan default untuk VPC Anda mungkin sudah memiliki aturan self-referencing inbound untuk semua lalu lintas. **Untuk mengatur akses antara penyimpanan data AWS Glue dan Amazon RDS** 1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/). 1. Di konsol Amazon RDS, identifikasi grup keamanan yang digunakan untuk mengontrol akses ke database Amazon RDS Anda. Di panel navigasi kiri, pilih **Databases**, lalu pilih instance yang ingin Anda sambungkan dari daftar di panel utama. Di halaman detail database, temukan **grup keamanan VPC** di tab **Konektivitas & keamanan**. 1. Berdasarkan arsitektur jaringan Anda, identifikasi grup keamanan terkait mana yang terbaik untuk dimodifikasi untuk memungkinkan akses ke layanan AWS Glue. Simpan namanya, *database-security-group* untuk referensi future. Jika tidak ada grup keamanan yang sesuai, ikuti petunjuk untuk [Menyediakan akses ke instans DB Anda di VPC Anda dengan membuat grup keamanan dalam dokumentasi](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SettingUp.html) Amazon RDS. 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. Di konsol VPC Amazon, identifikasi cara memperbarui. *database-security-group* Di panel navigasi kiri, pilih **Grup keamanan**, lalu pilih *database-security-group* dari daftar di panel utama. 1. Identifikasi ID grup keamanan untuk*database-security-group*,*database-sg-id*. Simpan untuk referensi masa depan. Di halaman detail grup keamanan, temukan **ID grup keamanan**. 1. Ubah aturan masuk untuk*database-security-group*, tambahkan aturan referensi diri untuk memungkinkan AWS Glue komponen berkomunikasi. Secara khusus, tambahkan atau konfirmasikan bahwa ada aturan di mana **Type** adalah`All TCP`, **Protocol** adalah`TCP`, **Port Range** mencakup semua port, dan **Source** adalah*database-sg-id*. Verifikasi bahwa grup keamanan yang Anda masukkan untuk **Sumber** sama dengan grup keamanan yang Anda edit. Di halaman detail grup keamanan, pilih **Edit aturan masuk**. Aturan inbound terlihat serupa dengan ini: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/setup-vpc-for-glue-access.html) 1. Tambahkan aturan untuk lalu lintas keluar. Di halaman detail grup keamanan, pilih **Edit aturan keluar**. Jika grup keamanan Anda mengizinkan semua lalu lintas keluar, Anda tidak perlu aturan terpisah. Contoh: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/setup-vpc-for-glue-access.html) Jika arsitektur jaringan Anda dirancang untuk membatasi lalu lintas keluar, buat aturan keluar berikut: Buat aturan referensi mandiri di mana **Type** adalah`All TCP`, **Protocol** adalah`TCP`, **Port Range** mencakup semua port, dan **Destination** adalah. *database-sg-id* Verifikasi bahwa grup keamanan yang Anda masukkan untuk **Tujuan** sama dengan grup keamanan yang Anda edit. Jika menggunakan titik akhir VPC Amazon S3, tambahkan aturan HTTPS untuk mengizinkan lalu lintas dari VPC ke Amazon S3. Buat aturan di mana **Type** adalah`HTTPS`, **Protocol** adalah`TCP`, **Port Range** adalah `443` dan **Destination** adalah ID dari daftar awalan terkelola untuk titik akhir gateway Amazon S3,. *s3-prefix-list-id* Untuk informasi selengkapnya tentang daftar awalan dan titik akhir gateway Amazon S3, [lihat titik akhir Gateway untuk Amazon S3 dalam dokumentasi Amazon VPC](https://docs.aws.amazon.com//vpc/latest/privatelink/vpc-endpoints-s3.html). Contoh: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/setup-vpc-for-glue-access.html)