Langkah 1: Buat grup parameter klaster DB kustom Langkah 2: Pilih atau buat cluster DB sumber Langkah 3: Buat gudang data Amazon Redshift Siapkan integrasi menggunakan AWS SDKs(Aurora Satu-satukuSQL)Langkah selanjutnya

Memulai dengan Aurora zero- ETL integrasi dengan Amazon Redshift

Sebelum Anda membuat ETL integrasi nol dengan Amazon Redshift, konfigurasikan cluster DB database Anda dan gudang data Amazon Redshift Anda dengan parameter dan izin yang diperlukan. Selama pengaturan, Anda akan menyelesaikan langkah-langkah berikut:

Buat grup parameter klaster DB kustom.
Buat sumber DB cluster.
Buat gudang data Amazon Redshift target.

Setelah Anda menyelesaikan tugas-tugas ini, lanjutkan ke Membuat Aurora zero- ETL integrasi dengan Amazon Redshift.

Anda dapat menggunakan AWS SDKsuntuk mengotomatiskan proses penyiapan untuk Anda. Untuk informasi selengkapnya, lihat Siapkan integrasi menggunakan AWS SDKs(Aurora Satu-satukuSQL).

Tip

Anda dapat RDS menyelesaikan langkah-langkah pengaturan ini untuk Anda saat Anda membuat integrasi, daripada melakukannya secara manual. Untuk segera mulai membuat integrasi, lihatMembuat Aurora zero- ETL integrasi dengan Amazon Redshift.

Langkah 1: Buat grup parameter klaster DB kustom

ETLIntegrasi nol Aurora dengan Amazon Redshift memerlukan nilai spesifik untuk parameter cluster DB yang mengontrol replikasi. Secara khusus, Aurora My SQL membutuhkan binlog (aurora_enhanced_binlog) yang ditingkatkan, dan Aurora Postgre SQL memerlukan replikasi logis yang ditingkatkan (). aurora.enhanced_logical_replication

Untuk mengonfigurasi pencatatan log biner atau replikasi logis, Anda harus membuat grup parameter klaster DB kustom terlebih dahulu, lalu mengaitkannya dengan klaster DB sumber.

Buat grup parameter klaster DB kustom dengan pengaturan berikut bergantung pada mesin DB sumber Anda. Untuk petunjuk cara membuat grup parameter, lihat Grup parameter cluster DB untuk cluster Amazon Aurora DB.

Aurora My SQL (keluarga aurora-mysql8.0):

aurora_enhanced_binlog=1
binlog_backup=0
binlog_format=ROW
binlog_replication_globaldb=0
binlog_row_image=full
binlog_row_metadata=full

Selain itu, pastikan bahwa parameter binlog_transaction_compression tidak ditetapkan ke ON, dan bahwa parameter binlog_row_value_options tidak diatur ke PARTIAL_JSON.

Untuk informasi lebih lanjut tentang Aurora Binlog saya yang SQL disempurnakan, lihat. Menyiapkan binlog yang disempurnakan untuk Aurora My SQL

Aurora Postgre SQL (keluarga aurora-postgresql15):

catatan

Untuk klaster Aurora Postgre SQL DB, Anda harus membuat grup parameter kustom dalam Lingkungan Pratinjau RDS Basis Data Amazon, di Timur AS (Ohio) (us-east-2) Wilayah AWS.

rds.logical_replication=1
aurora.enhanced_logical_replication=1
aurora.logical_replication_backup=0
aurora.logical_replication_globaldb=0

Mengaktifkan replikasi logis yang disempurnakan (aurora.enhanced_logical_replication) secara otomatis menyetel REPLICA IDENTITY parameter keFULL, yang berarti bahwa semua nilai kolom ditulis ke write ahead log ()WAL. Ini akan meningkatkan IOPS untuk cluster DB sumber Anda.

Langkah 2: Pilih atau buat cluster DB sumber

Setelah Anda membuat grup parameter cluster DB kustom, pilih atau buat atau Aurora SQL Postgre DB cluster. SQL Cluster ini akan menjadi sumber replikasi data ke Amazon Redshift. Untuk petunjuk membuat cluster , lihat.

Database harus menjalankan versi mesin DB yang didukung. Untuk daftar versi yang didukung, lihat Daerah yang Didukung dan engine Aurora DB untuk ETL integrasi nol dengan Amazon Redshift.

Untuk petunjuk membuat cluster , lihat.

catatan

Anda harus membuat cluster Aurora Postgre SQL DB dalam Lingkungan Pratinjau Basis Data RDS Amazon, di Timur AS (Ohio) (us-east-2) Wilayah AWS.

Saat Anda membuat database, di bawah Konfigurasi tambahan, ubah grup parameter cluster DB default ke grup parameter kustom yang Anda buat di langkah sebelumnya.

catatan

Untuk Aurora MySQL, jika Anda mengaitkan grup parameter dengan cluster DB setelah cluster sudah dibuat, Anda harus me-reboot instance DB utama di cluster untuk menerapkan perubahan sebelum Anda dapat membuat nol- ETL integrasi. Untuk petunjuk, lihat Mem-boot ulang klaster DB Amazon Aurora atau instans DB Amazon Aurora.

Selama rilis pratinjau integrasi SQL nol Aurora Postgre ETL dengan Amazon Redshift, Anda harus mengaitkan cluster dengan grup parameter cluster DB kustom saat membuat cluster. Anda tidak dapat melakukan tindakan ini setelah klaster DB sumber sudah dibuat. Jika tidak, Anda harus menghapus dan membuat ulang klaster.

Langkah 3: Buat gudang data Amazon Redshift

Setelah membuat cluster DB sumber, Anda harus membuat dan mengonfigurasi gudang data target di Amazon Redshift. Gudang data harus memenuhi persyaratan berikut:

Dibuat dalam pratinjau (hanya untuk sumber Aurora Postgre) SQL. Untuk SQL sumber Aurora My, Anda harus membuat cluster produksi dan kelompok kerja.
- Untuk membuat klaster terprovisi dalam pratinjau, pilih Buat klaster pratinjau dari banner di dasbor klaster terprovisi. Untuk informasi selengkapnya, lihat Membuat klaster pratinjau.
  
  Saat membuat klaster, tetapkan Jalur pratinjau ke preview_2023.
- Untuk membuat grup kerja Redshift Nirserver dalam pratinjau, pilih Buat grup kerja pratinjau dari banner di dasbor Nirserver. Untuk informasi selengkapnya, lihat Membuat grup kerja pratinjau.
Menggunakan tipe RA3 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.
Kelompok kerja tanpa server - Untuk mengaktifkan sensitivitas kasus pada grup kerja Redshift Tanpa Server, Anda harus menggunakan AWS CLI. Konsol Amazon Redshift saat ini tidak mendukung modifikasi nilai parameter Redshift Tanpa Server. 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 Aurora DB cluster sebagai sumber integrasi resmi. Untuk petunjuknya, lihat Mengonfigurasi otorisasi untuk gudang data Amazon Redshift Anda.

Siapkan integrasi menggunakan AWS SDKs(Aurora Satu-satukuSQL)

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 for Python (Boto3)untuk membuat cluster Aurora My SQL DB sumber dan menargetkan gudang data Amazon Redshift, masing-masing dengan nilai parameter yang diperlukan. Kemudian menunggu database tersedia sebelum membuat ETL integrasi nol 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_cluster_name = 'my-source-cluster' # A name for the source cluster
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_cluster(*args):
    """Creates a source Aurora MySQL DB cluster"""

    response = rds.create_db_cluster_parameter_group(
        DBClusterParameterGroupName=source_param_group_name,
        DBParameterGroupFamily='aurora-mysql8.0',
        Description='For Aurora MySQL zero-ETL integrations'
    )
    print('Created source parameter group: ' + response['DBClusterParameterGroup']['DBClusterParameterGroupName'])

    response = rds.modify_db_cluster_parameter_group(
        DBClusterParameterGroupName=source_param_group_name,
        Parameters=[
            {
                'ParameterName': 'aurora_enhanced_binlog',
                'ParameterValue': '1',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'binlog_backup',
                'ParameterValue': '0',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'binlog_format',
                'ParameterValue': 'ROW',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'binlog_replication_globaldb',
                'ParameterValue': '0',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'binlog_row_image',
                'ParameterValue': 'full',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'binlog_row_metadata',
                'ParameterValue': 'full',
                'ApplyMethod': 'pending-reboot'
            }
        ]
    )
    print('Modified source parameter group: ' + response['DBClusterParameterGroupName'])

    response = rds.create_db_cluster(
        DBClusterIdentifier=source_cluster_name,
        DBClusterParameterGroupName=source_param_group_name,
        Engine='aurora-mysql',
        EngineVersion='8.0.mysql_aurora.3.05.2',
        DatabaseName='myauroradb',
        MasterUsername='username',
        MasterUserPassword='Password01**'
    )
    print('Creating source cluster: ' + response['DBCluster']['DBClusterIdentifier'])
    source_arn = (response['DBCluster']['DBClusterArn'])
    create_target_cluster(target_cluster_name, source_arn, target_param_group_name)

    response = rds.create_db_instance(
        DBInstanceClass='db.r6g.2xlarge',
        DBClusterIdentifier=source_cluster_name,
        DBInstanceIdentifier=source_cluster_name + '-instance',
        Engine='aurora-mysql'
    )
    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='For Aurora 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 specifying cluster ARN 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_cluster_availability(*args):
    """Waits for both clusters to be available"""

    print('Waiting for clusters to be available...')

    response = rds.describe_db_clusters(
        DBClusterIdentifier=source_cluster_name
    )
    source_status = response['DBClusters'][0]['Status']
    source_arn = response['DBClusters'][0]['DBClusterArn']

    response = rds.describe_db_instances(
        DBInstanceIdentifier=source_cluster_name + '-instance'
    )
    source_instance_status = response['DBInstances'][0]['DBInstanceStatus']

    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 clusters are available.
    if source_status != 'available' or target_status != 'available' or  source_instance_status != 'available':
        time.sleep(60)
        response = wait_for_cluster_availability(
            source_cluster_name, target_cluster_name)
    else:
        print('Clusters 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 clusters"""

    response = rds.create_integration(
        SourceArn=source_arn,
        TargetArn=target_arn,
        IntegrationName='my-integration'
    )
    print('Creating integration: ' + response['IntegrationName'])
    
def main():
    """main function"""
    create_source_cluster(source_cluster_name, source_param_group_name)
    wait_for_cluster_availability(source_cluster_name, target_cluster_name)

if __name__ == "__main__":
    main()

Langkah selanjutnya

Dengan sumber cluster Aurora DB dan gudang data target Amazon Redshift, Anda sekarang dapat membuat integrasi nol dan mereplikasi ETL data. Untuk instruksi, lihat Membuat Aurora zero- ETL integrasi 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

Bekerja dengan nol- ETL integrasi

Membuat nol- ETL integrasi