# 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: 1. [Criar um grupo de parâmetros de de banco de dados personalizado](#zero-etl.parameters). 1. [Criar um banco de dados](#zero-etl.create-cluster) de origem. 1. [Criar um data warehouse de destino para o Amazon Redshift](#zero-etl-setting-up.data-warehouse) ou [Criar um lakehouse de destino do Amazon SageMaker](#zero-etl-setting-up.sagemaker). Depois de concluir essas tarefas, prossiga para [Criar integrações ETL zero do Amazon Aurora com o Amazon Redshift](zero-etl.creating.md) ou [Criar Integrações ETL zero entre o Amazon RDS e um lakehouse do Amazon SageMaker](zero-etl.creating-smlh.md). **dica** É possível fazer com que o RDS conclua essas etapas de configuração para você enquanto cria a integração, em vez de realizá-las manualmente. Para começar imediatamente a criar uma integração, consulte [Criar integrações ETL zero do Amazon Aurora com o Amazon Redshift](zero-etl.creating.md). 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: + Escolha um data warehouse se precisar de recursos tradicionais de armazenamento de dados com analytics baseada em SQL. + Escolha um lakehouse do Amazon SageMaker se precisar de recursos de machine learning e quiser usar os recursos do lakehouse para fluxos de trabalho de ciência de dados e ML. ## 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](USER_WorkingWithDBInstanceParamGroups.md). Recomendamos que você configure todos os valores dos parâmetros na mesma solicitação para evitar problemas de dependência. **RDS para MySQL**: + `binlog_format=ROW` + `binlog_row_image=full` 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](USER_PerfInsights.EnableMySQL.md). 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**: + `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` 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](https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-REPLICA-IDENTITY) 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. **Importante** Definir a identidade da réplica para registrar em log linhas completas [aumenta o volume do WAL](https://www.postgresql.org/docs/current/runtime-config-wal.html#GUC-WAL-LEVEL), o que pode aumentar a amplificação de gravação e o uso de E/S, especialmente para tabelas amplas ou atualizações frequentes. Para se preparar para esses impactos, planeje sua capacidade de armazenamento e requisitos de E/S, monitore o aumento do WAL e controle o atraso na replicação em workloads intensas em gravação. **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](USER_CreateDBInstance.md). 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](create-multi-az-db-cluster.md). 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](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md). 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. **nota** Se você associar o grupo de parâmetros ao banco de dados *depois* que o banco de dados for criado, deverá reinicializar o banco de dados para aplicar as alterações antes de criar uma Integração ETL zero. Para receber instruções, consulte [Reinicializar uma instância de banco de dados](USER_RebootInstance.md) ou [Reinicializar um cluster de banco de dados multi-AZ e instâncias de banco de dados de leitor do Amazon RDS](multi-az-db-clusters-concepts-rebooting.md). 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](USER_WorkingWithAutomatedBackups.Enabling.md). ## 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: + Usar um tipo de nó RA3 com pelo menos dois nós ou o Redshift sem servidor. + Ser criptografado (se estiver usando um cluster provisionado). Para obter mais informações, consulte [Criptografia de bancos de dados no Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html). Para obter instruções sobre como criar um data warehouse, consulte [Criar um cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/create-cluster) para clusters provisionados ou [Criar um grupo de trabalho com um namespace](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-console-workgroups-create-workgroup-wizard.html) 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 ([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)) 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: + **Cluster provisionado**: para ativar a distinção entre maiúsculas e minúsculas em um cluster provisionado, crie um grupo de parâmetros personalizado com o parâmetro `enable_case_sensitive_identifier` ativado. Em seguida, associe o grupo de parâmetros ao cluster. Para obter instruções, consulte [Gerenciar grupos de parâmetros usando o console](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-parameter-groups-console.html) ou [Configurar valores de parâmetros usando a AWS CLI](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html#configure-parameters-using-the-clil). **nota** Lembre-se de reinicializar o cluster depois de associar o grupo de parâmetros personalizado a ele. + **Grupo de trabalho de tecnologia sem servidor**: para ativar a distinção entre maiúsculas e minúsculas em um grupo de trabalho do Redshift Serverless, você deve usar a AWS CLI. Atualmente, o console do Amazon Redshift não é compatível com a modificação dos valores dos parâmetros do Redshift Serverless. Envie a seguinte solicitação de [atualização do grupo de trabalho](https://docs.aws.amazon.com/cli/latest/reference/redshift-serverless/update-workgroup.html): ``` aws redshift-serverless update-workgroup \ --workgroup-name target-workgroup \ --config-parameters parameterKey=enable_case_sensitive_identifier,parameterValue=true ``` Não é necessário reinicializar um grupo de trabalho após modificar seus valores de parâmetros. ### 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](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam). ## 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)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) 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. ### Código de exemplo em 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() ``` ## Etapa 3b: criar um catálogo do AWS Glue para uma Integração ETL zero do Amazon SageMaker Lakehouse Ao criar uma Integração ETL zero com um lakehouse do Amazon SageMaker, 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. + Para ter informações sobre como criar um catálogo gerenciado pelo Amazon Redshift, consulte [Creating an Amazon Redshift managed catalog in the AWS Glue Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/create-rms-catalog.html) no *Guia do desenvolvedor do AWS Lake Formation*. + Para ter informações sobre perfis vinculados ao serviço, consulte [Uso de funções vinculadas ao serviço para o Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/using-service-linked-roles.html) no *Guia de gerenciamento do Amazon Redshift*. + Para ter informações sobre as permissões de administrador somente para leitura do Lake Formation, consulte [Lake Formation personas and IAM permissions reference](https://docs.aws.amazon.com/lake-formation/latest/dg/permissions-reference.html) no *Guia do desenvolvedor do AWS Lake Formation*. ### 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**. #### Perfil de criação de destino do Lake Formation O perfil de criação de destino deve ser administrador do Lake Formation e requer as permissões a seguir. ------ #### [ 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" ] } ] } ``` ------ O perfil de criação de destino deve ter a relação de confiança a seguir. ------ #### [ 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" } ] } ``` ------ #### Perfil de transferência de dados do Glue O perfil de transferência de dados do Glue é necessário para operações de catálogo do MySQL e deve ter as permissões a seguir. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "DataTransferRolePolicy", "Effect": "Allow", "Action": [ "kms:GenerateDataKey", "kms:Decrypt", "glue:GetCatalog", "glue:GetDatabase" ], "Resource": [ "*" ] } ] } ``` ------ O perfil de transferência de dados do Glue deve ter a relação de confiança a seguir. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "glue.amazonaws.com", "redshift.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] } ``` ------ ## 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, é possível 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](zero-etl.creating.md).