Langkah 1: Buat grup parameter DB kustom Langkah 2: Pilih atau buat basis data sumber Langkah 3a: Buat gudang data target Siapkan integrasi menggunakan AWS SDKs Langkah 3b: Buat AWS Glue katalog untuk integrasi Amazon SageMaker AI Zero-ETL Langkah selanjutnya

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:

Buat grup parameter DB kustom.
Buat basis data sumber .
Buat gudang data target untuk Amazon Redshift atau Buat target Amazon SageMaker AI lakehouse.

Setelah Anda menyelesaikan tugas-tugas ini, lanjutkan ke Membuat integrasi nol-ETL Amazon RDS dengan Amazon Redshift atauMembuat integrasi Amazon RDS Zero-ETL dengan rumah danau Amazon SageMaker.

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, lihatMembuat integrasi nol-ETL Amazon RDS dengan Amazon Redshift.

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 lakehouse Amazon SageMaker AI 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 RDSAmazon DB Amazon. 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 keON.

Beberapa parameter ini (sepertibinlog_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. 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 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, 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 petunjuk membuat cluster DB multi-AZ, lihatMembuat cluster DB Multi-AZ untuk Amazon RDS.

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.

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 atau Mem-boot ulang cluster DB multi-AZ dan instans DB pembaca untuk Amazon RDS.

Selain itu, pastikan bahwa backup otomatis diaktifkan pada database. Untuk informasi selengkapnya, lihat Mengaktifkan pencadangan otomatis.

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.

Untuk petunjuk cara membuat gudang data, lihat Membuat klaster untuk klaster terprovisi, atau Membuat grup kerja dengan ruang nama untuk Redshift Nirserver.

Aktifkan kepekaan huruf besar/kecil di gudang data

Agar integrasi berhasil, parameter kepekaan huruf besar/kecil (enable_case_sensitive_identifier) 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 atau Mengonfigurasi nilai parameter menggunakan AWS CLI.

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 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.

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)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.


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 AI Zero-ETL

Saat membuat integrasi nol-ETL dengan Amazon SageMaker AI 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.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.
Untuk informasi tentang izin administrator hanya-baca untuk Lake Formation, lihat personas Lake Formation dan referensi izin IAM 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 pembuatan target haruslah administrator Lake Formation dan memerlukan izin berikut.

Peran penciptaan target harus memiliki hubungan kepercayaan berikut.

Peran transfer data Glue diperlukan untuk operasi katalog MySQL dan harus memiliki izin berikut.

Peran transfer data Glue harus memiliki hubungan kepercayaan berikut.

Langkah selanjutnya

Dengan basis data RDS sumber cluster dan gudang data target Amazon Redshift atau SageMaker Amazon AI lakehouse, Anda dapat membuat integrasi nol-ETL dan mereplikasi data. Untuk petunjuk, lihat Membuat integrasi nol-ETL Amazon RDS dengan Amazon Redshift.

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Integrasi nol-ETL

Membuat integrasi Nol-ETL dengan Amazon Redshift