Conceitos básicos sobre Integrações ETL zero do Amazon RDS

Antes de criar uma Integração ETL zero, configure o banco de dados do RDS e o data warehouse com as permissões e os parâmetros necessários. Durante a configuração, você realizará as seguintes etapas:

Depois de concluir essas tarefas, prossiga para Criar integrações ETL zero do Amazon Aurora com o Amazon Redshift ou Criar Integrações ETL zero entre o Amazon RDS e um lakehouse do Amazon SageMaker.

Para a Etapa 3, você pode optar por criar um data warehouse de destino (Etapa 3a) ou um lakehouse de destino (Etapa 3b), dependendo de suas necessidades:

Etapa 1: criar um grupo de parâmetros de de banco de dados personalizado

As Integrações ETL zero do Amazon RDS exigem valores específicos para os parâmetros de banco de dados que controlam a replicação de dados. Os parâmetros específicos dependem do mecanismo do banco de dados de origem. Para configurar esses parâmetros, primeiro é necessário criar um grupo de parâmetros de banco de dados personalizado e, depois, associá-lo ao banco de dados de origem. Configure os valores de parâmetros a seguir, de acordo com o mecanismo de banco de dados de origem. Para obter instruções de como criar um grupo de parâmetros, consulte Grupos de parâmetros de banco de dados para instâncias de banco de dados do Amazon RDS. Recomendamos que você configure todos os valores dos parâmetros na mesma solicitação para evitar problemas de dependência.

RDS para MySQL:

Além disso, verifique se o parâmetro binlog_row_value_options não está definido como PARTIAL_JSON. Se o banco de dados de origem for um cluster de banco de dados multi-AZ, o parâmetro binlog_transaction_compression não deve estar definido como ON.

Alguns desses parâmetros (como binlog_format) são dinâmicos, o que significa que você pode aplicar alterações no parâmetro sem acionar uma reinicialização. Isso significa que algumas sessões existentes podem continuar usando o valor antigo do parâmetro. Para evitar que isso cause problemas ao criar uma Integração ETL zero, habilite o Performance Schema. O Performance Schema garante que as pré-verificações de ETL zero sejam executadas, o que ajuda a detectar parâmetros ausentes no início do processo.

RDS para PostgreSQL:

Para várias integrações do PostgreSQL, será usado um slot de replicação lógica por integração. Analise os parâmetros max_replication_slots e max_wal_senders com base no seu uso.

Para que a sincronização de dados em Integrações ETL zero seja eficiente, defina rds.replica_identity_full na sua instância de banco de dados de origem. Isso instrui o banco de dados a registrar em log dados de linha completos no log de gravação antecipada (WAL) durante as operações UPDATE e DELETE, em vez de apenas informações de chave primária. A ETL zero exige dados de linha completa, mesmo quando todas as tabelas replicadas precisam ter chaves primárias. Para determinar quais dados são visíveis durante as consultas, o Amazon Redshift usa uma estratégia antijunção especializada para comparar seus dados com uma tabela interna de monitoramento de exclusões. O registro em log de imagens de linha completa ajuda o Amazon Redshift a realizar essas antijunções de forma eficiente. Sem dados de linha completa, o Amazon Redshift precisaria realizar pesquisas adicionais, o que poderia diminuir o desempenho durante operações de alto throughput no mecanismo colunar usado pelo Amazon Redshift.

RDS para Oracle:

Nenhuma alteração de parâmetro é necessária para o RDS para Oracle.

Etapa 2: Selecionar ou criar um banco de dados de origem

Depois de criar um grupo de parâmetros de de banco de dados personalizado, escolha ou crie uma instância de banco de dados do RDS. Esse banco de dados será a origem da replicação de dados para o data warehouse de destino. Consulte instruções para criar uma instância de banco de dados de uma única zona de disponibilidade ou multi-AZ, consulte Criar uma instância de banco de dados do Amazon RDS. Para receber instruções sobre a criação de um cluster de banco de dados multi-AZ (somente para RDS para MySQL), consulte Criar um cluster de banco de dados multi-AZ para o Amazon RDS.

O banco de dados deve estar executando uma versão de mecanismo de banco de dados compatível. Para conferir uma lista de versões compatíveis, consulte Regiões e mecanismos de banco de dados que permitem Integrações ETL zero com o Amazon RDS.

Ao criar o banco de dados, em Configuração adicional, altere o grupo de parâmetros de de banco de dados padrão para o grupo de parâmetros personalizado que você criou na etapa anterior.

Além disso, certifique-se de que os backups automatizados estejam habilitados no banco de dados. Para obter mais informações, consulte Ativar backups automáticos.

Etapa 3a: criar um data warehouse de destino

Depois de criar o banco de dados, será necessário criar e configurar um data warehouse de destino. O data warehouse deve cumprir os seguintes requisitos:

Para obter instruções sobre como criar um data warehouse, consulte Criar um cluster para clusters provisionados ou Criar um grupo de trabalho com um namespace para o Redshift Serverless.

Ative a distinção entre maiúsculas e minúsculas no data warehouse

Para que a integração seja bem-sucedida, o parâmetro de diferenciação de maiúsculas e minúsculas (enable_case_sensitive_identifier) deve estar ativado para o data warehouse. Por padrão, a distinção entre maiúsculas e minúsculas é desativada em todos os clusters provisionados e grupos de trabalho do Redshift Serverless.

Para ativar a distinção entre maiúsculas e minúsculas, execute as seguintes etapas, dependendo do tipo de data warehouse:

Configurar a autorização para o data warehouse

Depois de criar um data warehouse, você deve configurar o banco de dados do RDS de origem como uma origem de integração autorizada. Para obter instruções, consulte Configurar a autorização para o data warehouse do Amazon Redshift.

Configurar uma integração usando SDKs da AWS

Em vez de configurar cada recurso manualmente, é possível executar o script Python a seguir para configurar automaticamente os recursos necessários. O exemplo de código usa o AWS SDK para Python (Boto3) para criar uma instância de banco de dados do RDS para MySQL de origem e um data warehouse de destino, cada um com os valores de parâmetro necessários. Depois, ele espera que os bancos de dados estejam disponíveis antes de criar uma integração ETL zero entre eles. É possível comentar diferentes funções, dependendo dos recursos que você precisa configurar.

Execute os comandos a seguir para instalar as dependências necessárias:

pip install boto3
pip install time

No script, modifique opcionalmente os nomes dos grupos de parâmetros, a origem e o destino. A função final cria uma integração denominada my-integration após a configuração dos recursos.

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

Etapa 3b: criar um catálogo do AWS Glue para uma Integração ETL zero do Amazon SageMaker AI

Ao criar uma Integração ETL zero com um lakehouse do Amazon SageMaker AI, você deve criar um catálogo gerenciado pelo AWS Glue no AWS Lake Formation. O catálogo de destino deve ser um catálogo gerenciado pelo Amazon Redshift. Para criar um catálogo gerenciado pelo Amazon Redshift, primeiro crie um perfil vinculado ao serviço AWSServiceRoleForRedshift. No console do Lake Formation, adicione o AWSServiceRoleForRedshift como administrador somente para leitura.

Para ter mais informações sobre as tarefas anteriores, consulte os tópicos a seguir.

Configurar permissões para o catálogo do AWS Glue

Antes de criar um catálogo de destino para uma Integração ETL zero, você deve criar o perfil de criação de destino do Lake Formation e o perfil de transferência de dados do AWS Glue. Use o perfil de criação de destino do Lake Formation para criar o catálogo de destino. Ao criar o catálogo de destino, insira um perfil de transferência de dados do Glue no campo Perfil do IAM na seção Acesso por meio de mecanismos.

Próximas etapas

Com um banco de dados do RDS de origem e um data warehouse de destino do Amazon Redshift ou um lakehouse do Amazon SageMaker AI, você pode criar uma Integração ETL zero e começar a replicar dados. Para instruções, consulte Criar integrações ETL zero do Amazon Aurora com o Amazon Redshift.