Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Integrasi Amazon RDS
*Extract, transform,* and *load* (ETL) adalah proses menggabungkan data dari berbagai sumber menjadi gudang data sentral yang besar.
Integrasi nol-ETL membuat data dalam database RDS Anda Aurora waktu dekat. Amazon SageMaker AI Setelah data tersebut berada di gudang data target atau data lake, Anda dapat memberi daya pada beban kerja analitik, ML, dan AI Anda menggunakan kemampuan bawaan, seperti pembelajaran mesin, tampilan terwujud, berbagi data, akses gabungan ke beberapa penyimpanan data dan data lake, dan integrasi dengan SageMaker Amazon AI, Quick, dan lainnya. Layanan AWS
*Untuk membuat integrasi nol-ETL, Anda menentukan database RDS Aurora sebagai *sumber*, dan gudang data atau lakehouse yang didukung sebagai target.* Integrasi mereplikasi data dari database sumber ke gudang data target atau lakehouse.
Diagram berikut menggambarkan fungsi ini untuk integrasi nol-ETL dengan Amazon Redshift:
![\[Integrasi nol-ETL\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/images/zero-etl-integrations.png)
Diagram berikut menggambarkan fungsi ini untuk integrasi nol-ETL dengan rumah danau: Amazon SageMaker AI
![\[Integrasi nol-ETL dengan rumah danau Amazon SageMaker AI\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/images/zero-etl-rds-lakehouse.png)
Integrasi memantau kondisi pipeline data dan memulihkan dari masalah jika memungkinkan. Anda dapat membuat integrasi dari beberapa basis data RDS cluster ke dalam satu gudang data target tunggal atau lakehouse yang memungkinkan Anda memperoleh wawasan di beberapa aplikasi.
**Topics**
+ [Manfaat](#zero-etl.benefits)
+ [Konsep utama](#zero-etl.concepts)
+ [Batasan](#zero-etl.reqs-lims)
+ [Kuota](#zero-etl.quotas)
+ [Wilayah yang Didukung](#zero-etl.regions)
+ [Memulai dengan integrasi Amazon RDS Zero-ETL](zero-etl.setting-up.md)
+ [Membuat integrasi nol-ETL Amazon RDS dengan Amazon Redshift](zero-etl.creating.md)
+ [Membuat integrasi Amazon RDS Zero-ETL dengan rumah danau Amazon SageMaker](zero-etl.creating-smlh.md)
+ [](zero-etl.filtering.md)
+ [Menambahkan data ke database sumber RDS cluster dan menanyakannya](zero-etl.querying.md)
+ [Melihat dan memantau integrasi Amazon RDS Zero-ETL](zero-etl.describingmonitoring.md)
+ [](zero-etl.modifying.md)
+ [](zero-etl.deleting.md)
+ [Memecahkan masalah integrasi Amazon RDS](zero-etl.troubleshooting.md)
## Manfaat
Integrasi RDS Zero-ETL memiliki manfaat sebagai berikut:
+ Membantu Anda memperoleh wawasan menyeluruh dari berbagai sumber data.
+ Menghilangkan kebutuhan untuk membangun dan memelihara pipeline data yang kompleks yang melakukan operasi extract, transform, and load (ETL). Integrasi nol-ETL menghilangkan tantangan yang muncul dalam membangun dan mengelola pipeline dengan menyediakan dan mengelolanya untuk Anda.
+ Mengurangi beban dan biaya operasional, serta membantu Anda fokus pada peningkatan aplikasi Anda.
+ Memungkinkan Anda memanfaatkan analitik tujuan target dan kemampuan ML untuk memperoleh wawasan dari data transaksional dan lainnya, untuk merespons secara efektif peristiwa kritis dan sensitif terhadap waktu.
## Konsep utama
Saat mulai menggunakan integrasi nol-ETL, pertimbangkan konsep berikut ini:
**Integrasi**
Pipa data yang dikelola sepenuhnya yang secara otomatis mereplikasi data dan skema transaksional dari database RDS Aurora ke gudang data atau katalog.
**Database sumber **
Basis data RDS cluster tempat data direplikasi. Anda dapat menentukan instans DB Single-AZ atau Multi-AZ, atau cluster DB multi-AZ (hanya untuk RDS untuk MySQL).
**Target**
Gudang data atau lakehouse tempat data direplikasi. Ada dua jenis gudang data: gudang data [klaster terprovisi](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html) dan gudang data [nirserver](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-workgroup-namespace.html). Gudang data klaster terprovisi adalah kumpulan sumber daya komputasi yang disebut simpul, yang diatur ke dalam grup yang disebut *klaster*. Gudang data nirserver terdiri dari grup kerja yang menyimpan sumber daya komputasi, serta ruang nama yang menampung objek basis data dan pengguna. Kedua gudang data menjalankan mesin analitik dan berisi satu atau lebih database.
Target lakehouse terdiri dari katalog, database, tabel, dan tampilan. Untuk informasi lebih lanjut tentang arsitektur lakehouse, lihat [https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/lakehouse-components.html](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/lakehouse-components.html)di *Amazon SageMaker AI Unified StudioPanduan Pengguna*.
Beberapa basis data sumber dapat menulis ke target yang sama.
Untuk informasi selengkapnya, lihat [Arsitektur sistem gudang data](https://docs.aws.amazon.com/redshift/latest/dg/c_high_level_system_architecture.html) dalam *Panduan Developer Amazon Redshift*.
## Batasan
Keterbatasan berikut berlaku untuk integrasi RDS .
**Topics**
+ [Batasan umum](#zero-etl.reqs-lims-general)
+ [Batasan RDS for MySQL](#zero-etl.reqs-lims-mysql)
+ [RDS untuk batasan PostgreSQL](#zero-etl.reqs-lims-rds-postgres)
+ [Batasan RDS for Oracle](#zero-etl.reqs-lims-oracle)
+ [Batasan Amazon Redshift](#zero-etl.reqs-lims-redshift)
+ [Amazon SageMaker AI keterbatasan lakehouse](#zero-etl.reqs-lims-sagemaker-)
### Batasan umum
+ basis data sumber harus berada di Wilayah yang sama dengan target.
+ Anda tidak dapat mengganti nama jika memiliki integrasi yang ada.
+ Anda tidak dapat membuat beberapa integrasi antara database sumber dan target yang sama.
+ Anda tidak dapat menghapus database yang memiliki integrasi yang ada. Anda harus menghapus semua integrasi yang terkait terlebih dahulu.
+ Jika Anda menghentikan basis data sumber, beberapa transaksi terakhir mungkin tidak direplikasi ke target sampai Anda melanjutkan database.
+ Anda tidak dapat menghapus integrasi jika database sumber dihentikan.
+ Jika database Anda adalah sumber penerapan biru/hijau, lingkungan biru dan hijau tidak dapat memiliki integrasi nol-ETL selama peralihan. Anda harus menghapus integrasi tersebut terlebih dahulu dan beralih, lalu membuat ulang integrasi.
+ Anda tidak dapat membuat integrasi untuk database sumber yang memiliki integrasi lain yang sedang dibuat secara aktif.
+ Saat Anda pertama kali membuat integrasi, atau ketika tabel sedang disinkronkan ulang, seeding data dari sumber ke target dapat memakan waktu 20-25 menit atau lebih tergantung ukuran basis data sumber. Penundaan ini dapat menyebabkan peningkatan lag replika.
+ Beberapa jenis data tidak didukung. Untuk informasi selengkapnya, lihat [Perbedaan jenis data antara basis data RDS dan Amazon Redshift](zero-etl.querying.md#zero-etl.data-type-mapping).
+ Tabel sistem, tabel sementara, dan tampilan tidak direplikasi ke gudang target.
+ Melakukan perintah DDL (misalnya`ALTER TABLE`) pada tabel sumber dapat memicu sinkronisasi ulang tabel, membuat tabel tidak tersedia untuk kueri saat disinkronkan ulang. Untuk informasi selengkapnya, lihat [Satu atau beberapa tabel Amazon Redshift saya memerlukan sinkronisasi ulang](zero-etl.troubleshooting.md#zero-etl.troubleshooting.resync).
### Batasan RDS for MySQL
+ Database sumber Anda harus menjalankan versi RDS yang didukung untuk MySQL. Untuk daftar versi yang didukung, lihat [Daerah yang Didukung dan engine DB untuk integrasi Amazon RDS Zero-ETL](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
+ Integrasi nol-ETL tidak didukung pada instance utama dan instance replika baca di Wilayah yang sama. AWS
+ Integrasi nol-ETL mengandalkan pencatatan log biner MySQL (binlog) untuk mengambil perubahan data yang sedang berlangsung. Jangan gunakan pemfilteran data berbasis binlog, karena dapat menyebabkan inkonsistensi data antara basis data sumber dan target.
+ Integrasi nol-ETL didukung hanya untuk basis data yang dikonfigurasi untuk menggunakan mesin penyimpanan InnoDB.
+ Referensi kunci asing dengan pembaruan tabel yang telah ditentukan sebelumnya tidak didukung. Secara khusus, `ON DELETE` dan `ON UPDATE` aturan tidak didukung dengan`CASCADE`,`SET NULL`, dan `SET DEFAULT` tindakan. Mencoba membuat atau memperbarui tabel dengan referensi tersebut ke tabel lain akan menempatkan tabel ke dalam keadaan gagal.
+ Anda tidak dapat membuat integrasi untuk database sumber yang menggunakan penyimpanan magnetik.
### RDS untuk batasan PostgreSQL
+ Database sumber harus berupa RDS untuk instance PostgreSQL yang menjalankan versi 15.7\$1, 16.3\$1, atau 17.1\$1. Versi sebelumnya tidak didukung.
+ Integrasi RDS untuk PostgreSQL Zero-ETL tidak mendukung cluster DB multi-AZ sebagai basis data sumber.
+ Anda tidak dapat membuat integrasi nol-ETL dari RDS untuk instance replika baca PostgreSQL.
+ Tabel PostgreSQL yang tidak tercatat dan tampilan terwujud tidak direplikasi ke Amazon Redshift.
+ Replikasi tipe data PostgreSQL tertentu, [seperti tipe data geometri](https://www.postgresql.org/docs/current/datatype-geometric.html) dan data yang lebih besar dari 64KB, tidak didukung karena keterbatasan di Amazon Redshift. **Untuk informasi selengkapnya tentang perbedaan tipe data antara RDS untuk PostgreSQL dan Amazon Redshift, lihat di bagian Perbedaan tipe data. [](zero-etl.querying.md#zero-etl.data-type-mapping-postgres)**
+ Anda tidak dapat melakukan [pemutakhiran versi utama](USER_UpgradeDBInstance.PostgreSQL.md) pada RDS sumber untuk instance PostgreSQL saat memiliki integrasi nol-ETL aktif. Untuk memutakhirkan instance sumber, Anda harus terlebih dahulu menghapus semua integrasi nol-ETL yang ada. Setelah upgrade versi utama selesai, Anda dapat membuat ulang integrasi nol-ETL.
+ Jika Anda melakukan transaksi [partisi deklaratif](https://www.postgresql.org/docs/current/ddl-partitioning.html#DDL-PARTITIONING-DECLARATIVE) pada instans DB sumber, semua tabel yang terpengaruh memasukkan status gagal dan tidak lagi dapat diakses.
### Batasan RDS for Oracle
+ Database sumber harus berupa RDS untuk instance Oracle yang menjalankan versi 19c Enterprise Edition atau Edisi Standar 2, Pembaruan Rilis Juli 2019 atau yang lebih baru. Versi sebelumnya tidak didukung.
+ Anda tidak dapat membuat integrasi nol-ETL dari RDS untuk instance replika baca Oracle.
+ Anda tidak dapat mengganti nama [database penyewa](Oracle.Concepts.CDBs.md) ketika ada integrasi nol-ETL pada database penyewa itu.
+ Database penyewa hanya dapat memiliki satu integrasi nol-ETL.
+ RDS untuk Oracle dan Amazon Redshift memiliki beberapa perbedaan tipe data. Untuk informasi selengkapnya, lihat [RDS for Oracle](zero-etl.querying.md#zero-etl.data-type-mapping-oracle) di bagian **Perbedaan tipe data**.
### Batasan Amazon Redshift
*Untuk daftar batasan Amazon Redshift yang terkait dengan integrasi Nol-ETL, lihat [Pertimbangan saat menggunakan integrasi Nol-ETL dengan Amazon Redshift di Panduan Manajemen Pergeseran Merah Amazon.](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl.reqs-lims.html)*
### Amazon SageMaker AI keterbatasan lakehouse
Berikut ini adalah batasan untuk integrasi Amazon SageMaker AI lakehouse zero-ETL.
+ Nama katalog dibatasi hingga 19 karakter panjangnya.
## Kuota
Akun Anda memiliki kuota berikut yang terkait dengan integrasi RDS Zero-ETL. Kecuali ditentukan lain, masing-masing kuota ditentukan untuk setiap Wilayah.
| Nama | Default | Deskripsi |
| --- | --- | --- |
| Integrasi | 100 | Jumlah total integrasi dalam sebuah Akun AWS. |
| Integrasi per target | 50 | Jumlah integrasi yang mengirimkan data ke gudang data target tunggal atau lakehouse. |
| Integrasi per instans sumber | 5 | Jumlah integrasi yang mengirimkan data dari instans DB sumber tunggal. |
Selain itu, gudang target menempatkan batasan tertentu pada jumlah tabel yang diizinkan di setiap instance DB atau node cluster. *Untuk informasi selengkapnya tentang kuota dan batas Amazon Redshift, lihat [Kuota dan batas di Amazon Redshift di](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) Panduan Manajemen Pergeseran Merah Amazon.*
## Wilayah yang Didukung
Integrasi RDS Zero-ETL tersedia dalam subset. Wilayah AWS Untuk mengetahui daftar Wilayah yang didukung, lihat [Daerah yang Didukung dan engine DB untuk integrasi Amazon RDS Zero-ETL](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
# Memulai dengan integrasi Amazon RDS Zero-ETL
Sebelum Anda membuat integrasi nol-ETL, konfigurasikan basis data RDS Anda Aurora dan izin yang diperlukan. Selama pengaturan, Anda akan menyelesaikan langkah-langkah berikut:
1. [Buat grup parameter DB kustom.](#zero-etl.parameters)
1. [Buat basis data sumber ](#zero-etl.create-cluster).
1. [Buat gudang data target untuk Amazon Redshift](#zero-etl-setting-up.data-warehouse) atau [Buat target Amazon SageMaker ](#zero-etl-setting-up.sagemaker) Lakehouse.
Setelah Anda menyelesaikan tugas-tugas ini, lanjutkan ke [Membuat integrasi nol-ETL Amazon RDS dengan Amazon Redshift](zero-etl.creating.md) atau[Membuat integrasi Amazon RDS Zero-ETL dengan rumah danau Amazon SageMaker](zero-etl.creating-smlh.md).
**Tip**
Anda dapat meminta RDS menyelesaikan langkah-langkah pengaturan ini untuk Anda saat Anda membuat integrasi, daripada melakukannya secara manual. Untuk segera mulai membuat integrasi, lihat[Membuat integrasi nol-ETL Amazon RDS dengan Amazon Redshift](zero-etl.creating.md).
Untuk Langkah 3, Anda dapat memilih untuk membuat gudang data target (Langkah 3a) atau target lakehouse (Langkah 3b) tergantung pada kebutuhan Anda:
+ Pilih gudang data jika Anda memerlukan kemampuan pergudangan data tradisional dengan analitik berbasis SQL.
+ Pilih Amazon SageMaker Lakehouse jika Anda membutuhkan kemampuan pembelajaran mesin dan ingin menggunakan fitur lakehouse untuk ilmu data dan alur kerja ML.
## Langkah 1: Buat grup parameter DB kustom
Integrasi Amazon RDS Zero-ETL memerlukan nilai spesifik untuk parameter DB yang mengontrol replikasi data. Parameter spesifik tergantung pada mesin DB sumber Anda. Untuk mengkonfigurasi parameter ini, Anda harus terlebih dahulu membuat grup parameter DB kustom, dan kemudian mengaitkannya dengan database sumber. Konfigurasikan nilai parameter berikut tergantung pada mesin DB sumber Anda. Untuk petunjuk cara membuat grup parameter, lihat [Grup parameter DB untuk instans Amazon RDS Aurora DB](USER_WorkingWithDBInstanceParamGroups.md). Kami menyarankan Anda mengonfigurasi semua nilai parameter dalam permintaan yang sama untuk menghindari masalah ketergantungan.
**RDS untuk MySQL**:
+ `binlog_format=ROW`
+ `binlog_row_image=full`
Selain itu, pastikan parameter `binlog_row_value_options` *tidak* diatur ke `PARTIAL_JSON`. Jika database sumber adalah cluster DB multi-AZ, pastikan bahwa `binlog_transaction_compression` parameter *tidak* diatur ke`ON`.
Beberapa parameter ini (seperti`binlog_format`) bersifat dinamis, artinya Anda dapat menerapkan perubahan pada parameter tanpa memicu reboot. Ini berarti bahwa beberapa sesi yang ada mungkin terus menggunakan nilai parameter yang lama. [Untuk mencegah hal ini menyebabkan masalah saat membuat integrasi nol-ETL, aktifkan Skema Kinerja.](USER_PerfInsights.EnableMySQL.md) Skema Kinerja memastikan bahwa pra-pemeriksaan nol-ETL berjalan, yang membantu mendeteksi parameter yang hilang di awal proses.
**RDS untuk PostgreSQL**:
+ `rds.logical_replication = 1`
+ `rds.replica_identity_full = 1`
+ `session_replication_role = origin`
+ `wal_sender_timeout ≥ 20000 or = 0`
+ `max_wal_senders ≥ 20`
+ `max_replication_slots ≥ 20`
Untuk beberapa integrasi PostgreSQL, satu slot replikasi logis akan digunakan per integrasi. Tinjau `max_replication_slots` dan `max_wal_senders` parameter berdasarkan penggunaan Anda.
Untuk sinkronisasi data yang efisien dalam integrasi nol-ETL, atur `rds.replica_identity_full` instans DB sumber Anda. Ini menginstruksikan database untuk [mencatat data baris lengkap](https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-REPLICA-IDENTITY) di log write-ahead (WAL) selama `UPDATE` dan `DELETE` operasi, bukan hanya informasi kunci primer. Nol-ETL membutuhkan data baris lengkap bahkan ketika semua tabel yang direplikasi diperlukan untuk memiliki kunci utama. Untuk menentukan data mana yang terlihat selama kueri, Amazon Redshift gunakan strategi anti-bergabung khusus untuk membandingkan data Anda dengan tabel pelacakan penghapusan internal. Mencatat gambar baris penuh membantu Amazon Redshift melakukan anti-gabungan ini secara efisien. Tanpa data baris penuh, Amazon Redshift perlu melakukan pencarian tambahan, yang dapat memperlambat kinerja selama operasi throughput tinggi di mesin kolumnar yang digunakan Amazon Redshift.
**penting**
Menyetel identitas replika untuk mencatat baris penuh [meningkatkan volume WAL Anda](https://www.postgresql.org/docs/current/runtime-config-wal.html#GUC-WAL-LEVEL), yang dapat menyebabkan amplifikasi dan I/O penggunaan tulis yang lebih tinggi, terutama untuk tabel lebar atau pembaruan yang sering. Untuk mempersiapkan dampak ini, rencanakan kapasitas dan I/O persyaratan penyimpanan Anda, pantau pertumbuhan WAL Anda, dan lacak kelambatan replikasi dalam beban kerja berat tulis.
**RDS untuk Oracle**:
Tidak ada perubahan parameter yang diperlukan untuk RDS untuk Oracle.
## Langkah 2: Pilih atau buat basis data sumber
Setelah Anda membuat grup parameter DB kustom, pilih atau buat cluster DB instance RDS DB. database ini akan menjadi sumber replikasi data ke gudang data target. Untuk instruksi untuk membuat cluster DB multi-AZ (RDS hanya untuk MySQL), lihat. [Membuat cluster DB Multi-AZ untuk Amazon RDS](create-multi-az-db-cluster.md)
Database harus menjalankan versi mesin DB yang didukung. Untuk daftar versi yang didukung, lihat [Daerah yang Didukung dan engine DB untuk integrasi Amazon RDS Zero-ETL](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
Saat Anda membuat database, di bawah **Konfigurasi tambahan**, ubah **grup parameter DB** default ke grup parameter kustom yang Anda buat di langkah sebelumnya.
**catatan**
Jika Anda mengaitkan grup parameter dengan database sudah dibuat, Anda harus me-reboot untuk menerapkan perubahan sebelum Anda dapat membuat integrasi nol-ETL. Untuk petunjuk, lihat [Mem-boot ulang instans DB DB](USER_RebootInstance.md) atau [Mem-boot ulang cluster DB multi-AZ dan instans DB pembaca untuk Amazon RDS](multi-az-db-clusters-concepts-rebooting.md).
Selain itu, pastikan bahwa backup otomatis diaktifkan pada database. Untuk informasi selengkapnya, lihat [Mengaktifkan pencadangan otomatis](USER_WorkingWithAutomatedBackups.Enabling.md).
## Langkah 3a: Buat gudang data target
Setelah Anda membuat database sumber Anda, Anda harus membuat dan mengkonfigurasi gudang data target. Gudang data harus memenuhi persyaratan berikut:
+ Menggunakan tipe RA3 node dengan setidaknya dua node, atau Redshift Serverless.
+ Terenkripsi (jika menggunakan klaster yang disediakan). Untuk informasi selengkapnya, lihat [Enkripsi basis data Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html).
Untuk petunjuk cara membuat gudang data, lihat [Membuat klaster](https://docs.aws.amazon.com/redshift/latest/mgmt/create-cluster) untuk klaster terprovisi, atau [Membuat grup kerja dengan ruang nama](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-console-workgroups-create-workgroup-wizard.html) untuk Redshift Nirserver.
### Aktifkan kepekaan huruf besar/kecil di gudang data
Agar integrasi berhasil, parameter kepekaan huruf besar/kecil ([https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html](https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html)) harus diaktifkan untuk gudang data. Secara default, kepekaan huruf besar/kecil dinonaktifkan di semua klaster terprovisi dan grup kerja Redshift Nirserver.
Untuk mengaktifkan kepekaan huruf besar/kecil, lakukan langkah-langkah berikut bergantung pada jenis gudang data Anda:
+ **Klaster terprovisi** – Untuk mengaktifkan kepekaan huruf besar/kecil pada klaster terprovisi, buat grup parameter kustom dengan parameter `enable_case_sensitive_identifier` diaktifkan. Kemudian, hubungkan grup parameter dengan klaster. Untuk petunjuknya, lihat [Mengelola grup parameter menggunakan konsol](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-parameter-groups-console.html) atau [Mengonfigurasi nilai parameter menggunakan AWS CLI](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html#configure-parameters-using-the-clil).
**catatan**
Ingatlah untuk mem-boot ulang klaster setelah Anda mengaitkan grup parameter kustom dengannya.
+ **Grup kerja Nirserver** – Untuk mengaktifkan kepekaan huruf besar/kecil di grup kerja Redshift Nirserver, Anda harus menggunakan AWS CLI. Konsol Amazon Redshift saat ini tidak mendukung modifikasi nilai parameter Redshift Nirserver. Kirim permintaan [update-workgroup](https://docs.aws.amazon.com/cli/latest/reference/redshift-serverless/update-workgroup.html) berikut:
```
aws redshift-serverless update-workgroup \
--workgroup-name target-workgroup \
--config-parameters parameterKey=enable_case_sensitive_identifier,parameterValue=true
```
Anda tidak perlu mem-boot ulang grup kerja setelah Anda mengubah nilai parameternya.
### Konfigurasikan otorisasi untuk gudang data
Setelah Anda membuat gudang data, Anda harus mengkonfigurasi sumber RDS database cluster sebagai sumber integrasi resmi. Untuk petunjuknya, lihat [Mengonfigurasi otorisasi untuk gudang data Amazon Redshift Anda](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam).
## Siapkan integrasi menggunakan AWS SDKs
Daripada menyiapkan setiap sumber daya secara manual, Anda dapat menjalankan skrip Python berikut untuk menyiapkan sumber daya yang diperlukan secara otomatis. Contoh kode menggunakan [AWS SDK untuk Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)untuk membuat sumber RDS untuk instance MySQL DB dan gudang data target, masing-masing dengan nilai parameter yang diperlukan. Kemudian menunggu database tersedia sebelum membuat integrasi nol-ETL di antara mereka. Anda dapat menerapkan "comment out" pada berbagai fungsi tergantung pada sumber daya yang perlu Anda atur.
Untuk menginstal dependensi yang diperlukan, jalankan perintah berikut:
```
pip install boto3
pip install time
```
Dalam skrip, secara opsional, Anda dapat memodifikasi nama grup sumber, target, dan parameter. Fungsi akhir akan membuat integrasi bernama `my-integration` setelah sumber daya disiapkan.
### Contoh kode Python
```
import boto3
import time
# Build the client using the default credential configuration.
# You can use the CLI and run 'aws configure' to set access key, secret
# key, and default Region.
rds = boto3.client('rds')
redshift = boto3.client('redshift')
sts = boto3.client('sts')
source_db_name = 'my-source-db' # A name for the source database
source_param_group_name = 'my-source-param-group' # A name for the source parameter group
target_cluster_name = 'my-target-cluster' # A name for the target cluster
target_param_group_name = 'my-target-param-group' # A name for the target parameter group
def create_source_db(*args):
"""Creates a source RDS for MySQL DB instance"""
response = rds.create_db_parameter_group(
DBParameterGroupName=source_param_group_name,
DBParameterGroupFamily='mysql8.0',
Description='RDS for MySQL zero-ETL integrations'
)
print('Created source parameter group: ' + response['DBParameterGroup']['DBParameterGroupName'])
response = rds.modify_db_parameter_group(
DBParameterGroupName=source_param_group_name,
Parameters=[
{
'ParameterName': 'binlog_format',
'ParameterValue': 'ROW',
'ApplyMethod': 'pending-reboot'
},
{
'ParameterName': 'binlog_row_image',
'ParameterValue': 'full',
'ApplyMethod': 'pending-reboot'
}
]
)
print('Modified source parameter group: ' + response['DBParameterGroupName'])
response = rds.create_db_instance(
DBInstanceIdentifier=source_db_name,
DBParameterGroupName=source_param_group_name,
Engine='mysql',
EngineVersion='8.0.32',
DBName='mydb',
DBInstanceClass='db.m5.large',
AllocatedStorage=15,
MasterUsername='username',
MasterUserPassword='Password01**'
)
print('Creating source database: ' + response['DBInstance']['DBInstanceIdentifier'])
source_arn = (response['DBInstance']['DBInstanceArn'])
create_target_cluster(target_cluster_name, source_arn, target_param_group_name)
return(response)
def create_target_cluster(target_cluster_name, source_arn, target_param_group_name):
"""Creates a target Redshift cluster"""
response = redshift.create_cluster_parameter_group(
ParameterGroupName=target_param_group_name,
ParameterGroupFamily='redshift-1.0',
Description='RDS for MySQL zero-ETL integrations'
)
print('Created target parameter group: ' + response['ClusterParameterGroup']['ParameterGroupName'])
response = redshift.modify_cluster_parameter_group(
ParameterGroupName=target_param_group_name,
Parameters=[
{
'ParameterName': 'enable_case_sensitive_identifier',
'ParameterValue': 'true'
}
]
)
print('Modified target parameter group: ' + response['ParameterGroupName'])
response = redshift.create_cluster(
ClusterIdentifier=target_cluster_name,
NodeType='ra3.4xlarge',
NumberOfNodes=2,
Encrypted=True,
MasterUsername='username',
MasterUserPassword='Password01**',
ClusterParameterGroupName=target_param_group_name
)
print('Creating target cluster: ' + response['Cluster']['ClusterIdentifier'])
# Retrieve the target cluster ARN
response = redshift.describe_clusters(
ClusterIdentifier=target_cluster_name
)
target_arn = response['Clusters'][0]['ClusterNamespaceArn']
# Retrieve the current user's account ID
response = sts.get_caller_identity()
account_id = response['Account']
# Create a resource policy granting access to source database and account ID
response = redshift.put_resource_policy(
ResourceArn=target_arn,
Policy='''
{
\"Version\":\"2012-10-17\",
\"Statement\":[
{\"Effect\":\"Allow\",
\"Principal\":{
\"Service\":\"redshift.amazonaws.com\"
},
\"Action\":[\"redshift:AuthorizeInboundIntegration\"],
\"Condition\":{
\"StringEquals\":{
\"aws:SourceArn\":\"%s\"}
}
},
{\"Effect\":\"Allow\",
\"Principal\":{
\"AWS\":\"arn:aws:iam::%s:root\"},
\"Action\":\"redshift:CreateInboundIntegration\"}
]
}
''' % (source_arn, account_id)
)
return(response)
def wait_for_db_availability(*args):
"""Waits for both databases to be available"""
print('Waiting for source and target to be available...')
response = rds.describe_db_instances(
DBInstanceIdentifier=source_db_name
)
source_status = response['DBInstances'][0]['DBInstanceStatus']
source_arn = response['DBInstances'][0]['DBInstanceArn']
response = redshift.describe_clusters(
ClusterIdentifier=target_cluster_name
)
target_status = response['Clusters'][0]['ClusterStatus']
target_arn = response['Clusters'][0]['ClusterNamespaceArn']
# Every 60 seconds, check whether the databases are available
if source_status != 'available' or target_status != 'available':
time.sleep(60)
response = wait_for_db_availability(
source_db_name, target_cluster_name)
else:
print('Databases available. Ready to create zero-ETL integration.')
create_integration(source_arn, target_arn)
return
def create_integration(source_arn, target_arn):
"""Creates a zero-ETL integration using the source and target databases"""
response = rds.create_integration(
SourceArn=source_arn,
TargetArn=target_arn,
IntegrationName='my-integration'
)
print('Creating integration: ' + response['IntegrationName'])
def main():
"""main function"""
create_source_db(source_db_name, source_param_group_name)
wait_for_db_availability(source_db_name, target_cluster_name)
if __name__ == "__main__":
main()
```
## Langkah 3b: Buat AWS Glue katalog untuk integrasi Amazon SageMaker Lakehouse Zero-ETL
Saat membuat integrasi nol-ETL dengan Amazon SageMaker Lakehouse, Anda harus membuat katalog terkelola di. AWS Glue AWS Lake Formation Katalog target harus berupa katalog terkelola Amazon Redshift. Untuk membuat katalog terkelola Amazon Redshift, pertama-tama buat peran terkait `AWSServiceRoleForRedshift` layanan. Di konsol Lake Formation, tambahkan `AWSServiceRoleForRedshift` sebagai administrator hanya-baca.
Untuk informasi selengkapnya tentang tugas sebelumnya, lihat topik berikut.
+ *Untuk informasi tentang membuat katalog terkelola Amazon Redshift, lihat [Membuat katalog terkelola Amazon Redshift di Panduan AWS Glue Data Catalog Pengembang](https://docs.aws.amazon.com/lake-formation/latest/dg/create-rms-catalog.html).AWS Lake Formation *
+ *Untuk informasi tentang peran terkait layanan untuk Amazon Redshift, [lihat Menggunakan peran terkait layanan untuk Amazon Redshift di Panduan Manajemen Pergeseran Merah Amazon](https://docs.aws.amazon.com/redshift/latest/mgmt/using-service-linked-roles.html).*
+ *Untuk informasi tentang izin administrator hanya-baca untuk Lake Formation, lihat [personas Lake Formation dan referensi izin IAM](https://docs.aws.amazon.com/lake-formation/latest/dg/permissions-reference.html) di Panduan Pengembang.AWS Lake Formation *
### Konfigurasikan izin untuk katalog target AWS Glue
Sebelum membuat katalog target untuk integrasi nol-ETL, Anda harus membuat peran pembuatan target Lake Formation dan peran transfer data. AWS Glue Gunakan peran pembuatan target Lake Formation untuk membuat katalog target. Saat membuat katalog target, masukkan peran transfer data Glue di bidang **peran IAM** di **bagian Access from engine**.
#### Peran penciptaan target Lake Formation
Peran pembuatan target haruslah administrator Lake Formation dan memerlukan izin berikut.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "lakeformation:RegisterResource",
"Resource": "*"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"s3:PutEncryptionConfiguration",
"iam:PassRole",
"glue:CreateCatalog",
"glue:GetCatalog",
"s3:PutBucketTagging",
"s3:PutLifecycleConfiguration",
"s3:PutBucketPolicy",
"s3:CreateBucket",
"redshift-serverless:CreateNamespace",
"s3:DeleteBucket",
"s3:PutBucketVersioning",
"redshift-serverless:CreateWorkgroup"
],
"Resource": [
"arn:aws:glue:*:111122223333:catalog",
"arn:aws:glue:*:111122223333:catalog/*",
"arn:aws:s3:::*",
"arn:aws:redshift-serverless:*:111122223333:workgroup/*",
"arn:aws:redshift-serverless:*:111122223333:namespace/*",
"arn:aws:iam::111122223333:role/GlueDataCatalogDataTransferRole"
]
}
]
}
```
------
Peran penciptaan target harus memiliki hubungan kepercayaan berikut.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
},
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:user/Username"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
#### Glue peran transfer data
Peran transfer data Glue diperlukan untuk operasi katalog MySQL dan harus memiliki izin berikut.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataTransferRolePolicy",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt",
"glue:GetCatalog",
"glue:GetDatabase"
],
"Resource": [
"*"
]
}
]
}
```
------
Peran transfer data Glue harus memiliki hubungan kepercayaan berikut.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com",
"redshift.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
## Langkah selanjutnya
Dengan basis data RDS sumber cluster dan gudang data target Amazon Redshift atau SageMaker Amazon Lakehouse, Anda dapat membuat integrasi nol-ETL dan mereplikasi data. Untuk petunjuk, lihat [Membuat integrasi nol-ETL Amazon RDS dengan Amazon Redshift](zero-etl.creating.md).
# Membuat integrasi nol-ETL Amazon RDS dengan Amazon Redshift
Saat membuat integrasi Amazon RDS Zero-ETL, Anda menentukan basis data RDS sumber dan gudang data Amazon Redshift target. Anda juga dapat menyesuaikan pengaturan enkripsi dan menambahkan tag. Amazon RDS menciptakan integrasi antara cluster sumber dan targetnya. Setelah integrasi aktif, data apa pun yang Anda masukkan ke dalam database sumber akan direplikasi ke target Amazon Redshift yang dikonfigurasi.
## Prasyarat
Sebelum membuat integrasi nol-ETL, Anda harus membuat database sumber dan gudang data Amazon Redshift target. Anda juga harus mengizinkan replikasi ke gudang data dengan menambahkan database sebagai sumber integrasi resmi.
Untuk petunjuk cara menyelesaikan setiap langkah ini, lihat [Memulai dengan integrasi Amazon RDS Zero-ETL](zero-etl.setting-up.md).
## Izin yang diperlukan
Izin IAM tertentu diperlukan untuk membuat integrasi nol-ETL. Setidaknya, Anda memerlukan izin untuk melakukan tindakan berikut:
+
+ Lihat dan hapus semua integrasi nol-ETL.
+ Buat integrasi masuk ke gudang data target.
Contoh kebijakan berikut menunjukkan [izin hak istimewa paling sedikit](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) yang diperlukan untuk membuat dan mengelola integrasi. Anda mungkin tidak memerlukan izin persis ini jika pengguna atau peran Anda memiliki izin yang lebih luas, seperti kebijakan terkelola `AdministratorAccess`.
**catatan**
Redshift Amazon Resource Names (ARNs) memiliki format berikut. Perhatikan penggunaan garis miring ke depan `(/`), bukan titik dua (`:`), sebelum UUID ruang nama nirserver.
Klaster terprovisi – `arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid`
Nirserver – `arn:aws:redshift-serverless:{region}:{account-id}:namespace/namespace-uuid`
### Contoh kebijakan untuk target Redshift
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CreateIntegration",
"Effect": "Allow",
"Action": [
"rds:CreateIntegration"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:db:source-db",
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "DescribeIntegrationDetails",
"Effect": "Allow",
"Action": [
"rds:DescribeIntegrations"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "ChangeIntegrationDetails",
"Effect": "Allow",
"Action": [
"rds:DeleteIntegration",
"rds:ModifyIntegration"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "AllowRedShiftIntegration",
"Effect": "Allow",
"Action": [
"redshift:CreateInboundIntegration"
],
"Resource": [
"arn:aws:redshift:us-east-1:123456789012:namespace:namespace-uuid"
]
}
]
}
```
------
### Memilih gudang data target di akun yang berbeda
Jika Anda berencana untuk menentukan gudang data Amazon Redshift target yang ada di gudang lain Akun AWS, Anda harus membuat peran yang memungkinkan pengguna di akun saat ini mengakses sumber daya di akun target. Untuk informasi selengkapnya, lihat [Menyediakan akses ke pengguna IAM di pengguna lain Akun AWS yang Anda miliki](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html).
Peran harus memiliki izin berikut, yang memungkinkan pengguna melihat klaster terprovisi Amazon Redshift dan ruang nama Redshift Nirserver di akun target.
#### Izin dan kebijakan kepercayaan yang diperlukan
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"redshift:DescribeClusters",
"redshift-serverless:ListNamespaces"
],
"Resource":[
"*"
]
}
]
}
```
------
Peran harus memiliki kebijakan kepercayaan berikut ini, yang menentukan ID akun target.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Untuk petunjuk cara membuat peran, lihat [Membuat peran menggunakan kebijakan kepercayaan kustom](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html).
## Membuat integrasi nol-ETL
Anda dapat membuat integrasi nol-ETL menggunakan API Konsol Manajemen AWS, the AWS CLI, atau RDS.
**penting**
Integrasi nol-ETL tidak mendukung operasi penyegaran atau sinkronisasi ulang. Jika Anda mengalami masalah dengan integrasi setelah pembuatan, Anda harus menghapus integrasi dan membuat yang baru.
Secara default, RDS for MySQL akan langsung melakukan purging file log biner. Karena integrasi nol-ETL bergantung pada log biner untuk mereplikasi data dari sumber ke target, periode retensi untuk database sumber harus setidaknya satu jam. Segera setelah Anda membuat integrasi, Amazon RDS memeriksa periode penyimpanan file log biner untuk database sumber yang dipilih. Jika nilai saat ini adalah 0 jam, Amazon RDS secara otomatis mengubahnya menjadi 1 jam. Jika tidak, nilainya tetap sama.
### Konsol RDS
**Untuk membuat integrasi nol-ETL**
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 panel navigasi kiri, pilih **Integrasi nol-ETL**.
1. Pilih **Buat integrasi nol-ETL**.
1. Untuk **Pengidentifikasi integrasi**, masukkan nama untuk integrasi. Nama dapat memiliki maksimal 63 karakter alfanumerik dan dapat menyertakan tanda hubung.
**penting**
Nama katalog dibatasi hingga 19 karakter panjangnya. Pastikan pengenal integrasi Anda memenuhi persyaratan ini jika akan digunakan sebagai nama katalog.
1. Pilih **Berikutnya**.
1. Untuk **Sumber**, pilih database RDS cluster tempat data akan berasal.
**catatan**
RDS memberi tahu Anda jika parameter DB tidak dikonfigurasi dengan benar. Jika Anda menerima pesan ini, Anda dapat memilih **Perbaiki untuk saya**, atau mengonfigurasinya secara manual. Untuk petunjuk cara memperbaikinya secara manual, lihat [Langkah 1: Buat grup parameter DB kustom](zero-etl.setting-up.md#zero-etl.parameters).
Memodifikasi parameter DB membutuhkan boot ulang. Sebelum Anda dapat membuat integrasi, reboot harus lengkap dan nilai parameter baru harus berhasil diterapkan ke database.
1. Setelah basis data sumber Anda berhasil dikonfigurasi, pilih **Berikutnya**.
1. Untuk **Target**, lakukan hal berikut:
1. (Opsional) Untuk menggunakan target Amazon Redshift yang berbeda Akun AWS , pilih **Tentukan akun yang berbeda**. Kemudian, masukkan ARN peran IAM dengan izin untuk menampilkan gudang data Anda. Untuk petunjuk cara membuat peran IAM, lihat [Memilih gudang data target di akun yang berbeda](#zero-etl.create-permissions-cross-account).
1. Anda dapat memilih *klaster* Amazon Redshift terprovisi atau *ruang nama* Redshift Nirserver sebagai target.
**catatan**
RDS akan memberi tahu Anda jika pengaturan kebijakan sumber daya atau kepekaan huruf besar/kecil untuk gudang data yang ditentukan tidak dikonfigurasi dengan benar. Jika Anda menerima pesan ini, Anda dapat memilih **Perbaiki untuk saya**, atau mengonfigurasinya secara manual. Untuk petunjuk cara memperbaikinya secara manual, lihat [Mengaktifkan kepekaan huruf besar/kecil untuk gudang data Anda](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-setting-up.case-sensitivity) dan [Mengonfigurasi otorisasi untuk gudang data Anda](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam) dalam *Panduan Manajemen Amazon Redshift*.
Modifikasi kepekaan huruf besar/kecil untuk klaster Redshift *terprovisi* memerlukan boot ulang. Sebelum Anda dapat membuat integrasi, boot ulang harus selesai dan nilai parameter baru harus berhasil diterapkan ke klaster.
Jika sumber dan target yang Anda pilih berada di Akun AWS yang berbeda, maka Amazon RDS tidak dapat memperbaiki pengaturan ini untuk Anda. Anda harus menavigasi ke akun lain dan memperbaikinya secara manual di Amazon Redshift.
1. Setelah gudang data target Anda dikonfigurasi dengan benar, pilih **Berikutnya**.
1. (Opsional) Untuk **Tag**, tambahkan satu atau beberapa tag ke integrasi. Untuk informasi selengkapnya, lihat [Menandai sumber Amazon RDS](USER_Tagging.md).
1. Untuk **Enkripsi**, tentukan cara enkripsi integrasi Anda. Secara default, RDS mengenkripsi semua integrasi dengan file. Kunci milik AWS Untuk memilih kunci yang dikelola pelanggan, aktifkan **Sesuaikan pengaturan enkripsi** dan pilih kunci KMS yang akan digunakan untuk enkripsi. Untuk informasi selengkapnya, lihat [Mengenkripsi sumber daya Amazon RDS](Overview.Encryption.md).
Secara opsional, tambahkan konteks enkripsi. Untuk informasi lebih lanjut, lihat [Konteks enkripsi](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) di *Panduan Developer AWS Key Management Service *.
**catatan**
Amazon RDS menambahkan pasangan konteks enkripsi berikut selain yang Anda tambahkan:
`aws:redshift:integration:arn` - `IntegrationArn`
`aws:servicename:id` - `Redshift`
Ini mengurangi jumlah keseluruhan pasangan yang dapat Anda tambahkan dari 8 menjadi 6, dan berkontribusi pada batas karakter keseluruhan dari batasan hibah. *Untuk informasi selengkapnya, lihat [Menggunakan batasan hibah di Panduan Pengembang](https://docs.aws.amazon.com/kms/latest/developerguide/create-grant-overview.html#grant-constraints).AWS Key Management Service *
1. Pilih **Selanjutnya**.
1. Tinjau pengaturan integrasi Anda dan pilih **Buat integrasi nol-ETL**.
Jika pembuatan gagal, lihat [Saya tidak dapat membuat integrasi nol-ETL](zero-etl.troubleshooting.md#zero-etl.troubleshooting.creation) untuk langkah-langkah pemecahan masalah.
Integrasi memiliki status `Creating` ketika sedang dibuat dan gudang data Amazon Redshift target memiliki status `Modifying`. Selama waktu ini, Anda tidak dapat mengueri gudang data atau membuat perubahan konfigurasi apa pun di dalamnya.
Ketika integrasi berhasil dibuat, status integrasi dan gudang data Amazon Redshift target berubah menjadi `Active`.
### AWS CLI
Untuk membuat integrasi nol-ETL menggunakan AWS CLI, gunakan perintah [create-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) dengan opsi berikut:
**catatan**
Ingat bahwa nama katalog dibatasi hingga 19 karakter. Pilih nama integrasi Anda sesuai jika akan digunakan sebagai nama katalog.
+ `--integration-name` – Tentukan nama untuk integrasi.
+ `--source-arn`— Tentukan ARN dari database RDS Aurora yang akan menjadi sumber untuk integrasi.
+ `--target-arn` – Tentukan ARN gudang data Amazon Redshift yang akan menjadi target integrasi.
**Example**
Untuk Linux, macOS, atau Unix:
```
aws rds create-integration \
--integration-name my-integration \
--source-arn arn:aws:rds:{region}:{account-id}:my-db \
--target-arn arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid
```
Untuk Windows:
```
aws rds create-integration ^
--integration-name my-integration ^
--source-arn arn:aws:rds:{region}:{account-id}:my-db ^
--target-arn arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid
```
### API RDS
Untuk membuat integrasi nol-ETL menggunakan API Amazon RDS, gunakan operasi [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html) dengan parameter berikut ini:
**catatan**
Nama katalog dibatasi hingga 19 karakter. Pastikan IntegrationName parameter Anda memenuhi persyaratan ini jika akan digunakan sebagai nama katalog.
+ `IntegrationName` – Tentukan nama untuk integrasi.
+ `SourceArn`— Tentukan ARN dari database RDS Aurora yang akan menjadi sumber untuk integrasi.
+ `TargetArn` – Tentukan ARN gudang data Amazon Redshift yang akan menjadi target integrasi.
## Mengenkripsi integrasi dengan kunci yang dikelola pelanggan
Jika Anda menentukan kunci KMS kustom dan bukan Kunci milik AWS saat Anda membuat integrasi, kebijakan kunci harus menyediakan akses utama layanan Amazon Redshift ke `CreateGrant` tindakan tersebut. Selain itu, harus memungkinkan pengguna saat ini untuk melakukan `CreateGrant` tindakan `DescribeKey` dan tindakan.
Kebijakan contoh berikut menunjukkan cara memberikan izin yang diperlukan dalam kebijakan utama. Ini termasuk kunci konteks untuk lebih mengurangi ruang lingkup izin.
### Contoh kebijakan kunci
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Key policy",
"Statement": [
{
"Sid": "Enables IAM user permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "Allows the Redshift service principal to add a grant to a KMS key",
"Effect": "Allow",
"Principal": {
"Service": "redshift.amazonaws.com"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}": "{context-value}"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "Allows the current user or role to add a grant to a KMS key",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}": "{context-value}",
"kms:ViaService": "rds.us-east-1.amazonaws.com"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "Allows the current uer or role to retrieve information about a KMS key",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:DescribeKey",
"Resource": "*"
}
]
}
```
------
Untuk informasi selengkapnya, lihat [Membuat kebijakan kunci](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) di *Panduan Developer AWS Key Management Service *.
## Langkah selanjutnya
Setelah berhasil membuat integrasi nol-ETL, Anda harus membuat basis data tujuan dalam klaster atau grup kerja Amazon Redshift target Anda. Kemudian, Anda dapat mulai menambahkan data ke database RDS sumber cluster dan menanyakannya di Amazon Redshift. Untuk petunjuknya, lihat [Membuat basis data tujuan di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html).
# Membuat integrasi Amazon RDS Zero-ETL dengan rumah danau Amazon SageMaker
AWS Glue Anda juga dapat menyesuaikan pengaturan enkripsi dan menambahkan tag. Amazon RDS menciptakan integrasi antara cluster sumber dan targetnya. Setelah integrasi aktif, data apa pun yang Anda masukkan ke dalam database sumber akan direplikasi ke target yang dikonfigurasi.
## Prasyarat
Sebelum Anda membuat integrasi nol-ETL dengan Amazon SageMaker lakehouse, Anda harus membuat database sumber dan katalog terkelola target. AWS Glue Anda juga harus mengizinkan replikasi ke dalam katalog dengan menambahkan database sebagai sumber integrasi resmi.
Untuk petunjuk cara menyelesaikan setiap langkah ini, lihat [Memulai dengan integrasi Amazon RDS Zero-ETL](zero-etl.setting-up.md).
## Izin yang diperlukan
Izin IAM tertentu diperlukan untuk membuat integrasi nol-ETL dengan lakehouse. Amazon SageMaker Setidaknya, Anda memerlukan izin untuk melakukan tindakan berikut:
+
+ Lihat dan hapus semua integrasi nol-ETL.
+ Buat integrasi masuk ke dalam katalog AWS Glue terkelola target.
+ Akses bucket Amazon S3 yang digunakan oleh katalog terkelola. AWS Glue
+ Gunakan AWS KMS kunci untuk enkripsi jika enkripsi khusus dikonfigurasi.
+ Daftarkan sumber daya dengan Lake Formation.
+ Letakkan kebijakan sumber daya pada katalog AWS Glue terkelola untuk mengotorisasi integrasi masuk.
Kebijakan contoh berikut menunjukkan [izin hak istimewa paling sedikit](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) yang diperlukan untuk membuat dan mengelola integrasi dengan lakehouse. Amazon SageMaker Anda mungkin tidak memerlukan izin persis ini jika pengguna atau peran Anda memiliki izin yang lebih luas, seperti kebijakan terkelola `AdministratorAccess`.
Selain itu, Anda harus mengonfigurasi kebijakan sumber daya pada katalog AWS Glue terkelola target untuk mengotorisasi integrasi masuk. Gunakan AWS CLI perintah berikut untuk menerapkan kebijakan sumber daya.
### Contoh AWS CLI perintah untuk mengotorisasi integrasi masuk pada katalog target
```
aws glue put-resource-policy \
--policy-in-json '{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": [
"glue:AuthorizeInboundIntegration"
],
"Resource": ["arn:aws:glue:region:account_id:catalog/catalog_name"],
"Condition": {
"StringEquals": {
"aws:SourceArn": "arn:aws:rds:region:account_id:db:source_name"
}
}
},
{
"Effect": "Allow",
"Principal": {
"AWS": "account_id"
},
"Action": ["glue:CreateInboundIntegration"],
"Resource": ["arn:aws:glue:region:account_id:catalog/catalog_name"]
}
]
}' \
--region region
```
**catatan**
Glue catalog Amazon Resource Names (ARNs) memiliki format berikut:
Katalog Glue — `arn:aws:glue:{region}:{account-id}:catalog/catalog-name`
### Memilih katalog AWS Glue terkelola target di akun yang berbeda
Jika Anda berencana untuk menentukan katalog AWS Glue terkelola target yang ada di katalog lain Akun AWS, Anda harus membuat peran yang memungkinkan pengguna di akun saat ini mengakses sumber daya di akun target. Untuk informasi selengkapnya, lihat [Menyediakan akses ke pengguna IAM di pengguna lain Akun AWS yang Anda miliki](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html).
Peran harus memiliki izin berikut, yang memungkinkan pengguna untuk melihat AWS Glue katalog yang tersedia di akun target.
#### Izin dan kebijakan kepercayaan yang diperlukan
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"glue:GetCatalog"
],
"Resource":[
"*"
]
}
]
}
```
------
Peran harus memiliki kebijakan kepercayaan berikut ini, yang menentukan ID akun target.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal":{
"AWS": "arn:aws:iam::111122223333:root"
},
"Action":"sts:AssumeRole"
}
]
}
```
------
Untuk petunjuk cara membuat peran, lihat [Membuat peran menggunakan kebijakan kepercayaan kustom](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html).
## Membuat integrasi nol-ETL dengan rumah danau Amazon SageMaker
Anda dapat membuat integrasi nol-ETL dengan Amazon SageMaker lakehouse menggunakan Konsol Manajemen AWS,, atau RDS API. AWS CLI
**penting**
Integrasi nol-ETL dengan Amazon SageMaker lakehouse tidak mendukung operasi penyegaran atau sinkronisasi ulang. Jika Anda mengalami masalah dengan integrasi setelah pembuatan, Anda harus menghapus integrasi dan membuat yang baru.
Secara default, RDS for MySQL akan langsung melakukan purging file log biner. Karena integrasi nol-ETL bergantung pada log biner untuk mereplikasi data dari sumber ke target, periode retensi untuk database sumber harus setidaknya satu jam. Segera setelah Anda membuat integrasi, Amazon RDS memeriksa periode penyimpanan file log biner untuk database sumber yang dipilih. Jika nilai saat ini adalah 0 jam, Amazon RDS secara otomatis mengubahnya menjadi 1 jam. Jika tidak, nilainya tetap sama.
### Konsol RDS
**Untuk membuat integrasi nol-ETL dengan rumah danau Amazon SageMaker**
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 panel navigasi kiri, pilih **Integrasi nol-ETL**.
1. Pilih **Buat integrasi nol-ETL**.
1. Untuk **Pengidentifikasi integrasi**, masukkan nama untuk integrasi. Nama dapat memiliki maksimal 63 karakter alfanumerik dan dapat menyertakan tanda hubung.
1. Pilih **Selanjutnya**.
1. Untuk **Sumber**, pilih database RDS cluster tempat data akan berasal.
**catatan**
RDS memberi tahu Anda jika parameter DB tidak dikonfigurasi dengan benar. Jika Anda menerima pesan ini, Anda dapat memilih **Perbaiki untuk saya**, atau mengonfigurasinya secara manual. Untuk petunjuk cara memperbaikinya secara manual, lihat [Langkah 1: Buat grup parameter DB kustom](zero-etl.setting-up.md#zero-etl.parameters).
Memodifikasi parameter DB membutuhkan boot ulang. Sebelum Anda dapat membuat integrasi, reboot harus lengkap dan nilai parameter baru harus berhasil diterapkan ke database.
1. Setelah database sumber Anda berhasil dikonfigurasi, pilih **Berikutnya**.
1. Untuk **Target**, lakukan hal berikut:
1. (Opsional) Untuk menggunakan target Amazon SageMaker lakehouse yang berbeda Akun AWS , pilih **Tentukan akun yang berbeda**. Kemudian, masukkan ARN peran IAM dengan izin untuk menampilkan katalog Anda. AWS Glue Untuk petunjuk cara membuat peran IAM, lihat [Memilih katalog AWS Glue terkelola target di akun yang berbeda](#zero-etl.create-permissions-cross-account-smlh).
1. Untuk **AWS Glue katalog**, pilih target untuk data yang direplikasi dari database sumber. Anda dapat memilih katalog AWS Glue terkelola yang ada sebagai target.
1. Peran IAM target perlu menjelaskan izin pada katalog target dan harus memiliki izin berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "glue:GetCatalog",
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog/*",
"arn:aws:glue:us-east-1:111122223333:catalog"
]
}
]
}
```
------
Peran IAM target harus memiliki hubungan kepercayaan berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Anda harus memberikan izin deskripsi peran IAM target untuk katalog AWS Glue terkelola target dengan peran administrator Lake Formation yang dibuat. [Langkah 3b: Buat AWS Glue katalog untuk integrasi Amazon SageMaker Lakehouse Zero-ETL](zero-etl.setting-up.md#zero-etl-setting-up.sagemaker)
**catatan**
RDS memberi tahu Anda jika kebijakan sumber daya atau pengaturan konfigurasi untuk katalog AWS Glue terkelola yang ditentukan tidak dikonfigurasi dengan benar. Jika Anda menerima pesan ini, Anda dapat memilih **Perbaiki untuk saya**, atau mengonfigurasinya secara manual.
Jika sumber dan target yang Anda pilih berada di Akun AWS yang berbeda, maka Amazon RDS tidak dapat memperbaiki pengaturan ini untuk Anda. Anda harus menavigasi ke akun lain dan memperbaikinya secara manualSageMaker Unified Studio.
1. Setelah katalog AWS Glue terkelola target Anda dikonfigurasi dengan benar, pilih **Berikutnya**.
1. (Opsional) Untuk **Tag**, tambahkan satu atau beberapa tag ke integrasi. Untuk informasi selengkapnya, lihat [Menandai sumber Amazon RDS](USER_Tagging.md).
1. Untuk **Enkripsi**, tentukan cara enkripsi integrasi Anda. Secara default, RDS mengenkripsi semua integrasi dengan file. Kunci milik AWS Untuk memilih kunci yang dikelola pelanggan, aktifkan **Sesuaikan pengaturan enkripsi** dan pilih kunci KMS yang akan digunakan untuk enkripsi. Untuk informasi selengkapnya, lihat [Mengenkripsi sumber daya Amazon RDS](Overview.Encryption.md).
Secara opsional, tambahkan konteks enkripsi. Untuk informasi lebih lanjut, lihat [Konteks enkripsi](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) di *Panduan Developer AWS Key Management Service *.
**catatan**
Amazon RDS menambahkan pasangan konteks enkripsi berikut selain yang Anda tambahkan:
`aws:glue:integration:arn` - `IntegrationArn`
`aws:servicename:id` - `glue`
Ini mengurangi jumlah keseluruhan pasangan yang dapat Anda tambahkan dari 8 menjadi 6, dan berkontribusi pada batas karakter keseluruhan dari batasan hibah. *Untuk informasi selengkapnya, lihat [Menggunakan batasan hibah di Panduan Pengembang](https://docs.aws.amazon.com/kms/latest/developerguide/create-grant-overview.html#grant-constraints).AWS Key Management Service *
1. Pilih **Selanjutnya**.
1. Tinjau pengaturan integrasi Anda dan pilih **Buat integrasi nol-ETL**.
Jika pembuatan gagal, lihat [Memecahkan masalah integrasi Amazon RDS ](zero-etl.troubleshooting.md) untuk langkah-langkah pemecahan masalah.
Integrasi memiliki status `Creating` saat sedang dibuat, dan target Amazon SageMaker lakehouse memiliki status. `Modifying` Selama waktu ini, Anda tidak dapat menanyakan katalog atau membuat perubahan konfigurasi apa pun di dalamnya.
Ketika integrasi berhasil dibuat, status integrasi dan target Amazon SageMaker lakehouse keduanya berubah menjadi. `Active`
### AWS CLI
Untuk menyiapkan katalog AWS Glue terkelola target untuk integrasi nol-ETL menggunakan AWS CLI, Anda harus terlebih dahulu menggunakan [create-integration-resource-property](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html)perintah dengan opsi berikut:
+ `--resource-arn`— Tentukan ARN dari katalog AWS Glue terkelola yang akan menjadi target integrasi.
+ `--target-processing-properties`— Tentukan ARN peran IAM untuk mengakses katalog terkelola target AWS Glue
```
aws glue create-integration-resource-property --region us-east-1
--resource-arn arn:aws:glue:region:account_id:catalog/catalog_name \
--target-processing-properties '{"RoleArn" : "arn:aws:iam::account_id:role/TargetIamRole"}'
```
Untuk membuat integrasi nol-ETL dengan Amazon SageMaker lakehouse menggunakan AWS CLI, gunakan perintah [create-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) dengan opsi berikut:
+ `--integration-name` – Tentukan nama untuk integrasi.
+ `--source-arn`— Tentukan ARN dari database RDS Aurora yang akan menjadi sumber untuk integrasi.
+ `--target-arn`— Tentukan ARN dari katalog AWS Glue terkelola yang akan menjadi target integrasi.
**Example**
Untuk Linux, macOS, atau Unix:
```
aws rds create-integration \
--integration-name my-sagemaker-integration \
--source-arn arn:aws:rds:{region}:{account-id}:cluster:my-db \
--target-arn arn:aws:glue:{region}:{account-id}:catalog/catalog-name
```
Untuk Windows:
```
aws rds create-integration ^
--integration-name my-sagemaker-integration ^
--source-arn arn:aws:rds:{region}:{account-id}:cluster:my-db ^
--target-arn arn:aws:glue:{region}:{account-id}:catalog/catalog-name
```
### API RDS
Untuk membuat integrasi nol-ETL dengan Amazon SageMaker menggunakan Amazon RDS API, gunakan [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html)operasi dengan parameter berikut:
**catatan**
Nama katalog dibatasi hingga 19 karakter. Pastikan IntegrationName parameter Anda memenuhi persyaratan ini jika akan digunakan sebagai nama katalog.
+ `IntegrationName` – Tentukan nama untuk integrasi.
+ `SourceArn`— Tentukan ARN dari database RDS Aurora yang akan menjadi sumber untuk integrasi.
+ `TargetArn`— Tentukan ARN dari katalog AWS Glue terkelola yang akan menjadi target integrasi.
## Mengenkripsi integrasi dengan kunci yang dikelola pelanggan
Jika Anda menentukan kunci KMS kustom dan bukan Kunci milik AWS saat Anda membuat integrasi denganAmazon SageMaker, kebijakan kunci harus menyediakan akses utama SageMaker Unified Studio layanan ke `CreateGrant` tindakan tersebut. Selain itu, harus memungkinkan pengguna saat ini untuk melakukan `CreateGrant` tindakan `DescribeKey` dan tindakan.
Kebijakan contoh berikut menunjukkan cara memberikan izin yang diperlukan dalam kebijakan utama. Ini termasuk kunci konteks untuk lebih mengurangi ruang lingkup izin.
### Contoh kebijakan kunci
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Key policy",
"Statement": [
{
"Sid": "EnablesIAMUserPermissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "GlueServicePrincipalAddGrant",
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}":"{context-value}"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "AllowsCurrentUserRoleAddGrantKMSKey",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}":"{context-value}",
"kms:ViaService": "rds.us-east-1.amazonaws.com"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "AllowsCurrentUserRoleRetrieveKMSKeyInformation",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:DescribeKey",
"Resource": "*"
}
]
}
```
------
Untuk informasi selengkapnya, lihat [Membuat kebijakan kunci](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) di *Panduan Developer AWS Key Management Service *.
## Langkah selanjutnya
Setelah Anda berhasil membuat integrasi nol-ETLAmazon SageMaker, Anda dapat mulai menambahkan data ke database RDS sumber cluster Aurora dan menanyakannya di lakehouse Anda. Amazon SageMaker Data akan direplikasi secara otomatis dan tersedia untuk beban kerja analitik dan pembelajaran mesin.
#
Alih-alih mereplikasi seluruh database, Anda dapat menerapkan satu atau beberapa filter untuk secara selektif menyertakan atau mengecualikan tabel tertentu. Ini membantu Anda mengoptimalkan kinerja penyimpanan dan kueri dengan memastikan bahwa hanya data yang relevan yang ditransfer. Saat ini, penyaringan terbatas pada tingkat database dan tabel. Pemfilteran tingkat kolom dan baris tidak didukung.
Pemfilteran data dapat berguna ketika Anda ingin:
+
+ Menghemat biaya dengan melakukan analitik hanya menggunakan subset tabel daripada seluruh armada database.
+ Saring informasi sensitif—seperti nomor telepon, alamat, atau detail kartu kredit—dari tabel tertentu.
Anda dapat menambahkan filter data ke integrasi nol-ETL menggunakan, AWS Command Line Interface (AWS CLI) Konsol Manajemen AWS, atau Amazon RDS API.
Jika integrasi memiliki cluster yang disediakan sebagai targetnya, cluster harus berada di [patch 180](https://docs.aws.amazon.com/redshift/latest/mgmt/cluster-versions.html#cluster-version-180) atau lebih tinggi untuk menggunakan pemfilteran data.
**Topics**
+ [Format filter data](#zero-etl.filtering-format)
+ [Filter logika](#zero-etl.filtering-evaluate)
+ [Filter prioritas](#zero-etl.filtering-precedence)
+ [](#zero-etl.filtering-examples-mysql)
+ [](#zero-etl.filtering-examples-postgres)
+ [RDS untuk contoh Oracle](#zero-etl.filtering-examples-oracle)
+ [Menambahkan filter data ke integrasi](#zero-etl.add-filter)
+ [Menghapus filter data dari integrasi](#zero-etl.remove-filter)
## Format filter data
Anda dapat menentukan beberapa filter untuk satu integrasi. Setiap filter menyertakan atau mengecualikan tabel database yang ada dan yang akan datang yang cocok dengan salah satu pola dalam ekspresi filter. [Integrasi Amazon RDS Zero-ETL menggunakan sintaks filter Maxwell untuk pemfilteran data.](https://maxwells-daemon.io/filtering/)
Setiap filter memiliki elemen-elemen berikut:
| Elemen | Deskripsi |
| --- | --- |
| Jenis filter | Jenis `Include` filter *mencakup* semua tabel yang cocok dengan salah satu pola dalam ekspresi filter. Jenis `Exclude` filter *mengecualikan* semua tabel yang cocok dengan salah satu pola. |
| Ekspresi filter | Daftar pola yang dipisahkan koma. Ekspresi harus menggunakan [sintaks filter Maxwell](https://maxwells-daemon.io/filtering/). |
| Pola | Anda dapat menentukan nama literal, atau menentukan ekspresi reguler. Untuk , ekspresi reguler didukung dalam database dan nama tabel. Untuk , ekspresi reguler hanya didukung dalam skema dan nama tabel, bukan dalam nama database. Anda tidak dapat menyertakan filter tingkat kolom atau daftar denylist. Integrasi tunggal dapat memiliki maksimum 99 pola total. Di konsol, Anda dapat memasukkan pola dalam satu ekspresi filter, atau menyebarkannya di antara beberapa ekspresi. Pola tunggal tidak dapat melebihi 256 karakter panjangnya. |
**penting**
Jika Anda memilih sumber , Anda harus menentukan setidaknya satu pola filter data. Minimal, pola harus menyertakan database tunggal (`database-name.*.*`) untuk replikasi ke gudang data target.
Gambar berikut menunjukkan struktur di konsol:
![\[Filter data untuk integrasi nol-ETL\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/images/zero-etl-filter.png)
**penting**
Jangan sertakan informasi identitas pribadi, rahasia, atau sensitif dalam pola filter Anda.
### Filter data di AWS CLI
Saat menggunakan AWS CLI untuk menambahkan filter data, sintaksnya sedikit berbeda dari konsol. Anda harus menetapkan jenis filter (`Include`atau`Exclude`) untuk setiap pola satu per satu, sehingga Anda tidak dapat mengelompokkan beberapa pola di bawah satu jenis filter.
Misalnya, di konsol Anda dapat mengelompokkan pola dipisahkan koma berikut di bawah satu `Include` pernyataan:
****
```
mydb.mytable, mydb./table_\d+/
```
****
```
mydb.myschema.mytable, mydb.myschema./table_\d+/
```
Namun, saat menggunakan AWS CLI, filter data yang sama harus dalam format berikut:
****
```
'include: mydb.mytable, include: mydb./table_\d+/'
```
****
```
'include: mydb.myschema.mytable, include: mydb.myschema./table_\d+/'
```
## Filter logika
Jika Anda tidak menentukan filter data apa pun dalam integrasi Anda, Amazon RDS mengasumsikan filter `include:*.*` default, yang mereplikasi semua tabel ke gudang data target. Namun, jika Anda menambahkan setidaknya satu filter, logika default beralih ke`exclude:*.*`, yang mengecualikan semua tabel secara default. Ini memungkinkan Anda secara eksplisit menentukan database dan tabel mana yang akan disertakan dalam replikasi.
Misalnya, jika Anda menentukan filter berikut:
```
'include: db.table1, include: db.table2'
```
Amazon RDS mengevaluasi filter sebagai berikut:
```
'exclude:*.*, include: db.table1, include: db.table2'
```
Oleh karena itu, Amazon RDS hanya `table1` mereplikasi `table2` dan dari database `db` bernama ke gudang data target.
## Filter prioritas
Amazon RDS mengevaluasi filter data dalam urutan yang Anda tentukan. Dalam Konsol Manajemen AWS, ia memproses ekspresi filter dari kiri ke kanan dan atas ke bawah. Filter kedua atau pola individual yang mengikuti yang pertama dapat menimpanya.
Misalnya, jika filter pertama adalah`Include books.stephenking`, itu hanya mencakup `stephenking` tabel dari `books` database. Namun, jika Anda menambahkan filter kedua`Exclude books.*`, itu akan menggantikan filter pertama. Ini mencegah tabel apa pun dari `books` indeks direplikasi ke gudang data target.
Ketika Anda menentukan setidaknya satu filter, logika dimulai dengan mengasumsikan secara `exclude:*.*` default, yang secara otomatis *mengecualikan* semua tabel dari replikasi. Sebagai praktik terbaik, tentukan filter dari yang paling luas hingga yang paling spesifik. Mulailah dengan satu atau beberapa `Include` pernyataan untuk menentukan data yang akan direplikasi, lalu tambahkan `Exclude` filter untuk menghapus tabel tertentu secara selektif.
Prinsip yang sama berlaku untuk filter yang Anda definisikan menggunakan AWS CLI. Amazon RDS mengevaluasi pola filter ini dalam urutan yang Anda tentukan, sehingga sebuah pola dapat menggantikan pola yang Anda tentukan sebelumnya.
##
Contoh berikut menunjukkan cara kerja penyaringan data untuk contoh nol-ETL:
+ Sertakan semua database dan semua tabel:
```
'include: *.*'
```
+ Sertakan semua tabel dalam `books` database:
```
'include: books.*'
```
+ Kecualikan tabel apa pun bernama`mystery`:
```
'include: *.*, exclude: *.mystery'
```
+ Sertakan dua tabel spesifik dalam `books` database:
```
'include: books.stephen_king, include: books.carolyn_keene'
```
+ Sertakan semua tabel dalam `books` database, kecuali yang berisi substring`mystery`:
```
'include: books.*, exclude: books./.*mystery.*/'
```
+ Sertakan semua tabel dalam `books` database, kecuali yang dimulai dengan`mystery`:
```
'include: books.*, exclude: books./mystery.*/'
```
+ Sertakan semua tabel dalam `books` database, kecuali yang diakhiri dengan`mystery`:
```
'include: books.*, exclude: books./.*mystery/'
```
+ Sertakan semua tabel dalam `books` database yang dimulai dengan`table_`, kecuali yang bernama`table_stephen_king`. Misalnya, `table_movies` atau `table_books` akan direplikasi, tetapi tidak`table_stephen_king`.
```
'include: books./table_.*/, exclude: books.table_stephen_king'
```
##
Contoh berikut menunjukkan cara kerja penyaringan data untuk PostgreSQL Zero-ETL:
+ Sertakan semua tabel dalam `books` database:
```
'include: books.*.*'
```
+ Kecualikan tabel apa pun yang disebutkan `mystery` dalam `books` database:
```
'include: books.*.*, exclude: books.*.mystery'
```
+ Sertakan satu tabel dalam `books` database dalam `mystery` skema, dan satu tabel dalam `employee` database dalam `finance` skema:
```
'include: books.mystery.stephen_king, include: employee.finance.benefits'
```
+ Sertakan semua tabel dalam `books` database dan `science_fiction` skema, kecuali yang berisi substring`king`:
```
'include: books.science_fiction.*, exclude: books.*./.*king.*/
```
+ Sertakan semua tabel dalam `books` database, kecuali yang memiliki nama skema yang dimulai dengan`sci`:
```
'include: books.*.*, exclude: books./sci.*/.*'
```
+ Sertakan semua tabel dalam `books` database, kecuali yang ada di `mystery` skema yang diakhiri dengan`king`:
```
'include: books.*.*, exclude: books.mystery./.*king/'
```
+ Sertakan semua tabel dalam `books` database yang dimulai dengan`table_`, kecuali yang bernama`table_stephen_king`. Misalnya, `table_movies` dalam `fiction` skema dan `table_books` skema direplikasi, tetapi tidak `table_stephen_king` di salah satu `mystery` skema:
```
'include: books.*./table_.*/, exclude: books.*.table_stephen_king'
```
## RDS untuk contoh Oracle
Contoh berikut menunjukkan cara kerja penyaringan data untuk RDS untuk integrasi Nol-ETL Oracle:
+ Sertakan semua tabel dalam database buku:
```
'include: books.*.*'
```
+ Kecualikan setiap tabel bernama misteri dalam database buku:
```
'include: books.*.*, exclude: books.*.mystery'
```
+ Sertakan satu tabel dalam database buku dalam skema misteri, dan satu tabel dalam database karyawan dalam skema keuangan:
```
'include: books.mystery.stephen_king, include: employee.finance.benefits'
```
+ Sertakan semua tabel dalam skema misteri dalam database buku:
```
'include: books.mystery.*'
```
### Pertimbangan sensitivitas kasus
Oracle Database dan Amazon Redshift menangani casing nama objek secara berbeda, yang memengaruhi konfigurasi filter data dan kueri target. Perhatikan hal-hal berikut:
+ Oracle Database menyimpan database, skema, dan nama objek dalam huruf besar kecuali secara eksplisit dikutip dalam pernyataan. `CREATE` Misalnya, jika Anda membuat `mytable` (tanpa tanda kutip), kamus data Oracle menyimpan nama tabel sebagai`MYTABLE`. Jika Anda mengutip nama objek, kamus data mempertahankan kasus ini.
+ Filter data nol-ETL peka huruf besar/kecil dan harus sesuai dengan kasus nama objek yang tepat seperti yang muncul di kamus data Oracle.
+ Amazon Redshift menanyakan default ke nama objek huruf kecil kecuali dikutip secara eksplisit. Misalnya, kueri `MYTABLE` (tanpa tanda kutip) mencari`mytable`.
Perhatikan perbedaan kasus saat Anda membuat filter Amazon Redshift dan menanyakan datanya.
#### Membuat integrasi huruf besar
Ketika Anda membuat tabel tanpa menentukan nama dalam tanda kutip ganda, database Oracle menyimpan nama dalam huruf besar dalam kamus data. Misalnya, Anda dapat membuat `MYTABLE` menggunakan salah satu pernyataan SQL berikut.
```
CREATE TABLE REINVENT.MYTABLE (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE reinvent.mytable (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE REinvent.MyTable (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE reINVENT.MYtabLE (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
Karena Anda tidak mengutip nama tabel dalam pernyataan sebelumnya, database Oracle menyimpan nama objek dalam huruf besar sebagai. `MYTABLE`
Untuk mereplikasi tabel ini ke Amazon Redshift, Anda harus menentukan nama huruf besar di filter data perintah Anda. `create-integration` Nama filter nol-ETL dan nama kamus data Oracle harus cocok.
```
aws rds create-integration \
--integration-name upperIntegration \
--data-filter "include: ORCL.REINVENT.MYTABLE" \
...
```
Secara default, Amazon Redshift menyimpan data dalam huruf kecil. Untuk melakukan kueri `MYTABLE` dalam database yang direplikasi di Amazon Redshift, Anda harus mengutip `MYTABLE` nama huruf besar sehingga cocok dengan kasus di kamus data Oracle.
```
SELECT * FROM targetdb1."REINVENT"."MYTABLE";
```
Kueri berikut tidak menggunakan mekanisme kutipan. Mereka semua mengembalikan kesalahan karena mereka mencari tabel Amazon Redshift bernama`mytable`, yang menggunakan nama huruf kecil default, tetapi tabel tersebut dinamai `MYTABLE` dalam kamus data Oracle.
```
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".MyTable;
SELECT * FROM targetdb1."REINVENT".mytable;
```
Kueri berikut menggunakan mekanisme kutipan untuk menentukan nama kasus campuran. Semua kueri mengembalikan kesalahan karena mereka mencari tabel Amazon Redshift yang tidak diberi nama. `MYTABLE`
```
SELECT * FROM targetdb1."REINVENT"."MYtablE";
SELECT * FROM targetdb1."REINVENT"."MyTable";
SELECT * FROM targetdb1."REINVENT"."mytable";
```
#### Membuat integrasi huruf kecil
Dalam contoh alternatif berikut, Anda menggunakan tanda kutip ganda untuk menyimpan nama tabel dalam huruf kecil di kamus data Oracle. Anda membuat `mytable` sebagai berikut.
```
CREATE TABLE REINVENT."mytable" (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
Database Oracle menyimpan nama tabel seperti `mytable` dalam huruf kecil. Untuk mereplikasi tabel ini ke Amazon Redshift, Anda harus menentukan `mytable` nama huruf kecil di filter data nol-ETL Anda.
```
aws rds create-integration \
--integration-name lowerIntegration \
--data-filter "include: ORCL.REINVENT.mytable" \
...
```
Saat Anda menanyakan tabel ini di database yang direplikasi di Amazon Redshift, Anda dapat menentukan nama huruf kecil. `mytable` Query berhasil karena mencari tabel bernama`mytable`, yang merupakan nama tabel dalam kamus data Oracle.
```
SELECT * FROM targetdb1."REINVENT".mytable;
```
Karena Amazon Redshift default ke nama objek huruf kecil, kueri berikut juga berhasil ditemukan. `mytable`
```
SELECT * FROM targetdb1."REINVENT".MYtablE;
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".MyTable;
```
Kueri berikut menggunakan mekanisme kutipan untuk nama objek. Mereka semua mengembalikan kesalahan karena mereka mencari tabel Amazon Redshift yang namanya berbeda dari. `mytable`
```
SELECT * FROM targetdb1."REINVENT"."MYTABLE";
SELECT * FROM targetdb1."REINVENT"."MyTable";
SELECT * FROM targetdb1."REINVENT"."MYtablE";
```
#### Buat tabel dengan integrasi kasus campuran
Dalam contoh berikut, Anda menggunakan tanda kutip ganda untuk menyimpan nama tabel dalam huruf kecil di kamus data Oracle. Anda membuat `MyTable` sebagai berikut.
```
CREATE TABLE REINVENT."MyTable" (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
Database Oracle menyimpan nama tabel ini seperti `MyTable` halnya kasus campuran. Untuk mereplikasi tabel ini ke Amazon Redshift, Anda harus menentukan nama kasus campuran dalam filter data.
```
aws rds create-integration \
--integration-name mixedIntegration \
--data-filter "include: ORCL.REINVENT.MyTable" \
...
```
Saat Anda menanyakan tabel ini di database yang direplikasi di Amazon Redshift, Anda harus menentukan `MyTable` nama kasus campuran dengan mengutip nama objek.
```
SELECT * FROM targetdb1."REINVENT"."MyTable";
```
Karena Amazon Redshift default ke nama objek huruf kecil, kueri berikut tidak menemukan objek karena mereka mencari nama huruf kecil. `mytable`
```
SELECT * FROM targetdb1."REINVENT".MYtablE;
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".mytable;
```
**catatan**
Anda tidak dapat menggunakan ekspresi reguler dalam nilai filter untuk nama database, skema, atau nama tabel di RDS untuk integrasi Oracle.
## Menambahkan filter data ke integrasi
Anda dapat mengonfigurasi pemfilteran data menggunakan Konsol Manajemen AWS, API AWS CLI, atau Amazon RDS.
**penting**
Jika Anda menambahkan filter setelah membuat integrasi, Amazon RDS memperlakukannya seolah-olah selalu ada. Ini menghapus data apa pun di gudang data target yang tidak cocok dengan kriteria pemfilteran baru dan menyinkronkan ulang semua tabel yang terpengaruh.
### Konsol RDS
**Untuk menambahkan filter data ke integrasi nol-ETL**
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 panel navigasi, pilih integrasi **nol-ETL**. Pilih integrasi yang ingin Anda tambahkan filter data, lalu pilih **Ubah**.
1. Di bawah **Sumber**, tambahkan satu atau lebih `Include` dan `Exclude` pernyataan.
Gambar berikut menunjukkan contoh filter data untuk integrasi MySQL:
![\[Filter data untuk integrasi nol-ETL di konsol RDS\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/images/zero-etl-filter-data.png)
1. Jika Anda puas dengan perubahan, pilih **Lanjutkan** dan **Simpan perubahan**.
### AWS CLI
[Untuk menambahkan filter data ke integrasi nol-ETL menggunakan AWS CLI, panggil perintah modify-integration.](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-integration.html) Selain pengidentifikasi integrasi, tentukan `--data-filter` parameter dengan daftar filter Maxwell yang dipisahkan koma. `Include` `Exclude`
**Example**
Contoh berikut menambahkan pola filter ke`my-integration`.
Untuk Linux, macOS, atau Unix:
```
aws rds modify-integration \
--integration-identifier my-integration \
--data-filter 'include: foodb.*, exclude: foodb.tbl, exclude: foodb./table_\d+/'
```
Untuk Windows:
```
aws rds modify-integration ^
--integration-identifier my-integration ^
--data-filter 'include: foodb.*, exclude: foodb.tbl, exclude: foodb./table_\d+/'
```
### API RDS
Untuk memodifikasi integrasi nol-ETL menggunakan RDS API, panggil operasi. [ModifyIntegration](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyIntegration.html) Tentukan pengidentifikasi integrasi dan berikan daftar pola filter yang dipisahkan koma.
## Menghapus filter data dari integrasi
Saat Anda menghapus filter data dari integrasi, Amazon RDS mengevaluasi kembali filter yang tersisa seolah-olah filter yang dihapus tidak pernah ada. Kemudian mereplikasi data yang sebelumnya dikecualikan yang sekarang memenuhi kriteria ke dalam gudang data target. Ini memicu sinkronisasi ulang semua tabel yang terpengaruh.
# Menambahkan data ke database sumber RDS cluster dan menanyakannya
Untuk menyelesaikan pembuatan integrasi nol-ETL yang mereplikasi data dari Amazon RDS Amazon Redshift, Anda harus membuat database di tujuan target.
Untuk koneksi dengan Amazon Redshift, sambungkan ke klaster atau grup kerja Amazon Redshift Anda dan buat database dengan referensi ke pengenal integrasi Anda. Kemudian, Anda dapat menambahkan data ke basis data RDS sumber Anda cluster dan melihatnya direplikasi di Amazon Redshift atau. Amazon SageMaker
**Topics**
+ [Membuat database target](#zero-etl.create-db)
+ [Menambahkan data ke database sumber](#zero-etl.add-data-rds)
+ [Menanyakan data Amazon RDS Anda di Amazon Redshift](#zero-etl.query-data-redshift)
+ [Perbedaan jenis data antara basis data RDS dan Amazon Redshift](#zero-etl.data-type-mapping)
+ [](#zero-etl.ddl-postgres)
## Membuat database target
Sebelum Anda dapat mulai mereplikasi data ke Amazon Redshift, setelah Anda membuat integrasi, Anda harus membuat database di gudang data target Anda. Database ini harus menyertakan referensi ke identifier integrasi. Anda dapat menggunakan konsol Amazon Redshift atau Editor kueri v2 untuk membuat basis data.
Untuk petunjuk cara membuat basis data tujuan, lihat [Membuat basis data tujuan di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html#zero-etl-using.create-db).
## Menambahkan data ke database sumber
Setelah Anda mengkonfigurasi integrasi Anda, Anda dapat mengisi sumber RDS database Aurora dengan data yang ingin Anda replikasi ke gudang data Anda.
**catatan**
Ada perbedaan antara tipe data di Amazon RDS Aurora dan gudang analitik target. Untuk tabel pemetaan jenis data, lihat [Perbedaan jenis data antara basis data RDS dan Amazon Redshift](#zero-etl.data-type-mapping).
Pertama, sambungkan ke database sumber menggunakan klien MySQL pilihan Anda. Untuk petunjuk, lihat [Menghubungkan ke instans MySQL DB Anda](USER_ConnectToInstance.md).
Kemudian, buat tabel dan masukkan urutan data sampel.
**penting**
Pastikan tabel memiliki kunci primer. Jika tidak, tabel tidak dapat direplikasi ke gudang data target.
untuk **MySQL**
Contoh berikut menggunakan [utilitas MySQL Workbench](https://dev.mysql.com/downloads/workbench/).
```
CREATE DATABASE my_db;
USE my_db;
CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
**RDS untuk PostgreSQL**
Contoh berikut menggunakan terminal interaktif PostgreSQL `[psql](https://www.postgresql.org/docs/current/app-psql.html)`. Saat menghubungkan ke database, sertakan nama database yang ingin Anda tiru.
```
psql -h mydatabase.123456789012.us-east-2.rds.amazonaws.com -p 5432 -U username -d named_db;
named_db=> CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
named_db=> INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
**RDS untuk Oracle**
Contoh berikut menggunakan SQL\$1 Plus untuk terhubung ke RDS Anda untuk database Oracle.
```
sqlplus 'user_name@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=dns_name)(PORT=port))(CONNECT_DATA=(SID=database_name)))'
SQL> CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
SQL> INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
## Menanyakan data Amazon RDS Anda di Amazon Redshift
Setelah Anda menambahkan data ke database RDS cluster, itu direplikasi ke database tujuan dan siap untuk ditanyakan.
**Untuk mengueri data yang direplikasi**
1. Buka konsol Amazon Redshift dan pilih **Editor kueri v2** dari panel navigasi kiri.
1. Hubungkan ke klaster atau grup kerja Anda dan pilih basis data tujuan Anda (yang Anda buat dari integrasi) dari menu dropdown (**destination\$1database** dalam contoh ini). Untuk petunjuk cara membuat basis data tujuan, lihat [Membuat basis data tujuan di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html#zero-etl-using.create-db).
1. Gunakan pernyataan SELECT untuk menanyakan data Anda. Dalam contoh ini, Anda dapat menjalankan perintah berikut untuk memilih semua data dari tabel yang Anda buat di basis data RDS sumber DB cluster:
```
SELECT * from my_db."books_table";
```
![\[Jalankan pernyataan SELECT dalam editor kueri. Hasilnya adalah satu baris data sampel yang ditambahkan ke database Amazon RDS.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/images/zero-etl-redshift-editor.png)
+ `my_db` adalah nama skema basis data RDS.
+ `books_table` adalah nama tabel RDS.
Anda juga dapat menanyakan data menggunakan klien baris perintah. Contoh:
```
destination_database=# select * from my_db."books_table";
ID | Title | Author | Copyright | Genre | txn_seq | txn_id
----+–------------+---------------+-------------+------------------------+----------+--------+
1 | The Shining | Stephen King | 1977 | Supernatural fiction | 2 | 12192
```
**catatan**
Untuk kepekaan huruf besar/kecil, gunakan tanda kutip ganda (" ") untuk nama skema, tabel, dan kolom. Untuk informasi selengkapnya, lihat [enable\$1case\$1sensitive\$1identifier](https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html).
## Perbedaan jenis data antara basis data RDS dan Amazon Redshift
Tabel berikut menunjukkan pemetaan RDS untuk MySQL, RDS untuk PostgreSQL, dan RDS untuk tabel Oracle menunjukkan pemetaan Aurora MySQL dan Aurora PostgreSQL *Amazon RDS saat ini hanya mendukung jenis data ini untuk integrasi nol-ETL.*
Jika tabel di database sumber Anda menyertakan tipe data yang tidak didukung, tabel tidak sinkron dan tidak dapat dikonsumsi oleh target tujuan. Streaming dari sumber ke target berlanjut, tetapi tabel dengan jenis data yang tidak didukung tidak tersedia. Untuk memperbaiki tabel dan membuatnya tersedia di tujuan target, Anda harus secara manual mengembalikan perubahan yang melanggar dan kemudian menyegarkan integrasi dengan menjalankan`[ALTER DATABASE...INTEGRATION REFRESH](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATABASE.html)`.
**catatan**
Anda tidak dapat menyegarkan integrasi nol-ETL dengan lakehouse. Amazon SageMaker Sebagai gantinya, hapus dan coba buat integrasi lagi.
**Topics**
+ [RDS for MySQL](#zero-etl.data-type-mapping-mysql)
+ [](#zero-etl.data-type-mapping-postgres)
+ [RDS for Oracle](#zero-etl.data-type-mapping-oracle)
### RDS for MySQL
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
###
Integrasi nol-ETL untuk RDS untuk PostgreSQL tidak mendukung tipe data khusus atau tipe data yang dibuat oleh ekstensi.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### RDS for Oracle
**Tipe data yang tidak didukung**
RDS berikut untuk tipe data Oracle tidak didukung oleh Amazon Redshift:
+ `ANYDATA`
+ `BFILE`
+ `REF`
+ `ROWID`
+ `UROWID`
+ `VARRAY`
+ `SDO_GEOMETRY`
+ Jenis data yang ditentukan pengguna
**Perbedaan tipe data**
Tabel berikut menunjukkan perbedaan tipe data yang mempengaruhi integrasi nol-ETL ketika RDS untuk Oracle adalah sumbernya dan Amazon Redshift adalah targetnya.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
##
Integrasi nol-ETL memanfaatkan kesamaan ini untuk merampingkan replikasi data dari RDS untuk PostgreSQL Aurora PostgreSQL , dan struktur tabel.
Pertimbangkan poin-poin berikut saat mengelola RDS untuk PostgreSQL Aurora PostgreSQL integrasi
+ Isolasi dikelola di tingkat database.
+ Replikasi terjadi pada tingkat database.
+ RDS untuk PostgreSQL database PostgreSQL dipetakan ke database Amazon Redshift berdasarkan nama, dengan data mengalir ke database Redshift yang berganti nama sesuai jika aslinya diganti namanya.
Terlepas dari kesamaan mereka, Amazon Redshift dan RDS untuk PostgreSQL Aurora PostgreSQL . Bagian berikut menguraikan respons sistem Amazon Redshift untuk operasi DDL umum.
**Topics**
+ [Operasi basis data](#zero-etl.ddl-postgres-database)
+ [Operasi skema](#zero-etl.ddl-postgres-schema)
+ [Operasi tabel](#zero-etl.ddl-postgres-table)
### Operasi basis data
Tabel berikut menunjukkan respon sistem untuk operasi DDL database.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### Operasi skema
Tabel berikut menunjukkan respon sistem untuk operasi skema DDL.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### Operasi tabel
Tabel berikut menunjukkan respon sistem untuk operasi tabel DDL.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
# Melihat dan memantau integrasi Amazon RDS Zero-ETL
Anda dapat melihat detail integrasi nol-ETL Amazon RDS untuk melihat informasi konfigurasi dan statusnya saat ini. Anda juga dapat memantau status integrasi dengan mengueri tampilan sistem tertentu di Amazon Redshift. Selain itu, Amazon Redshift menerbitkan metrik terkait integrasi tertentu ke Amazon, yang dapat Anda lihat dalam konsol CloudWatch Amazon Redshift.
**Topics**
+ [Melihat integrasi](#zero-etl.describing)
+ [Integrasi pemantauan menggunakan tabel sistem untuk Amazon Redshift](#zero-etl.monitoring)
+ [Memantau integrasi dengan Amazon EventBridge untuk Amazon Redshift](#zero-etl.eventbridge)
## Melihat integrasi
Anda dapat melihat integrasi Amazon RDS Zero-ETL menggunakan, API, atau RDS Konsol Manajemen AWS. AWS CLI
### Konsol
**Untuk melihat detail integrasi nol-ETL**
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 panel navigasi sebelah kiri, pilih **Integrasi nol-ETL**.
1. Pilih integrasi untuk melihat detail lebih lanjut tentangnya, seperti basis data sumber dan gudang data target.
![\[Detail tentang integrasi nol-ETL\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/images/zero-etl-integration-view.png)
Integrasi dapat memiliki status berikut:
+ `Creating` – Integrasi sedang dibuat.
+ `Active` – Integrasi sedang mengirimkan data transaksional ke gudang data target.
+ `Syncing` – Integrasi telah mengalami kesalahan yang dapat dipulihkan dan sedang melakukan reseeding data. Tabel yang terpengaruh tidak tersedia untuk kueri sampai selesai disinkronkan ulang.
+ `Needs attention` – Integrasi mengalami peristiwa atau kesalahan yang memerlukan intervensi manual untuk menyelesaikannya. Untuk memperbaiki masalah, ikuti petunjuk dalam pesan kesalahan di halaman detail integrasi.
+ `Failed` – Integrasi mengalami peristiwa atau kesalahan yang tidak dapat dipulihkan dan tidak dapat diperbaiki. Anda harus menghapus dan membuat ulang integrasi.
+ `Deleting` – Integrasi sedang dihapus.
### AWS CLI
Untuk melihat semua integrasi nol-ETL di akun saat ini menggunakan AWS CLI, gunakan [perintah deskripsi-integrasi dan tentukan opsi](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-integrations.html). `--integration-identifier`
**Example**
Untuk Linux, macOS, atau Unix:
```
aws rds describe-integrations \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
Untuk Windows:
```
aws rds describe-integrations ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
### API RDS
Untuk melihat integrasi nol-ETL menggunakan API Amazon RDS, gunakan operasi [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeIntegrations.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeIntegrations.html) dengan parameter `IntegrationIdentifier`.
## Integrasi pemantauan menggunakan tabel sistem untuk Amazon Redshift
Amazon Redshift memiliki tabel dan tampilan sistem yang berisi informasi tentang bagaimana sistem berfungsi. Anda dapat mengueri tabel dan tampilan sistem ini dengan cara yang sama seperti Anda akan mengueri tabel basis data lainnya. Untuk informasi selengkapnya tentang tabel dan tampilan sistem di Amazon Redshift, lihat [Referensi tabel dan tampilan sistem](https://docs.aws.amazon.com//redshift/latest/dg/cm_chap_system-tables.html) di Panduan Pengembang *Database Amazon Redshift*.
Anda dapat menanyakan tampilan dan tabel sistem berikut untuk mendapatkan informasi tentang integrasi Zero-ETL Anda:
+ [SVV\$1INTEGRATION](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION.html) – Menyediakan detail konfigurasi untuk integrasi Anda.
+ [SVV\$1INTEGRATION\$1TABLE\$1STATE](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html) – Menjelaskan status setiap tabel dalam integrasi.
+ [SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_STATE_CHANGE.html) – Menampilkan log perubahan status tabel untuk integrasi.
+ [SYS\$1INTEGRATION\$1ACTIVITY](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_INTEGRATION_ACTIVITY.html) – Menyediakan informasi tentang proses integrasi yang selesai.
Semua CloudWatch metrik Amazon terkait integrasi berasal dari Amazon Redshift. *Untuk informasi selengkapnya, lihat [Metrik untuk integrasi Nol-ETL di Panduan Manajemen Pergeseran](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.monitoring.html) Merah Amazon.* Saat ini, Amazon RDS Aurora tidak mempublikasikan metrik integrasi apa pun. CloudWatch
## Memantau integrasi dengan Amazon EventBridge untuk Amazon Redshift
Amazon Redshift mengirim peristiwa terkait integrasi ke Amazon. EventBridge *Untuk daftar acara dan acara terkait IDs, lihat [Pemberitahuan peristiwa integrasi nol-ETL dengan Amazon di Panduan Manajemen Pergeseran Merah EventBridge Amazon](https://docs.aws.amazon.com/redshift/latest/mgmt/integration-event-notifications).*
#
Anda hanya dapat memodifikasi nama, deskripsi, dan opsi pemfilteran data untuk integrasi nol-ETL di gudang data yang didukung. Anda tidak dapat memodifikasi AWS KMS kunci yang digunakan untuk mengenkripsi integrasi, atau basis data sumber atau target.
Jika Anda menambahkan filter data ke integrasi yang ada, Amazon RDS mengevaluasi kembali filter seolah-olah selalu ada. Ini menghapus data apa pun yang saat ini ada di gudang data target yang tidak sesuai dengan kriteria penyaringan baru. Jika Anda *menghapus* filter data dari integrasi, itu mereplikasi data apa pun yang sebelumnya tidak cocok dengan kriteria pemfilteran (tetapi sekarang) ke gudang data target. Untuk informasi selengkapnya, lihat [](zero-etl.filtering.md).
Anda dapat memodifikasi integrasi nol-ETL menggunakan Konsol Manajemen AWS, API, AWS CLI atau Amazon RDS.
## Konsol RDS
**Untuk memodifikasi integrasi nol-ETL**
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 panel navigasi, pilih **integrasi nol-ETL**, lalu pilih integrasi yang ingin Anda ubah.
1. Pilih **Ubah** dan buat modifikasi pada pengaturan apa pun yang tersedia.
1. Ketika semua perubahan seperti yang Anda inginkan, pilih **Ubah**.
## AWS CLI
[Untuk memodifikasi integrasi nol-ETL menggunakan AWS CLI, panggil perintah modify-integration.](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-integration.html) Seiring dengan`--integration-identifier`, tentukan salah satu opsi berikut:
+ `--integration-name`— Tentukan nama baru untuk integrasi.
+ `--description`— Tentukan deskripsi baru untuk integrasi.
+ `--data-filter`— Tentukan opsi pemfilteran data untuk integrasi. Untuk informasi selengkapnya, lihat [](zero-etl.filtering.md).
**Example**
Permintaan berikut memodifikasi integrasi yang ada.
Untuk Linux, macOS, atau Unix:
```
aws rds modify-integration \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374 \
--integration-name my-renamed-integration
```
Untuk Windows:
```
aws rds modify-integration ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374 ^
--integration-name my-renamed-integration
```
## API RDS
Untuk memodifikasi integrasi nol-ETL menggunakan RDS API, panggil operasi. [ModifyIntegration](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyIntegration.html) Tentukan pengidentifikasi integrasi, dan parameter yang ingin Anda modifikasi.
#
Data transaksional Anda tidak dihapus dari Amazon RDS Amazon atau tujuan analitik, tetapi Amazon RDS tidak mengirim data baru ke Amazon Redshift atau. Amazon SageMaker
Anda hanya dapat menghapus integrasi ketika integrasi ini memiliki status `Active`, `Failed`, `Syncing`, atau `Needs attention`.
Anda dapat menghapus integrasi nol-ETL menggunakan Konsol Manajemen AWS,, atau RDS API AWS CLI.
## Konsol
**Untuk menghapus integrasi nol-ETL**
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 panel navigasi sebelah kiri, pilih **Integrasi nol-ETL**.
1. Pilih integrasi nol-ETL yang ingin Anda hapus.
1. Pilih **Tindakan**, **Hapus**, dan konfirmasi penghapusan.
## AWS CLI
Untuk menghapus integrasi nol-ETL, gunakan perintah [delete-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-integration.html) dan tentukan opsi `--integration-identifier`.
**Example**
Untuk Linux, macOS, atau Unix:
```
aws rds delete-integration \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
Untuk Windows:
```
aws rds delete-integration ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
## API RDS
Untuk menghapus integrasi nol-ETL menggunakan API Amazon RDS, gunakan operasi [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteIntegration.html) dengan parameter `IntegrationIdentifier`.
# Memecahkan masalah integrasi Amazon RDS
Anda dapat memeriksa status integrasi nol-ETL dengan menanyakan tabel sistem [SVV\$1INTEGRATION di tujuan analitik](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION.html). Jika kolom `state` memiliki nilai `ErrorState`, artinya ada sesuatu yang salah. Untuk informasi selengkapnya, lihat [Integrasi pemantauan menggunakan tabel sistem untuk Amazon Redshift](zero-etl.describingmonitoring.md#zero-etl.monitoring).
Gunakan informasi berikut untuk memecahkan masalah umum dengan integrasi Amazon RDS Zero-ETL.
**penting**
Operasi resync dan refresh tidak tersedia untuk integrasi nol-ETL dengan lakehouse. Amazon SageMaker AI Jika ada masalah dengan integrasi, Anda harus menghapus integrasi dan membuat integrasi baru. Anda tidak dapat menyegarkan atau menyinkronkan ulang integrasi yang ada.
**Topics**
+ [Saya tidak dapat membuat integrasi nol-ETL](#zero-etl.troubleshooting.creation)
+ [Integrasi saya terjebak dalam keadaan `Syncing`](#zero-etl.troubleshooting.syncing)
+ [Tabel saya tidak bereplikasi ke Amazon Redshift](#zero-etl.troubleshooting.primarykey)
+ [Satu atau beberapa tabel Amazon Redshift saya memerlukan sinkronisasi ulang](#zero-etl.troubleshooting.resync)
+ [Masalah gagal integrasi untuk integrasi Amazon SageMaker AI lakehouse zero-ETL](#zero-etl.troubleshooting.integration-issues)
## Saya tidak dapat membuat integrasi nol-ETL
Jika Anda tidak dapat membuat integrasi nol-ETL, pastikan bahwa berikut ini benar untuk database sumber Anda:
+ Database sumber Anda harus menjalankan versi mesin DB yang didukung. Untuk daftar versi yang didukung, lihat [Daerah yang Didukung dan engine DB untuk integrasi Amazon RDS Zero-ETL](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
+ Anda mengkonfigurasi parameter DB dengan benar. Jika parameter yang diperlukan disetel secara tidak benar atau tidak terkait dengan database, pembuatan gagal. Lihat [Langkah 1: Buat grup parameter DB kustom](zero-etl.setting-up.md#zero-etl.parameters).
Selain itu, pastikan hal-hal berikut ini sudah benar untuk gudang data target Anda:
+ Kepekaan huruf besar/kecil diaktifkan. Lihat [Mengaktifkan kepekaan huruf besar/kecil untuk gudang data Anda](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-setting-up.case-sensitivity).
+ Anda menambahkan prinsipal yang diotorisasi dan sumber integrasi yang benar. Lihat [Mengonfigurasi otorisasi untuk gudang data Amazon Redshift Anda](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam).
+ Gudang data dienkripsi (jika itu adalah cluster yang disediakan). Lihat [enkripsi basis data Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html).
## Integrasi saya terjebak dalam keadaan `Syncing`
Integrasi Anda mungkin secara konsisten menunjukkan status `Syncing` jika Anda mengubah nilai salah satu parameter DB yang diperlukan.
Untuk memperbaiki masalah ini, periksa nilai parameter dalam grup parameter yang terkait dengan database sumber, dan pastikan bahwa mereka cocok dengan nilai yang diperlukan. Untuk informasi selengkapnya, lihat [Langkah 1: Buat grup parameter DB kustom](zero-etl.setting-up.md#zero-etl.parameters).
Jika Anda memodifikasi parameter apa pun, pastikan untuk me-reboot database untuk menerapkan perubahan.
## Tabel saya tidak bereplikasi ke Amazon Redshift
Jika Anda tidak melihat satu atau beberapa tabel yang tercermin di Amazon Redshift, Anda dapat menjalankan perintah berikut untuk menyinkronkan ulang tabel tersebut:
```
ALTER DATABASE dbname INTEGRATION REFRESH TABLES table1, table2;
```
Untuk informasi selengkapnya, lihat [ALTER DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATABASE.html) di referensi Amazon Redshift SQL.
Data Anda mungkin tidak mereplikasi karena satu atau beberapa tabel sumber Anda tidak memiliki kunci utama. Dasbor pemantauan di Amazon Redshift menampilkan status tabel ini sebagai`Failed`, dan status integrasi nol-ETL keseluruhan berubah menjadi. `Needs attention` Untuk mengatasi masalah ini, Anda dapat mengidentifikasi kunci yang ada di tabel Anda yang dapat menjadi kunci utama, atau Anda dapat menambahkan kunci primer sintetis. Untuk solusi mendetail, lihat [Menangani tabel tanpa kunci utama saat membuat Amazon Aurora MySQL atau Amazon RDS untuk integrasi Nol-ETL MySQL](https://aws.amazon.com/blogs/database/handle-tables-without-primary-keys-while-creating-amazon-aurora-mysql-or-amazon-rds-for-mysql-zero-etl-integrations-with-amazon-redshift/) dengan Amazon Redshift.
## Satu atau beberapa tabel Amazon Redshift saya memerlukan sinkronisasi ulang
Menjalankan perintah tertentu pada database sumber Anda mungkin memerlukan tabel Anda untuk disinkronkan ulang. Dalam kasus ini, tampilan sistem [SVV\$1INTEGRATION\$1TABLE\$1STATE](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html) menunjukkan `table_state` dari `ResyncRequired`. Artinya, integrasi harus memuat ulang data sepenuhnya untuk tabel spesifik tersebut dari MySQL ke Amazon Redshift.
Ketika tabel mulai disinkronkan ulang, tabel ini akan beralih ke status `Syncing`. Anda tidak perlu mengambil tindakan manual apa pun untuk menyinkronkan ulang tabel. Saat data tabel disinkronkan ulang, Anda tidak dapat mengaksesnya di Amazon Redshift.
Berikut ini adalah beberapa contoh operasi yang dapat menempatkan tabel ke dalam status `ResyncRequired`, dan beberapa kemungkinan alternatif untuk dipertimbangkan.
| Operasi | Contoh | Alternatif |
| --- | --- | --- |
| Menambahkan kolom ke posisi tertentu | ALTER TABLE table_name
ADD COLUMN column_name INTEGER
NOT NULL first;
| Amazon Redshift tidak mendukung penambahan kolom ke posisi tertentu menggunakan kata kunci first atau after. Jika urutan kolom dalam tabel target tidak penting, tambahkan kolom ke akhir tabel menggunakan perintah yang lebih sederhana:ALTER TABLE table_name
ADD COLUMN column_name column_type;
|
| Menambahkan kolom stempel waktu dengan CURRENT\$1TIMESTAMP default | ALTER TABLE table_name
ADD COLUMN column_name TIMESTAMP
NOT NULL DEFAULT CURRENT_TIMESTAMP;
| Nilai CURRENT\$1TIMESTAMP untuk baris tabel yang ada dihitung oleh RDS for MySQL dan tidak dapat disimulasikan di Amazon Redshift tanpa sinkronisasi ulang data tabel penuh. Jika memungkinkan, alihkan nilai default ke konstanta literal seperti `2023-01-01 00:00:15` untuk menghindari latensi dalam ketersediaan tabel. |
| Melakukan beberapa operasi kolom dalam satu perintah | ALTER TABLE table_name
ADD COLUMN column_1,
RENAME COLUMN column_2 TO column_3;
| Pertimbangkan untuk membagi perintah menjadi dua operasi terpisah, ADD dan RENAME, yang tidak memerlukan sinkronisasi ulang. |
## Masalah gagal integrasi untuk integrasi Amazon SageMaker AI lakehouse zero-ETL
Jika Anda mengalami masalah dengan integrasi nol-ETL yang ada dengan Amazon SageMaker AI lakehouse, satu-satunya resolusi adalah menghapus integrasi dan membuat yang baru. Tidak seperti AWS layanan lain, integrasi nol-ETL tidak mendukung operasi penyegaran atau sinkronisasi ulang.
Untuk mengatasi masalah integrasi:
1. Hapus integrasi nol-ETL yang bermasalah menggunakan konsol, CLI, atau API.
1. Verifikasi bahwa database sumber dan konfigurasi gudang data target sudah benar.
1. Buat integrasi nol-ETL baru dengan konfigurasi yang sama atau diperbarui.
Proses ini akan menghasilkan inisialisasi ulang lengkap dari pipeline data, yang mungkin memakan waktu tergantung pada ukuran database sumber Anda.