# Integrações ETL zero do Amazon RDS
Uma Integração ETL zero do Amazon RDS com o Amazon Redshift e o Amazon SageMaker AI permite analytics e machine learning (ML) quase em tempo real usando dados do RDS. Essa é uma solução totalmente gerenciada para disponibilizar dados transacionais no destino de analytics depois que eles são gravados em um banco dados do RDS. *Extração, transformação* e *carregamento* (ETL) é o processo de combinar dados de várias fontes em um grande data warehouse central.
Uma Integração ETL zero torna os dados no banco de dados do RDS disponíveis no Amazon Redshift ou em um lakehouse do Amazon SageMaker AI quase em tempo real. Quando esses dados estiverem no data warehouse ou data lake de destino, você poderá potencializar suas workloads de analytics, ML e IA usando os recursos integrados, como machine learning, visões materializadas, compartilhamento de dados, acesso federado a vários datastores e data lakes e integrações ao Amazon SageMaker AI, ao Quick e a outros Serviços da AWS.
Para criar uma Integração ETL zero, especifique um banco de dados do Aurora RDS como a *origem* e um data warehouse ou lakehouse compatível como o *destino*. A integração replica os dados do banco de dados de origem no data warehouse ou lakehouse de destino.
O seguinte diagrama mostra essa funcionalidade de Integração ETL zero com o Amazon Redshift:
![\[Uma integração ETL zero\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/zero-etl-integrations.png)
O seguinte diagrama mostra essa funcionalidade para uma Integração ETL zero com um lakehouse do Amazon SageMaker AI:
![\[Uma Integração ETL zero com um lakehouse do Amazon SageMaker AI\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/zero-etl-rds-lakehouse.png)
A integração monitora a integridade do pipeline de dados e se recupera de problemas quando possível. É possível criar integrações de vários bancos de dados do RDS em um único data warehouse ou lakehouse de destino, o que permite que você obtenha insights em várias aplicações.
**Topics**
+ [Benefícios](#zero-etl.benefits)
+ [Principais conceitos](#zero-etl.concepts)
+ [Limitações](#zero-etl.reqs-lims)
+ [Cotas](#zero-etl.quotas)
+ [Regiões com suporte](#zero-etl.regions)
+ [Conceitos básicos sobre Integrações ETL zero do Amazon RDS](zero-etl.setting-up.md)
+ [Criar integrações ETL zero do Amazon Aurora com o Amazon Redshift](zero-etl.creating.md)
+ [Criar Integrações ETL zero entre o Amazon RDS e um lakehouse do Amazon SageMaker](zero-etl.creating-smlh.md)
+ [Filtragem de dados para Integrações ETL zero do Amazon RDS](zero-etl.filtering.md)
+ [Adicionar dados a um banco de dados do RDS de origem e consultá-los](zero-etl.querying.md)
+ [Visualizar e monitorar Integrações ETL zero do Amazon RDS](zero-etl.describingmonitoring.md)
+ [Modificar Integrações ETL zero do Amazon RDS](zero-etl.modifying.md)
+ [Excluir Integrações ETL zero do Amazon RDS](zero-etl.deleting.md)
+ [Solução de problemas em Integrações ETL zero do Amazon RDS](zero-etl.troubleshooting.md)
## Benefícios
As Integrações ETL zero do RDS oferecem os seguintes benefícios:
+ Ajudam você a obter insights holísticos de várias fontes de dados.
+ Eliminam a necessidade de criar e manter canais de dados complexos que executam operações de extração, transformação e carregamento (ETL). As integrações ETL zero eliminam os desafios que surgem com a criação e o gerenciamento de pipelines, provisionando-os e gerenciando-os para você.
+ Reduzem a carga e os custos operacionais para que você possa se concentrar em melhorar as aplicações.
+ Permitem que você aproveite os recursos de analytics e ML do destino pretendido para obter insights de dados transacionais e outros dados e responder de forma eficaz a eventos críticos e urgentes.
## Principais conceitos
Ao começar a usar integrações ETL zero, considere os seguintes conceitos:
**Integração**
Um pipeline de dados totalmente gerenciado que replica automaticamente dados e esquemas transacionais de um banco de dados do RDS em um data warehouse ou catálogo.
**Banco de dados de origem**
O banco de dados do RDS do qual os dados são replicados. É possível especificar uma instância de banco de dados Single-AZ ou multi-AZ ou um cluster de banco de dados multi-AZ. (somente para RDS para MySQL).
**Target**
O data warehouse ou lakehouse para o qual os dados são replicados. Há dois tipos de data warehouse: um data warehouse de [cluster provisionado](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html) e um data warehouse [sem servidor](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-workgroup-namespace.html). Um data warehouse de cluster provisionado é um conjunto de recursos computacionais chamados nós, que são organizados em um grupo chamado *cluster*. Um data warehouse sem servidor é composto por um grupo de trabalho que armazena recursos computacionais e um namespace que abriga os objetos e usuários do banco de dados. Ambos os data warehouses executam um mecanismo de analytics e contêm um ou mais bancos de dados.
Um lakehouse de destino consiste em catálogos, bancos de dados, tabelas e visualizações. Para ter mais informações sobre arquitetura de lakehouse, consulte [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) no *Guia do usuário do Amazon SageMaker AI Unified Studio*.
Vários bancos de dados de origem podem gravar no mesmo destino.
Para obter mais informações, consulte [Arquitetura do sistema de data warehouse](https://docs.aws.amazon.com/redshift/latest/dg/c_high_level_system_architecture.html) no *Guia do desenvolvedor do Amazon Redshift*.
## Limitações
As limitações a seguir se aplicam às Integrações ETL zero do RDS.
**Topics**
+ [Limitações gerais](#zero-etl.reqs-lims-general)
+ [Limitações do RDS para MySQL](#zero-etl.reqs-lims-mysql)
+ [Limitações do RDS para PostgreSQL](#zero-etl.reqs-lims-rds-postgres)
+ [Limitações do RDS para Oracle](#zero-etl.reqs-lims-oracle)
+ [Limitações do Amazon Redshift](#zero-etl.reqs-lims-redshift)
+ [Amazon SageMaker AILimitações referentes a lakehouses do](#zero-etl.reqs-lims-sagemaker-)
### Limitações gerais
+ O banco de dados de origem deve estar na mesma região que o destino.
+ Não será possível renomear um banco de dados se o cluster tiver integrações existentes.
+ Não é possível criar várias integrações entre os mesmos bancos de dados de origem e destino.
+ Você não pode excluir um banco de dados que tenha integrações existentes. É necessário excluir todas as integrações correspondentes primeiro.
+ Se você interromper o banco de dados de origem, as últimas transações provavelmente não serão replicadas no destino enquanto você não retomar o banco de dados.
+ Você não poderá excluir uma integração se o banco de dados de origem for interrompido.
+ Se o banco de dados for a origem de uma implantação azul/verde, os ambientes azul e verde não poderão ter integrações ETL zero existentes durante a transição. Você deve excluir a integração primeiro, alternar e, depois, recriá-la.
+ Não é possível criar uma integração para um banco de dados de origem que tenha outra integração sendo criada ativamente.
+ Quando você cria inicialmente uma integração ou quando uma tabela está sendo ressincronizada, a propagação de dados da origem para o destino pode levar de 20 a 25 minutos ou mais, dependendo do tamanho do banco de dados de origem. Esse atraso pode levar a um maior atraso na réplica.
+ Alguns tipos de dados não são compatíveis. Para obter mais informações, consulte [Diferenças de tipos de dados entre os bancos de dados RDS e Amazon Redshift](zero-etl.querying.md#zero-etl.data-type-mapping).
+ As tabelas do sistema, tabelas temporárias e visualizações não são replicadas nos warehouses de destino.
+ A execução de comandos de DDL (por exemplo, `ALTER TABLE`) em uma tabela de origem pode acionar uma ressincronização da tabela, tornando a tabela indisponível para consulta durante a ressincronização. Para obter mais informações, consulte [Uma ou mais das minhas tabelas do Amazon Redshift exigem ressincronização.](zero-etl.troubleshooting.md#zero-etl.troubleshooting.resync).
### Limitações do RDS para MySQL
+ O banco de dados de origem deve executar uma versão compatível do RDS para MySQL. 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).
+ Não é possível usar Integrações ETL zero na instância primária e em uma instância de réplica de leitura na mesma região da AWS.
+ As integrações ETL zero dependem do registro em log binário (binlog) do MySQL para capturar alterações contínuas de dados. Não use a filtragem de dados baseada em log binário, pois isso pode causar inconsistências de dados entre os bancos de dados de origem e de destino.
+ As integrações ETL zero são compatíveis apenas com bancos de dados configurados para usar o mecanismo de armazenamento InnoDB.
+ Referências de chave externa com atualizações de tabelas predefinidas não são compatíveis. Especificamente, as regras `ON DELETE` e `ON UPDATE` não são compatíveis com as ações `CASCADE`, `SET NULL` e `SET DEFAULT`. A tentativa de criar ou atualizar uma tabela com essas referências a outra tabela colocará a tabela em um estado de falha.
+ Não é possível criar uma integração para um banco de dados de origem que use armazenamento magnético.
### Limitações do RDS para PostgreSQL
+ O banco de dados de origem deve ser uma instância do RDS para PostgreSQL executando as versões 15.7\$1, 16.3\$1 ou 17.1\$1. Versões anteriores não são compatíveis.
+ As integrações ETL zero do RDS para PostgreSQL não comportam clusters de banco de dados multi-AZ como bancos de dados de origem.
+ Não é possível criar uma Integração ETL zero com base em uma instância de réplica de leitura do RDS para PostgreSQL.
+ As visões materializadas e tabelas do PostgreSQL não registradas em log não são replicadas para o Amazon Redshift.
+ Não é possível replicar determinados tipos de dados do PostgreSQL, [como tipos de dados de geometria](https://www.postgresql.org/docs/current/datatype-geometric.html) e dados acima de 64 KB, devido às limitações do Amazon Redshift. Para ter mais informações sobre as diferenças entre os tipos de dados do RDS para PostgreSQL e do Amazon Redshift, consulte [RDS para PostgreSQL](zero-etl.querying.md#zero-etl.data-type-mapping-postgres) na seção **Diferenças entre tipos de dados**.
+ Não é possível realizar uma [atualização de versão principal](USER_UpgradeDBInstance.PostgreSQL.md) na instância de origem do RDS para PostgreSQL enquanto ela tiver uma integração ETL zero ativa. Para atualizar a instância de origem, você deve primeiro excluir todas as Integrações ETL zero existentes. Após a conclusão da atualização da versão principal, você pode recriar as Integrações ETL zero.
+ Se você realizar transações de [particionamento declarativo](https://www.postgresql.org/docs/current/ddl-partitioning.html#DDL-PARTITIONING-DECLARATIVE) na instância de banco de dados de origem, todas as tabelas afetadas entrarão em um estado de falha e não estarão mais acessíveis.
### Limitações do RDS para Oracle
+ O banco de dados de origem deve ser uma instância do RDS para Oracle executando a versão 19c Enterprise Edition ou Standard Edition 2, com atualização de versão de julho de 2019 ou posterior. Versões anteriores não são compatíveis.
+ Não é possível criar uma Integração ETL zero com base em uma instância de réplica de leitura do RDS para Oracle.
+ Também não é possível renomear um [banco de dados de locatários](Oracle.Concepts.CDBs.md) quando há uma Integração ETL zero nesse banco de dados de locatário.
+ Um banco de dados de locatários pode ter apenas uma Integração ETL zero.
+ Há alguns diferenças entre os tipos de dados do RDS para Oracle e do Amazon Redshift. Para ter mais informações, consulte [RDS para Oracle](zero-etl.querying.md#zero-etl.data-type-mapping-oracle) na seção **Diferenças entre tipos de dados**.
### Limitações do Amazon Redshift
Para conferir uma lista das limitações do Amazon Redshift relacionadas às integrações ETL zero, consulte [Considerações ao usar integrações ETL zero com o Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl.reqs-lims.html) no *Guia de gerenciamento do Amazon Redshift*.
### Amazon SageMaker AILimitações referentes a lakehouses do
A seguir é apresentada uma limitação para Integrações ETL zero com lakehouses do Amazon SageMaker AI.
+ Os nomes de catálogo podem ter no máximo 19 caracteres de comprimento.
## Cotas
Sua conta tem as cotas a seguir relacionadas a Integrações ETL zero do RDS. Salvo indicação em contrário, cada cota aplica-se por região.
| Nome | Padrão | Descrição |
| --- | --- | --- |
| Integrações | 100 | O número total de integrações em uma Conta da AWS. |
| Integrações por destino | 50 | O número de integrações que enviam dados a um único data warehouse ou lakehouse de destino. |
| de origem | 5 | O número de integrações que enviam dados de uma única instância de banco de dados de origem. |
Além disso, o warehouse de destino impõe certos limites ao número de tabelas permitidas em cada instância de banco de dados ou nó de cluster. Para ter mais informações sobre cotas e limites do Amazon Redshift, consulte [Cotas e limites no Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) no *Guida de gerenciamento do Amazon Redshift*.
## Regiões com suporte
As Integrações ETL zero do RDS estão disponíveis em um subconjunto de Regiões da AWS. Para obter uma lista de regiõ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).
# 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).
# Criar integrações ETL zero do Amazon Aurora com o Amazon Redshift
Ao criar uma integração ETL zero do Amazon RDS, especifique o banco de dados RDS de origem e o data warehouse de destino do Amazon Redshift. Você também pode personalizar as configurações de criptografia e adicionar etiquetas. O Amazon RDS cria uma integração entre o banco de dados de origem e o destino. Quando a integração está ativa, todos os dados inseridos no banco de dados de origem serão replicados no destino configurado do Amazon Redshift.
## Pré-requisitos
Antes de criar uma integração ETL zero, é necessário criar um banco de dados de origem e um data warehouse de destino do Amazon Redshift. Também é necessário permitir a replicação no data warehouse adicionando o banco de dados como uma origem de integração autorizada.
Para obter instruções sobre como concluir cada uma dessas etapas, consulte [Conceitos básicos sobre Integrações ETL zero do Amazon RDS](zero-etl.setting-up.md).
## Permissões obrigatórias
Algumas permissões do IAM são necessárias para criar uma integração ETL zero. No mínimo, são necessárias permissões para executar as seguintes ações:
+ Crie integrações ETL zero para o banco de dados do RDS de origem.
+ Visualizar e excluir todas as integrações ETL zero.
+ Criar integrações de entrada no data warehouse de destino.
As políticas de exemplo a seguir demonstram as [permissões de privilégio mínimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) necessárias para criar e gerenciar integrações. Talvez você não precise dessas permissões exatas se o usuário ou o perfil tiver permissões mais amplas, como uma política gerenciada `AdministratorAccess`.
**nota**
Os ARNs do Amazon Redshift têm o formato a seguir. Observe o uso de uma barra (`(/`) em vez de dois pontos (`:`) antes do UUID do namespace sem servidor.
Cluster provisionado: `arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid`
Sem servidor: `arn:aws:redshift-serverless:{region}:{account-id}:namespace/namespace-uuid`
### Exemplo de política para o destino do 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"
]
}
]
}
```
------
### Escolher um data warehouse de destino em uma conta diferente
Se você planeja especificar um data warehouse de destino do Amazon Redshift que esteja em outraConta da AWS, deverá criar um perfil que permita que os usuários da conta atual acessem os recursos na conta de destino. Para obter mais informações, consulte [Fornecer acesso a um usuário do IAM em outra Conta da AWS de sua propriedade](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html).
O perfil deve ter as permissões a seguir, que possibilitam ao usuário visualizar os clusters provisionados do Amazon Redshift e os namespaces do Redshift sem servidor disponíveis na conta de destino.
#### Permissões necessárias e política de confiança
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"redshift:DescribeClusters",
"redshift-serverless:ListNamespaces"
],
"Resource":[
"*"
]
}
]
}
```
------
O perfil deve ter a seguinte política de confiança, que especifica o ID da conta de destino.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Para obter instruções sobre como criar o perfil, consulte [Criar um perfil usando políticas de confiança personalizadas](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html).
## Criar integrações ETL zero
É possível criar uma integração ETL zero usando o Console de gerenciamento da AWS, a AWS CLI ou a API do RDS.
**Importante**
As Integrações ETL zero não permitem operações de atualização ou ressincronização. Se você encontrar problemas com uma integração após a criação, deverá excluir a integração e criar outra.
Por padrão, o RDS para MySQL limpa imediatamente os arquivos de log binários. Como as integrações ETL zero dependem de logs binários para replicar dados da origem para o destino, o período de retenção do banco de dados de origem deve ser de pelo menos uma hora. Assim que você cria uma integração, o Amazon RDS verifica o período de retenção do arquivo de log binário para o banco de dados de origem selecionado. Se o valor atual for 0 hora, o Amazon RDS o alterará automaticamente para 1 hora. Caso contrário, o valor permanecerá o mesmo.
### Console do RDS
**Como criar uma integração ETL zero**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No painel de navegação à esquerda, escolha **Integrações ETL zero**.
1. Escolha **Criar integração ETL zero**.
1. Em **Nome da integração**, insira um nome para a integração. O nome pode ter até 60 caracteres alfanuméricos e pode incluir hifens.
**Importante**
Os nomes de catálogo podem ter no máximo 19 caracteres de comprimento. O identificador da integração deve atender a esse requisito se for usado como nome de catálogo.
1. Escolha **Próximo**.
1. Em **Origem**, selecione o banco de dados do RDS de onde os dados serão originados.
**nota**
O RDS notifica você se os parâmetros do de banco de dados não estiverem configurados corretamente. Se você receber essa mensagem, poderá escolher **Corrigir para mim** ou configurá-las manualmente. Para obter instruções sobre como corrigi-los manualmente, consulte[Etapa 1: criar um grupo de parâmetros de de banco de dados personalizado](zero-etl.setting-up.md#zero-etl.parameters).
A modificação dos parâmetros de banco de dados requer uma reinicialização. Antes de criar a integração, a reinicialização deve ser concluída e os valores do novo parâmetro deve ser aplicado com êxito ao banco de dados.
1. Depois que o banco de dados de origem for configurado com êxito, selecione **Próximo**.
1. Em **Destino 1**, faça o seguinte:
1. (Opcional) Para usar uma Conta da AWS diferente para o destino do Amazon Redshift, escolha **Especificar uma conta diferente**. Depois, insira o ID da e o nome de um perfil do IAM com permissões para exibir seus data warehouses. Para obter instruções sobre como criar um perfil do IAM, consulte [Escolher um data warehouse de destino em uma conta diferente](#zero-etl.create-permissions-cross-account).
1. Em **Data warehouse do Amazon Redshift**, selecione o destino para os dados replicados do banco de dados de origem. Você pode escolher um *cluster* provisionado do Amazon Redshift ou um *namespace* do Redshift sem servidor como destino.
**nota**
O RDS notifica você se a política de recursos ou as configurações de diferenciação de maiúsculas e minúsculas do data warehouse especificado não estiverem configuradas corretamente. Se você receber essa mensagem, poderá escolher **Corrigir para mim** ou configurá-las manualmente. Para obter instruções [sobre como corrigi-los manualmente, consulte Ativar a diferenciação de maiúsculas e minúsculas para seu armazém de dados](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-setting-up.case-sensitivity) e [Configurar a autorização para seu armazém de dados](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam) no *Guia de gerenciamento do Amazon Redshift*.
A modificação da distinção entre maiúsculas e minúsculas de um *cluster provisionado* do Redshift requer uma reinicialização. Antes de criar a integração, a reinicialização deve ser concluída e o novo valor do parâmetro deve ser aplicado com êxito ao cluster.
Se a origem e o destino selecionados estiverem em valores diferentesContas da AWS, o Amazon RDS não poderá corrigir essas configurações para você. Você deve navegar até a outra conta e corrigi-la manualmente no Amazon Redshift.
1. Depois que seu data warehouse de destino estiver configurado corretamente, escolha **Avançar**.
1. (Opcional) Em **Etiquetas**, adicione uma ou mais etiquetas à integração. Para obter mais informações, consulte [Marcar recursos do do Amazon RDS](USER_Tagging.md).
1. Em **Criptografia**, especifique como você deseja que sua integração seja criptografada. Por padrão, o RDS criptografa todas as integrações com uma Chave pertencente à AWS. Para escolher uma chave gerenciada pelo cliente em vez disso, habilite a opção **Personalizar configurações de criptografia** e escolha uma chave do KMS para criptografia. Para obter mais informações, consulte [Criptografar recursos do Amazon RDS](Overview.Encryption.md).
Como opção, adicione um contexto de criptografia. Para obter mais informações, consulte [Contexto de criptografia](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) no *Guia do desenvolvedor AWS Key Management Service*.
**nota**
O Amazon RDS adiciona os seguintes pares de contexto de criptografia, além dos adicionados por você:
`aws:redshift:integration:arn` - `IntegrationArn`
`aws:servicename:id` - `Redshift`
Isso reduz o número geral de pares que você pode adicionar de oito para seis e contribui com o limite geral de caracteres da restrição de concessão. Para ter mais informações, consulte [Using grant constraints](https://docs.aws.amazon.com/kms/latest/developerguide/create-grant-overview.html#grant-constraints) no *Guia do desenvolvedor do AWS Key Management Service*.
1. Escolha **Próximo**.
1. Revise suas configurações de integração e escolha **Criar integração sem ETL**.
Se a criação falhar, consulte [Não consigo criar uma integração ETL zero.](zero-etl.troubleshooting.md#zero-etl.troubleshooting.creation) para conferir etapas de solução de problemas.
A integração tem um status de `Creating` enquanto está sendo criada, e o data warehouse de destino do Amazon Redshift tem um status de `Modifying`. Durante esse período, você não pode consultar o data warehouse nem alterar sua configuração.
Quando a integração tiver sido criada com sucesso, o status da integração e do data warehouse de destino do Amazon Redshift vão mudar para `Active`.
### AWS CLI
Para criar uma integração sem ETL usando oAWS CLI, use o comando [create-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) com as seguintes opções:
**nota**
Lembre-se de que os nomes de catálogo podem ter no máximo 19 caracteres. Escolha o nome da integração adequadamente se você pretende usá-lo como nome de catálogo.
+ `--integration-name`— Especifique um nome para a integração.
+ `--source-arn`: especifique o ARN do banco de dados do RDS que será a origem da integração.
+ `--target-arn`: especifique o ARN do data warehouse do Amazon Redshift que será o destino da integração.
**Example**
Para Linux, macOS ou 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
```
Para 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 do RDS
Para criar uma implantação azul/verde usando a API do Amazon RDS, use a operação [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html) com os seguintes parâmetros:
**nota**
Os nomes de catálogo podem ter no máximo 19 caracteres. O parâmetro IntegrationName deve atender a esse requisito se for usado como nome de catálogo.
+ `IntegrationName`— Especifique um nome para a integração.
+ `SourceArn`: especifique o ARN do banco de dados do RDS que será a origem da integração.
+ `TargetArn`: especifique o ARN do data warehouse do Amazon Redshift que será o destino da integração.
## Criptografar integrações com uma chave gerenciada pelo cliente
Se você especificar uma chave do KMS personalizada em vez de uma Chave pertencente à AWS ao criar uma integração, a política de chaves deverá fornecer ao serviço Amazon Redshift um acesso de entidade principal à ação `CreateGrant`. Além disso, ela deve permitir que o usuário atual execute as ações `DescribeKey` e `CreateGrant`.
O exemplo de política a seguir demonstra como conceder as permissões necessárias na política de chave. Ele inclui chaves de contexto para reduzir ainda mais o escopo das permissões.
### Exemplo de política de chave
------
#### [ 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": "*"
}
]
}
```
------
Para obter mais informações, consulte [Criar uma política de chave](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) no *Guia do desenvolvedor do AWS Key Management Service*.
## Próximas etapas
Depois de criar com sucesso uma integração ETL zero, você deve criar um banco de dados de destino em seu cluster ou grupo de trabalho de destino do Amazon Redshift. Depois, você poderá começar a adicionar dados ao banco de dados do RDS e consultá-los no Amazon Redshift. Para obter instruções, consulte [Criar bancos de dados de destino no Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html).
# Criar Integrações ETL zero entre o Amazon RDS e um lakehouse do Amazon SageMaker
Ao criar uma Integração ETL zero entre o Amazon RDS e um lakehouse do Amazon SageMaker, você deve especificar o banco de dados do RDS de origem e o catálogo de destino gerenciado pelo AWS Glue. Você também pode personalizar as configurações de criptografia e adicionar etiquetas. O Amazon RDS cria uma integração entre o banco de dados de origem e o destino. Quando a integração estiver ativa, todos os dados inseridos no banco de dados de origem serão replicados no destino configurado.
## Pré-requisitos
Antes de criar uma Integração ETL zero com um lakehouse do Amazon SageMaker, você deve criar um banco de dados de origem e um catálogo de destino gerenciado pelo AWS Glue. Também é necessário permitir a replicação no catálogo adicionando o banco de dados como uma origem de integração autorizada.
Para obter instruções sobre como concluir cada uma dessas etapas, consulte [Conceitos básicos sobre Integrações ETL zero do Amazon RDS](zero-etl.setting-up.md).
## Permissões obrigatórias
Algumas permissões do IAM são necessárias para criar uma Integração ETL zero com o lakehouse do Amazon SageMaker. No mínimo, são necessárias permissões para executar as seguintes ações:
+ Crie integrações ETL zero para o banco de dados do RDS de origem.
+ Visualizar e excluir todas as integrações ETL zero.
+ Criar integrações de entrada no catálogo de destino gerenciado pelo AWS Glue.
+ Acessar os buckets do Amazon S3 usados pelo catálogo gerenciado pelo AWS Glue.
+ Usar chaves do AWS KMS para criptografia se a criptografia personalizada estiver configurada.
+ Registrar recursos com o Lake Formation.
+ Inserir a política de recursos no catálogo gerenciado pelo AWS Glue para autorizar integrações de entrada.
O exemplo de política a seguir demonstra as [permissões de privilégio mínimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) necessárias para criar e gerenciar integrações com um lakehouse do Amazon SageMaker. Talvez você não precise dessas permissões exatas se o usuário ou o perfil tiver permissões mais amplas, como uma política gerenciada `AdministratorAccess`.
Além disso, você deve configurar uma política de recursos no catálogo de destino gerenciado pelo AWS Glue para autorizar integrações de entrada. Use o comando da AWS CLI a seguir para aplicar a política de recursos.
### Exemplo de comando da AWS CLI para autorizar integrações de entrada no catálogo de destino
```
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
```
**nota**
Os nomes de recurso da Amazon (ARNs) do catálogo do Glue têm o seguinte formato:
Catálogo do Glue: `arn:aws:glue:{region}:{account-id}:catalog/catalog-name`.
### Escolher um catálogo de destino gerenciado pelo AWS Glue em uma conta diferente
Se você planeja especificar um catálogo de destino gerenciado pelo AWS Glue que esteja em outra Conta da AWS, deverá criar um perfil que permita que os usuários da conta atual acessem os recursos na conta de destino. Para obter mais informações, consulte [Fornecer acesso a um usuário do IAM em outra Conta da AWS de sua propriedade](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html).
O perfil deve ter as permissões a seguir, que possibilitam ao usuário visualizar os catálogos disponíveis do AWS Glue na conta de destino.
#### Permissões necessárias e política de confiança
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"glue:GetCatalog"
],
"Resource":[
"*"
]
}
]
}
```
------
O perfil deve ter a seguinte política de confiança, que especifica o ID da conta de destino.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal":{
"AWS": "arn:aws:iam::111122223333:root"
},
"Action":"sts:AssumeRole"
}
]
}
```
------
Para obter instruções sobre como criar o perfil, consulte [Criar um perfil usando políticas de confiança personalizadas](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html).
## Criar Integrações ETL zero com um lakehouse do Amazon SageMaker
É possível criar uma Integração ETL zero com um lakehouse do Amazon SageMakerusando o Console de gerenciamento da AWS, a AWS CLI ou a API do RDS.
**Importante**
Em Integrações ETL zero com um lakehouse do Amazon SageMaker, não é possível usar operações de atualização ou ressincronização. Se você encontrar problemas com uma integração após a criação, deverá excluir a integração e criar outra.
Por padrão, o RDS para MySQL limpa imediatamente os arquivos de log binários. Como as integrações ETL zero dependem de logs binários para replicar dados da origem para o destino, o período de retenção do banco de dados de origem deve ser de pelo menos uma hora. Assim que você cria uma integração, o Amazon RDS verifica o período de retenção do arquivo de log binário para o banco de dados de origem selecionado. Se o valor atual for 0 hora, o Amazon RDS o alterará automaticamente para 1 hora. Caso contrário, o valor permanecerá o mesmo.
### Console do RDS
**Como criar Integrações ETL zero com um lakehouse do Amazon SageMaker**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No painel de navegação à esquerda, escolha **Integrações ETL zero**.
1. Escolha **Criar integração ETL zero**.
1. Em **Nome da integração**, insira um nome para a integração. O nome pode ter até 60 caracteres alfanuméricos e pode incluir hifens.
1. Escolha **Próximo**.
1. Em **Origem**, selecione o banco de dados do RDS de onde os dados serão originados.
**nota**
O RDS notifica você se os parâmetros do de banco de dados não estiverem configurados corretamente. Se você receber essa mensagem, poderá escolher **Corrigir para mim** ou configurá-las manualmente. Para obter instruções sobre como corrigi-los manualmente, consulte[Etapa 1: criar um grupo de parâmetros de de banco de dados personalizado](zero-etl.setting-up.md#zero-etl.parameters).
A modificação dos parâmetros de banco de dados requer uma reinicialização. Antes de criar a integração, a reinicialização deve ser concluída e os valores do novo parâmetro deve ser aplicado com êxito ao banco de dados.
1. Depois que o banco de dados de origem for configurado com êxito, selecione **Próximo**.
1. Em **Destino 1**, faça o seguinte:
1. (Opcional) Para usar uma Conta da AWS diferente para o lakehouse de destino do Amazon SageMaker, escolha **Especificar uma conta diferente**. Depois, insira o ARN de um perfil do IAM com permissões para exibir seus catálogos do AWS Glue. Para obter instruções sobre como criar um perfil do IAM, consulte [Escolher um catálogo de destino gerenciado pelo AWS Glue em uma conta diferente](#zero-etl.create-permissions-cross-account-smlh).
1. Em **Catálogo do AWS Glue**, selecione o destino para os dados replicados do banco de dados de origem. Você pode escolher um catálogo existente gerenciado pelo AWS Glue como destino.
1. O perfil do IAM de destino precisa de permissões de descrição no catálogo de destino e deve ter as seguintes permissões:
------
#### [ 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"
]
}
]
}
```
------
O perfil do IAM deve ter a seguinte relação de confiança:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Você deve conceder ao perfil do IAM de destino as permissões de descrição referentes ao catálogo de destino gerenciado pelo AWS Glue com o perfil de administrador do Lake Formation criado na seção [Etapa 3b: criar um catálogo do AWS Glue para uma Integração ETL zero do Amazon SageMaker Lakehouse](zero-etl.setting-up.md#zero-etl-setting-up.sagemaker).
**nota**
O RDS notificará você se a política de recursos ou as configurações do catálogo gerenciado pelo AWS Glue especificado não estiverem configuradas corretamente. Se você receber essa mensagem, poderá escolher **Corrigir para mim** ou configurá-las manualmente.
Se a origem e o destino selecionados estiverem em valores diferentesContas da AWS, o Amazon RDS não poderá corrigir essas configurações para você. Você deve navegar até a outra conta e corrigi-la manualmente no SageMaker Unified Studio.
1. Depois que o catálogo de destino gerenciado pelo AWS Glue estiver configurado corretamente, escolha **Próximo**.
1. (Opcional) Em **Etiquetas**, adicione uma ou mais etiquetas à integração. Para obter mais informações, consulte [Marcar recursos do do Amazon RDS](USER_Tagging.md).
1. Em **Criptografia**, especifique como você deseja que sua integração seja criptografada. Por padrão, o RDS criptografa todas as integrações com uma Chave pertencente à AWS. Para escolher uma chave gerenciada pelo cliente em vez disso, habilite a opção **Personalizar configurações de criptografia** e escolha uma chave do KMS para criptografia. Para obter mais informações, consulte [Criptografar recursos do Amazon RDS](Overview.Encryption.md).
Como opção, adicione um contexto de criptografia. Para obter mais informações, consulte [Contexto de criptografia](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) no *Guia do desenvolvedor AWS Key Management Service*.
**nota**
O Amazon RDS adiciona os seguintes pares de contexto de criptografia, além dos adicionados por você:
`aws:glue:integration:arn` - `IntegrationArn`
`aws:servicename:id` - `glue`
Isso reduz o número geral de pares que você pode adicionar de oito para seis e contribui com o limite geral de caracteres da restrição de concessão. Para ter mais informações, consulte [Using grant constraints](https://docs.aws.amazon.com/kms/latest/developerguide/create-grant-overview.html#grant-constraints) no *Guia do desenvolvedor do AWS Key Management Service*.
1. Escolha **Próximo**.
1. Revise suas configurações de integração e escolha **Criar integração sem ETL**.
Se a criação falhar, consulte [Solução de problemas em Integrações ETL zero do Amazon RDS](zero-etl.troubleshooting.md) para conferir etapas de solução de problemas.
A integração tem o status `Creating` enquanto está sendo criada, e o lakehouse de destino do Amazon SageMaker tem o status `Modifying`. Durante esse período, não é possível consultar o catálogo nem alterar sua configuração.
Quando a integração é criada com êxito, o status da integração e o lakehouse de destino do Amazon SageMaker mudam para `Active`.
### AWS CLI
Para preparar um catálogo de destino gerenciado pelo AWS Glue para Integração ETL zero usando a AWS CLI, você deve primeiro usar o comando [create-integration-resource-property](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) com as seguintes opções:
+ `--resource-arn`: especifique o ARN do catálogo gerenciado pelo AWS Glue que será o destino da integração.
+ `--target-processing-properties`: especifique o ARN do perfil do IAM para acessar o catálogo de destino gerenciado pelo 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"}'
```
Para criar uma Integração ETL zero com um lakehouse do Amazon SageMaker usando a AWS CLI, use o comando [create-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) com as seguintes opções:
+ `--integration-name`— Especifique um nome para a integração.
+ `--source-arn`: especifique o ARN do banco de dados do RDS que será a origem da integração.
+ `--target-arn`: especifique o ARN do catálogo gerenciado pelo AWS Glue que será o destino da integração.
**Example**
Para Linux, macOS ou 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
```
Para 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 do RDS
Para criar uma Integração ETL zero como Amazon SageMaker usando a API do Amazon RDS, use a operação [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html) com os seguintes parâmetros:
**nota**
Os nomes de catálogo podem ter no máximo 19 caracteres. O parâmetro IntegrationName deve atender a esse requisito se for usado como nome de catálogo.
+ `IntegrationName`— Especifique um nome para a integração.
+ `SourceArn`: especifique o ARN do banco de dados do RDS que será a origem da integração.
+ `TargetArn`: especifique o ARN do catálogo gerenciado pelo AWS Glue que será o destino da integração.
## Criptografar integrações com uma chave gerenciada pelo cliente
Se você especificar uma chave do KMS personalizada em vez de uma Chave pertencente à AWS ao criar uma integração com o Amazon SageMaker, a política de chave deverá fornecer à entidade principal do serviço SageMaker Unified Studio acesso à ação `CreateGrant`. Além disso, ela deve permitir que o usuário atual execute as ações `DescribeKey` e `CreateGrant`.
O exemplo de política a seguir demonstra como conceder as permissões necessárias na política de chave. Ele inclui chaves de contexto para reduzir ainda mais o escopo das permissões.
### Exemplo de política de chave
------
#### [ 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": "*"
}
]
}
```
------
Para obter mais informações, consulte [Criar uma política de chave](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) no *Guia do desenvolvedor do AWS Key Management Service*.
## Próximas etapas
Depois de criar com sucesso uma Integração ETL zero com o Amazon SageMaker, você poderá começar a adicionar dados ao banco de dados do RDS de origem e consultá-los no lakehouse do Amazon SageMaker. Os dados serão replicados automaticamente e disponibilizados para workloads de analytics e machine learning.
# Filtragem de dados para Integrações ETL zero do Amazon RDS
As Integrações ETL zero do Amazon RDS permitem filtragem de dados, o que possibilita controlar quais dados são replicados do banco de dados do Amazon RDS de origem para o data warehouse de destino. Em vez de replicar todo o banco de dados, você pode aplicar um ou mais filtros para incluir ou excluir seletivamente tabelas específicas. Isso ajuda a otimizar o desempenho do armazenamento e das consultas, garantindo que somente os dados relevantes sejam transferidos. No momento, a filtragem é limitada aos níveis de banco de dados e tabela. Não é possível aplicar filtragem em nível de coluna e linha.
A filtragem de dados pode ser útil quando você deseja:
+ Una determinadas tabelas de dois ou mais bancos de dados de origem diferentes para não precisar de dados completos de nenhum banco de dados.
+ Economize custos realizando análises usando apenas um subconjunto de tabelas em vez de uma frota inteira de bancos de dados.
+ Filtre informações confidenciais, como números de telefone, endereços ou detalhes do cartão de crédito, de determinadas tabelas.
É possível adicionar filtros de dados a uma integração ETL zero usando o Console de gerenciamento da AWS, a AWS Command Line Interface (AWS CLI) ou a API do Amazon RDS.
Se a integração tiver um cluster provisionado como destino, o cluster deverá estar no [patch 180](https://docs.aws.amazon.com/redshift/latest/mgmt/cluster-versions.html#cluster-version-180) ou posterior para usar a filtragem de dados.
**Topics**
+ [Formato de um filtro de dados](#zero-etl.filtering-format)
+ [Lógica de filtros](#zero-etl.filtering-evaluate)
+ [Precedência do filtro](#zero-etl.filtering-precedence)
+ [Exemplos do RDS para MySQL](#zero-etl.filtering-examples-mysql)
+ [Exemplos do RDS para PostgreSQL](#zero-etl.filtering-examples-postgres)
+ [Exemplos do RDS para Oracle](#zero-etl.filtering-examples-oracle)
+ [Adicionar filtros de dados a uma integração](#zero-etl.add-filter)
+ [Remover filtros de dados de uma integração](#zero-etl.remove-filter)
## Formato de um filtro de dados
É possível definir vários filtros para uma única integração. Cada filtro inclui ou exclui qualquer tabela de banco de dados existente e futura que corresponda a um dos padrões na expressão do filtro. As integrações ETL zero do Amazon RDS usam a [sintaxe de filtro Maxwell](https://maxwells-daemon.io/filtering/) para a filtragem de dados.
Cada filtro tem os seguintes elementos:
| Elemento | Descrição |
| --- | --- |
| Tipo de filtro | Um tipo de filtro `Include` *inclui* todas as tabelas que correspondem a um dos padrões na expressão do filtro. Um tipo de filtro `Exclude` *exclui* todas as tabelas que correspondem a um dos padrões. |
| Expressão de filtro | Uma lista separada por vírgulas de padrões. As expressões devem usar a [sintaxe de filtro Maxwell](https://maxwells-daemon.io/filtering/). |
| Pattern | Um padrão de filtro no formato `database.table` para o RDS para MySQL ou `database.schema.table` para o RDS para PostgreSQL. É possível especificar nomes literais ou definir expressões regulares. No RDS para MySQL, são aceitas expressões regulares em nomes de banco de dados e de tabela. No RDS para PostgreSQL, as expressões regulares são aceitas somente em nomes de esquema e de tabela, não em nomes de banco de dados. Não é possível incluir filtros ao nível da coluna nem listas de bloqueio. Uma única integração pode ter um máximo de 99 padrões no total. No console, é possível inserir padrões em uma única expressão de filtro ou distribuí-los entre várias expressões. Um único padrão não pode exceder 256 caracteres. |
**Importante**
Se você selecionar um RDS para PostgreSQL, deverá especificar pelo menos um padrão de filtro de dados. O padrão deve incluir no mínimo um banco de dados único (`database-name.*.*`) para replicação no data warehouse de destino.
A imagem a seguir mostra a estrutura dos filtros de dados do RDS para MySQL no console:
![\[Filtragem de dados para uma Integração ETL zero\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/zero-etl-filter.png)
**Importante**
Não inclua informações pessoais, confidenciais ou sigilosas em seus padrões de filtragem.
### Filtros de dados na AWS CLI
Ao usar a AWS CLI para adicionar um filtro de dados, a sintaxe difere um pouco da sintaxe do console. Você deve atribuir um tipo de filtro (`Include` ou `Exclude`) a cada padrão individualmente; portanto, não é possível agrupar vários padrões sob um tipo de filtro.
Por exemplo, no console, é possível agrupar os seguintes padrões separados por vírgula em uma única instrução `Include`:
**RDS para MySQL**
```
mydb.mytable, mydb./table_\d+/
```
**RDS para PostgreSQL**
```
mydb.myschema.mytable, mydb.myschema./table_\d+/
```
No entanto, ao usar a AWS CLI, o mesmo filtro de dados deve estar no seguinte formato:
**RDS para MySQL**
```
'include: mydb.mytable, include: mydb./table_\d+/'
```
**RDS para PostgreSQL**
```
'include: mydb.myschema.mytable, include: mydb.myschema./table_\d+/'
```
## Lógica de filtros
Se você não especificar nenhum filtro de dados na integração, o Amazon RDS assumirá o filtro padrão `include:*.*`, o que replica todas as tabelas no data warehouse de destino. Entretanto, se você adicionar pelo menos um filtro, a lógica padrão mudará para `exclude:*.*`, o que exclui todas as tabelas por padrão. Isso permite que você defina explicitamente quais bancos de dados e tabelas incluir na replicação.
Por exemplo, se você definir o seguinte filtro:
```
'include: db.table1, include: db.table2'
```
O Amazon RDS avaliará o filtro da seguinte forma:
```
'exclude:*.*, include: db.table1, include: db.table2'
```
Portanto, o Amazon RDS replica somente a `table1` e a `table2` do banco de dados denominado `db` para o data warehouse de destino.
## Precedência do filtro
O Amazon RDS avalia os filtros de dados na ordem em que você especificar. No Console de gerenciamento da AWS, ele processa expressões de filtro da esquerda para a direita e de cima para baixo. Um segundo filtro ou um padrão individual subsequente pode substituir o primeiro.
Por exemplo, se o primeiro filtro for `Include books.stephenking`, ele incluirá somente a tabela `stephenking` do banco de dados `books`. No entanto, se você adicionar um segundo filtro, `Exclude books.*`, ele substituirá o primeiro filtro. Isso impede que qualquer tabela do índice `books` seja replicada para o data warehouse de destino.
Quando você especifica pelo menos um filtro, a lógica primeiro assume `exclude:*.*`, o que significa que todas as tabelas são automaticamente *excluídas* da replicação. Como prática recomendada, defina filtros do mais amplo ao mais específico. Comece com uma ou mais instruções `Include` para especificar os dados a serem replicados e, em seguida, adicione filtros `Exclude` para remover seletivamente determinadas tabelas.
O mesmo princípio se aplica aos filtros que você define usando a AWS CLI. O Amazon RDS avalia esses padrões de filtro na ordem em que você os especifica; portanto, um padrão pode substituir um especificado antes dele.
## Exemplos do RDS para MySQL
Os seguintes exemplos demonstram como a filtragem de dados funciona para exemplos do RDS para MySQL de Integração ETL zero:
+ Inclua todos os bancos de dados e todas as tabelas:
```
'include: *.*'
```
+ Inclua todas as tabelas no banco de dados `books`:
```
'include: books.*'
```
+ Exclua todas as tabelas chamadas `mystery`:
```
'include: *.*, exclude: *.mystery'
```
+ Inclua duas tabelas específicas no banco de dados `books`:
```
'include: books.stephen_king, include: books.carolyn_keene'
```
+ Inclua todas as tabelas no banco de dados `books`, exceto aquelas que contêm a substring `mystery`:
```
'include: books.*, exclude: books./.*mystery.*/'
```
+ Inclua todas as tabelas no banco de dados `books`, exceto aquelas que começam com `mystery`:
```
'include: books.*, exclude: books./mystery.*/'
```
+ Inclua todas as tabelas no banco de dados `books`, exceto aquelas que terminam com `mystery`:
```
'include: books.*, exclude: books./.*mystery/'
```
+ Inclua todas as tabelas no banco de dados `books` que começam com `table_`, exceto aquela chamada `table_stephen_king`. Por exemplo, `table_movies` ou `table_books` seria replicada, mas não `table_stephen_king`.
```
'include: books./table_.*/, exclude: books.table_stephen_king'
```
## Exemplos do RDS para PostgreSQL
Os seguintes exemplos demonstram como a filtragem de dados funciona para Integrações ETL zero do RDS para PostgreSQL:
+ Inclua todas as tabelas no banco de dados `books`:
```
'include: books.*.*'
```
+ Exclua todas as tabelas denominadas `mystery` no banco de dados `books`:
```
'include: books.*.*, exclude: books.*.mystery'
```
+ Inclua uma tabela no banco de dados `books` no esquema `mystery` e uma tabela no banco de dados `employee` no esquema `finance`:
```
'include: books.mystery.stephen_king, include: employee.finance.benefits'
```
+ Inclua todas as tabelas no banco de dados `books` e no esquema `science_fiction`, exceto aquelas que contêm a substring `king`:
```
'include: books.science_fiction.*, exclude: books.*./.*king.*/
```
+ Inclua todas as tabelas no banco de dados `books`, exceto aquelas que têm um nome de esquema que começa com `sci`:
```
'include: books.*.*, exclude: books./sci.*/.*'
```
+ Inclua todas as tabelas no banco de dados `books`, exceto aquelas no esquema `mystery` que terminam com `king`:
```
'include: books.*.*, exclude: books.mystery./.*king/'
```
+ Inclua todas as tabelas no banco de dados `books` que começam com `table_`, exceto aquela chamada `table_stephen_king`. Por exemplo, `table_movies` no esquema `fiction` e `table_books` no esquema `mystery` são replicados, mas não `table_stephen_king` em nenhum dos esquemas:
```
'include: books.*./table_.*/, exclude: books.*.table_stephen_king'
```
## Exemplos do RDS para Oracle
Os seguintes exemplos demonstram como a filtragem de dados funciona para Integrações ETL zero do RDS para Oracle:
+ Inclua todas as tabelas no banco de dados “books”:
```
'include: books.*.*'
```
+ Exclua todas as tabelas denominadas “mystery” no banco de dados “books”:
```
'include: books.*.*, exclude: books.*.mystery'
```
+ Inclua uma tabela no banco de dados “books” no esquema “mystery” e uma tabela no banco de dados no esquema “finance”:
```
'include: books.mystery.stephen_king, include: employee.finance.benefits'
```
+ Inclua todas as tabelas no esquema “mystery” dentro do banco de dados “books”:
```
'include: books.mystery.*'
```
### Considerações sobre distinção de maiúsculas e minúsculas
O banco de dados Oracle e o Amazon Redshift lidam com maiúsculas e minúsculas de nomes de objetos de forma diferente, o que afeta tanto a configuração do filtro de dados quanto as consultas de destino. Observe o seguinte:
+ O banco de dados Oracle armazena nomes de bancos de dados, esquemas e objetos em maiúsculas, a menos que seja explicitamente citado na instrução `CREATE`. Por exemplo, se você criar `mytable` (sem aspas), o dicionário de dados Oracle armazenará o nome da tabela como `MYTABLE`. Se você citar o nome do objeto, o dicionário de dados preservará o tamanho da letra.
+ Os filtros de dados ETL zero diferenciam maiúsculas e minúsculas e devem corresponder exatamente às maiúsculas e minúsculas dos nomes dos objetos conforme eles aparecem no dicionário de dados Oracle.
+ As consultas do Amazon Redshift usam como padrão nomes de objetos em minúsculas, a menos que sejam explicitamente citados. Por exemplo, uma consulta de `MYTABLE` (sem aspas) procura `mytable`.
Preste atenção às diferenças de tamanho da letra ao criar o filtro do Amazon Redshift e consultar os dados.
#### Criar uma integração em maiúsculas
Quando você cria uma tabela sem especificar o nome entre aspas duplas, o banco de dados Oracle armazena o nome em maiúsculas no dicionário de dados. Por exemplo, você pode criar `MYTABLE` usando qualquer uma das instruções SQL a seguir.
```
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));
```
Como você não citou o nome da tabela nas instruções anteriores, o banco de dados Oracle armazena o nome do objeto em maiúsculas como `MYTABLE`.
Para replicar essa tabela no Amazon Redshift, você deve especificar o nome em maiúsculas no filtro de dados do seu comando `create-integration`. O nome do filtro ETL zero e o nome do dicionário de dados Oracle devem coincidir.
```
aws rds create-integration \
--integration-name upperIntegration \
--data-filter "include: ORCL.REINVENT.MYTABLE" \
...
```
Por padrão, o Amazon Redshift armazena dados em letras minúsculas. Para consultar `MYTABLE` no banco de dados replicado no Amazon Redshift, você deve citar o nome `MYTABLE` em maiúsculas para que coincida com o tamanho da letra no dicionário de dados Oracle.
```
SELECT * FROM targetdb1."REINVENT"."MYTABLE";
```
As consultas a seguir não usam o mecanismo de citação. Todas elas exibem um erro porque pesquisam uma tabela do Amazon Redshift chamada `mytable`, que usa o nome padrão em minúsculas, mas a tabela é denominada `MYTABLE` no dicionário de dados Oracle.
```
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".MyTable;
SELECT * FROM targetdb1."REINVENT".mytable;
```
As consultas a seguir usam o mecanismo de citação para especificar um nome com maiúsculas e minúsculas. Todas as consultas exibem um erro porque pesquisam uma tabela do Amazon Redshift que não se chama `MYTABLE`.
```
SELECT * FROM targetdb1."REINVENT"."MYtablE";
SELECT * FROM targetdb1."REINVENT"."MyTable";
SELECT * FROM targetdb1."REINVENT"."mytable";
```
#### Criar uma integração em minúsculas
No exemplo alternativo a seguir, você vai usar aspas duplas para armazenar o nome da tabela em minúsculas no dicionário de dados Oracle. Você vai criar `mytable` da forma a seguir.
```
CREATE TABLE REINVENT."mytable" (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
O banco de dados Oracle armazena o nome da tabela como `mytable` em letras minúsculas. Para replicar essa tabela no Amazon Redshift, você deve especificar o nome em maiúsculas `mytable` no filtro de dados ETL zero.
```
aws rds create-integration \
--integration-name lowerIntegration \
--data-filter "include: ORCL.REINVENT.mytable" \
...
```
Ao consultar essa tabela no banco de dados replicado no Amazon Redshift, você pode especificar o nome `mytable` em minúsculas. A consulta é bem-sucedida porque procura uma tabela chamada`mytable`, que é o nome da tabela no dicionário de dados Oracle.
```
SELECT * FROM targetdb1."REINVENT".mytable;
```
Como o Amazon Redshift usa como padrão nomes de objetos em minúsculas, as consultas a seguir também conseguem encontrar `mytable`.
```
SELECT * FROM targetdb1."REINVENT".MYtablE;
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".MyTable;
```
As consultas a seguir usam o mecanismo de citação para o nome do objeto. Todas elas exibem um erro porque pesquisam uma tabela do Amazon Redshift cujo nome é diferente de `mytable`.
```
SELECT * FROM targetdb1."REINVENT"."MYTABLE";
SELECT * FROM targetdb1."REINVENT"."MyTable";
SELECT * FROM targetdb1."REINVENT"."MYtablE";
```
#### Criar uma tabela com uma integração em maiúsculas e minúsculas
No exemplo a seguir, você vai usar aspas duplas para armazenar o nome da tabela em minúsculas no dicionário de dados Oracle. Você vai criar `MyTable` da forma a seguir.
```
CREATE TABLE REINVENT."MyTable" (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
O banco de dados Oracle armazena esse nome de tabela como `MyTable` com letras maiúsculas e minúsculas. Para replicar essa tabela no Amazon Redshift, você deve especificar o nome em maiúsculas e minúsculas no filtro de dados.
```
aws rds create-integration \
--integration-name mixedIntegration \
--data-filter "include: ORCL.REINVENT.MyTable" \
...
```
Ao consultar essa tabela no banco de dados replicado no Amazon Redshift, você deve especificar o nome `MyTable` em maiúsculas e minúsculas, citando o nome do objeto.
```
SELECT * FROM targetdb1."REINVENT"."MyTable";
```
Como o Amazon Redshift usa como padrão nomes de objetos em minúsculas, as consultas a seguir não encontram o objeto porque estão procurando pelo nome `mytable` em minúsculas.
```
SELECT * FROM targetdb1."REINVENT".MYtablE;
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".mytable;
```
**nota**
Não é possível usar expressões regulares no valor de filtro para nome de banco de dados, esquema ou nome de tabela em integrações do RDS para Oracle.
## Adicionar filtros de dados a uma integração
É possível configurar a filtragem de dados usando o Console de gerenciamento da AWS, a AWS CLI ou a API do Amazon RDS.
**Importante**
Se você adicionar um filtro depois de criar uma integração, o Amazon RDS o tratará como se ele sempre tivesse existido. Ele remove quaisquer dados no data warehouse de destino que não correspondam aos novos critérios de filtragem e ressincroniza todas as tabelas afetadas.
### Console do RDS
**Para adicionar filtros de dados para uma integração ETL zero**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No painel de navegação, escolha **Integrações ETL zero**. Selecione a integração à qual você deseja adicionar filtros de dados e escolha **Modificar**.
1. Em **Fonte**, adicione uma ou mais instruções `Exclude` e `Include`.
A seguinte imagem mostra um exemplo de filtros de dados para uma integração do MySQL:
![\[Filtragens de dados para uma integração ETL zero no console do RDS\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/zero-etl-filter-data.png)
1. Quando as alterações estiverem adequadas para você, escolha **Continuar** e **Salvar alterações**.
### AWS CLI
Para adicionar filtros de dados a uma integração ETL zero usando a AWS CLI, chame o comando [modify-integration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-integration.html). Além do identificador de integração, especifique o parâmetro `--data-filter` com uma lista separada por vírgulas dos filtros Maxwell `Include` e `Exclude`.
**Example**
O exemplo a seguir adiciona padrões de filtro a `my-integration`.
Para Linux, macOS ou Unix:
```
aws rds modify-integration \
--integration-identifier my-integration \
--data-filter 'include: foodb.*, exclude: foodb.tbl, exclude: foodb./table_\d+/'
```
Para Windows:
```
aws rds modify-integration ^
--integration-identifier my-integration ^
--data-filter 'include: foodb.*, exclude: foodb.tbl, exclude: foodb./table_\d+/'
```
### API do RDS
Para modificar uma integração ETL zero usando a API do RDS, chame a operação [ModifyIntegration](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyIntegration.html). Especifica o identificador de integração e fornece uma lista separada por vírgulas de padrões de filtro.
## Remover filtros de dados de uma integração
Quando você remove um filtro de dados de uma integração, o Amazon RDS reavalia os filtros restantes como se o filtro removido nunca tivesse existido. Em seguida, ele replica quaisquer dados anteriormente excluídos que agora atendem aos critérios no data warehouse de destino. Isso aciona uma ressincronização de todas as tabelas afetadas.
# Adicionar dados a um banco de dados do RDS de origem e consultá-los
Para criar uma Integração ETL zero que replica dados do Amazon RDS no Amazon Redshift, você deve criar um banco de dados de destino pretendido.
Para conexões com o Amazon Redshift, conecte-se ao cluster ou grupo de trabalho do Amazon Redshift e crie um banco de dados com uma referência ao identificador da integração. Depois, é possível adicionar dados ao banco de dados do RDS de origem e vê-los replicados no Amazon Redshift ou no Amazon SageMaker.
**Topics**
+ [Criar um banco de dados de destino](#zero-etl.create-db)
+ [Adicionar dados ao banco de dados de origem](#zero-etl.add-data-rds)
+ [Consultar os dados do Amazon RDS no Amazon Redshift](#zero-etl.query-data-redshift)
+ [Diferenças de tipos de dados entre os bancos de dados RDS e Amazon Redshift](#zero-etl.data-type-mapping)
+ [Operações de DDL para o RDS para PostgreSQL](#zero-etl.ddl-postgres)
## Criar um banco de dados de destino
Depois de criar uma integração, para começar a replicar dados no Amazon Redshift, você deve primeiro criar um banco de dados no data warehouse de destino. Esse banco de dados deve incluir uma referência ao identificador da integração. Você pode usar o console do Amazon Redshift ou o Editor de Consultas v2 para criar o banco de dados.
Para conferir instruções sobre como criar um banco de dados de destino, consulte [Criar bancos de dados de destino no Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html#zero-etl-using.create-db).
## Adicionar dados ao banco de dados de origem
Depois de configurar a integração, você pode preencher o banco de dados do RDS de origem com dados que você deseja replicar no data warehouse.
**nota**
Há diferenças entre os tipos de dados no Amazon RDS e no warehouse de analytics de destino. Para obter uma tabela de mapeamentos de tipos de dados, consulte. [Diferenças de tipos de dados entre os bancos de dados RDS e Amazon Redshift](#zero-etl.data-type-mapping)
Primeiro, conecte-se ao banco de dados de origem usando o cliente do MySQL de sua escolha. Para instruções, consulte [Conectar-se à instância de banco de dados do MySQL](USER_ConnectToInstance.md).
Depois, crie uma tabela e insira uma linha de dados de exemplo.
**Importante**
Verifique se a tabela tem uma chave primária. Caso contrário, ela não poderá ser replicada no data warehouse de destino.
**RDS para MySQL**
O exemplo a seguir usa o [utilitário 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 para PostgreSQL**
O exemplo a seguir usa o terminal interativo do PostgreSQL `[psql](https://www.postgresql.org/docs/current/app-psql.html)`. Ao se conectar ao banco de dados, inclua o nome do banco de dados que você deseja replicar.
```
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 para Oracle**
O exemplo a seguir usa o SQL\$1Plus para se conectar ao banco de dados do RDS para 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');
```
## Consultar os dados do Amazon RDS no Amazon Redshift
Depois que os dados são adicionados ao banco de dados do RDS, eles são replicados no banco de dados de destino e podem ser consultados.
**Como consultar os dados replicados**
1. Navegue até o console do Amazon Redshift e escolha **Editor de Consultas v2** no painel de navegação esquerdo.
1. Conecte-se ao cluster ou grupo de trabalho e escolha o banco de dados de destino (criado na integração) no menu suspenso (**destination\$1database** neste exemplo). Para conferir instruções sobre como criar um banco de dados de destino, consulte [Criar bancos de dados de destino no Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html#zero-etl-using.create-db).
1. Use uma declaração SELECT para consultar dados. Neste exemplo, é possível executar o comando a seguir para selecionar todos os dados da tabela que você criou no banco de dados do RDS de origem:
```
SELECT * from my_db."books_table";
```
![\[Execute uma instrução SELECT no Editor de Consultas. O resultado é uma única linha de dados de amostra adicionada ao banco de dados do Amazon RDS.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/zero-etl-redshift-editor.png)
+ `my_db` é o nome do esquema do banco de dados RDS.
+ `books_table` é o nome da tabela do RDS.
Também é possível consultar os dados usando o cliente de linha de comandos. Por exemplo:
```
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
```
**nota**
Para diferenciar letras maiúsculas de minúsculas, use aspas duplas (“ ”) para nomes de esquemas, tabelas e colunas. Para obter mais informações, consulte [enable\$1case\$1sensitive\$1identifier](https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html).
## Diferenças de tipos de dados entre os bancos de dados RDS e Amazon Redshift
Abaixo, as tabelas mostram as associações entre tipos de dados do RDS para MySQL, RDS para PostgreSQL e RDS para Oracle e tipos de dados de destino correspondentes. No momento, o *Amazon RDS é compatível somente com esses tipos de dados para integrações ETL zero.*
Se uma tabela no banco de dados de origem incluir um tipo de dado incompatível, a tabela ficará fora de sincronia e não poderá ser consumida no destino pretendido. O streaming da origem para o destino continuará, mas a tabela com o tipo de dados não compatível não estará disponível. Para corrigir a tabela e disponibilizá-la no destino pretendido, você deve reverter manualmente a alteração incompatível e, em seguida, atualizar a integração executando `[ALTER DATABASE...INTEGRATION REFRESH](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATABASE.html)`.
**nota**
Não é possível atualizar Integrações ETL zero com um lakehouse do Amazon SageMaker. Em vez disso, exclua e tente criar a integração novamente.
**Topics**
+ [RDS para MySQL](#zero-etl.data-type-mapping-mysql)
+ [RDS para PostgreSQL](#zero-etl.data-type-mapping-postgres)
+ [RDS para Oracle](#zero-etl.data-type-mapping-oracle)
### RDS para MySQL
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### RDS para PostgreSQL
As Integrações ETL zero para o RDS para PostgreSQL não são compatíveis com tipos de dados personalizados nem tipos de dados criados por extensões.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### RDS para Oracle
**Tipos de dados incompatíveis**
Não é possível usar os seguintes tipos de dados do RDS para Oracle no Amazon Redshift:
+ `ANYDATA`
+ `BFILE`
+ `REF`
+ `ROWID`
+ `UROWID`
+ `VARRAY`
+ `SDO_GEOMETRY`
+ Tipos de dados definidos pelo usuário
**Diferenças entre os tipos de dados**
A tabela a seguir mostra as diferenças entre os tipos de dados que afetam uma Integração ETL zero quando o RDS para Oracle é a origem e o Amazon Redshift é o destino.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
## Operações de DDL para o RDS para PostgreSQL
Como o Amazon Redshift é derivado do PostgreSQL, ele compartilha vários recursos com o RDS para PostgreSQL porque ambos têm em comum a arquitetura do PostgreSQL. As Integrações ETL zero utilizam essas semelhanças para simplificar a replicação de dados do RDS para PostgreSQL para o Amazon Redshift, associando bancos de dados por nome e utilizando o banco de dados compartilhado, o esquema e a estrutura de tabelas.
Pense nos seguintes pontos ao gerenciar Integrações ETL zero do RDS para PostgreSQL:
+ O isolamento é gerenciado no nível do banco de dados.
+ A replicação ocorre no nível do banco de dados.
+ Os bancos de dados do RDS para PostgreSQL são associados aos bancos de dados do Amazon Redshift por nome, e os dados fluirão para o banco de dados do Redshift renomeado correspondente caso o original seja renomeado.
Apesar de suas semelhanças, o Amazon Redshift e o RDS para PostgreSQL têm diferenças importantes. As seções a seguir descrevem as respostas do sistema do Amazon Redshift para operações comuns de DDL.
**Topics**
+ [Operações do banco de dados](#zero-etl.ddl-postgres-database)
+ [Operações de esquema](#zero-etl.ddl-postgres-schema)
+ [Operações de tabela](#zero-etl.ddl-postgres-table)
### Operações do banco de dados
A tabela a seguir mostra as respostas do sistema para operações de DDL do banco de dados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### Operações de esquema
A tabela a seguir mostra as respostas do sistema para operações de DDL do esquema.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### Operações de tabela
A tabela a seguir mostra as respostas do sistema para operações de DDL da tabela.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
# Visualizar e monitorar Integrações ETL zero do Amazon RDS
Você pode ver os detalhes de uma integração ETL zero do Amazon RDS para ver suas informações de configuração e status atual. Também é possível monitorar o status da integração consultando visualizações específicas do sistema no Amazon Redshift. Além disso, o Amazon Redshift publica determinadas métricas relacionadas à integração no Amazon CloudWatch, que você pode visualizar no console do Amazon Redshift.
**Topics**
+ [Visualizar integrações](#zero-etl.describing)
+ [Monitorar integrações usando tabelas de sistema para o Amazon Redshift](#zero-etl.monitoring)
+ [Monitorar integrações com o Amazon EventBridge para o Amazon Redshift](#zero-etl.eventbridge)
## Visualizar integrações
Você pode visualizar Integrações ETL zero do Amazon RDS usando o Console de gerenciamento da AWS, a AWS CLI ou a API do RDS.
### Console
**Como visualizar os detalhes de uma integração ETL zero**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No painel de navegação à esquerda, escolha **Integrações ETL zero**.
1. Selecione uma integração para ver mais detalhes sobre ela, como o banco de dados de origem e o data warehouse de destino.
![\[Detalhes de uma integração ETL zero\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/zero-etl-integration-view.png)
Uma integração pode ter os seguintes status:
+ `Creating`: a integração está sendo criada.
+ `Active`: a integração está enviando dados transacionais para o data warehouse de destino.
+ `Syncing`: a integração encontrou um erro recuperável e precisa reprocessar os dados. As tabelas afetadas não estarão disponíveis para consulta enquanto a ressincronização não for concluída.
+ `Needs attention`: a integração encontrou um evento ou erro que requer intervenção manual para resolvê-lo. Para corrigir o problema, siga as instruções na mensagem de erro na página de detalhes da integração.
+ `Failed`: a integração encontrou um evento ou erro irrecuperável que não pode ser corrigido. Você precisa excluir e recriar a integração.
+ `Deleting`: a integração está sendo excluída.
### AWS CLI
Para visualizar todas as integrações ETL zero na conta atual usando a AWS CLI, use o comando [describe-integrations](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-integrations.html) e especifique a opção `--integration-identifier`.
**Example**
Para Linux, macOS ou Unix:
```
aws rds describe-integrations \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
Para Windows:
```
aws rds describe-integrations ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
### API do RDS
Para visualizar a integração ETL zero usando a API do Amazon RDS, use a operação [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeIntegrations.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeIntegrations.html) com o parâmetro `IntegrationIdentifier`.
## Monitorar integrações usando tabelas de sistema para o Amazon Redshift
O Amazon Redshift tem visualizações e tabelas do sistema que contêm informações sobre como o sistema está funcionando. Você pode consultar essas visualizações e tabelas do sistema da mesma maneira como consultaria qualquer outra tabela de banco de dados. Para ter mais informações sobre visualizações e tabelas do sistema no Amazon Redshift, consulte [Referência de visualizações e tabelas do sistema](https://docs.aws.amazon.com//redshift/latest/dg/cm_chap_system-tables.html) no *Guia do desenvolvedor de banco de dados do Amazon Redshift*.
Você pode consultar as seguintes visualizações e tabelas de sistema para obter informações sobre Integrações ETL zero do :
+ [SVV\$1INTEGRATION](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION.html): fornece detalhes de configuração para suas integrações.
+ [SVV\$1INTEGRATION\$1TABLE\$1STATE](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html): descreve o estado de cada tabela em uma integração.
+ [SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_STATE_CHANGE.html): exibe os logs de alteração do estado de uma integração.
+ [SYS\$1INTEGRATION\$1ACTIVITY](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_INTEGRATION_ACTIVITY.html): fornece informações sobre execuções de integração concluídas.
Todas as métricas do Amazon CloudWatch relacionadas à integração se originam no Amazon Redshift. Para ter mais informações, consulte [Métricas para integrações ETL zero](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.monitoring.html) no *Guia de gerenciamento do Amazon Redshift*. No momento, o Amazon RDS não publica nenhuma métrica relacionada à integração no Amazon CloudWatch.
## Monitorar integrações com o Amazon EventBridge para o Amazon Redshift
O Amazon Redshift envia eventos relacionados à integração ao Amazon EventBridge. Para obter uma lista de eventos e seus IDs de eventos correspondentes, consulte [Notificações de eventos de integração ETL zero com o Amazon EventBridge](https://docs.aws.amazon.com/redshift/latest/mgmt/integration-event-notifications) no *Guia de gerenciamento do Amazon Redshift.*
# Modificar Integrações ETL zero do Amazon RDS
É possível modificar somente o nome, a descrição e as opções de filtragem de dados de uma Integração ETL zero em um data warehouse compatível. Não é possível modificar a chave do AWS KMS usada para criptografar a integração ou os bancos de dados de origem ou de destino.
Se você adicionar um filtro de dados a uma integração existente, o Amazon RDS reavaliará o filtro como se ele sempre tivesse existido. Ele remove todos os dados que no momento estão no data warehouse de destino e não correspondem aos novos critérios de filtragem. Se você *remover* um filtro de dados de uma integração, ele replicará todos os dados que anteriormente não correspondiam aos critérios de filtragem (mas agora correspondem) no data warehouse de destino. Para obter mais informações, consulte [Filtragem de dados para Integrações ETL zero do Amazon RDS](zero-etl.filtering.md).
É possível modificar uma integração ETL zero usando o Console de gerenciamento da AWS, a AWS CLI ou a API do Amazon RDS.
## Console do RDS
**Para modificar uma integração ETL zero**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No painel de navegação, escolha **Integrações ETL zero** e a integração que você deseja modificar.
1. Escolha **Modificar** e altere as configurações disponíveis.
1. Quando todas as alterações estiverem conforme desejado, escolha **Modificar**.
## AWS CLI
Para modificar uma integração ETL zero usando a AWS CLI, chame o comando [modify-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-integration.html). Junto com o `--integration-identifier`, especifique qualquer uma das seguintes opções:
+ `--integration-name`: especifique um novo nome para a integração.
+ `--description`: especifique uma nova descrição para a integração.
+ `--data-filter`: especifique as opções de filtragem de dados para a integração. Para obter mais informações, consulte [Filtragem de dados para Integrações ETL zero do Amazon RDS](zero-etl.filtering.md).
**Example**
A solicitação a seguir modifica uma integração existente.
Para Linux, macOS ou Unix:
```
aws rds modify-integration \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374 \
--integration-name my-renamed-integration
```
Para Windows:
```
aws rds modify-integration ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374 ^
--integration-name my-renamed-integration
```
## API do RDS
Para modificar uma integração ETL zero usando a API do RDS, chame a operação [ModifyIntegration](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyIntegration.html). Especifique o identificador de integração e os parâmetros que você deseja modificar.
# Excluir Integrações ETL zero do Amazon RDS
Quando você exclui uma integração ETL zero, o Amazon RDS a remove do banco de dados de origem. Os dados transacionais não são excluídos do Amazon RDS ou do destino de analytics, mas o Amazon RDS não envia dados novos ao Amazon Redshift ou ao Amazon SageMaker.
Só será possível excluir uma integração quando ela tiver o status `Active`, `Failed`, `Syncing` ou `Needs attention`.
É possível excluir as integrações ETL zero usando o Console de gerenciamento da AWS, a AWS CLI ou a API do RDS.
## Console
**Como excluir uma integração ETL zero**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No painel de navegação à esquerda, escolha **Integrações ETL zero**.
1. Selecione a integração ETL zero que você deseja excluir.
1. Escolha **Ações** e **Excluir**, depois confirme a exclusão.
## AWS CLI
Para excluir uma integração ETL zero, use o comando [delete-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-integration.html) e especifique a opção `--integration-identifier`.
**Example**
Para Linux, macOS ou Unix:
```
aws rds delete-integration \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
Para Windows:
```
aws rds delete-integration ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
## API do RDS
Para excluir uma integração ETL zero usando a API do Amazon RDS, use a operação [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteIntegration.html) com o parâmetro `IntegrationIdentifier`.
# Solução de problemas em Integrações ETL zero do Amazon RDS
Você pode verificar o estado de uma Integração ETL zero consultando a tabela de sistema [SVV\$1INTEGRATION](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION.html) no destino de analytics. Se a coluna `state` tiver um valor de `ErrorState`, isso significa que há algo errado. Para obter mais informações, consulte [Monitorar integrações usando tabelas de sistema para o Amazon Redshift](zero-etl.describingmonitoring.md#zero-etl.monitoring).
Use as informações a seguir para solucionar problemas comuns em Integrações ETL zero do Amazon RDS.
**Importante**
As operações de ressincronização e atualização não estão disponíveis para Integrações ETL zero com um lakehouse do Amazon SageMaker AI. Se houver problemas com uma integração, você deve excluí-la e criar outra. Não é possível atualizar ou ressincronizar uma integração existente.
**Topics**
+ [Não consigo criar uma integração ETL zero.](#zero-etl.troubleshooting.creation)
+ [Minha integração está travada em um estado de `Syncing`.](#zero-etl.troubleshooting.syncing)
+ [Minhas tabelas não estão sendo replicadas para o Amazon Redshift.](#zero-etl.troubleshooting.primarykey)
+ [Uma ou mais das minhas tabelas do Amazon Redshift exigem ressincronização.](#zero-etl.troubleshooting.resync)
+ [Problemas de falha em Integrações ETL zero com um lakehouse do Amazon SageMaker AI](#zero-etl.troubleshooting.integration-issues)
## Não consigo criar uma integração ETL zero.
Se você não conseguir criar uma integração ETL zero, verifique se as seguintes informações estão corretas para o banco de dados de origem:
+ O banco de dados de origem 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).
+ Você configurou corretamente os parâmetros de banco de dados. Se os parâmetros necessários forem definidos incorretamente ou não estiverem associados ao banco de dados, a criação falhará. Consulte [Etapa 1: criar um grupo de parâmetros de de banco de dados personalizado](zero-etl.setting-up.md#zero-etl.parameters).
Além disso, confira se o indicado a seguir está correto para seu data warehouse de destino:
+ Ter a diferenciação entre maiúsculas e minúsculas habilitada. Consulte [Ativar a diferenciação entre maiúsculas e minúsculas em um data warehouse](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-setting-up.case-sensitivity).
+ Você adicionou a entidade principal autorizada e a origem de integração corretas. 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).
+ O data warehouse é criptografado (se for um cluster provisionado). Consulte [Criptografia de banco de dados do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html).
## Minha integração está travada em um estado de `Syncing`.
Sua integração poderá mostrar consistentemente um status de `Syncing` se você alterar o valor de um dos parâmetros obrigatórios do banco de dados.
Para corrigir esse problema, confira os valores dos parâmetros no grupo de parâmetros associado ao banco de dados de origem e verifique se eles correspondem aos valores obrigatórios. Para obter mais informações, consulte [Etapa 1: criar um grupo de parâmetros de de banco de dados personalizado](zero-etl.setting-up.md#zero-etl.parameters).
Se você modificar algum parâmetro, reinicialize o banco de dados para aplicar as alterações.
## Minhas tabelas não estão sendo replicadas para o Amazon Redshift.
Caso não veja uma ou mais tabelas refletidas no Amazon Redshift, execute um dos seguintes comandos para ressincronizá-las:
```
ALTER DATABASE dbname INTEGRATION REFRESH TABLES table1, table2;
```
Para ter mais informações, consulte [ALTER DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATABASE.html) na referência do Amazon Redshift SQL.
Talvez seus dados não estejam sendo replicados porque uma ou mais tabelas de origem não têm uma chave primária. O painel de monitoramento no Amazon Redshift exibe o status dessas tabelas como `Failed`, e o status da integração ETL zero geral muda para `Needs attention`. Para resolver esse problema, é possível identificar uma chave em sua tabela que pode se tornar uma chave primária ou adicionar uma chave primária sintética. Para conhecer as soluções detalhadas, consulte [Handle tables without primary keys while creating Amazon Aurora MySQL or Amazon RDS for MySQL zero-ETL integrations with Amazon Redshift](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/).
## Uma ou mais das minhas tabelas do Amazon Redshift exigem ressincronização.
A execução de determinados comandos no banco de dados de origem pode exigir que suas tabelas sejam novamente sincronizadas. Nesses casos, a visualização do sistema [SVV\$1INTEGRATION\$1TABLE\$1STATE](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html) mostra um `table_state` de `ResyncRequired`, o que significa que a integração deve recarregar completamente os dados dessa tabela específica do MySQL para o Amazon Redshift.
Quando a tabela começa a ser ressincronizada, ela entra em um estado de `Syncing`. Você não precisa realizar nenhuma ação manual para ressincronizar uma tabela. Enquanto os dados da tabela estiverem sendo sincronizados novamente, você não poderá acessá-los no Amazon Redshift.
A seguir estão alguns exemplos de operações que podem colocar uma tabela em um estado `ResyncRequired` e possíveis alternativas a serem consideradas.
| Operation | Exemplo | Alternativa |
| --- | --- | --- |
| Adicionar uma coluna em uma posição específica | ALTER TABLE table_name
ADD COLUMN column_name INTEGER
NOT NULL first;
| O Amazon Redshift não oferece suporte à adição de colunas em posições específicas usando as palavras-chave first ou after. Se a ordem das colunas na tabela de destino não for crítica, adicione a coluna no final da tabela usando um comando mais simples:ALTER TABLE table_name
ADD COLUMN column_name column_type;
|
| Adicionar uma coluna de carimbo de data/hora com o CURRENT\$1TIMESTAMP padrão | ALTER TABLE table_name
ADD COLUMN column_name TIMESTAMP
NOT NULL DEFAULT CURRENT_TIMESTAMP;
| O valor CURRENT\$1TIMESTAMP das linhas da tabela é calculado pelo RDS para MySQL e não pode ser simulado no Amazon Redshift sem uma nova sincronização completa dos dados da tabela. Se possível, altere o valor padrão para uma constante literal, como `2023-01-01 00:00:15`, a fim de evitar latência na disponibilidade da tabela. |
| Executar várias operações de coluna em um único comando | ALTER TABLE table_name
ADD COLUMN column_1,
RENAME COLUMN column_2 TO column_3;
| Considere dividir o comando em duas operações separadas, ADD e RENAME, que não exigirão ressincronização. |
## Problemas de falha em Integrações ETL zero com um lakehouse do Amazon SageMaker AI
Se você encontrar problemas em uma Integração ETL zero existente com um lakehouse do Amazon SageMaker AI, a única solução é excluir a integração e criar outra. Diferentemente de outros serviços da AWS, as Integrações ETL zero não permitem operações de atualização ou ressincronização.
Para resolver problemas de integração:
1. Exclua a Integração ETL zero que apresenta problemas usando o console, a CLI ou a API.
1. Verifique se as configurações do banco de dados de origem e do data warehouse de destino estão corretas.
1. Crie outra Integração ETL zero com a mesma configuração ou a configuração atualizada.
Esse processo provocará a reinicialização completa do pipeline de dados, o que pode levar algum tempo, dependendo do tamanho do banco de dados de origem.