$ dgmgrl RDS_DATAGUARD@RDS_CUSTOM_ORCL_D**CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Fri Sep 30 22:44:49 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "ORCL_D"
Connected as SYSDG.
DGMGRL>
DGMGRL> show database orcl_d
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Average Apply Rate: 11.00 KByte/s
Instance(s):
ORCL
SUCCESS
DGMGRL>
-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B| DBA | | Altere a configuração de transporte de log conectando-se ao DGMGRL a partir do nó primário. | Altere o modo de transporte de log para`FastSync`, correspondente à configuração de transporte de redo `SYNC+NOAFFIRM`. Para garantir que você tenha configurações válidas após a troca de função, altere-as tanto para o banco de dados principal quanto para o banco de dados auxiliar.**Não CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 11 20:24:11 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_B"
Connected as SYSDG.
DGMGRL>
DGMGRL> show database rdscdb_b
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 2.00 KByte/s
Real Time Query: OFF
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL>
DGMGRL>**CDB**
DGMGRL> edit database orcl_d set property logxptmode=fastsync;
Property "logxptmode" updated
DGMGRL> show database orcl_d LogXptMode;
LogXptMode = 'fastsync'
DGMGRL> edit database orcl_a set property logxptmode=fastsync;
Property "logxptmode" updated
DGMGRL> show database orcl_a logxptmode;
LogXptMode = 'fastsync'
DGMGRL>
DGMGRL> edit database rdscdb_b set property logxptmode=fastsync;DGMGRL> edit database rdscdb_b set property logxptmode=fastsync;| DBA | | Altere o modo de proteção para MaxAvailability. | Altere o modo de proteção para `MaxAvailability` conectando-se ao `DGMGRL` a partir do nó primário.**Não CDB**
Property "logxptmode" updated
DGMGRL> show database rdscdb_b LogXptMode;
LogXptMode = 'fastsync'
DGMGRL> edit database rdscdb_a set property logxptmode=fastsync;
Property "logxptmode" updated
DGMGRL> show database rdscdb_a logxptmode;
LogXptMode = 'fastsync'
DGMGRL>
DGMGRL> edit configuration set protection mode as maxavailability;**CDB**
Succeeded.
DGMGRL> show configuration;
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 38 seconds ago)
DGMGRL>
DGMGRL> show configuration| DBA | ### Altere o status da réplica de montagem para somente leitura e ative a aplicação de redo | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Pare a aplicação de redo para o banco de dados em espera. | A réplica de leitura é criada no modo `MOUNT` por padrão. Para abri-la no modo somente leitura, primeiro você precisa desativar a aplicação de redo conectando-se ao `DGMGRL` a partir do nó primário ou de espera.**Não CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 57 seconds ago)
DGMGRL>
DGMGRL> show database orcl_dDGMGRL> show database orcl_d**CDB**
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 11.00 KByte/s
Real Time Query: OFF
Instance(s):
ORCL
Database Status:
SUCCESS
DGMGRL> edit database orcl_d set state=apply-off;
Succeeded.
DGMGRL> show database orcl_d
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-OFF
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 42 seconds (computed 1 second ago)
Average Apply Rate: (unknown)
Real Time Query: OFF
Instance(s):
ORCL
Database Status:
SUCCESS
DGMGRL>
DGMGRL> show configurationDGMGRL> show configuration| DBA | | Abra a instância de réplica de leitura no modo somente leitura. | Conecte-se ao banco de dados em espera usando a entrada TNS e abra-o no modo somente leitura conectando-se a ele a partir do nó primário ou em espera.**Não CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 57 seconds ago)
DGMGRL> show database rdscdb_b;
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 2.00 KByte/s
Real Time Query: OFF
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL> edit database rdscdb_b set state=apply-off;
Succeeded.
DGMGRL> show database rdscdb_b;
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-OFF
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: (unknown)
Real Time Query: OFF
Instance(s):
RDSCDB
Database Status:
SUCCESS
$ sqlplus RDS_DATAGUARD@RDS_CUSTOM_ORCL_D as sysdg**CDB**
-bash-4.2$ sqlplus RDS_DATAGUARD@RDS_CUSTOM_ORCL_D as sysdg
SQL*Plus: Release 19.0.0.0.0 - Production on Fri Sep 30 23:00:14 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2020, Oracle. All rights reserved.
Enter password:
Last Successful login time: Fri Sep 30 2022 22:48:27 +00:00
Connected to:
Oracle Database 19c Enterprise Edition Release 19.0.0.0.0 - Production
Version 19.10.0.0.0
SQL> select open_mode from v$database;
OPEN_MODE
--------------------
MOUNTED
SQL> alter database open read only;
Database altered.
SQL> select open_mode from v$database;
OPEN_MODE
--------------------
READ ONLY
SQL>
-bash-4.2$ sqlplus C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B as sysdg| DBA | | Ative aplicação de redo na instância da réplica de leitura. | Ative aplicação de redo na instância da réplica de leitura usando `DGMGR`L do nó primário ou de espera.**Não CDB**
SQL*Plus: Release 19.0.0.0.0 - Production on Wed Jan 11 21:14:07 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2022, Oracle. All rights reserved.
Enter password:
Last Successful login time: Wed Jan 11 2023 21:12:05 +00:00
Connected to:
Oracle Database 19c Enterprise Edition Release 19.0.0.0.0 - Production
Version 19.16.0.0.0
SQL> select name,open_mode from v$database;
NAME OPEN_MODE
--------- --------------------
RDSCDB MOUNTED
SQL> alter database open read only;
Database altered.
SQL> select name,open_mode from v$database;
NAME OPEN_MODE
--------- --------------------
RDSCDB READ ONLY
SQL>
$ dgmgrl RDS_DATAGUARD@RDS_CUSTOM_ORCL_D**CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Fri Sep 30 23:02:16 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "ORCL_D"
Connected as SYSDG.
DGMGRL>
edit database orcl_d set state=apply-on;
DGMGRL> edit database orcl_d set state=apply-on;
Succeeded.
DGMGRL> show database orcl_d
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Average Apply Rate: 496.00 KByte/s
Real Time Query: ON
Instance(s):
ORCL
Database Status:
SUCCESS
DGMGRL>
-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B| DBA | ## Recursos relacionados + [Configurando o Amazon RDS como um PeopleSoft banco de dados Oracle (whitepaper](https://d1.awsstatic.com/whitepapers/configuring-amazon-rds-as-peoplesoft-database.pdf) da AWS) + [Guia do Oracle Data Guard Broker](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/index.html) (documentação de referência da Oracle) + [Conceitos e administração do Data Guard ](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/index.html)(Documentação de referência do Oracle) ## Mais informações **Selecione seu modo de proteção de banco de dados** O Oracle Data Guard fornece três modos de proteção para configurar seu ambiente Data Guard com base em seus requisitos de disponibilidade, proteção e desempenho. A tabela a seguir resume os três modos seguintes: | | | Modo de proteção | Configuração de transporte de redo | Description | | --- |--- |--- | | ***MÁXIMA PERFORMANCE*** | `ASYNC` | Para transações que acontecem no banco de dados principal, os dados de redo são transmitidos e gravados de forma assíncrona no redo log do banco de dados em espera. Portanto, o impacto no desempenho é mínimo.`MaxPerformance` não é possível fornecer RPO=0 devido ao envio assíncrono de log. | | ***PROTEÇÃO MÁXIMA*** | `SYNC+AFFIRM` | Para transações no banco de dados principal, os dados de redo são transmitidos e gravados de forma síncrona no redo log do banco de dados de espera no disco antes que a transação seja confirmada. Se o banco de dados em espera ficar indisponível, o banco de dados principal se desligará para garantir que as transações sejam protegidas. | | ***DISPONIBILIDADE MÁXIMA*** | `SYNC+AFFIRM` | Isso é semelhante ao modo `MaxProtection`, exceto quando nenhuma confirmação é recebida do banco de dados em espera. Nesse caso, ele opera como se estivesse no modo `MaxPerformance` para preservar a disponibilidade do banco de dados principal até que seja capaz de gravar seu fluxo de redo em um banco de dados em espera sincronizado novamente. | | `SYNC+NOAFFIRM` | Para transações no banco de dados principal, o redo é transmitido de forma síncrona para o banco de dados em espera, e o principal espera somente pela confirmação de que o redo foi recebido no de espera, não de ter sido gravado no disco auxiliar. Esse modo, também conhecido como `FastSync`, pode fornecer um benefício de desempenho em detrimento da exposição potencial à perda de dados em um caso especial de várias falhas simultâneas. | As réplicas de leitura no RDS Custom for Oracle são criadas com o modo de proteção de desempenho máximo, que também é o modo de proteção padrão para o Oracle Data Guard. O modo de desempenho máximo fornece o menor impacto no desempenho do banco de dados principal, o que pode ajudá-lo a atender ao requisito de objetivo de ponto de recuperação (RPO) medido em segundos. Para trabalhar para atingir um objetivo de zero perda de dados (RPO=0), você pode personalizar o modo de proteção do Oracle Data Guard para `MaxAvailability` com a configuração `SYNC+NOAFFIRM` de transporte de redo para melhor desempenho. Como as confirmações no banco de dados primário são reconhecidas somente depois que os vetores de redo correspondentes são transmitidos com sucesso para o banco de dados em espera, a latência da rede entre a instância primária e a réplica pode ser crucial para workloads sensíveis à confirmação. Recomendamos realizar testes de carga para sua workload para avaliar o impacto no desempenho quando a réplica de leitura é personalizada para ser executada no modo `MaxAvailability`. A implantação da réplica de leitura na mesma zona de disponibilidade do banco de dados principal fornece menor latência de rede em comparação com a implantação da réplica de leitura em uma zona de disponibilidade diferente. No entanto, a implantação das réplicas primária e de leitura na mesma zona de disponibilidade pode não atender aos requisitos de HA porque, no caso improvável de indisponibilidade da zona de disponibilidade, tanto a instância primária quanto a instância de réplica de leitura são afetadas. # Análise das dependências de objetos em migrações parciais de banco de dados da Oracle para o PostgreSQL *Anuradha Chintha, Amazon Web Services* ## Resumo Este padrão descreve a importância de identificar e gerenciar sistematicamente as dependências do sistema ao migrar parcialmente um banco de dados da Oracle para o Amazon Relational Database Service (Amazon RDS) ou para o Amazon Aurora compatível com PostgreSQL. Em uma migração parcial, apenas um subconjunto de objetos e dados do banco de dados original é migrado, enquanto o banco de dados de origem continua operando e atendendo às aplicações que dependem de componentes não migrados. É necessário identificar e analisar o escopo da migração ao lidar com bancos de dados de grande porte que contam com aplicações fortemente acopladas com dependências upstream e downstream. Para iniciar uma migração parcial, identifique os objetos do escopo, incluindo tabelas, acionadores, visualizações, procedimentos armazenados, funções e pacotes. O processo de identificação do escopo segue uma abordagem abrangente: + Os objetos de escopo de primeiro nível são identificados por meio de referências diretas no código da aplicação e em trabalhos críticos específicos de módulos. + Os objetos de segundo nível são obtidos por meio de uma análise abrangente de dependências. Ao compreender como as diversas partes do seu sistema se relacionam, é possível planejar de forma mais adequada a sequência correta para migrar os componentes do banco de dados e diminuir o risco de falhas na migração. A tabela a seguir lista os diferentes tipos de análise de dependências. | | | Tipo de análise | Áreas de foco | Finalidade | | --- |--- |--- | | Dependências de objetos | TabelasVisualizaçõesProcedimentos armazenadosFunçõesAcionadores | Identificar relacionamentos entre os objetos do banco de dados e suas estruturas hierárquicas | | Dependências de segmento | Relacionamentos de chave estrangeiraCadeias de chave primáriaReferências entre esquemas | Mapear os relacionamentos de dados e manter a integridade referencial | | Dependências de segurança | Permissões de usuárioHierarquias de perfisPrivilégios de objeto | Garantir a migração adequada do controle de acesso e a manutenção da segurança | | Padrões de acesso | Operações de leituraOperações de gravação | Determinar os padrões de interação com o banco de dados | Para manter a consistência entre os sistemas de origem e de destino, estabeleça mecanismos de sincronização de dados durante o período de transição. Além disso, é necessário modificar o código da aplicação e as funções para lidar com a distribuição de dados entre os bancos de dados de origem da Oracle e de destino do PostgreSQL. ## Pré-requisitos e limitações **Pré-requisitos ** + Um ativo Conta da AWS + Um banco de dados da Oracle (origem) + Um Amazon RDS ou Amazon Aurora compatível com PostgreSQL (destino) **Versões do produto** + Oracle 19c ou posterior + PostgreSQL 16 ou posterior ## Arquitetura **Pilha de tecnologia de origem** + Oracle 19c ou posterior **Pilha de tecnologias de destino** + Amazon RDS ou Amazon Aurora compatível com PostgreSQL **Arquitetura de destino** O diagrama apresentado a seguir ilustra o processo de migração de um banco de dados da Oracle on-premises para o Amazon RDS para Oracle, que envolve: + Identificação das dependências do banco de dados + Migrando código e objetos do banco de dados usando AWS Schema Conversion Tool ()AWS SCT + Migração de dados usando AWS Database Migration Service ()AWS DMS + Replicando mudanças contínuas por meio da captura de dados de alteração (CDC) usando AWS DMS Para obter mais informações, consulte [Integração AWS Database Migration Service com AWS Schema Conversion Tool](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_DMSIntegration.html) na AWS documentação. ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/90160825-3199-4382-95a8-ad63139c5c89/images/b09c36a4-27fa-412e-877e-57a31bcce0dc.png) ## Ferramentas **Serviços da AWS** + O [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) para Oracle ajuda você a configurar, operar e escalar um banco de dados relacional da Oracle na Nuvem AWS. + O Amazon Aurora é um mecanismo de banco de dados relacional totalmente gerenciado criado para a nuvem e compatível com o MySQL e o PostgreSQL. + AWS Schema Conversion Tool (AWS SCT) oferece suporte a migrações heterogêneas de bancos de dados convertendo automaticamente o esquema do banco de dados de origem e a maior parte do código personalizado em um formato compatível com o banco de dados de destino. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) ajuda você a migrar armazenamentos de dados para Nuvem AWS ou entre combinações de configurações na nuvem e no local. **Outros serviços** + O [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) é um ambiente de desenvolvimento integrado que simplifica o desenvolvimento e o gerenciamento de bancos de dados Oracle em implantações tradicionais e baseadas em nuvem. Para este padrão, você pode usar [SQL\$1Plus](https://docs.oracle.com/cd/B19306_01/server.102/b14357/qstart.htm). ## Práticas recomendadas Para obter as práticas recomendadas sobre provisionamento e migração de um banco de dados da Oracle, consulte [Best practices for migrating to Amazon RDS for Oracle](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html). ## Épicos ### Identificação das dependências de objetos | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma tabela de objetos. | Identifique os objetos que são essenciais para a funcionalidade da aplicação e crie uma tabela chamada `DEPENDENT_ANALYSIS_BASELINE`. Adicione registros para cada objeto na tabela. Para obter um exemplo, consulte a seção * Informações adicionais*. | Engenheiro de dados, DBA | | Crie um procedimento de banco de dados. | Crie um procedimento armazenado chamado `sp_object_dependency_analysis` para analisar as dependências de objetos nas duas direções (para frente e para trás) usando os dados da tabela `DBA_DEPENDENCIES`. Para obter um exemplo, consulte a seção * Informações adicionais*. | Engenheiro de dados, DBA | | Execute o procedimento. | Execute os scripts em cada nível sucessivo até que não sejam encontradas novas dependências de objetos. Todas as dependências e os níveis são armazenados na tabela `DEPENDENT_ANALYSIS_BASELINE`. | DBA, engenheiro de dados | ### Criação de um procedimento para dependências em nível de segmento | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma tabela de dependências. | Crie uma tabela de dependência em nível de segmento chamada `REFERENTIAL_ANALYSIS_BASELINE`. Quando todas as dependências em nível de objeto forem identificadas, verifique as tabelas principais de `DEPENDENT_ANALYSIS_BASELINE`, consultando a tabela `DBA_CONSTRAINT`.Exclua dependências em que as tabelas de referência da linha de base sejam mencionadas por outras tabelas. O preenchimento é responsável por tratar esses relacionamentos. A seguir, apresentamos um script de exemplo:
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 11 21:21:11 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_B"
Connected as SYSDG.
DGMGRL> edit database rdscdb_b set state=apply-on;
Succeeded.
DGMGRL> show database rdscdb_b
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Average Apply Rate: 35.00 KByte/s
Real Time Query: ON
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL> show database rdscdb_b
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 16.00 KByte/s
Real Time Query: ON
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL>
CREATE TABLE REFERENTIAL_ANALYSIS_BASELINE| Engenheiro de dados, DBA | | Crie um procedimento de banco de dados. | Crie um procedimento chamado `SP_OBJECT_REFERENTIAL_ANALYSIS` e gere uma análise referencial para todos os objetos identificados. Para obter um exemplo, consulte a seção * Informações adicionais*. | Engenheiro de dados, DBA | | Execute o procedimento. | Execute o procedimento para obter as dependências referenciais. Gere os detalhes do objeto de análise referencial em `REFERENTIAL_ANALYSIS_BASELINE`. | Engenheiro de dados, DBA | ### Identificação de objetos que realizam operações de leitura e gravação | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie tabelas para objetos de leitura e gravação. | Use o seguinte script para criar uma tabela de objetos de leitura chamada `TABLE_READ_OBJECT_DETAILS` e uma tabela de objetos de gravação chamada `TABLE_WRITE_OBJECT_DETAILS`:
(CHILD_OWNER VARCHAR2(50 BYTE),
CHILD_NAME VARCHAR2(100 BYTE),
PARENT_OWNER VARCHAR2(50 BYTE),
PARENT_NAME VARCHAR2(50 BYTE),
REFERENCE_PATH VARCHAR2(1000 BYTE));
CREATE TABLE TABLE_READ_OBJECT_DETAILS
(OWNER VARCHAR2(50 BYTE),
TAB_NAME VARCHAR2(50 BYTE),
READER_OWNER VARCHAR2(50 BYTE),
READER_NAME VARCHAR2(50 BYTE),
READER_TYPE VARCHAR2(50 BYTE));
CREATE TABLE TABLE_WRITE_OBJECT_DETAILS| Engenheiro de dados, DBA | | Crie um procedimento para análise. | Crie os procedimentos `SP_READER_OBJECTS_ANALYSIS` e `SP_WRITER_OBJECTS_ANALYSIS` para analisar, respectivamente, os objetos de leitura e de gravação. Esses procedimentos usam correspondência de padrões para encontrar objetos relacionados. Para obter um exemplo, consulte a seção *Informações adicionais*. | Engenheiro de dados, DBA | | Execute os procedimentos. | Execute esses procedimentos para identificar os objetos com dependência. | DBA, engenheiro de dados | ### Análise dos privilégios do banco de dados | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma tabela para analisar privilégios. | Crie uma tabela para analisar privilégios chamada `OBJECT_PRIVS_ANALYSIS`. Para capturar recursivamente os privilégios de objetos na tabela `DEPENDENT_ANALYSIS_BASELINE`, use o seguinte script:
(TABLE_NAME VARCHAR2(100 BYTE),
WRITEOBJ_OWNER VARCHAR2(100 BYTE),
WRITEOBJ_NAME VARCHAR2(100 BYTE),
WRITEOBJ_TYPE VARCHAR2(100 BYTE),
LINE VARCHAR2(100 BYTE),
TEXT VARCHAR2(4000 BYTE),
OWNER VARCHAR2(50 BYTE));
CREATE TABLE OBJECT_PRIVS_ANALYSIS| Engenheiro de dados, DBA | | Crie um procedimento para analisar privilégios. | Crie um procedimento chamado `SP_OBJECT_PRIVS_ANALYSIS`. Gere uma análise de privilégios para os objetos identificados. Para obter um exemplo, consulte a seção * Informações adicionais*. | DBA, engenheiro de dados | | Execute o procedimento. | Execute o procedimento para capturar os dados na tabela `OBJECT_PRIVS_ANALYSIS`. | DBA, engenheiro de dados | ## Solução de problemas | Problema | Solução | | --- | --- | | Não é possível acessar as tabelas do dicionário | Certifique-se de que o usuário que criou os objetos de análise consegue acessar as tabelas do DBA. | ## Recursos relacionados **Documentação da AWS** + [Documentação do Amazon RDS e do Aurora](https://docs.aws.amazon.com/rds/) + [Oracle database 19c to Amazon Aurora PostgreSQL migration playbook](https://docs.aws.amazon.com/dms/latest/oracle-to-aurora-postgresql-migration-playbook/chap-oracle-aurora-pg.html) + [O que é AWS Database Migration Service?](https://docs.aws.amazon.com/dms/latest/userguide/) + [What is the AWS Schema Conversion Tool?](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/) **Outras documentações** + [Oracle database objects](https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Database-Objects.html) ## Mais informações **Script para `DEPENDENT_ANALYSIS_BASELINE`** ``` CREATE TABLE DEPENDENT_ANALYSIS_BASELINE (OWNER VARCHAR2(128 BYTE) NOT NULL ENABLE, OBJECT_NAME VARCHAR2(128 BYTE) NOT NULL ENABLE, OBJECT_TYPE VARCHAR2(20 BYTE), DEPEDNCY_LEVEL NUMBER, PROJECT_NEED VARCHAR2(20 BYTE), CATAGORY VARCHAR2(4000 BYTE), COMMENTS VARCHAR2(4000 BYTE), CATAGORY1 CLOB, COMMENTS1 CLOB, CUSTOMER_COMMENTS VARCHAR2(1000 BYTE), BACKFILL_TO_GUS VARCHAR2(1000 BYTE), BACKFILL_NEAR_REAL_TIME_OR_BATCH VARCHAR2(1000 BYTE), PK_EXISTS VARCHAR2(3 BYTE), UI_EXISTS VARCHAR2(3 BYTE), LOB_EXISTS VARCHAR2(3 BYTE), MASTER_LINK VARCHAR2(100 BYTE), CONSTRAINT PK_DEPENDENT_ANALYSIS_BASELINE PRIMARY KEY (OWNER,OBJECT_NAME,OBJECT_TYPE)); ``` **Procedimento para `SP_WRITER_OBJECTS_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_WRITER_OBJECTS_ANALYSIS IS BEGIN EXECUTE IMMEDIATE 'TRUNCATE TABLE TABLE_WRITE_OBJECT_DETAILS'; FOR I IN (SELECT OWNER, OBJECT_NAME FROM DEPENDENT_ANALYSIS_BASELINE WHERE OBJECT_TYPE = 'TABLE') LOOP INSERT INTO TABLE_WRITE_OBJECT_DETAILS(OWNER, TABLE_NAME, WRITEOBJ_OWNER, WRITEOBJ_NAME, WRITEOBJ_TYPE, LINE, TEXT) SELECT DISTINCT I.OWNER, I.OBJECT_NAME, OWNER WRITEOBJ_OWNER, NAME, TYPE, LINE, TRIM(TEXT) FROM DBA_SOURCE WHERE UPPER(TEXT) LIKE '%' || I.OBJECT_NAME || '%' AND (UPPER(TEXT) LIKE '%INSERT%' || I.OBJECT_NAME || '%' OR UPPER(TEXT) LIKE '%UPDATE%' || I.OBJECT_NAME || '%' OR UPPER(TEXT) LIKE '%DELETE%' || I.OBJECT_NAME || '%' OR UPPER(TEXT) LIKE '%UPSERT%' || I.OBJECT_NAME || '%' OR UPPER(TEXT) LIKE '%MERGE%' || I.OBJECT_NAME || '%') AND UPPER(TEXT) NOT LIKE '%PROCEDURE%' AND UPPER(TEXT) NOT LIKE 'PROCEDURE%' AND UPPER(TEXT) NOT LIKE '%FUNCTION%' AND UPPER(TEXT) NOT LIKE 'FUNCTION%' AND UPPER(TEXT) NOT LIKE '%TRIGGER%' AND UPPER(TEXT) NOT LIKE 'TRIGGER%' AND UPPER(TRIM(TEXT)) NOT LIKE '%AFTER UPDATE%' AND UPPER(TRIM(TEXT)) NOT LIKE 'BEFORE UPDATE%' AND UPPER(TRIM(TEXT)) NOT LIKE 'BEFORE INSERT%' AND UPPER(TRIM(TEXT)) NOT LIKE 'AFTER INSERT%' AND UPPER(TRIM(TEXT)) NOT LIKE 'BEFORE DELETE%' AND UPPER(TRIM(TEXT)) NOT LIKE 'AFTER DELETE%' AND UPPER(TRIM(TEXT)) NOT LIKE '%GGLOGADM.GG_LOG_ERROR%' AND (TRIM(TEXT) NOT LIKE '/*%' AND TRIM(TEXT) NOT LIKE '--%' ) AND (OWNER, NAME, TYPE) IN (SELECT OWNER, NAME, TYPE FROM DBA_DEPENDENCIES WHERE REFERENCED_NAME = I.OBJECT_NAME); END LOOP; END; ``` **Script para `SP_READER_OBJECTS_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_READER_OBJECTS_ANALYSIS IS BEGIN EXECUTE IMMEDIATE 'TRUNCATE TABLE TABLE_READ_OBJECT_DETAILS'; FOR I IN (SELECT OWNER, OBJECT_NAME FROM DEPENDENT_ANALYSIS_BASELINE WHERE OBJECT_TYPE = 'TABLE') LOOP INSERT INTO TABLE_READ_OBJECT_DETAILS SELECT DISTINCT i.owner, i.object_name, owner, name, type FROM dba_dependencies WHERE referenced_name = I.OBJECT_NAME AND referenced_type = 'TABLE' AND type NOT IN ('SYNONYM', 'MATERIALIZED VIEW', 'VIEW') AND (owner, name, type) NOT IN ( SELECT DISTINCT owner, trigger_name, 'TRIGGER' FROM dba_triggers WHERE table_name = I.OBJECT_NAME AND table_owner = i.owner UNION ALL SELECT DISTINCT owner, name, type FROM dba_source WHERE upper(text) LIKE '%' || I.OBJECT_NAME || '%' AND (upper(text) LIKE '%INSERT %' || I.OBJECT_NAME || '%' OR upper(text) LIKE '%UPDATE% ' || I.OBJECT_NAME || '%' OR upper(text) LIKE '%DELETE %' || I.OBJECT_NAME || '%' OR upper(text) LIKE '%UPSERT %' || I.OBJECT_NAME || '%' OR upper(text) LIKE '%MERGE %' || I.OBJECT_NAME || '%') AND upper(text) NOT LIKE '%PROCEDURE %' AND upper(text) NOT LIKE 'PROCEDURE %' AND upper(text) NOT LIKE '%FUNCTION %' AND upper(text) NOT LIKE 'FUNCTION %' AND upper(text) NOT LIKE '%TRIGGER %' AND upper(text) NOT LIKE 'TRIGGER %' AND upper(trim(text)) NOT LIKE 'BEFORE INSERT %' AND upper(trim(text)) NOT LIKE 'BEFORE UPDATE %' AND upper(trim(text)) NOT LIKE 'BEFORE DELETE %' AND upper(trim(text)) NOT LIKE 'AFTER INSERT %' AND upper(trim(text)) NOT LIKE 'AFTER UPDATE %' AND upper(trim(text)) NOT LIKE 'AFTER DELETE %' AND (trim(text) NOT LIKE '/*%' AND trim(text) NOT LIKE '--%')); END LOOP; END; ``` **Script para `SP_OBJECT_REFERENTIAL_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_OBJECT_REFERENTIAL_ANALYSIS IS BEGIN EXECUTE IMMEDIATE 'TRUNCATE TABLE REFERENTIAL_ANALYSIS_BASELINE'; INSERT INTO REFERENTIAL_ANALYSIS_BASELINE WITH rel AS ( SELECT DISTINCT c.owner, c.table_name, c.r_owner r_owner, (SELECT table_name FROM dba_constraints WHERE constraint_name = c.r_constraint_name AND owner = c.r_owner) r_table_name FROM dba_constraints c WHERE constraint_type = 'R' AND c.owner NOT IN (SELECT username FROM dba_users WHERE oracle_maintained = 'Y') AND c.r_owner NOT IN (SELECT username FROM dba_users WHERE oracle_maintained = 'Y')), tab_list AS ( SELECT OWNER, object_name FROM DEPENDENT_ANALYSIS_BASELINE WHERE UPPER(OBJECT_TYPE) = 'TABLE') SELECT DISTINCT owner child_owner, table_name child, r_owner parent_owner, r_table_name parent, SYS_CONNECT_BY_PATH(r_table_name, ' -> ') || ' -> ' || table_name PATH FROM rel START WITH (r_owner, r_table_name) IN (SELECT * FROM tab_list) CONNECT BY NOCYCLE (r_owner, r_table_name) = ((PRIOR owner, PRIOR table_name)) UNION SELECT DISTINCT owner child_owner, table_name child, r_owner parent_owner, r_table_name parent, SYS_CONNECT_BY_PATH(table_name, ' -> ') || ' -> ' || r_table_name PATH FROM rel START WITH (owner, table_name) IN (SELECT * FROM tab_list) CONNECT BY NOCYCLE (owner, table_name) = ((PRIOR r_owner, PRIOR r_table_name)); END; ``` **Script para `SP_OBJECT_PRIVS_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_OBJECT_PRIVS_ANALYSIS IS V_SQL VARCHAR2(4000); V_CNT NUMBER; BEGIN V_SQL := 'TRUNCATE TABLE OBJECT_PRIVS_ANALYSIS'; EXECUTE IMMEDIATE V_SQL; FOR I IN (SELECT OWNER, OBJECT_NAME FROM DEPENDENT_ANALYSIS_BASELINE WHERE OBJECT_TYPE = 'TABLE') LOOP INSERT INTO OBJECT_PRIVS_ANALYSIS(OWNER, OBJECT_NAME, USER_NAME, PRIVS) WITH obj_to_role AS ( SELECT DISTINCT GRANTEE role_name, DECODE(privilege, 'SELECT', 'READ', 'REFERENCE', 'READ', 'INSERT', 'WRITE', 'UPDATE', 'WRITE', 'DELETE', 'WRITE', privilege) privs FROM DBA_TAB_PRIVS t, DBA_ROLES r WHERE OWNER = I.OWNER AND TYPE = 'TABLE' AND TABLE_NAME = I.OBJECT_NAME AND t.GRANTEE = r.ROLE AND r.ROLE IN (SELECT ROLE FROM DBA_ROLES WHERE ORACLE_MAINTAINED = 'N') ) SELECT I.OWNER, I.OBJECT_NAME, grantee, privs FROM ( -- Recursively Role to User mapping with privilege SELECT DISTINCT grantee, privs FROM (SELECT rp.granted_role, rp.grantee, privs, (SELECT DECODE(COUNT(*), 0, 'ROLE', 'USER') FROM (SELECT 'User' FROM DBA_users WHERE username = rp.GRANTEE)) grantee_type FROM DBA_role_privs rp, obj_to_role r WHERE rp.granted_role = r.role_name AND grantee IN ((SELECT USERNAME FROM DBA_USERS WHERE ORACLE_MAINTAINED = 'N') UNION (SELECT ROLE FROM DBA_ROLES WHERE ORACLE_MAINTAINED = 'N')) AND granted_role IN (SELECT ROLE FROM DBA_ROLES WHERE ORACLE_MAINTAINED = 'N') START WITH granted_role IN (SELECT DISTINCT role_name FROM obj_to_role) CONNECT BY granted_role = PRIOR grantee) WHERE grantee_type = 'USER' ) UNION ( -- Direct Object grants to User SELECT I.OWNER, I.OBJECT_NAME, GRANTEE, DECODE(privilege, 'SELECT', 'READ', 'REFERENCE', 'READ', 'INSERT', 'WRITE', 'UPDATE', 'WRITE', 'DELETE', 'WRITE', privilege) privs FROM DBA_TAB_PRIVS, DBA_USERS WHERE GRANTEE = USERNAME AND OWNER = I.OWNER AND TYPE = 'TABLE' AND TABLE_NAME = I.OBJECT_NAME ) ORDER BY 2 DESC; END LOOP; END; ``` **Procedimento para `SP_OBJECT_DEPENDENCY_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_OBJECT_DEPENDENCY_ANALYSIS (v_level NUMBER) IS TYPE typ IS RECORD ( schema VARCHAR2(100), obj_type VARCHAR2(100), obj_name VARCHAR2(100), path VARCHAR2(5000) ); TYPE array IS TABLE OF typ; l_data array; c SYS_REFCURSOR; l_errors NUMBER; l_errno NUMBER; l_msg VARCHAR2(4000); l_idx NUMBER; l_level NUMBER; BEGIN l_level := v_level + 1; OPEN c FOR WITH obj_list AS ( SELECT owner schema_name, object_type, object_name FROM DEPENDENT_ANALYSIS_BASELINE WHERE depedncy_level = v_level ), fw_dep_objects AS ( SELECT level lvl, owner, name, type, referenced_owner, referenced_name, referenced_type, SYS_CONNECT_BY_PATH(name, ' -> ') || ' -> ' || referenced_name PATH FROM dba_dependencies START WITH (owner, CASE WHEN type = 'PACKAGE BODY' THEN 'PACKAGE' ELSE type END, name) IN (SELECT schema_name, object_type, object_name FROM obj_list) CONNECT BY NOCYCLE (owner, type, name) = ((PRIOR referenced_owner, PRIOR referenced_type, PRIOR referenced_name)) ), bw_dep_objects AS ( SELECT level lvl, owner, name, type, referenced_owner, referenced_name, referenced_type, SYS_CONNECT_BY_PATH(name, ' <- ') || ' <- ' || referenced_name PATH FROM dba_dependencies START WITH (referenced_owner, CASE WHEN referenced_type = 'PACKAGE BODY' THEN 'PACKAGE' ELSE referenced_type END, referenced_name) IN (SELECT schema_name, object_type, object_name FROM obj_list) CONNECT BY NOCYCLE (referenced_owner, referenced_type, referenced_name) = ((PRIOR owner, PRIOR type, PRIOR name)) ) SELECT * FROM ( (SELECT DISTINCT referenced_owner schema, referenced_type obj_type, referenced_name obj_name, path FROM fw_dep_objects) UNION (SELECT DISTINCT owner schema, type obj_type, name obj_name, path FROM bw_dep_objects) ) WHERE schema IN (SELECT username FROM all_users WHERE oracle_maintained = 'N') ORDER BY obj_type; LOOP FETCH c BULK COLLECT INTO l_data LIMIT 100; BEGIN FORALL i IN 1..l_data.count SAVE EXCEPTIONS INSERT INTO DEPENDENT_ANALYSIS_BASELINE ( owner, object_name, object_type, catagory, depedncy_level, project_need, comments ) VALUES ( l_data(i).schema, l_data(i).obj_name, CASE WHEN l_data(i).obj_type = 'PACKAGE BODY' THEN 'PACKAGE' ELSE l_data(i).obj_type END, 'level ' || l_level || ' dependency', l_level, '', 'from dependency proc' || l_data(i).path ); EXCEPTION WHEN OTHERS THEN l_errors := sql%bulk_exceptions.count; FOR i IN 1..l_errors LOOP l_errno := sql%bulk_exceptions(i).error_code; l_msg := SQLERRM(-l_errno); l_idx := sql%bulk_exceptions(i).error_index; UPDATE DEPENDENT_ANALYSIS_BASELINE SET catagory1 = catagory1 || ', found in level' || l_level || ' dependent of ' || l_data(l_idx).path, comments1 = comments1 || ', from dependency proc exception ' || l_data(i).path WHERE owner = l_data(l_idx).schema AND object_name = l_data(l_idx).obj_name AND object_type = l_data(l_idx).obj_type; END LOOP; END; EXIT WHEN c%NOTFOUND; END LOOP; CLOSE c; END; ``` # Avaliar o desempenho das consultas para migrar bancos de dados do SQL Server para o MongoDB Atlas na AWS *Battulga Purevragchaa, Amazon Web Services* *Krishnakumar Sathyanarayana, EUA Inc PeerIslands * *Babu Srinivasan, MongoDB* ## Resumo Este padrão fornece orientação para carregar o MongoDB com dados quase reais e avaliar o desempenho das consultas do MongoDB o mais próximo possível do cenário de produção. A avaliação fornece informações para ajudar no planejamento de sua migração para o MongoDB a partir de um banco de dados relacional. O padrão usa o [Gerador PeerIslands de Dados de Teste e o Analisador de Desempenho](https://tools.peerislands.io/) para testar o desempenho da consulta. Esse padrão é particularmente útil para a migração do Microsoft SQL Server para o MongoDB, pois realizar transformações de esquema e carregar dados das instâncias atuais do SQL Server para o MongoDB pode ser muito complexo. Em vez disso, você pode carregar dados quase reais no MongoDB, entender o desempenho do MongoDB e ajustar o design do esquema antes de iniciar a migração efetiva. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Familiaridade com o [MongoDB Atlas](https://www.mongodb.com/docs/atlas/getting-started/) + Esquema do MongoDB de destino + Padrões de consulta típicos **Limitações** + Os tempos de carregamento de dados e o desempenho serão limitados pelo tamanho da instância do cluster MongoDB. Sugerimos que você escolha instâncias recomendadas para uso em produção para entender o desempenho no mundo real. + PeerIslands Atualmente, o Gerador de Dados de Teste e o Analisador de Desempenho oferecem suporte somente a consultas e cargas de dados on-line. O processamento em lote off-line (por exemplo, carregamento de dados no MongoDB usando conectores Spark) ainda não é compatível. + PeerIslands O gerador de dados de teste e o analisador de desempenho oferecem suporte às relações de campo dentro de uma coleção. Não é compatível com relacionamentos entre coleções. **Edições do produto** + Este padrão fornece suporte ao [MongoDB Atlas](https://www.mongodb.com/atlas) e ao [MongoDB Enterprise Advanced](https://www.mongodb.com/products/mongodb-enterprise-advanced). ## Arquitetura **Pilha de tecnologias de destino** + MongoDB Atlas ou MongoDB Enterprise Advanced **Arquitetura** ![\[Arquitetura voltada à análise da performance de consultas durante a migração de um banco de dados do SQL Server para o MongoDB Atlas na AWS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/25f0ab73-d587-4bd0-9fc0-ac675d5aa349/images/717caae4-d52e-4c78-bb7d-2ecb5acccd42.png) PeerIslands O gerador de dados de teste e o analisador de desempenho são criados usando Java e Angular e armazenam os dados gerados no Amazon Elastic Block Store (Amazon EBS). A ferramenta consiste em dois fluxos de trabalho: geração de dados de testes e testes de desempenho. + Na geração de dados de testes, você cria um modelo, que é a representação JSON do modelo de dados que precisa ser gerado. Depois de você criar o modelo, você pode gerar os dados em uma coleção de destino, conforme definido pela configuração de geração de carga. + Nos testes de desempenho, você cria um perfil. Um perfil é um cenário de teste de vários estágios em que você pode configurar operações de criação, leitura, atualização e exclusão (CRUD), pipelines de agregação, a ponderação de cada operação e a duração de cada estágio. Depois de criar o perfil, você pode executar testes de desempenho no banco de dados de destino com base na configuração. PeerIslands O Test Data Generator and Performance Analyzer armazena seus dados no Amazon EBS, para que você possa conectar o Amazon EBS ao MongoDB usando qualquer mecanismo de conexão compatível com o MongoDB, incluindo peering, listas de permissões e endpoints privados. Por padrão, a ferramenta não inclui componentes operacionais; no entanto, ela pode ser configurada com o Amazon Managed Service para Prometheus, Amazon Managed Grafana, Amazon e AWS Secrets Manager CloudWatch, se necessário. ## Ferramentas + PeerIslands O [gerador de dados de teste e o analisador de desempenho](https://tools.peerislands.io/) incluem dois componentes. O componente Test Data Generator ajuda você a gerar dados reais altamente específicos do cliente com base no esquema do MongoDB. A ferramenta é totalmente orientada por interface de usuário com uma rica biblioteca de dados e pode ser usada para gerar rapidamente bilhões de registros no MongoDB. A ferramenta também fornece recursos para implementar relacionamentos entre campos no esquema do MongoDB. O componente Performance Analyzer ajuda você a gerar consultas e agregações altamente específicas do cliente, além de realizar testes de desempenho realistas no MongoDB. Você pode usar o Performance Analyzer para testar o desempenho do MongoDB com perfis de carga avançados e consultas parametrizadas para seu caso de uso específico. ## Práticas recomendadas Consulte os recursos a seguir: + [Práticas recomendadas de design do esquema do MongoDB](https://www.mongodb.com/developer/products/mongodb/mongodb-schema-design-best-practices/) (site do desenvolvedor do MongoDB) + [Práticas recomendadas de implantação do MongoDB Atlas na AWS](https://www.mongodb.com/presentation/best-practices-of-deploying-mongodb-atlas-on-aws) (site do MongoDB) + [Conectando aplicativos com segurança a um plano de dados MongoDB Atlas com a AWS (publicação no blog da AWS](https://aws.amazon.com/blogs/apn/connecting-applications-securely-to-a-mongodb-atlas-data-plane-with-aws-privatelink/)) PrivateLink + [Guia de práticas recomendadas para desempenho do MongoDB ](https://www.mongodb.com/basics/best-practices)(site do MongoDB) ## Épicos ### Entender seus dados de origem | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Entenda o espaço ocupado pelo banco de dados da origem do SQL Server atual. | Entenda o espaço ocupado por seu SQL Server atual. Para isso, execute consultas no esquema `INFORMATION` do banco de dados. Determine o número de tabelas e o tamanho de cada uma delas. Analise o índice associado a cada tabela. Para obter mais informações sobre análise de SQL, consulte a postagem do blog [SQL2Mongo: Data Migration Journey](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) no PeerIslands site. | DBA | | Entenda o esquema de origem. | Determine o esquema da tabela e a representação comercial dos dados (por exemplo, códigos postais, nomes e moeda). Use seu diagrama de relacionamento de entidades (ER) existente ou gere o diagrama ER a partir do banco de dados existente. Para obter mais informações, consulte a postagem do blog [SQL2Mongo: Data Migration Journey](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) no PeerIslands site. | DBA | | Entenda os padrões de consulta. | Documente as dez principais consultas SQL que você usa. Você pode usar as tabelas **performance\$1schema.events\$1statements\$1summary\$1by\$1digest** que estão disponíveis no banco de dados para entender as principais consultas. Para obter mais informações, consulte a postagem do blog [SQL2Mongo: Data Migration Journey](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) no PeerIslands site. | DBA | | Entenda os compromissos de SLA. | Documente os contratos de nível de serviço (SLAs) de destino para operações de banco de dados. As medidas típicas incluem latência de consultas e consultas por segundo. As medidas e suas metas geralmente estão disponíveis em documentos de requisitos não funcionais (NFR). | DBA | ### Definir o esquema do MongoDB | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Defina o esquema de destino. | Defina várias opções para o esquema de destino do MongoDB. Para obter mais informações sobre [Esquemas](https://www.mongodb.com/docs/atlas/app-services/schemas/) consulte a documentação do MongoDB. Considere as práticas recomendadas e os padrões de design com base nas relações da tabela. | Engenheiro do MongoDB | | Defina padrões de consulta de destino. | Defina consultas e pipelines de agregação do MongoDB. Essas consultas são equivalentes às principais consultas que você registrou para seu workload do SQL Server. Para entender como estruturar pipelines de agregação do MongoDB, consulte a [documentação do MongoDB](https://www.mongodb.com/docs/manual/core/aggregation-pipeline/). | Engenheiro do MongoDB | | Defina o tipo de instância do MongoDB. | Determine o tamanho da instância que você planeja usar para testes. Para obter orientação, consulte a [Documentação do MongoDB](https://www.mongodb.com/docs/atlas/sizing-tier-selection/). | Engenheiro do MongoDB | ### Preparar o banco de dados de destino | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Configure o cluster MongoDB Atlas. | Para configurar um cluster MongoDB na AWS, siga as instruções na [documentação do MongoDB](https://www.mongodb.com/docs/atlas/tutorial/create-new-cluster/). | Engenheiro do MongoDB | | Criar usuários no banco de dados de destino. | Configure o cluster MongoDB Atlas para acesso e segurança de rede seguindo as instruções na [documentação do MongoDB](https://www.mongodb.com/docs/atlas/connect-to-database-deployment/). | Engenheiro do MongoDB | | Crie funções apropriadas na AWS e configure o controle de acesso baseado em funções para o Atlas. | Se necessário, configure usuários adicionais seguindo as instruções na [documentação do MongoDB](https://www.mongodb.com/docs/atlas/security/set-up-unified-aws-access/). Configure [a autenticação e a autorização](https://www.mongodb.com/docs/atlas/security/config-db-auth/) por meio de funções da AWS. | Engenheiro do MongoDB | | Configure o Compass para acesso ao MongoDB Atlas. | Configure o [utilitário de GUI do MongoDB Compass](https://www.mongodb.com/products/compass) para facilitar a navegação e o acesso. | Engenheiro do MongoDB | ### Configurar a carga base usando o Test Data Generator | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Instale o Test Data Generator. | Instale o [PeerIsland Test Data Generator](https://github.com/PeerIslands/loadgen_binary) em seu ambiente. | Engenheiro do MongoDB | | Configure o Test Data Generator para gerar os dados apropriados. | Crie um modelo usando a biblioteca de dados para gerar dados específicos para cada campo no esquema do MongoDB. Para obter mais informações, veja o vídeo [MongoDB Data Generator & Perf. Analyzer](https://vimeo.com/570068857). | Engenheiro do MongoDB | | Escale horizontalmente o Test Data Generator para gerar a carga necessária. | Use o modelo que você criou para iniciar a geração de carga em relação à coleção de destino configurando o paralelismo necessário. Determine os prazos e a escala para gerar os dados necessários. | Engenheiro do MongoDB | | Valide a carga no MongoDB Atlas. | Verifique os dados carregados no MongoDB Atlas. | Engenheiro do MongoDB | | Gere os índices necessários no MongoDB. | Defina índices conforme necessário, com base nos padrões de consulta. Para obter as melhores práticas, consulte a [documentação da MongoDB](https://www.mongodb.com/docs/manual/applications/indexes/). | Engenheiro do MongoDB | ### Realizar testes de desempenho | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Configure perfis de carga no Performance Analyzer. | Crie um perfil de teste de desempenho no Performance Analyzer configurando consultas específicas e sua ponderação correspondente, duração da execução do teste e estágios. Para obter mais informações, veja o vídeo [MongoDB Data Generator & Perf. Analyzer](https://vimeo.com/570068857). | Engenheiro do MongoDB | | Execute os testes de desempenho. | Use o perfil que você criou para iniciar o teste em relação à coleção de destino configurando o paralelismo necessário. Escale horizontalmente a ferramenta de teste de desempenho para executar consultas no MongoDB Atlas. | Engenheiro do MongoDB | | Registre os resultados dos testes. | Registre a latência P95 e P99 para as consultas. | Engenheiro do MongoDB | | Ajuste seu esquema e seus padrões de consulta. | Modifique índices e padrões de consulta para resolver quaisquer problemas de desempenho. | Engenheiro do MongoDB | ### Fechar o projeto | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Encerre os recursos temporários da AWS. | Exclua todos os recursos temporários que você usou para o Test Data Generator and Performance Analyzer. | Administrador da AWS | | Atualize os resultados dos testes de desempenho. | Entenda o desempenho de consultas do MongoDB e compare-o com o seu. SLAs Se necessário, ajuste o esquema do MongoDB e execute o processo novamente. | Engenheiro do MongoDB | | Conclua o projeto. | Feche o projeto e forneça feedback. | Engenheiro do MongoDB | ## Recursos relacionados + GitHub [repositório: S3toAtlas](https://github.com/mongodb-partners/S3toAtlas) + Esquema: [design do esquema do MongoDB](https://www.mongodb.com/developer/products/mongodb/mongodb-schema-design-best-practices/) + Pipelines de agregação: [pipelines de agregação do MongoDB](https://www.mongodb.com/docs/manual/core/aggregation-pipeline/) + Dimensionamento do MongoDB Atlas: [seleção de camadas de dimensionamento](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) + Vídeo: [Data Generator](https://vimeo.com/570068857) & Perf. Analyzer do MongoDB + Referências: [documentação do MongoDB](https://www.mongodb.com/docs/) + Tutoriais:** **[Guia do desenvolvedor do MongoDB, ](https://www.mongodb.com/docs/develop-applications/)[MongoDB Jumpstart](https://www.youtube.com/playlist?list=PL4RCxklHWZ9v2lcat4oEVGQhZg6r4IQGV) + AWS Marketplace:** **[MongoDB Atlas no AWS Marketplace](https://aws.amazon.com/marketplace/seller-profile?id=c9032c7b-70dd-459f-834f-c1e23cf3d092) + Soluções de parceiros da AWS:** **[ MongoDB Atlas na implantação de referência da AWS](https://aws.amazon.com/quickstart/architecture/mongodb-atlas/) Recursos adicionais: + [Análise SQL](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) + [Fóruns da comunidade de desenvolvedores do MongoDB](https://www.mongodb.com/community/forums/) + [Perguntas sobre ajuste de desempenho do MongoDB](https://www.mongodb.com/developer/products/mongodb/performance-tuning-tips/) + [Análise operacional com Atlas e Redshift](https://github.com/mongodb-partners/Atlas_to_Redshift) + [Modernização de aplicativos com o MongoDB Atlas e o AWS Elastic Beanstalk](https://github.com/mongodb-partners/MEANStack_with_Atlas_on_AWS_EB) # Automatize blue/green as implantações dos bancos de dados globais do Amazon Aurora usando os princípios de IaC *Ishwar Chauthaiwale, ANKIT JAIN e Ramu Jagini, Amazon Web Services* ## Resumo Gerenciar atualizações de bancos de dados, migrações ou esforços de escalabilidade pode ser um desafio para organizações que executam workloads críticas em [bancos de dados globais do Amazon Aurora](https://aws.amazon.com/rds/aurora/global-database/). Garantir que essas operações sejam realizadas sem interrupções, sem tempo de inatividade, é essencial para manter a disponibilidade do serviço e evitar interrupções para seus usuários. Uma estratégia de blue/green implantação oferece uma solução para esse desafio, permitindo que você execute dois ambientes idênticos simultaneamente: azul (o ambiente atual) e verde (o novo ambiente). Uma blue/green estratégia permite que você implemente mudanças, realize testes e alterne o tráfego entre ambientes com o mínimo de risco e tempo de inatividade. Esse padrão ajuda você a automatizar o processo de blue/green implantação dos bancos de dados globais do Aurora usando princípios de infraestrutura como código (IaC). Ele usa [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html), [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html), e o [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) para simplificar blue/green as implantações. Para melhorar a confiabilidade, ele usa identificadores de transação globais (GTIDs) para replicação. A replicação baseada em GTID fornece melhor consistência de dados e recursos de failover entre ambientes em comparação com a replicação de log binário (binlog). **nota** Este padrão pressupõe que você esteja usando um cluster de banco de dados global do Aurora edição compatível com MySQL do Aurora. Se você estiver usando o Aurora compatível com o PostgreSQL em vez disso, use os equivalentes PostgreSQL dos comandos do MySQL. Siga as etapas neste padrão para fazer o seguinte: + Provisione um banco de dados global Aurora verde: usando CloudFormation modelos, você cria um ambiente verde que reflete seu ambiente azul existente. + Configurar a replicação baseada em GTID: você configura a replicação GTID para manter os ambientes azul e verde sincronizados. + Alternar o tráfego sem problemas: você usa o Route 53 e o Lambda para alternar automaticamente o tráfego do ambiente azul para o verde após a sincronização completa. + Finalizar a implantação: você valida que o ambiente verde está totalmente operacional como banco de dados primário e, em seguida, interrompe a replicação e limpa todos os recursos temporários. A abordagem neste padrão fornece os seguintes benefícios: + Reduz o tempo de inatividade durante atualizações ou migrações críticas do banco de dados: a automação garante uma transição suave entre ambientes com o mínimo de interrupção do serviço. + Permite reversões rápidas: se surgir um problema depois que o tráfego for transferido para o ambiente verde, você poderá reverter rapidamente para o ambiente azul e manter a continuidade do serviço. + Melhora os testes e a verificação: o ambiente verde pode ser totalmente testado sem afetar o ambiente azul ativo, o que reduz a probabilidade de erros na produção. + Garante a consistência de dados: a replicação baseada em GTID mantém seus ambientes azul e verde sincronizados, o que evita perda de dados ou inconsistências durante a migração. + Mantém a continuidade dos negócios: automatizar suas blue/green implantações ajuda a evitar longas interrupções e perdas financeiras, mantendo seus serviços disponíveis durante atualizações ou migrações. ## Pré-requisitos e limitações **Pré-requisitos ** + Um ativo Conta da AWS. + Um cluster de banco de dados global de origem do Aurora compatível com MySQL (ambiente azul). Os bancos de dados globais fornecem uma configuração multirregional para alta disponibilidade e recuperação de desastres. Para obter instruções sobre como configurar um cluster de banco de dados global, consulte a [documentação do Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html). + [Replicação baseada em GTID](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) habilitada no cluster de origem. **Limitações** + Alguns Serviços da AWS não estão disponíveis em todos Regiões da AWS. Para conferir a disponibilidade de uma região, consulte [Serviços da AWS by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para endpoints específicos, consulte a página [Cotas e endpoints de serviços](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e clique no link correspondente ao serviço desejado. **Versões do produto** + Aurora compatível com MySQL 8.0 ou posterior ## Arquitetura ![\[Usar a replicação GTID para sincronizar ambientes azuis e verdes em diferentes regiões.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/19922266-c2e5-460b-9a0f-22e6d6736094/images/7a8c3095-7904-4080-906f-0c403c289a4f.png) O diagrama ilustra o seguinte: + Configuração de banco de dados global: um cluster de banco de dados global Aurora é implantado estrategicamente em dois. Regiões da AWS Essa configuração permite distribuição geográfica e redundância regional para recursos aprimorados de recuperação de desastres. + Replicação da região primária para a região secundária: o mecanismo de replicação lógica garante a sincronização perfeita dos dados da região primária para a região secundária. Essa replicação mantém a consistência de dados com latência mínima em distâncias geográficas. + Replicação baseada em GTID entre clusters: a replicação baseada em GTID mantém a consistência transacional e o fluxo de dados ordenado entre o cluster primário azul e o cluster primário verde e garante a sincronização confiável dos dados. + Replicação azul primária para secundária: a replicação lógica estabelece um pipeline de dados robusto entre o cluster principal azul e seu cluster secundário. Essa replicação permite a sincronização contínua de dados e a alta disponibilidade. + Configuração de DNS do Route 53: os registros da zona hospedada do Route 53 gerenciam a resolução de DNS para todos os endpoints do banco de dados de cluster azul e verde. Essa configuração fornece mapeamento contínuo de endpoints e permite o roteamento eficiente do tráfego durante cenários de failover. ## Ferramentas **Serviços da AWS** + O [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) é um mecanismo de banco de dados relacional totalmente gerenciado criado para a nuvem e compatível com o MySQL e o PostgreSQL. + [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)ajuda você a modelar e configurar seus AWS recursos para que você possa passar menos tempo gerenciando esses recursos e mais tempo se concentrando nos aplicativos que são executados em AWS. Você cria um modelo que descreve todos os AWS recursos que você deseja e se CloudFormation encarrega de provisionar e configurar esses recursos para você. + O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que permite a execução de código sem a necessidade de provisionar ou gerenciar servidores. O Lambda executa o código somente quando necessário e dimensiona automaticamente, desde algumas solicitações por dia até milhares por segundo. + O [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) é um serviço web de DNS altamente disponível e escalável. ## Práticas recomendadas [Recomendamos que você analise minuciosamente a AWS documentação para aprofundar sua compreensão da [estratégia de implantação azul/verde](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-overview.html), da [replicação baseada em GTID e das políticas de roteamento](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) ponderado no Route 53.](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) Esse conhecimento é crucial para implementar e gerenciar com eficácia suas migrações de banco de dados, garantindo a consistência de dados e otimizando o roteamento de tráfego. Ao obter uma compreensão abrangente desses AWS recursos e das melhores práticas, você estará mais bem equipado para lidar com futuras atualizações, minimizar o tempo de inatividade e manter um ambiente de banco de dados resiliente e seguro. Para obter diretrizes sobre como usar o Serviços da AWS para esse padrão, consulte a AWS documentação a seguir: + [Melhores práticas com o Amazon Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.BestPractices.html) + Práticas recomendadas [CloudFormation ](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/best-practices.html) + [Melhores práticas para trabalhar com AWS Lambda funções](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) + [Melhores práticas para o Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/best-practices.html) ## Épicos ### Criar o ambiente verde | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um backup snapshot do cluster azul. | Em uma blue/green implantação, o ambiente verde representa uma versão nova e idêntica do seu ambiente de banco de dados atual (azul). Você usa o ambiente verde para testar atualizações com segurança, validar alterações e garantir a estabilidade antes de mudar o tráfego de produção. Ele atua como um ponto de partida para a implementação de alterações no banco de dados com o mínimo de interrupção no ambiente ativo.Para criar um ambiente verde, primeiro você cria um snapshot do cluster primário (azul) em seu banco de dados global compatível com o Aurora MySQL. Esse snapshot serve como base para a criação do ambiente verde.Para criar um snapshot:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Como alternativa, você pode usar o AWS Command Line Interface (AWS CLI) para criar o instantâneo:
(OWNER VARCHAR2(50 BYTE),
OBJECT_NAME VARCHAR2(50 BYTE),
USER_NAME VARCHAR2(50 BYTE),
PRIVS VARCHAR2(50 BYTE));
aws rds create-db-cluster-snapshot --db-cluster-snapshot-identifier blue-green-demo --db-cluster-identifier ex-global-cluster --region eu-west-1Certifique-se de que o snapshot tenha concluído com êxito antes de prosseguir para a próxima etapa. | DBA | | Gere o CloudFormation modelo para seu banco de dados global e seus recursos. | O gerador CloudFormation IaC ajuda você a gerar CloudFormation modelos a partir de AWS recursos existentes. Use esse recurso para criar um CloudFormation modelo para seu banco de dados global atual compatível com o Aurora MySQL e seus recursos associados. Esse modelo configura grupos de sub-redes, grupos de segurança, grupos de parâmetros e outras configurações do.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html) | DBA | | Modifique o CloudFormation modelo para o ambiente verde. | Personalize o CloudFormation modelo para refletir as configurações do ambiente verde. Isso inclui atualizar nomes e identificadores de recursos para garantir que o ambiente verde opere independentemente do cluster azul.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Se você usar a propriedade `SnapshotIdentifier` para restaurar um cluster de banco de dados, evite especificar propriedades como `GlobalClusterIdentifier`, `MasterUsername` ou `MasterUserPassword`. | DBA | | Implante a CloudFormation pilha para criar recursos para o ambiente verde. | Nesta etapa, você implanta o CloudFormation modelo personalizado para criar os recursos para o ambiente verde.Para implantar a CloudFormation pilha:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)CloudFormation inicia o processo de criação de recursos ambientais verdes. Esse processo pode levar alguns minutos para ser concluído. | DBA | | Valide a CloudFormation pilha e os recursos. | Quando a implantação da CloudFormation pilha estiver concluída, você precisará verificar se o ambiente ecológico foi criado com sucesso:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Após a verificação, seu ambiente verde está pronto para configuração adicional, incluindo a replicação do ambiente azul. | DBA | ### Configurar a replicação baseada em GTID | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Verifique as configurações do GTID no cluster azul. | GTIDs forneça um método altamente confiável para replicar dados entre seus ambientes azul e verde. A [replicação baseada em GTID](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) oferece uma abordagem resiliente e simplificada ao atribuir um identificador exclusivo a cada transação no ambiente azul. Esse método garante que a sincronização de dados entre ambientes seja perfeita, consistente e mais fácil de gerenciar do que a replicação tradicional de binlogs.Antes de configurar a replicação, você precisa garantir que a replicação baseada em GTID esteja habilitada corretamente no cluster azul. Essa etapa garante que cada transação no ambiente azul seja rastreada de forma exclusiva e possa ser replicada no ambiente verde.Para confirmar se o GTID está habilitado:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Essas configurações permitem o rastreamento GTID para todas as transações futuras no ambiente azul. Depois de confirmar essas configurações, é possível começar a configurar a replicação. | DBA | | Crie um usuário de replicação. | Para replicar dados do ambiente azul para o ambiente verde, é necessário criar um usuário de replicação dedicado no cluster azul. Esse usuário será responsável por gerenciar o processo de replicação.Para configurar o usuário de replicação:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Agora, esse usuário tem as permissões necessárias para replicar dados entre os dois ambientes. | DBA | | Configurar a replicação baseada em GTID no cluster verde. | A próxima etapa é configurar o cluster verde para replicação baseada em GTID. Essa configuração garante que o ambiente verde espelhe continuamente todas as transações que acontecem no ambiente azul.Para configurar o cluster verde:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html) | DBA | | Inicie a replicação no cluster verde. | É possível iniciar o processo de replicação agora. No cluster verde, execute o comando:
START SLAVE;Isso permite que o ambiente verde comece a sincronizar dados e a receber e aplicar transações do ambiente azul. | DBA | | Verifique o processo de replicação. | Para verificar se o ambiente verde está replicando com precisão os dados do cluster azul:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Se todos os indicadores estiverem corretos, a replicação baseada em GTID funcionará sem problemas e o ambiente verde estará totalmente sincronizado com o ambiente azul. | DBA | ### Alternar o tráfego do cluster azul para o verde | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Configure as políticas de roteamento ponderado do Route 53. | Depois de verificar consistência de dados entre os ambientes azul e verde, é possível alternar o tráfego do cluster azul para o cluster verde. Essa transição deve ser suave, minimizar o tempo de inatividade e garantir a integridade do banco de dados da sua aplicação. Para atender a esses requisitos, você pode usar o Route 53 para roteamento de DNS e o Lambda para automatizar a troca de tráfego. Além disso, um plano de reversão bem definido garante que você possa reverter para o cluster azul em caso de problemas.A primeira etapa é configurar o roteamento ponderado no Route 53. O roteamento ponderado permite controlar a distribuição do tráfego entre os clusters azul e verde e transferir gradualmente o tráfego de um ambiente para outro.Para configurar o roteamento ponderado:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Para obter mais informações sobre políticas de roteamento ponderado, consulte a [documentação do Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html). | AWS DevOps | | Implante uma função do Lambda para monitorar o atraso na replicação. | Para garantir que o ambiente verde esteja totalmente sincronizado com o ambiente azul, implante uma função do Lambda que monitore o atraso na replicação entre os clusters. Essa função pode verificar o status da replicação, especificamente a métrica **Seconds\$1Behind\$1Master**, para determinar se o cluster verde está pronto para lidar com todo o tráfego.Veja abaixo um exemplo da função do Lambda que você pode usar:
import boto3Essa função verifica o atraso de replicação e retorna o valor. Se o atraso for zero, o cluster verde estará totalmente sincronizado com o cluster azul. | AWS DevOps | | Automatize o ajuste de peso do DNS usando o Lambda. | Quando o atraso de replicação chegar a zero, é hora de mudar todo o tráfego para o cluster verde. Você pode automatizar essa transição usando outra função do Lambda que ajusta os pesos do DNS no Route 53 para direcionar 100% do tráfego para o cluster verde.Veja abaixo um exemplo de uma função do Lambda que automatiza a troca de tráfego:
def check_replication_lag(event, context):
client = boto3.client('rds')
response = client.describe_db_instances(DBInstanceIdentifier='green-cluster-instance')
replication_status = response['DBInstances'][0]['ReadReplicaDBInstanceIdentifiers']
if replication_status:
lag = replication_status[0]['ReplicationLag']
return lag
return -1
import boto3Essa função verifica o atraso de replicação e atualiza os pesos do DNS do Route 53 quando o atraso é zero para mudar totalmente o tráfego para o cluster verde.** **Durante o processo de substituição, se o cluster azul tiver tráfego intenso de gravação, considere pausar temporariamente as operações de gravação durante a transição. Isso garante que a replicação seja atualizada e evita inconsistências de dados entre os clusters azul e verde. | AWS DevOps | | Verifique o interruptor de tráfego. | Depois que a função do Lambda ajustar os pesos do DNS, você deve verificar se todo o tráfego foi direcionado para o cluster verde e se a troca foi bem-sucedida.Para verificar:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Se tudo estiver funcionando conforme o esperado, a mudança de tráfego estará concluída. | AWS DevOps | | Se você encontrar algum problema, reverta as alterações. | Ter um plano de reversão é fundamental no caso de surgirem problemas após a mudança de tráfego. Veja como reverter rapidamente para o cluster azul, se necessário:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Ao implementar esse plano de reversão, você pode garantir o mínimo de interrupção para seus usuários no caso de problemas inesperados. | AWS DevOps | ### Validar e interromper a replicação baseada em GTID | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Interrompa a replicação baseada em GTID no cluster verde. | Depois de mudar o tráfego do ambiente azul para o ambiente verde, você deve validar o sucesso da transição e garantir que o cluster verde esteja funcionando conforme o esperado. Além disso, a replicação baseada em GTID entre os clusters azul e verde deve ser interrompida, porque o ambiente verde agora serve como banco de dados primário. A conclusão dessas tarefas garante que seu ambiente esteja seguro, simplificado e otimizado para operações contínuas.Para interromper a replicação:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Quando você interrompe a replicação, o cluster verde se torna totalmente independente e funciona como o ambiente do banco de dados primário para suas workloads. | DBA | | Limpe recursos. | A limpeza de todos os recursos temporários ou não utilizados que foram criados durante a migração do cluster azul para o verde garante que seu ambiente permaneça otimizado, seguro e econômico. A limpeza inclui ajustar as configurações de segurança, fazer backups finais e descomissionar recursos desnecessários.Para limpar recursos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)A limpeza dos recursos ajuda a manter um ambiente seguro e simplificado, reduz custos e garante que somente a infraestrutura necessária permaneça. | AWS DevOps | ## Recursos relacionados CloudFormation: + [CloudFormation Guia do usuário](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) + Práticas recomendadas [CloudFormation ](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/best-practices.html) + [Gerar modelos a partir de recursos existentes com o gerador de IaC](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/generate-IaC.html) + [Importar aplicativos inteiros para CloudFormation](https://aws.amazon.com/blogs/devops/import-entire-applications-into-aws-cloudformation/) (postagem AWS do blog) Amazon Aurora: + [Amazon Aurora Guia do usuário](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Welcome.html) + [Gerenciando um cluster de banco de dados Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_Aurora.html) Estratégia de implantações azul/verde: + [Visão geral das implantações do Amazon Aurora Blue/Green ](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-overview.html) Replicação baseada em GTID: + [Usar a replicação baseada em GTID](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) (documentação do Amazon RDS) AWS Lambda: + [AWS Lambda Guia do desenvolvedor](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) + [Melhores práticas para trabalhar com AWS Lambda funções](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) Amazon Route 53: + [Guia do desenvolvedor do Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) + [Roteamento ponderado](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) Ferramentas de cliente do MySQL: + [PyMYSQL](https://github.com/PyMySQL/PyMySQL) # Automatize a replicação de instâncias do Amazon RDS em Contas da AWS *Parag Nagwekar e Arun Chandapillai, Amazon Web Services* ## Resumo Esse padrão mostra como automatizar o processo de replicação, rastreamento e reversão de suas instâncias de banco de dados do Amazon Relational Database Service (Amazon RDS) em diferentes instâncias usando e. Contas da AWS AWS Step Functions AWS Lambda Você pode usar essa automação para realizar a replicação em larga escala de instâncias de banco de dados do RDS sem nenhum impacto no desempenho ou sobrecarga operacional, independentemente do tamanho da sua organização. Você também pode usar esse padrão para ajudar sua organização a cumprir as estratégias obrigatórias de governança de dados ou os requisitos de conformidade que exigem que seus dados sejam replicados e redundantes em diferentes e. Contas da AWS Regiões da AWS A replicação entre contas de dados do Amazon RDS em escala é um processo manual ineficiente e propenso a erros que pode ser caro e demorado, mas a automação nesse padrão pode ajudar você a obter a replicação entre contas com segurança, eficácia e eficiência. ## Pré-requisitos e limitações **Pré-requisitos ** + Dois Contas da AWS + Uma instância de banco de dados do RDS, ativa e em execução na origem Conta da AWS + Um grupo de sub-redes para a instância de banco de dados do RDS no destino Conta da AWS + Uma chave AWS Key Management Service (AWS KMS) criada na origem Conta da AWS e compartilhada com a conta de destino (para obter mais informações sobre os detalhes da política, consulte a seção [Informações adicionais](#automate-the-replication-of-amazon-rds-instances-across-aws-accounts-additional) desse padrão). + Um AWS KMS key no destino Conta da AWS para criptografar o banco de dados na conta de destino **Limitações** + Alguns Serviços da AWS não estão disponíveis em todos Regiões da AWS. Para conferir a disponibilidade de uma região, consulte [Serviços da AWS by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para endpoints específicos, consulte a página [Cotas e endpoints de serviços](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e clique no link correspondente ao serviço desejado. **Versões do produto** + Python 3.9 (usando) AWS Lambda + PostgreSQL 11.3, 13.x e 14.x ## Arquitetura **Pilha de tecnologia** + Amazon Relational Database Service (Amazon RDS) + Amazon Simple Notification Service (Amazon SNS) + AWS Key Management Service (AWS KMS) + AWS Lambda + AWS Secrets Manager + AWS Step Functions **Arquitetura de destino** O diagrama a seguir mostra uma arquitetura para usar o Step Functions para orquestrar a replicação agendada e sob demanda de instâncias de banco de dados do RDS de uma conta de origem (conta A) para uma conta de destino (conta B). ![\[Replicação de instâncias de banco de dados do Amazon RDS entre contas de origem e de destino usando o Step Functions.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/6310ad9b-1b1a-4a67-b684-ef605fef3e87/images/001550bb-cf6b-493d-9de9-0229a43753a1.png) Na conta de origem (conta A no diagrama), a máquina de estado Step Functions executa o seguinte: 1. Cria um snapshot da instância de banco de dados do RDS na conta A. 1. Copia e criptografa o snapshot com um AWS KMS key da conta A. Para garantir a criptografia em trânsito, o snapshot é criptografado, independentemente de a instância de banco de dados estar criptografada ou não. 1. Compartilha o snapshot do banco de dados com a conta B dando à conta B acesso ao snapshot. 1. Envia uma notificação para o tópico do SNS e, em seguida, o tópico do SNS invoca a função do Lambda na conta B. Na conta de destino (conta B no diagrama), a função do Lambda executa a máquina de estado Step Functions para orquestrar o seguinte: 1. Copia o instantâneo compartilhado da conta A para a conta B, enquanto usa o AWS KMS key da conta A para descriptografar os dados primeiro e depois criptografar os dados usando a conta B. AWS KMS key 1. Lê o segredo do Secrets Manager para capturar o nome da instância de banco de dados atual. 1. Restaura a instância de banco de dados do snapshot com um novo nome e padrão para o AWS KMS key Amazon RDS. 1. Lê o endpoint do novo banco de dados e atualiza o segredo no Secrets Manager com o novo endpoint do banco de dados e, em seguida, marca a instância de banco de dados anterior para que ela possa ser excluída posteriormente. 1. Mantém as N instâncias mais recentes dos bancos de dados e exclui todas as outras instâncias. ## Ferramentas **Serviços da AWS** + O [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) ajuda você a configurar, operar e escalar um banco de dados relacional na Nuvem AWS. + O [Amazon Simple Notification Service (Amazon SNS)](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) ajuda você a coordenar e gerenciar a troca de mensagens entre publicadores e clientes, incluindo servidores web e endereços de e-mail. + [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)ajuda você a configurar AWS recursos, provisioná-los de forma rápida e consistente e gerenciá-los durante todo o ciclo de vida em Contas da AWS e. Regiões da AWS + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) ajuda você a criar e controlar chaves criptográficas para ajudar a proteger seus dados. + O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que ajuda a executar código sem exigir provisionamento ou gerenciamento de servidores. Ele executa o código somente quando necessário e dimensiona automaticamente, assim, você paga apenas pelo tempo de computação usado. + [AWS SDK para Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html)é um kit de desenvolvimento de software que ajuda você a integrar seu aplicativo, biblioteca ou script Python com o. Serviços da AWS + O [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) ajuda a substituir credenciais codificadas, incluindo senhas, por uma chamada de API ao Secrets Manager para recuperar o segredo por programação. + [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html)é um serviço de orquestração sem servidor que ajuda você a combinar funções do Lambda e outras para criar aplicativos essenciais para os negócios. Serviços da AWS **Repositório de código** O código desse padrão está disponível no repositório GitHub [Crossaccount RDS Replication](https://github.com/aws-samples/aws-rds-crossaccount-replication). ## Épicos ### Automatize a replicação de instâncias de banco de dados do RDS Contas da AWS com um único clique | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Implante a CloudFormation pilha na conta de origem. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Administrador de nuvem, arquiteto de nuvem | | Implante a CloudFormation pilha na conta de destino. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Arquiteto de nuvem, DevOps engenheiro, administrador de nuvem | | Verificar a criação da instância de banco de dados do RDS na conta de destino. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Administrador de nuvem, arquiteto de nuvem, DevOps engenheiro | | Inscrever a função do Lambda no tópico do SNS. | Você deve executar os seguintes comandos AWS Command Line Interface (AWS CLI) para inscrever a função Lambda na conta de destino (conta B) no tópico SNS na conta de origem (conta A).Na conta A, execute o comando a seguir:
def switch_traffic(event, context):
route53 = boto3.client('route53')
lag = check_replication_lag(event, context)
if lag == 0:
response = route53.change_resource_record_sets(
HostedZoneId='YOUR_HOSTED_ZONE_ID',
ChangeBatch={
'Changes': [
{
'Action': 'UPSERT',
'ResourceRecordSet': {
'Name': 'db.example.com',
'Type': 'CNAME',
'SetIdentifier': 'GreenCluster',
'Weight': 100,
'TTL': 60,
'ResourceRecords': [{'Value': 'green-cluster-endpoint'}]
}
},
{
'Action': 'UPSERT',
'ResourceRecordSet': {
'Name': 'db.example.com',
'Type': 'CNAME',
'SetIdentifier': 'BlueCluster',
'Weight': 0,
'TTL': 60,
'ResourceRecords': [{'Value': 'blue-cluster-endpoint'}]
}
}
]
}
)
return response
aws sns add-permission \Na conta B, execute o comando a seguir:
--label lambda-access --aws-account-id\
--topic-arn\
--action-name Subscribe ListSubscriptionsByTopic
aws lambda add-permission \Na conta B, execute o comando a seguir:
--function-name\
--source-arn\
--statement-id function-with-sns \
--action lambda:InvokeFunction \
--principal sns.amazonaws.com
aws sns subscribe \| Administrador de nuvem, arquiteto de nuvem, DBA | | Sincronizar a instância de banco de dados do RDS da conta de origem com a conta de destino. | Iniciar a replicação do banco de dados sob demanda iniciando a máquina de estado Step Functions na conta de origem.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html)Um agendador está disponível para ajudar você a executar a replicação automaticamente, conforme o agendamento, mas esse recurso está desativado por padrão. Você pode encontrar o nome da CloudWatch regra da Amazon para o agendador na guia **Recursos** da CloudFormation pilha na conta de destino. Para obter instruções sobre como modificar a regra de CloudWatch eventos, consulte [Excluindo ou desabilitando uma regra de CloudWatch eventos](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Delete-or-Disable-Rule.html) na CloudWatch documentação. | Arquiteto de nuvem, DevOps engenheiro, administrador de nuvem | | Reverter seu banco de dados para qualquer uma das cópias anteriores quando necessário. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Administrador de nuvem, DBA, engenheiro DevOps | ## Recursos relacionados + [Cross-Region read replicas](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.CrossRegionReadReplicas.html) (documentação do Amazon RDS) + [Blue/Green Deployments](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.BlueGreenDeployments.html) (documentação do Amazon RDS) ## Mais informações Você pode usar o exemplo de política a seguir para compartilhar suas AWS KMS key informações Contas da AWS. ``` { "Version": "2012-10-17", "Id": "cross-account-rds-kms-key", "Statement": [ { "Sid": "Enable user permissions", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::
--protocol "lambda" \
--topic-arn\
--notification-endpoint
sqlcmd -S servername -U username -P password -i[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html)
| AWS DevOps, DBA | | Crie tarefas no Agendador de Tarefas. | Para criar uma tarefa no Agendador de Tarefas, use as seguintes etapas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html)Para executar a tarefa manualmente, clique com o botão direito na tarefa recém-criada e selecione **Executar**. | DBA | | Visualize o status da tarefa. | Para visualizar o status de uma tarefa no Agendador de Tarefas, use as seguintes etapas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html) | DBA, AWS DevOps | ### Automatize tarefas com AWS Lambda | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Implemente a solução. | Para implementar a solução deste padrão, use as seguintes etapas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html) | AWS DevOps, DevOps engenheiro | ## Solução de problemas | Problema | Solução | | --- | --- | | Problemas relacionados ao Lambda | Para obter ajuda com erros e problemas que você pode encontrar ao usar AWS Lambda, consulte [Solução de problemas no Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-troubleshooting.html) na AWS documentação. | ## Recursos relacionados + [Tipos de EC2 instância da Amazon](https://aws.amazon.com/ec2/instance-types/) + [AWS Lambda documentação](https://docs.aws.amazon.com/lambda/latest/dg/with-eventbridge-scheduler.html) + [AWS Lambda preços](https://aws.amazon.com/lambda/pricing/) + [Task Scheduler for developers](https://learn.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-start-page) (site da Microsoft) # Automatização do failover e do failback entre regiões usando o DR Orchestrator Framework *Jitendra Kumar, Pavithra Balasubramanian e Oliver Francis, Amazon Web Services* ## Resumo Este padrão descreve como usar o [DR Orchestrator Framework](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/dr-orchestrator-framework-overview.html) para a orquestração e a automatização das etapas manuais e propensas a erros, que são necessárias para realizar a recuperação de desastres entre regiões da Amazon Web Services (AWS). O padrão abrange os seguintes bancos de dados: + Amazon Relational Database Service (Amazon RDS) para MySQL, Amazon RDS para PostgreSQL ou Amazon RDS para MariaDB + Edição compatível com MySQL do Amazon Aurora ou Edição compatível com PostgreSQL do Amazon Aurora (usando um arquivo centralizado) + Amazon ElastiCache (Redis OSS) A fim de demonstrar o funcionamento do DR Orchestrator Framework, você deve criar duas instâncias ou dois clusters de banco de dados. O primário está no Região da AWS `us-east-1`, e o secundário está dentro`us-west-2`. Para criar esses recursos, você usa os AWS CloudFormation modelos na `App-Stack` pasta do GitHub repositório [aws-cross-region-dr-databases](https://github.com/aws-samples/aws-cross-region-dr-databases). ## Pré-requisitos e limitações **Pré-requisitos gerais** + Estrutura do DR Orchestrator implantada tanto no primário quanto no secundário Regiões da AWS + Dois buckets do [Amazon Simple Storage Service](https://aws.amazon.com/s3/) + Uma [nuvem privada virtual (VPC)](https://aws.amazon.com/vpc/) com duas sub-redes e um grupo de segurança AWS **Pré-requisitos específicos por mecanismo** + **Amazon Aurora** — Pelo menos um banco de dados global do Aurora deve estar disponível em dois. Regiões da AWS Você pode usar `us-east-1` como região primária e `us-west-2` como região secundária. + **Amazon ElastiCache (Redis OSS)** — Um armazenamento de dados ElastiCache global deve estar disponível em dois. Regiões da AWS Você pode `use us-east-1` como região primária e `us-west-2` como região secundária. **Limitações do Amazon RDS** + O DR Orchestrator Framework não verifica o atraso de replicação antes de executar um failover ou failback. O atraso de replicação deve ser verificado manualmente. + Esta solução foi testada usando uma instância de banco de dados primário com uma réplica de leitura. Se você desejar usar mais de uma réplica de leitura, teste a solução minuciosamente antes de implementá-la em um ambiente de produção. **Limitações do Aurora** + A disponibilidade e a compatibilidade de recursos variam entre versões específicas de cada mecanismo de banco de dados e entre Regiões da AWS. Para obter mais informações sobre a disponibilidade de recursos e regiões para a replicação entre regiões, consulte [Cross-Region read replicas](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.CrossRegionReadReplicas.html). + Os bancos de dados globais do Aurora têm requisitos de configuração específicos para as classes de instância de banco de dados Aurora suportadas e o número máximo de. Regiões da AWS Para obter mais informações, consulte [Configuration requirements of an Amazon Aurora Global Database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html#aurora-global-database.configuration.requirements). + Esta solução foi testada usando uma instância de banco de dados primário com uma réplica de leitura. Se você desejar usar mais de uma réplica de leitura, teste a solução minuciosamente antes de implementá-la em um ambiente de produção. **ElastiCache Limitações ** + Para obter informações sobre a disponibilidade regional para o armazenamento de dados global e os requisitos ElastiCache de configuração, consulte [Pré-requisitos e](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastores-Getting-Started.html) limitações na documentação. ElastiCache **Versões de produtos** do **Amazon RDS** O Amazon RDS é compatível com as seguintes versões de mecanismos: + **MySQL**: o Amazon RDS oferece suporte a instâncias de banco de dados que executam as seguintes versões do mecanismo [MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_MySQL.html): MySQL 8.0 e MySQL 5.7. + **PostgreSQL**: para obter informações sobre as versões compatíveis do Amazon RDS para PostgreSQL, consulte [Available PostgreSQL database versions](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html#PostgreSQL.Concepts.General.DBVersions). + **MariaDB**: o Amazon RDS oferece suporte a instâncias de banco de dados que executam as seguintes versões do mecanismo [MariaDB](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_MariaDB.html): + MariaDB 10.11 + MariaDB 10.6 + MariaDB 10.5 **Versões de produtos do Aurora** + A transição do Amazon Aurora Global Database requer o Aurora compatível com MySQL com compatibilidade para o mecanismo MySQL 5.7, versão 2.09.1 ou versões posteriores Para obter mais informações, consulte [Limitations of Amazon Aurora global databases](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html#aurora-global-database.limitations). **ElastiCache Versões do produto (Redis OSS)** A Amazon ElastiCache (Redis OSS) oferece suporte às seguintes versões do Redis: + Redis 7.1 (aprimorado) + Redis 7.0 (aprimorado) + Redis 6.2 (aprimorado) + Redis 6.0 (aprimorado) + Redis 5.0.6 (aprimorado) Para obter mais informações, consulte [Versões suportadas ElastiCache (Redis OSS).](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastores-Getting-Started.html) ## Arquitetura **Arquitetura do** **Amazon RDS** A arquitetura do Amazon RDS inclui os seguintes recursos: + A instância de banco de dados primária do Amazon RDS criada na região primária (`us-east-1`) com read/write acesso para clientes + Uma réplica de leitura do Amazon RDS, criada na região secundária (`us-west-2`), com acesso somente de leitura para clientes + O Framework DR Orchestrator implantado tanto na região primária quanto na região secundária ![\[Diagrama da arquitetura do RDS distribuída em duas regiões em uma única conta da AWS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/ad217033-600c-40da-929c-b9f9aecb4c2c.png) O diagrama mostra o seguinte: 1. Replicação assíncrona entre a instância primária e a instância secundária 1. Acesso de leitura e de gravação para clientes na região primária 1. Acesso somente de leitura para clientes na região secundária **Arquitetura do Aurora** A arquitetura do Amazon Aurora inclui os seguintes recursos: + O cluster de banco de dados principal do Aurora criado na região primária (`us-east-1`) com um endpoint de gravação ativo + Um cluster de banco de dados do Aurora criado na região secundária (`us-west-2`) com um endpoint de gravação inativo + O Framework DR Orchestrator implantado tanto na região primária quanto na região secundária ![\[Diagrama da implantação do Aurora em duas regiões em uma única conta da AWS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/524ec002-5aa7-47b2-8c8d-6d1a3b535e9e.png) O diagrama mostra o seguinte: 1. Replicação assíncrona entre o cluster primário e o cluster secundário 1. O cluster de banco de dados primário com um endpoint de gravação ativo 1. O cluster de banco de dados secundário com um endpoint de gravação inativo **ElastiCache Arquitetura (Redis OSS)** A arquitetura Amazon ElastiCache (Redis OSS) inclui os seguintes recursos: + Um armazenamento de dados global ElastiCache (Redis OSS) criado com dois clusters: 1. O cluster primário na região primária (`us-east-1`) 1. O cluster secundário na região secundária (`us-west-2`) + Um link da Amazon entre regiões com criptografia TLS 1.2 entre os dois clusters + O Framework DR Orchestrator implantado tanto na região primária quanto na região secundária ![\[Diagrama de uma ElastiCache implantação em duas regiões com o link entre regiões da Amazon.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/cf6620a0-dd42-4042-8dc2-012bf514ffc0.png) **Automação e escala** O DR Orchestrator Framework é escalável e oferece suporte ao failover ou failback de mais de um banco de dados em paralelo. AWS Você pode usar o seguinte código de carga útil para fazer o failover de vários AWS bancos de dados em sua conta. Neste exemplo, três AWS bancos de dados (dois bancos de dados globais, como o Aurora compatível com MySQL ou o Aurora PostgreSQL, e uma instância do Amazon RDS for MySQL) fazem o failover para a região de recuperação de desastres: ``` { "StatePayload": [ { "layer": 1, "resources": [ { "resourceType": "PlannedFailoverAurora", "resourceName": "Switchover (planned failover) of Amazon Aurora global databases (MySQL)", "parameters": { "GlobalClusterIdentifier": "!Import dr-globaldb-cluster-mysql-global-identifier", "DBClusterIdentifier": "!Import dr-globaldb-cluster-mysql-cluster-identifier" } }, { "resourceType": "PlannedFailoverAurora", "resourceName": "Switchover (planned failover) of Amazon Aurora global databases (PostgreSQL)", "parameters": { "GlobalClusterIdentifier": "!Import dr-globaldb-cluster-postgres-global-identifier", "DBClusterIdentifier": "!Import dr-globaldb-cluster-postgres-cluster-identifier" } }, { "resourceType": "PromoteRDSReadReplica", "resourceName": "Promote RDS for MySQL Read Replica", "parameters": { "RDSInstanceIdentifier": "!Import rds-mysql-instance-identifier", "TargetClusterIdentifier": "!Import rds-mysql-instance-global-arn" } } ] } ] } ``` ## Ferramentas **AWS serviços** + O [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) é um mecanismo de banco de dados relacional totalmente gerenciado criado para a nuvem e compatível com o MySQL e o PostgreSQL. + ElastiCacheA [Amazon](https://docs.aws.amazon.com/elasticache/) ajuda você a configurar, gerenciar e escalar ambientes distribuídos de cache na memória no Nuvem AWS. Esse padrão usa Amazon ElastiCache (Redis OSS). + O [AWS Lambda](https://aws.amazon.com/lambda/) é um serviço de computação que ajuda a executar código sem exigir provisionamento ou gerenciamento de servidores. Ele executa o código somente quando necessário e dimensiona automaticamente, assim, você paga apenas pelo tempo de computação usado. Nesse padrão, as funções Lambda são usadas AWS Step Functions para executar as etapas. + O [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) ajuda você a configurar, operar e escalar um banco de dados relacional na Nuvem AWS. Este padrão é compatível com Amazon RDS para MySQL, Amazon RDS para PostgreSQL e Amazon RDS para MariaDB. + [AWS SDK para Python (Boto3)](https://aws.amazon.com/sdk-for-python/)ajuda você a integrar seu aplicativo, biblioteca ou script Python com o. Serviços da AWS Nesse padrão, o Boto3 APIs é usado para se comunicar com as instâncias do banco de dados ou bancos de dados globais. + [AWS Step Functions](https://aws.amazon.com/step-functions/)é um serviço de orquestração sem servidor que ajuda você a combinar AWS Lambda funções e outras Serviços da AWS para criar aplicativos essenciais para os negócios. Neste padrão, máquinas de estado do Step Functions são usadas para realizar a orquestração e executar o failover e o failback entre regiões das instâncias de banco de dados ou de bancos de dados globais. **Repositório de código** O código desse padrão está disponível no repositório [aws-cross-region-dr-databases](https://github.com/aws-samples/aws-cross-region-dr-databases/tree/main/App-Stack) em. GitHub ## Épicos ### Instalação do DR Orchestrator Framework | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Clone o GitHub repositório. | Para clonar o repositório, execute o seguinte comando:
@echo off
sqlcmd -S [ServerName] -d [DatabaseName] -U username -P password -i "PathToSQLScript\Script.sql" -o "PathToOutput\Output.txt"
git clone https://github.com/aws-samples/aws-cross-region-dr-databases.git| AWS DevOps, administrador da AWS | | Empacote o código das funções do Lambda em um arquivo .zip. | Crie os arquivos de compactação das funções do Lambda para incluir as dependências do DR Orchestrator Framework:
cd| Administrador da AWS | | Crie os buckets do S3. | Os buckets do S3 são necessários para armazenar o DR Orchestrator Framework juntamente com a configuração mais recente. Crie dois buckets do S3, sendo um na região primária (`us-east-1`) e outro na região secundária (`us-west-2`):[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html)Substitua `xxxxxx` por um valor com randomização para tornar os nomes dos buckets exclusivos. | Administrador da AWS | | Crie sub-redes e grupos de segurança. | Tanto na região primária (`us-east-1`) quanto na região secundária (`us-west-2`), crie duas sub-redes e um grupo de segurança para a implantação da função do Lambda em sua VPC:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | Administrador da AWS | | Atualize os arquivos de parâmetros do DR Orchestrator. | Na pasta `/DR-Orchestration-artifacts
bash scripts/deploy-orchestrator-sh.sh
[| Administrador da AWS | | Faça o upload do código do DR Orchestrator Framework para o bucket do S3. | O código estará mais seguro em um bucket do S3 do que no diretório local. Faça o upload do diretório `DR-Orchestration-artifacts`, incluindo todos os arquivos e as subpastas, nos buckets do S3.Para fazer o upload do código, execute as seguintes etapas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | Administrador da AWS | | Faça a implantação do DR Orchestrator Framework na região primária. | Para implantar o DR Orchestrator Framework na região primária (`us-east-1`), execute os seguintes comandos:
{
"ParameterKey": "TemplateStoreS3BucketName",
"ParameterValue": "dr-orchestrator-xxxxxx-us-east-1"
},
{
"ParameterKey": "TemplateVPCId",
"ParameterValue": "vpc-xxxxxx"
},
{
"ParameterKey": "TemplateLambdaSubnetID1",
"ParameterValue": "subnet-xxxxxx"
},
{
"ParameterKey": "TemplateLambdaSubnetID2",
"ParameterValue": "subnet-yyyyyy"
},
{
"ParameterKey": "TemplateLambdaSecurityGroupID",
"ParameterValue": "sg-xxxxxxxxxx"
}
]
cd| Administrador da AWS | | Faça a implantação do DR Orchestrator Framework na região secundária. | Na região secundária (`us-west-2`), execute os seguintes comandos:/DR-Orchestration-artifacts/cloudformation
aws cloudformation deploy \
--region us-east-1 \
--stack-name dr-orchestrator \
--template-file Orchestrator-Deployer.yaml \
--parameter-overrides file://Orchestrator-Deployer-parameters-us-east-1.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cd| Administrador da AWS | | Verificar a implantação. | Se o CloudFormation comando for executado com êxito, ele retornará a seguinte saída:/DR-Orchestration-artifacts/cloudformation
aws cloudformation deploy \
--region us-west-2 \
--stack-name dr-orchestrator \
--template-file Orchestrator-Deployer.yaml \
--parameter-overrides file://Orchestrator-Deployer-parameters-us-west-2.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
Successfully created/updated stack - dr-orchestratorComo alternativa, você pode navegar até o CloudFormation console e verificar o status da `dr-orchestrator` pilha. | Administrador da AWS | ### Criação das instâncias ou dos clusters de banco de dados | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie as sub-redes e os grupos de segurança do banco de dados. | Na sua VPC, crie duas sub-redes e um grupo de segurança para a instância de banco de dados ou para o banco de dados global em ambas as regiões, primária (`us-east-1`) e secundária (`us-west-2`):[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | Administrador da AWS | | Atualize o arquivo de parâmetros da instância ou do cluster de banco de dados primário. | Na pasta `
{
"Parameters": {
"SubnetIds": "subnet-xxxxxx,subnet-xxxxxx",
"DBSecurityGroup": "sg-xxxxxxxxxx",
"MySqlGlobalIdentifier":"rds-mysql-instance",
"InitialDatabaseName": "mysqldb",
"DBPortNumber": "3789",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2",
"KMSKeyAliasName": "rds/rds-mysql-instance-KmsKeyId"
}
}
**Amazon Aurora** No arquivo `Aurora-MySQL-parameter-us-east-1.json`, atualize `SubnetIds` e `DBSecurityGroup` com os nomes dos recursos que você criou:{
"Parameters": {
"SubnetIds": "subnet1-xxxxxx,subnet2-xxxxxx",
"DBSecurityGroup": "sg-xxxxxxxxxx",
"GlobalClusterIdentifier":"dr-globaldb-cluster-mysql",
"DBClusterName":"dbcluster-01",
"SourceDBClusterName":"dbcluster-02",
"DBPortNumber": "3787",
"DBInstanceClass":"db.r5.large",
"InitialDatabaseName": "sampledb",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2",
"KMSKeyAliasName": "rds/dr-globaldb-cluster-mysql-KmsKeyId"
}
}**Amazon ElastiCache (Redis OSS)**No arquivo `ElastiCache-parameter-us-east-1.json`, atualize `SubnetIds` e `DBSecurityGroup` com os nomes dos recursos que você criou.{
"Parameters": {
"CacheNodeType": "cache.m5.large",
"DBSecurityGroup": "sg-xxxxxxxxxx",
"SubnetIds": "subnet-xxxxxx,subnet-xxxxxx",
"EngineVersion": "5.0.6",
"GlobalReplicationGroupIdSuffix": "demo-redis-global-datastore",
"NumReplicas": "1",
"NumShards": "1",
"ReplicationGroupId": "demo-redis-cluster",
"DBPortNumber": "3788",
"TransitEncryption": "true",
"KMSKeyAliasName": "elasticache/demo-redis-global-datastore-KmsKeyId",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2"
}
} | Administrador da AWS |
| Implante a instância ou o cluster de banco de dados na região primária. | Para implantar a instância ou o cluster na região primária (`us-east-1`), execute os comandos, apresentados a seguir, de acordo com o mecanismo de banco de dados que você está usando.**Amazon RDS**cd**Amazon Aurora**/App-Stack
aws cloudformation deploy \
--region us-east-1 \
--stack-name rds-mysql-app-stack \
--template-file RDS-MySQL-Primary.yaml \
--parameter-overrides file://RDS-MySQL-parameter-us-east-1.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cd**Amazon ElastiCache (Redis OSS)**/App-Stack
aws cloudformation deploy \
--region us-east-1 \
--stack-name aurora-mysql-app-stack \
--template-file Aurora-MySQL-Primary.yaml \
--parameter-overrides file://Aurora-MySQL-parameter-us-east-1.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cdVerifique se os CloudFormation recursos foram implantados com êxito. | Administrador da AWS | | Atualize o arquivo de parâmetros da instância ou do cluster de banco de dados secundário. | Na pasta `/App-Stack
aws cloudformation deploy \
--region us-east-1 --stack-name elasticache-ds-app-stack \
--template-file ElastiCache-Primary.yaml \
--parameter-overrides file://ElastiCache-parameter-us-east-1.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
{
"Parameters": {
"SubnetIds": "subnet-aaaaaaaaa,subnet-bbbbbbbbb",
"DBSecurityGroup": "sg-cccccccccc",
"MySqlGlobalIdentifier":"rds-mysql-instance",
"InitialDatabaseName": "mysqldb",
"DBPortNumber": "3789",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2",
"KMSKeyAliasName": "rds/rds-mysql-instance-KmsKeyId",
"PrimaryRegionKMSKeyArn":"arn:aws:kms:us-east-1:xxxxxxxxx:key/mrk-xxxxxxxxxxxxxxxxxxxxx"
}
} **Amazon Aurora**No arquivo `Aurora-MySQL-parameter-us-west-2.json`, atualize `SubnetIDs` e `DBSecurityGroup` com os nomes dos recursos que você criou. Atualize o `PrimaryRegionKMSKeyArn` com o valor de `AuroraKmsKeyId` obtido da seção **Saídas** da CloudFormation pilha para a instância de banco de dados primária:{
"Parameters": {
"SubnetIds": "subnet1-aaaaaaaaa,subnet2-bbbbbbbbb",
"DBSecurityGroup": "sg-cccccccccc",
"GlobalClusterIdentifier":"dr-globaldb-cluster-mysql",
"DBClusterName":"dbcluster-01",
"SourceDBClusterName":"dbcluster-02",
"DBPortNumber": "3787",
"DBInstanceClass":"db.r5.large",
"InitialDatabaseName": "sampledb",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2",
"KMSKeyAliasName": "rds/dr-globaldb-cluster-mysql-KmsKeyId"
}
}**Amazon ElastiCache (Redis OSS)**No arquivo `ElastiCache-parameter-us-west-2.json`, atualize `SubnetIDs` e `DBSecurityGroup` com os nomes dos recursos que você criou. Atualize o `PrimaryRegionKMSKeyArn` com o valor de `ElastiCacheKmsKeyId` obtido da seção **Saídas** da CloudFormation pilha para a instância de banco de dados primária:{
"Parameters": {
"CacheNodeType": "cache.m5.large",
"DBSecurityGroup": "sg-cccccccccc",
"SubnetIds": "subnet-aaaaaaaaa,subnet-bbbbbbbbb",
"EngineVersion": "5.0.6",
"GlobalReplicationGroupIdSuffix": "demo-redis-global-datastore",
"NumReplicas": "1",
"NumShards": "1",
"ReplicationGroupId": "demo-redis-cluster",
"DBPortNumber": "3788",
"TransitEncryption": "true",
"KMSKeyAliasName": "elasticache/demo-redis-global-datastore-KmsKeyId",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2"
}
} | Administrador da AWS |
| Implante a instância ou o cluster de banco de dados na região secundária. | Execute os comandos apresentados a seguir, de acordo com o seu mecanismo de banco de dados.**Amazon RDS**cd**Amazon Aurora**/App-Stack
aws cloudformation deploy \
--region us-west-2 \
--stack-name rds-mysql-app-stack \
--template-file RDS-MySQL-DR.yaml \
--parameter-overrides file://RDS-MySQL-parameter-us-west-2.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cd**Amazon ElastiCache (Redis OSS)**/App-Stack
aws cloudformation deploy \
--region us-west-2 \
--stack-name aurora-mysql-app-stack \
--template-file Aurora-MySQL-DR.yaml \
--parameter-overrides file://Aurora-MySQL-parameter-us-west-2.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cdVerifique se os CloudFormation recursos foram implantados com êxito. | Administrador da AWS | ## Recursos relacionados + [Estratégia de recuperação de desastres para bancos de dados em AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/strategy-database-disaster-recovery/welcome.html) (estratégia de orientação AWS prescritiva) + [Automatize sua solução de DR para bancos de dados relacionais em AWS(guia](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/dr-orchestrator-framework-overview.html) de orientação AWS prescritiva) + [Usar bancos de dados globais do Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html) + [Replicação Regiões da AWS usando datastores globais](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastore.html) + [Automatize sua solução de DR para bancos de dados relacionais em AWS(guia](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/introduction.html) de orientação AWS prescritiva) # Faça backup automático dos bancos de dados SAP HANA usando o Systems Manager e EventBridge *Ambarish Satarkar e Gaurav Rath, Amazon Web Services* ## Resumo Esse padrão descreve como automatizar os backups do banco de dados SAP HANA usando o AWS Systems Manager, a Amazon, o EventBridge Amazon Simple Storage Service (Amazon S3) e o AWS Backint Agent para SAP HANA. Esse padrão fornece uma abordagem baseada em shell script usando o comando `BACKUP DATA` e elimina a necessidade de manter scripts e configurações de tarefas para cada instância do sistema operacional (SO) em vários sistemas. | | | Observação: em abril de 2023, o AWS Backup anunciou suporte para bancos de dados SAP HANA no Amazon Elastic Compute Cloud (Amazon EC2). Para obter mais informações, consulte Bancos de [dados SAP HANA no backup de EC2 instâncias da Amazon](https://docs.aws.amazon.com/aws-backup/latest/devguide/backup-saphana.html).Com base nas necessidades da sua organização, você pode usar o serviço AWS Backup para fazer backup automático de seus bancos de dados SAP HANA ou usar esse padrão. | | --- | ## Pré-requisitos e limitações **Pré-requisitos ** + Uma instância existente do SAP HANA com uma versão compatível em estado de execução em uma instância gerenciada do Amazon Elastic Compute Cloud EC2 (Amazon) que está configurada para Systems Manager + Systems Manager Agent (SSM Agent) 2.3.274.0 ou mais recente instalado + Um bucket S3 que não tenha acesso público habilitado + Uma `hdbuserstore`chave nomeada `SYSTEM` + Um perfil do AWS Identity and Access Management (IAM) para o runbook de automação ser executado dentro da agenda + As políticas `AmazonSSMManagedInstanceCore` e `ssm:StartAutomationExecution` são anexadas ao perfil de serviço do Systems Manager Automation. **Limitações** + O AWS Backint Agent para SAP HANA não é compatível com a desduplicação. + O AWS Backint Agent para SAP HANA não é compatível com a compactação de dados. **Versões do produto** O AWS Backint Agent é compatível com os seguintes sistemas operacionais: + SUSE Linux Enterprise Server + SUSE Linux Enterprise Server para SAP + Red Hat Enterprise Linux para SAP O AWS Backint Agent oferece suporte aos seguintes bancos de dados: + SAP HANA 1.0 SP12 (nó único e vários nós) + SAP HANA 2.0 e mais recente (nó único e nós múltiplos) ## Arquitetura **Pilha de tecnologias de destino** + AWS Backint Agent + Amazon S3 + AWS Systems Manager + Amazon EventBridge + SAP HANA **Arquitetura de destino** O diagrama a seguir mostra os scripts de instalação que instalam o AWS Backint Agent, o bucket S3 e o Systems Manager EventBridge e, que usam um documento de comando para agendar backups regulares. ![\[Fluxo de trabalho para agendar backups regulares.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/0aa22a27-d100-483d-95f9-c3101f40402c/images/201d2b9a-b88e-4432-82cd-240b81da981e.png) **Automação e escala** + Vários AWS Backint Agents podem ser instalados usando um runbook do Systems Manager Automation. + Cada execução do runbook do Systems Manager pode ser escalada para um número *n* de instâncias do SAP HANA, com base na seleção de destinos. + EventBridge pode automatizar os backups do SAP HANA. ## Ferramentas + O [AWS Backint Agent for SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-sap-hana.html) é um aplicativo independente que se integra aos seus fluxos de trabalho existentes para fazer backup do seu banco de dados SAP HANA em um bucket S3 que você especifica no arquivo de configuração. O AWS Backint Agent oferece suporte a backups completos, incrementais e diferenciais de bancos de dados SAP HANA. Ele é executado em um servidor de banco de dados SAP HANA, onde backups e catálogos são transferidos do banco de dados SAP HANA para o AWS Backint Agent. + EventBridgeA [Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html) é um serviço de barramento de eventos sem servidor que você pode usar para conectar seus aplicativos a dados de várias fontes. EventBridge fornece um fluxo de dados em tempo real de seus aplicativos, aplicativos de software como serviço (SaaS) e serviços da AWS para destinos como funções do AWS Lambda, endpoints de invocação HTTP usando destinos de API ou barramentos de eventos em outras contas. + O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objeto. Você pode utilizar o Amazon S3 para armazenar e recuperar qualquer volume de dados, a qualquer momento, de qualquer lugar na web. + O [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) ajuda você a visualizar e controlar a infraestrutura na AWS. Usando o console do Systems Manager, você pode visualizar dados operacionais de vários serviços da AWS e automatizar tarefas operacionais nos recursos da AWS. **Código ** O código desse padrão está disponível no [aws-backint-automated-backup](https://github.com/aws-samples/aws-backint-automated-backup) GitHub repositório. ## Épicos ### Crie uma chave hdbuserstore SYSTEM | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma chave hdbuserstore. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html) | Administrador da AWS, administrador do SAP HANA | ### Instale o AWS Backint Agent | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Instale o AWS Backint Agent. | Siga as instruções em [Instalar e configurar o AWS Backint Agent para SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-installing-configuring.html) na documentação do AWS Backint Agent. | Administrador da AWS, administrador do SAP HANA | ### Crie um documento de comando do Systems Manager | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um documento de comando do Systems Manager. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html) | Administrador da AWS, administrador do SAP HANA | ### Agende backups com uma frequência regular | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Agende backups regulares usando a Amazon EventBridge. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html)Você pode verificar o sucesso do backup no caminho do bucket do S3./App-Stack
aws cloudformation deploy \
--region us-west-2 \
--stack-name elasticache-ds-app-stack \
--template-file ElastiCache-DR.yaml \
--parameter-overrides file://ElastiCache-parameter-us-west-2.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
s3:/Você também pode verificar os backups do catálogo de backup do SAP HANA. | Administrador da AWS, administrador do SAP HANA | ## Recursos relacionados + [AWS Backint Agent para SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-sap-hana.html) + [Instale e configure o AWS Backint Agent para SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-installing-configuring.html) # Geração automática de um modelo do PynamoDB e funções de CRUD para o Amazon DynamoDB por meio de uma aplicação do Python *Vijit Vashishtha, Dheeraj Alimchandani e Dhananjay Karanjkar, Amazon Web Services* ## Resumo É comum exigir entidades e funções para operações de criar, ler, atualizar e excluir (CRUD, na sigla em inglês) a fim de realizar operações no banco de dados do Amazon DynamoDB de maneira eficiente. O PynamoDB é uma interface baseada em Python que oferece suporte ao Python 3. Além disso, a interface oferece recursos como suporte a transações do Amazon DynamoDB, serialização e desserialização automáticas de valores de atributos e compatibilidade com estruturas populares do Python, como Flask e Django. Esse padrão auxilia desenvolvedores que usam o Python e o DynamoDB, oferecendo uma biblioteca que facilita a criação automática de modelos PynamoDB e de funções para operações de CRUD. Enquanto gera as funções de CRUD essenciais para tabelas de banco de dados, o padrão também pode reverter a engenharia de modelos do PynamoDB e de funções de CRUD usando tabelas do Amazon DynamoDB. Este padrão foi projetado para simplificar operações de banco de dados usando uma aplicação baseada em Python. Os principais recursos desta solução são os seguintes: + **Esquema JSON para um modelo do PynamoDB**: gere automaticamente modelos do PynamoDB em Python importando um arquivo de esquema JSON. + **Geração de funções de CRUD**: gere automaticamente funções para realizar operações de CRUD em tabelas do DynamoDB. + **Engenharia reversa usando o DynamoDB**: use o mapeamento objeto-relacional (ORM, na sigla em inglês) do PynamoDB para reverter engenharia de modelos do PynamoDB e de funções de CRUD para tabelas existentes do Amazon DynamoDB. ## Pré-requisitos e limitações **Pré-requisitos ** + Um ativo Conta da AWS + Python versão 3.8 ou versões posteriores, [baixado](https://www.python.org/downloads/) e instalado + Jinja2 na versão 3.1.2 ou em versões posteriores, [baixado](https://pypi.org/project/Jinja2/#files) e instalado + Tabelas do Amazon DynamoDB para as quais você deseja gerar o ORM + AWS Command Line Interface (AWS CLI), [instalado](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) e [configurado](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) + PynamoDB na versão 5.4.1 ou versões posteriores, [instalado](https://pynamodb.readthedocs.io/en/stable/tutorial.html#installation) ## Arquitetura **Pilha de tecnologias de destino** + Script JSON + Aplicação do Python + Modelo do PynamoDB + Instância de banco de dados do Amazon DynamoDB **Arquitetura de destino** ![\[Uso de uma aplicação do Python para gerar funções de CRUD e o modelo do PynamoDB usando as tabelas do DynamoDB.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/74cc4c73-5c8b-448d-98fb-b681cfa5f860/images/c2c367d6-d88a-4f49-8571-89160539eb08.png) 1. Você cria um arquivo de esquema JSON de entrada. Esse arquivo de esquema JSON representa os atributos das respectivas tabelas do DynamoDB das quais você deseja gerar modelos do PynamoDB e funções de CRUD. O arquivo contém as seguintes três chaves principais: + `name`: o nome da tabela de destino no DynamoDB. + `region`— O Região da AWS local onde a mesa está hospedada + `attributes`: os atributos que fazem parte da tabela de destino, como a [chave de partição](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey) (também conhecida como *atributo de hash*), [chave de classificação](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey), [índices secundários locais](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSI.html), [índices secundários globais](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html) e qualquer [atributo não relacionado à chave](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.TablesItemsAttributes). Esta ferramenta espera que o esquema de entrada forneça apenas os atributos não relacionados às chaves, pois a aplicação busca os atributos relacionados às chaves diretamente da tabela de destino. Para obter um exemplo de como especificar atributos para o arquivo de esquema JSON, consulte a seção [Informações adicionais](#automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application-additional) deste padrão. 1. Execute a aplicação do Python e forneça o arquivo de esquema JSON como entrada. 1. A aplicação do Python lê o arquivo de esquema JSON. 1. A aplicação do Python se conecta às tabelas do DynamoDB para derivar o esquema e os tipos de dados. A aplicação executa a operação [describe\$1table](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/describe_table.html) e busca os atributos de chave e de índice para a tabela. 1. A aplicação do Python combina os atributos do arquivo de esquema JSON com os da tabela do DynamoDB. Ele usa o mecanismo de modelos Jinja para gerar um modelo do PynamoDB e as funções de CRUD correspondentes. 1. Você acessa o modelo do PynamoDB para realizar operações de CRUD na tabela do DynamoDB. ## Ferramentas **Serviços da AWS** + O [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) é um serviço de banco de dados NoSQL totalmente gerenciado que fornece performance rápida, previsível e escalável. **Outras ferramentas** + O [Jinja](https://jinja.palletsprojects.com/en/) é um mecanismo de geração de modelos extensível que compila modelos em código Python otimizado. Este padrão usa o mecanismo Jinja para gerar conteúdo dinâmico com a incorporação de espaços reservados e de lógica nos modelos. + O [PynamoDB](https://pynamodb.readthedocs.io/en/stable/) é uma interface baseada em Python para o Amazon DynamoDB. + [Python](https://www.python.org/) é uma linguagem de programação de computador de uso geral. **Repositório de código** O código desse padrão está disponível no repositório de modelos [PyNamoDB de GitHub geração automática](https://github.com/aws-samples/amazon-reverse-engineer-dynamodb) e funções CRUD. O repositório é dividido em duas partes principais: o pacote de controle e os modelos. *Pacote de controle* O pacote Python de controle contém a lógica principal da aplicação, que ajuda a gerar o modelo do PynamoDB e as funções de CRUD. Ele contém o seguinte: + `input_json_validator.py`: este script em Python valida o arquivo de esquema JSON de entrada e cria os objetos Python que contêm a lista das tabelas de destino do DynamoDB e os atributos requeridos para cada uma. + `dynamo_connection.py`: este script estabelece uma conexão com a tabela do DynamoDB e emprega a operação `describe_table` para extrair os atributos necessários para criar o modelo do PynamoDB. + `generate_model.py`: este script contém a classe `GenerateModel` do Python, que cria o modelo do PynamoDB com base no arquivo de esquema JSON de entrada e na operação `describe_table`. + `generate_crud.py`: para as tabelas do DynamoDB especificadas no arquivo de esquema JSON, este script usa a operação `GenerateCrud` para criar as classes do Python correspondentes. *Modelos* Este diretório do Python contém os seguintes modelos do Jinja: + `model.jinja`: este modelo do Jinja contém a expressão de modelo para gerar o script do modelo do PynamoDB. + `crud.jinja`: este modelo do Jinja contém a expressão de modelo para gerar o script das funções de CRUD. ## Épicos ### Configurar o ambiente | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Clonar o repositório. | Digite o comando apresentado a seguir para clonar o repositório [Auto-generate PynamoDB models and CRUD functions](https://github.com/aws-samples/amazon-reverse-engineer-dynamodb)./ / /usr/sap/ /SYS/global/hdb/backint/DB_ /
git clone https://github.com/aws-samples/amazon-reverse-engineer-dynamodb.git| Desenvolvedor de aplicativos | | Configure o ambiente do Python. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Desenvolvedor de aplicativos | ### Geração do modelo do PynamoDB e das funções de CRUD | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Modifique o arquivo de esquema JSON. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Desenvolvedor de aplicativos | | Execute a aplicação do Python. | Digite o comando apresentado a seguir para gerar os modelos do PynamoDB e as funções de CRUD, substituindo `
python main.py --file| Desenvolvedor de aplicativos | ### Verificação do modelo do PynamoDB e das funções de CRUD | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Verifique o modelo do PynamoDB gerado. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Desenvolvedor de aplicativos | | Verifique as funções de CRUD geradas. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Desenvolvedor de aplicativos | ## Recursos relacionados + [Componentes principais do Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html) (documentação do DynamoDB) + [Melhorar o acesso aos dados com índices secundários no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) (documentação do DynamoDB) ## Mais informações **Atributos de amostra para o arquivo do esquema JSON** ``` [ { "name": "test_table", "region": "ap-south-1", "attributes": [ { "name": "id", "type": "UnicodeAttribute" }, { "name": "name", "type": "UnicodeAttribute" }, { "name": "age", "type": "NumberAttribute" } ] } ] ``` # Bloqueie o acesso público ao Amazon RDS usando o Cloud Custodian *Abhay Kumar e Dwarika Patra, Amazon Web Services* ## Resumo Muitas organizações executam suas cargas de trabalho e serviços em vários fornecedores de nuvem. Nesses ambientes de nuvem híbrida, a infraestrutura de nuvem precisa de uma governança rígida da nuvem, além da segurança fornecida pelos provedores de nuvem individuais. Um banco de dados na nuvem, por exemplo, Amazon Relational Database Service (Amazon RDS) é um serviço importante que deve ser monitorado para detectar quaisquer vulnerabilidades de acesso e permissão. Embora você possa restringir o acesso ao banco de dados do Amazon RDS configurando um grupo de segurança, você pode adicionar uma segunda camada de proteção para proibir ações como acesso público. Impedir o acesso público auxilia no atendimento aos requisitos do Regulamento Geral sobre a Proteção de Dados (GDPR, na sigla em inglês), da Health Insurance Portability and Accountability Act (HIPAA), do National Institute of Standards and Technology (NIST) e do Payment Card Industry Data Security Standard (PCI DSS). O Cloud Custodian é um mecanismo de regras de código aberto que você pode usar para aplicar restrições de acesso a recursos da Amazon Web Services (AWS), como o Amazon RDS. Com o Cloud Custodian, você pode definir regras que validam o ambiente em relação aos padrões definidos de segurança e conformidade. Você pode usar o Cloud Custodian para gerenciar seus ambientes de nuvem ajudando a garantir a conformidade com políticas de segurança, políticas de tags e coleta de resíduos de recursos não utilizados e gerenciamento de custos. Com o Cloud Custodian, você pode usar uma única interface para implementar a governança em um ambiente de nuvem híbrida. Por exemplo, você pode usar a interface do Cloud Custodian para interagir com o AWS Microsoft Azure, reduzindo o esforço de trabalhar com mecanismos como AWS Config grupos de AWS segurança e políticas do Azure. Esse padrão fornece instruções para usar o Cloud Custodian on para impor AWS a restrição de acessibilidade pública nas instâncias do Amazon RDS. ## Pré-requisitos e limitações **Pré-requisitos ** + Um ativo Conta da AWS + [Um par de chaves](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-creds-create) + AWS Lambda instalado ## Arquitetura O diagrama a seguir mostra o Cloud Custodian implantando a política AWS Lambda, AWS CloudTrail iniciando o `CreateDBInstance` evento e a configuração da função Lambda como falsa no Amazon RDS. `PubliclyAccessible` ![\[Uso do Cloud Custodian na AWS para restringir o acesso público às instâncias do Amazon RDS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/90f9537e-9365-4da2-8a28-da0ff374743c/images/6d04ca3b-6aa4-4c62-ade9-8b7474928c5e.png) ## Ferramentas **Serviços da AWS** + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html)ajuda você a auditar a governança, a conformidade e o risco operacional do seu Conta da AWS. + [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) é uma ferramenta de código aberto que ajuda você a interagir Serviços da AWS por meio de comandos em seu shell de linha de comando. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ajuda você a gerenciar com segurança o acesso aos seus AWS recursos controlando quem está autenticado e autorizado a usá-los. + O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que ajuda a executar código sem exigir provisionamento ou gerenciamento de servidores. Ele executa o código somente quando necessário e dimensiona automaticamente, assim, você paga apenas pelo tempo de computação usado. + O [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) ajuda você a configurar, operar e escalar um banco de dados relacional na Nuvem AWS. **Outras ferramentas** + O [Cloud Custodian](https://cloudcustodian.io/) unifica as ferramentas e os scripts que muitas organizações usam para gerenciar suas contas de nuvem pública em uma ferramenta de código aberto. Ele usa um mecanismo de regras sem estado para definição e aplicação de políticas, com métricas, resultados estruturados e relatórios detalhados para a infraestrutura de nuvem. Ele se integra perfeitamente a um runtime de tecnologia sem servidor para fornecer remediação e resposta em tempo real com baixa sobrecarga operacional. ## Épicos ### Configure o AWS CLI | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Instale AWS CLI o. | Para instalar o AWS CLI, siga as instruções na [AWS documentação](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html). | Administrador da AWS | | Configure as AWS credenciais. | Defina as configurações que ele AWS CLI usa para interagir AWS, incluindo o formato de saída Região da AWS e o que você deseja usar.
$>aws configurePara obter mais informações, consulte a [documentação do AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html). | Administrador da AWS | | Criar um perfil do IAM. | Para criar um perfil do IAM com a função de execução do Lambda, execute o comando a seguir.
AWS Access Key ID [None]:
AWS Secret Access Key [None]:
Default region name [None]:
Default output format [None]:
aws iam create-role --role-name lambda-ex --assume-role-policy-document '{"Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Principal": {"Service": "lambda.amazonaws.com"}, "Action": "sts:AssumeRole"}]} | AWS DevOps |
### Configurar o Cloud Custodian
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Instale o Cloud Custodian. | Para instalar o Cloud Custodian em seu sistema operacional e ambiente, siga as instruções na [documentação do Cloud Custodian](https://cloudcustodian.io/docs/quickstart/index.html#install-cc). | DevOps engenheiro |
| Verifique o esquema do Cloud Custodian. | Para ver a lista completa dos recursos do Amazon RDS com os quais você pode executar políticas, use o comando a seguir.custodian schema aws.rds| DevOps engenheiro | | Crie a política do Cloud Custodian. | Salve o código que está no *arquivo de política do Cloud Custodian* na seção [Informações adicionais](#block-public-access-to-amazon-rds-by-using-cloud-custodian-additional) usando uma extensão YAML. | DevOps engenheiro | | Defina as ações do Cloud Custodian para alterar a bandeira de acesso público. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/block-public-access-to-amazon-rds-by-using-cloud-custodian.html) | DevOps engenheiro | | Execute uma simulação. | (Opcional) Para verificar quais recursos são identificados pela política sem executar nenhuma ação nos recursos, use o comando a seguir.
custodian run -dryrun| DevOps engenheiro | ### Implante a política | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Implante a política usando o Lambda. | Para criar a função do Lambda que executará a política, use o comando a seguir..yaml -s
custodian run -s policy.yamlEssa política será então iniciada pelo AWS CloudTrail `CreateDBInstance` evento.Como resultado, AWS Lambda definirá o sinalizador de acesso público `false` para instâncias que correspondam aos critérios. | DevOps engenheiro | ## Recursos relacionados + [AWS Lambda site](https://aws.amazon.com/lambda/) + [Site do Amazon RDS](https://aws.amazon.com/rds/) + [Documentação do Cloud Custodian](https://cloudcustodian.io/docs/quickstart/index.html) ## Mais informações **Arquivo YAML da política do Cloud Custodian** ``` policies: - name: "block-public-access" resource: rds description: | This Enforcement blocks public access for RDS instances. mode: type: cloudtrail events: - event: CreateDBInstance # Create RDS instance cloudtrail event source: rds.amazonaws.com ids: requestParameters.dBInstanceIdentifier role: arn:aws:iam::1234567890:role/Custodian-compliance-role filters: - type: event key: 'detail.requestParameters.publiclyAccessible' value: true actions: - type: set-public-access state: false ``` **arquivo rds.py de atributos c7n** ``` @actions.register('set-public-access') class RDSSetPublicAvailability(BaseAction): schema = type_schema( "set-public-access", state={'type': 'boolean'}) permissions = ('rds:ModifyDBInstance',) def set_accessibility(self, r): client = local_session(self.manager.session_factory).client('rds') waiter = client.get_waiter('db_instance_available') waiter.wait(DBInstanceIdentifier=r['DBInstanceIdentifier']) client.modify_db_instance( DBInstanceIdentifier=r['DBInstanceIdentifier'], PubliclyAccessible=self.data.get('state', False)) def process(self, rds): with self.executor_factory(max_workers=2) as w: futures = {w.submit(self.set_accessibility, r): r for r in rds} for f in as_completed(futures): if f.exception(): self.log.error( "Exception setting public access on %s \n %s", futures[f]['DBInstanceIdentifier'], f.exception()) return rds ``` **Integração com o CSPM do Security Hub** O Cloud Custodian pode ser integrado ao [AWS Security Hub CSPM](https://aws.amazon.com/security-hub/) para enviar descobertas de segurança e executar ações de correção. Para obter mais informações, consulte [Anunciando a integração do Cloud Custodian](https://aws.amazon.com/blogs/opensource/announcing-cloud-custodian-integration-aws-security-hub/) com. AWS Security Hub CSPM # Configurar a autenticação do Windows para Amazon RDS para Microsoft SQL Server usando AWS Managed Microsoft AD *Ramesh Babu Donti, Amazon Web Services* ## Resumo Esse padrão mostra como configurar a autenticação do Windows para um Amazon Relational Database Service (Amazon RDS) para instâncias do SQL Server AWS Directory Service for Microsoft Active Directory usando AWS Managed Microsoft AD(). A autenticação do Windows permite que os usuários se conectem à instância do RDS usando as credenciais de domínio, em vez de nomes de usuário e senhas específicos do banco de dados. É possível habilitar a autenticação do Windows tanto ao criar um novo banco de dados SQL Server do RDS quanto ao adicioná-la a uma instância de banco de dados existente. A instância do banco de dados se integra AWS Managed Microsoft AD para fornecer autenticação e autorização centralizadas para usuários do domínio que acessam o banco de dados do SQL Server. Esta configuração aprimora a segurança ao aproveitar a infraestrutura existente do Active Directory e elimina a necessidade de gerenciar credenciais de banco de dados separadas para os usuários de domínio. ## Pré-requisitos e limitações **Pré-requisitos ** + Um ativo Conta da AWS com as permissões apropriadas + Uma nuvem privada virtual (VPC) com os seguintes recursos: + Gateways da internet e tabelas de rotas configurados + Gateways NAT em sub-redes públicas (se o acesso à internet for necessário para as instâncias) + AWS Identity and Access Management Funções (IAM): + Uma função de domínio com as seguintes políticas AWS gerenciadas: + `AmazonSSMManagedInstanceCore`para habilitar AWS Systems Manager + `AmazonSSMDirectoryServiceAccess` para fornecer permissões para adicionar instâncias aos diretórios + Um perfil de monitoramento aprimorado do RDS (se o monitoramento aprimorado estiver habilitado) + Grupos de segurança: + Grupo de segurança do serviço de diretório para permitir as portas de comunicação do Active Directory + Um grupo de segurança da Amazon Elastic Compute Cloud (Amazon EC2) para permitir comunicações por RDP `3389` e domínio + Um grupo de segurança do RDS para permitir a porta `1433` do SQL Server de fontes autorizadas + Conectividade de rede: + Resolução de DNS adequada e conectividade de rede entre sub-redes **Limitações** + Para obter informações sobre Regiões da AWS esse suporte AWS Managed Microsoft AD com o RDS para SQL Server, consulte [Disponibilidade de região e versão](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerWinAuth.html#USER_SQLServerWinAuth.RegionVersionAvailability). + Alguns Serviços da AWS não estão disponíveis em todos Regiões da AWS. Para conferir a disponibilidade de uma região, consulte [Serviços da AWS by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para endpoints específicos, consulte a página [Cotas e endpoints de serviços](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e clique no link correspondente ao serviço desejado. ## Arquitetura **Pilha de tecnologia de origem** + Um Active Directory local ou AWS Managed Microsoft AD **Pilha de tecnologias de destino** + Amazon EC2 + Amazon RDS para Microsoft SQL Server + AWS Managed Microsoft AD **Arquitetura de destino** ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/e02f6059-6631-46f6-819c-5961af7ba4ae/images/1aa50e3b-b4f6-4d44-9f9e-6cbb248a159c.png) A arquitetura inclui o seguinte: + Uma função do IAM que une a EC2 instância da Amazon ao AWS Managed Microsoft AD domínio. + Uma instância EC2 do Amazon Windows para administração e teste de banco de dados. + Uma Amazon VPC com uma sub-rede privada para hospedar a instância do Amazon RDS e recursos internos entre zonas de disponibilidade. + Grupos de segurança para controle de acesso à rede: + Um grupo de segurança do Amazon RDS para controlar o acesso de entrada à porta `1433` do SQL Server proveniente de fontes autorizadas. + Um grupo EC2 de segurança da Amazon para gerenciar o acesso RDP por meio de portas `3389` e portas de comunicação de domínio. + Um grupo de segurança do Directory Services para comunicações do Active Directory pelas portas `53`, `88`, `389` e `445`. + AWS Managed Microsoft AD para fornecer serviços centralizados de autenticação e autorização para recursos do Windows. + Uma instância de banco de dados do Amazon RDS para SQL Server na sub-rede privada com autenticação do Windows habilitada. ## Ferramentas **Serviços da AWS** + [O Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) fornece capacidade de computação escalável no. Nuvem AWS Você poderá iniciar quantos servidores virtuais precisar e escalá-los na vertical rapidamente. + O Amazon Relational Database Service (Amazon RDS) ajuda você a configurar, operar e escalar um banco de dados relacional na Nuvem AWS. + [AWS Directory Service](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/what_is.html)fornece várias maneiras de usar o Microsoft Active Directory (AD) com outros Serviços da AWS , como Amazon Elastic Compute Cloud (Amazon EC2), Amazon Relational Database Service (Amazon RDS) para SQL Server e FSx Amazon para Windows File Server. + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)permite que suas cargas de trabalho e AWS recursos com reconhecimento de diretório usem o Microsoft Active Directory no. Nuvem AWS + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ajuda você a gerenciar com segurança o acesso aos seus AWS recursos controlando quem está autenticado e autorizado a usá-los. **Outros serviços** + O [Microsoft SQL Server Management Studio (SSMS)](https://learn.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms) é uma ferramenta para gerenciar o SQL Server, incluindo acesso, configuração e administração de componentes do SQL Server. ## Práticas recomendadas + Para obter as práticas recomendadas gerais, consulte [Práticas recomendadas do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_BestPractices.html). ## Épicos ### Configure AWS Managed Microsoft AD | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Configure o tipo de diretório. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Configure as informações do diretório. | Na seção **Informações do diretório**, insira as informações obrigatórias e mantenha os valores opcionais:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Configure a VPC e as sub-redes. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Analise e crie o diretório. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | ### Crie e configure uma EC2 instância da Amazon | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Configure uma AMI para Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Definir configurações de rede. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Configure o armazenamento. | Configure os volumes do Amazon EBS conforme necessário. | DBA, engenheiro DevOps | | Configure os detalhes avançados e inicie a instância. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | ### Criação e configuração do RDS para SQL Server com autenticação do Windows | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um banco de dados e configure as opções do mecanismo. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Escolher um modelo. | Escolha um modelo de amostra que atenda aos seus requisitos. | DBA, engenheiro DevOps | | Defina configurações do banco de dados. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Configure a instância. | Na seção **Configuração da instância**, em **Classe da instância de banco de dados**, selecione um tamanho de instância que atenda às suas necessidades. | DBA, engenheiro DevOps | | Configure o armazenamento. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Configure a conectividade. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Configure a autenticação do Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Configure o monitoramento. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html)Observação: as métricas são úteis quando você deseja ver como diferentes processos ou threads usam a CPU. Você também pode exportar registros de erros para a Amazon CloudWatch se o **registro de erros** estiver ativado. | DBA, engenheiro DevOps | | Defina configurações adicionais. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Analise os custos e crie o banco de dados. | Analise a seção **Custos mensais estimados** e, em seguida, selecione **Criar banco de dados**. | DBA, engenheiro DevOps | ### Configuração do acesso ao banco de dados e teste das conexões | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Conecte-se à máquina do Windows. | Conecte-se à sua máquina do Windows e inicie o SQL Server Management Studio.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Configure a conexão com o SSMS. | Configure a conexão com o banco de dados usando a autenticação do Windows.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Faça as configurações de segurança. | Configure os parâmetros de segurança necessários para o SSMS na versão 20 ou em versões posteriores.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | | Crie um login do Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html)
CREATE LOGIN [| DBA, engenheiro DevOps | | Teste a autenticação do Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, engenheiro DevOps | ## Recursos relacionados + [Criando seu AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html) + [Unindo uma instância EC2 do Amazon Windows à sua AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/launching_instance.html) + [Regiões e mecanismos de banco de dados compatíveis para autenticação Kerberos no Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.KerberosAuthentication.html) + [What is SQL Server Management Studio (SSMS)?](https://learn.microsoft.com/en-us/ssms/sql-server-management-studio-ssms) # Configurar o acesso entre contas ao Amazon DynamoDB *Shashi Dalmia, Imhoertha Ojior e Esteban Serna Parra, Amazon Web Services* ## Resumo Esse padrão explica as etapas para configurar o acesso entre contas ao Amazon DynamoDB usando políticas baseadas em recursos. Para os workloads que usam o DynamoDB, está se tornando cada vez mais comum adotar [estratégias de isolamento de workloads](https://aws.amazon.com/solutions/guidance/workload-isolation-on-aws/?did=sl_card&trk=sl_card) para reduzir ameaças de segurança e atender aos requisitos de conformidade. A implementação de estratégias de isolamento da carga de trabalho geralmente requer acesso entre contas e regiões aos recursos do DynamoDB usando políticas baseadas em identidade (IAM). AWS Identity and Access Management Isso envolve definir permissões do IAM e estabelecer uma relação de confiança entre Contas da AWS o. As [políticas baseadas em recursos para o DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/access-control-resource-based.html) simplificam significativamente a postura de segurança para workloads entre contas. Esse padrão fornece etapas e exemplos de código para demonstrar como você pode configurar AWS Lambda funções em uma Conta da AWS para gravar dados em uma tabela de banco de dados do DynamoDB em uma conta diferente. ## Pré-requisitos e limitações **Pré-requisitos ** + Dois ativos Contas da AWS. Esse padrão se refere a essas contas como *Conta A* e *Conta B.* + AWS Command Line Interface (AWS CLI) [instalado](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) e [configurado](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) para acessar a Conta A, para criar a tabela do DynamoDB. As outras etapas desse padrão fornecem instruções para usar os consoles IAM, DynamoDB e Lambda. Se você planeja usar AWS CLI em vez disso, configure-o para acessar as duas contas. **Limitações** + Alguns Serviços da AWS não estão disponíveis em todos Regiões da AWS. Para conferir a disponibilidade de uma região, consulte [Serviços da AWS by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para endpoints específicos, consulte a página [Cotas e endpoints de serviços](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e clique no link correspondente ao serviço desejado. ## Arquitetura O diagrama a seguir mostra uma arquitetura de conta única. AWS Lambda, Amazon Elastic Compute Cloud (Amazon EC2) e DynamoDB estão todos na mesma conta. Nesse cenário, as funções Lambda e as EC2 instâncias da Amazon podem acessar o DynamoDB. Para conceder acesso à tabela do DynamoDB, você pode criar uma política baseada em identidade no IAM ou uma política baseada em recursos no DynamoDB. ![\[Uso das permissões do IAM para acessar uma tabela do DynamoDB na mesma conta.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/bfc32fe8-5db0-4cac-a30f-b870a1a82875/images/cbb009eb-422d-4833-a1bc-0c571d83c21f.png) O diagrama a seguir mostra uma arquitetura de várias contas. Se os recursos em um Conta da AWS precisarem acessar uma tabela do DynamoDB em uma conta diferente, você precisará configurar uma política baseada em recursos no DynamoDB para conceder o acesso necessário. Por exemplo, no diagrama apresentado a seguir, o acesso à tabela do DynamoDB na Conta A é concedido a uma função do Lambda na Conta B usando uma política baseada em recursos. ![\[Uso de uma política baseada em recursos para acessar uma tabela do DynamoDB em uma conta diferente.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/bfc32fe8-5db0-4cac-a30f-b870a1a82875/images/9f9165a8-b767-4427-a2ae-31b5b8c83326.png) Este padrão descreve o acesso entre contas entre o Lambda e o DynamoDB. Você pode usar etapas semelhantes para outras, Serviços da AWS se as permissões apropriadas estiverem configuradas em ambas as contas. Por exemplo, se você desejar conceder a uma função do Lambda acesso a um bucket do Amazon Simple Storage Service (Amazon S3) na Conta A, você pode criar uma [política baseada em recursos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-policies.html) no Amazon S3 e adicionar as permissões ao [perfil de execução do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) na Conta B. ## Ferramentas **Serviços da AWS** + O [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) é um serviço de banco de dados NoSQL totalmente gerenciado que fornece performance rápida, previsível e escalável. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ajuda você a gerenciar com segurança o acesso aos seus recursos da AWS controlando quem está autenticado e autorizado a usá-los. + O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que ajuda a executar código sem exigir provisionamento ou gerenciamento de servidores. Ele executa o código somente quando necessário e dimensiona automaticamente, assim, você paga apenas pelo tempo de computação usado. **Código ** Este padrão inclui código de amostra na seção [Informações adicionais](#configure-cross-account-access-to-amazon-dynamodb-additional) para mostrar como configurar uma função do Lambda na Conta B para escrever na tabela do DynamoDB na Conta A. O código é fornecido apenas para fins de ilustração e teste. Se você estiver implementando este padrão em um ambiente de produção, use o código como referência e personalize-o para o seu próprio ambiente. ## Práticas recomendadas + Siga as [práticas recomendadas para as políticas baseadas em recursos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/rbac-best-practices.html) na documentação do DynamoDB. + Respeite o princípio de privilégio mínimo, garantindo somente as permissões estritamente necessárias para a execução de uma tarefa. Para obter mais informações, consulte [Concessão de privilégio mínimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#grant-least-priv) e [Práticas recomendadas de segurança](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) na documentação do IAM. ## Épicos ### Criação de um perfil e de uma política do IAM para a função do Lambda na Conta B | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma política na Conta B. | Essa política do IAM permite a [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html)ação de uma tabela do DynamoDB na Conta A.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | AWS geral | | Crie um perfil na Conta B. | A função do Lambda na Conta B usa este perfil do IAM para acessar a tabela do DynamoDB na Conta A.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)Para obter mais informações sobre a criação de funções, consulte a [documentação de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html). | AWS geral | | Anote o ARN do perfil do . | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | AWS geral | ### Crie uma tabela do DynamoDB na conta A | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma tabela do DynamoDB. | Use o AWS CLI comando a seguir para criar uma tabela do DynamoDB.\ ] FROM WINDOWS;
GO
aws dynamodb create-table \Substitua o seguinte nesta amostra de código:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)Você especifica a configuração da política baseada em recursos na instrução `create-table` usando o parâmetro `--resource-policy`. Esta política faz referência ao ARN da tabela do DynamoDB na Conta A.Para obter mais informações sobre criar tabelas, consulte a [documentação do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html). | AWS geral | ### Criação de uma função do Lambda na Conta B | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma função do Lambda para gravar dados no DynamoDB. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)Para obter mais informações sobre como criar funções do Lambda, consulte a [documentação do Lambda.](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html) | AWS geral | ### Limpeza | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Excluir recursos. | Para evitar custos associados aos recursos criados neste padrão, faça o seguinte para excluir esses recursos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | AWS geral | ## Solução de problemas | Problema | Solução | | --- | --- | | Ao criar a função do Lambda, você recebe um erro `ResourceNotFoundException`. | Confirme se você inseriu corretamente a ID Região da AWS e a ID da Conta A. Elas fazem parte do ARN da tabela do DynamoDB. | ## Recursos relacionados + [Introdução ao DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) (Documentação do DynamoDB) + [Conceitos básicos do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) (documentação do Lambda) + [Usar políticas baseadas em recursos para o DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/access-control-resource-based.html) (documentação do DynamoDB) + [Criação de políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) (Documentação do IAM) + [Lógica de avaliação de políticas entre contas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html) (Documentação do IAM) + [Referência de elementos de política JSON do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) (Documentação do IAM) ## Mais informações *Código de exemplo* ``` import boto3 from datetime import datetime dynamodb_client = boto3.client('dynamodb') def lambda_handler(event, context): now = datetime.now().isoformat() data = dynamodb_client.put_item(TableName='arn:aws:dynamodb:
--table-name Table-Account-A \
--attribute-definitions \
AttributeName=category,AttributeType=S \
AttributeName=item,AttributeType=S \
--key-schema \
AttributeName=category,KeyType=HASH \
AttributeName=item,KeyType=RANGE \
--provisioned-throughput \
ReadCapacityUnits=5,WriteCapacityUnits=5 \
--resource-policy \
'{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Statement1",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam:::role/ "
},
"Action": "dynamodb:PutItem",
"Resource": "arn:aws:dynamodb:: :table/Table-Account-A"
}
]
}'
SELECT SERVERPROPERTY('ComputernamePhysicalNetBios') .A saída exibirá o nome da réplica secundária atual (`WSFCNODE1`). | DBA |
## Solução de problemas
| Problema | Solução |
| --- | --- |
| A criação do receptor falha com a mensagem “O cluster WSFC não pôde colocar o recurso de nome de rede online”. | Para obter mais informações, consulte a postagem do blog da Microsoft [Criar receptor falha com a mensagem “O cluster WSFC não pôde colocar o recurso de nome da rede online”](https://techcommunity.microsoft.com/t5/sql-server-support-blog/create-listener-fails-with-message-the-wsfc-cluster-could-not/ba-p/318235). |
| Problemas potenciais, incluindo outros problemas de receptor ou problemas de acesso à rede. | Consulte [Solução de problemas configuração de Grupos de disponibilidade Always On (SQL Server)](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/troubleshoot-always-on-availability-groups-configuration-sql-server?view=sql-server-ver16) na documentação da Microsoft. |
## Recursos relacionados
+ [Configurar o roteamento somente leitura para um Grupo de disponibilidade Always On (Sempre ativo)](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/configure-read-only-routing-for-an-availability-group-sql-server?view=sql-server-ver16)
+ [Solução de problemas de configuração de grupos de disponibilidade Always On (SQL Server)](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/troubleshoot-always-on-availability-groups-configuration-sql-server?view=sql-server-ver16)
## Mais informações
**Etapa 1. Atualizar as réplicas para somente leitura**
```
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE1' WITH (SECONDARY_ROLE (ALLOW_CONNECTIONS = READ_ONLY))
GO
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE2' WITH (SECONDARY_ROLE (ALLOW_CONNECTIONS = READ_ONLY))
GO
```
**Etapa 2. Criar o URL de roteamento**
```
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE1' WITH (SECONDARY_ROLE (READ_ONLY_ROUTING_URL = N'TCP://WSFCNode1.tagechtalk.com:1433'))
GO
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE2' WITH (SECONDARY_ROLE (READ_ONLY_ROUTING_URL = N'TCP://WSFCNode2.tagechtalk.com:1433'))
GO
```
**Etapa 3. Criar a lista de roteamento**
```
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE1' WITH (PRIMARY_ROLE(READ_ONLY_ROUTING_LIST=('WSFCNODE2','WSFCNODE1')));
GO
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE2' WITH (PRIMARY_ROLE (READ_ONLY_ROUTING_LIST=('WSFCNODE1','WSFCNODE2')));
GO
```
**Etapa 4. Validar a lista de roteamento**
```
SELECT AGSrc.replica_server_name AS PrimaryReplica, AGRepl.replica_server_name AS ReadOnlyReplica, AGRepl.read_only_routing_url AS RoutingURL , AGRL.routing_priority AS RoutingPriority FROM sys.availability_read_only_routing_lists AGRL INNER JOIN sys.availability_replicas AGSrc ON AGRL.replica_id = AGSrc.replica_id INNER JOIN sys.availability_replicas AGRepl ON AGRL.read_only_replica_id = AGRepl.replica_id INNER JOIN sys.availability_groups AV ON AV.group_id = AGSrc.group_id ORDER BY PrimaryReplica
```
**Etapa 5. Utilitário de comando SQL**
```
sqlcmd -S SQLAG1,1433 -E -d test -K ReadOnly
```
# Conecte-se usando um túnel SSH no pgAdmin
*Jeevan Shetty e Bhanu Ganesh Gudivada, Amazon Web Services*
## Resumo
Por motivos de segurança, é sempre bom colocar bancos de dados em uma sub-rede privada. As consultas no banco de dados podem ser executadas conectando-se por meio de um host bastion do Amazon Elastic Compute Cloud (Amazon EC2) em uma sub-rede pública na nuvem da Amazon Web Services (AWS). Isso requer a instalação de software, como o pGADmin DBeaver ou, que são comumente usados por desenvolvedores ou administradores de banco de dados, no host da Amazon. EC2
Executar o pgAdmin em um servidor Linux e acessá-lo por meio de um navegador da Web requer a instalação de dependências adicionais, configuração e configuração de permissões.
Como solução alternativa, desenvolvedores ou administradores de banco de dados podem se conectar a um banco de dados PostgreSQL usando o pgAdmin para habilitar um túnel SSH a partir do sistema local. Nessa abordagem, o pGadmin usa o host da EC2 Amazon na sub-rede pública como um host intermediário antes de se conectar ao banco de dados. O diagrama na seção *Arquitetura* mostra a configuração.
**nota**
Certifique-se de que o grupo de segurança conectado ao banco de dados PostgreSQL permita a conexão na porta 5432 do host da Amazon. EC2
## Pré-requisitos e limitações
**Pré-requisitos **
+ Uma conta da AWS existente
+ Uma nuvem privada virtual (VPC) com uma sub-rede pública e uma sub-rede privada
+ Uma EC2 instância com um grupo de segurança anexado
+ Um banco de dados Amazon Aurora Edição Compatível com PostgreSQL com um grupo de segurança anexado
+ Um par de chaves Secure Shell (SSH) para configurar o túnel
**Versões do produto**
+ pgAdmin versão 6.2\$1
+ Amazon Aurora Edição Compatível com PostgreSQL 12.7\$1
## Arquitetura
**Pilha de tecnologias de destino**
+ Amazon EC2
+ Amazon Aurora compatível com PostgreSQL
**Arquitetura de destino**
O diagrama a seguir mostra o uso do pGADmin com um túnel SSH para se conectar por meio de um gateway de internet à instância, que se conecta EC2 ao banco de dados.
![\[O pGADmin com túnel SSH se conecta por meio do gateway da Internet à instância que se conecta EC2 ao banco de dados.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/7d25d570-5685-4f1a-bef0-212e257cb589/images/4556d930-f9b3-4b65-be5d-d40dd9437d5a.png)
## Ferramentas
**Serviços da AWS**
+ O [Amazon Aurora Edição Compatível com PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) é um mecanismo de banco de dados relacional totalmente gerenciado que ajuda você a configurar, operar e escalar as implantações de PostgreSQL.
+ [A Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/ec2/) fornece capacidade de computação escalável na Nuvem AWS. Você poderá iniciar quantos servidores virtuais precisar e escalá-los na vertical rapidamente.
**Outros serviços**
+ O [pgAdmin](https://www.pgadmin.org/) é uma ferramenta de gerenciamento de código aberto para PostgreSQL. Ele fornece uma interface gráfica que ajuda você a criar, manter e usar objetos de banco de dados.
## Épicos
### Criar a conexão
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Crie um servidor. | No pgAdmin escolha **Criar** e, em seguida, escolha **Servidor**. Para obter ajuda adicional com a configuração do pgAdmin para registrar um servidor, configurar uma conexão e conectar-se por meio de tunelamento SSH usando a caixa de diálogo do servidor, consulte os links na seção *Recursos relacionados*. | DBA |
| Forneça um nome para o servidor. | Na guia **Geral**, insira um nome. | DBA |
| Insira os detalhes do banco de dados. | Na guia **Conexão**, insira valores para o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/connect-by-using-an-ssh-tunnel-in-pgadmin.html) | DBA |
| Insira os detalhes EC2 do servidor Amazon. | Na guia **Túnel SSH**, forneça os detalhes da EC2 instância da Amazon que está na sub-rede pública.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/connect-by-using-an-ssh-tunnel-in-pgadmin.html) | DBA |
| Salve e conecte-se. | Escolha **Salvar** para concluir a configuração e conectar-se ao banco de dados Aurora compatível com o PostgreSQL usando o túnel SSH. | DBA |
## Recursos relacionados
+ [Diálogo do servidor](https://www.pgadmin.org/docs/pgadmin4/latest/server_dialog.html)
+ [Conectar-se ao servidor](https://www.pgadmin.org/docs/pgadmin4/latest/connect_to_server.html)
# Converta consultas JSON Oracle em SQL do banco de dados PostgreSQL
*Pinesh Singal e Lokesh Gurram, Amazon Web Services*
## Resumo
Esse processo de migração do on-premises para a nuvem da Amazon Web Services (AWS) usa a AWS Schema Conversion Tool (AWS SCT) para converter o código de um banco de dados Oracle em um banco de dados PostgreSQL. A maior parte do código é convertida automaticamente pela AWS SCT. No entanto, as consultas Oracle relacionadas ao JSON não são convertidas automaticamente.
A partir da versão Oracle 12.2, o Oracle Database suporta várias funções JSON que ajudam na conversão de dados baseados em JSON em dados baseados em ROW. No entanto, a AWS SCT não converte automaticamente dados baseados em JSON em linguagem compatível com o PostgreSQL.
Esse padrão de migração se concentra principalmente na conversão manual das consultas Oracle relacionadas ao JSON com funções como `JSON_OBJECT`, `JSON_ARRAYAGG` e `JSON_TABLE` de um banco de dados Oracle para um banco de dados PostgreSQL.
## Pré-requisitos e limitações
**Pré-requisitos **
+ Uma conta AWS ativa
+ Uma instância do banco de dados Oracle on-premises (em funcionamento)
+ Uma instância de banco de dados do Amazon Relational Database Service (Amazon RDS) para PostgreSQL ou Amazon Aurora Edição Compatível com PostgreSQL (em funcionamento)
**Limitações**
+ As consultas relacionadas ao JSON exigem um formato fixo de `KEY` e `VALUE`. Não usar esse formato retorna o resultado errado.
+ Se alguma alteração na estrutura JSON adicionar novos pares `KEY` e `VALUE` na seção de resultados, o procedimento ou função correspondente deverá ser alterado na consulta SQL.
+ Algumas funções relacionadas ao JSON são suportadas em versões anteriores do Oracle e do PostgreSQL, mas com menos recursos.
**Versões do produto**
+ Oracle Database versão 12.2 e posterior
+ Amazon RDS para PostgreSQL ou Aurora compatível com PostgreSQL versão 9.5 e posterior
+ Versão mais recente da AWS SCT (testada usando a versão 1.0.664)
## Arquitetura
**Pilha de tecnologia de origem**
+ Uma instância de banco de dados Oracle com a versão 19c
**Pilha de tecnologias de destino**
+ Uma instância de banco de dados do Amazon RDS para PostgreSQL ou Aurora compatível com PostgreSQL com a versão 13
**Arquitetura de destino**
![\[A descrição segue o diagrama.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/5e2c3b07-9ef5-417f-b049-bcea58f2c3ec/images/2ff8b00b-8849-4ef1-9be1-579f7b51be10.png)
1. Use a AWS SCT com o código da função JSON para converter o código-fonte do Oracle para o PostgreSQL.
1. A conversão produz arquivos .sql migrados compatíveis com o PostgreSQL.
1. Converta manualmente os códigos de função Oracle JSON não convertidos em códigos de função JSON do PostgreSQL.
1. Execute os arquivos .sql na instância de banco de dados de destino do Aurora compatível com o PostgreSQL.
## Ferramentas
**Serviços da AWS**
+ O [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) é um mecanismo de banco de dados relacional totalmente gerenciado que é construído para a nuvem e compatível com o MySQL e o PostgreSQL.
+ O [Amazon Relational Database Service (Amazon RDS) para PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) ajuda você a configurar, operar e escalar um banco de dados relacional PostgreSQL na Nuvem AWS.
+ O [AWS Schema Conversion Tool (AWS SCT](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html)) oferece suporte a migrações heterogêneas de bancos de dados convertendo automaticamente o esquema do banco de dados de origem e a maior parte do código personalizado em um formato compatível com o banco de dados de destino.
**Outros serviços**
+ O [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) é um ambiente de desenvolvimento integrado que simplifica o desenvolvimento e o gerenciamento de bancos de dados Oracle em implantações tradicionais e baseadas em nuvem.
+ pgAdmin ou. DBeaver [O pgAdmin](https://www.pgadmin.org/) é uma ferramenta de gerenciamento de código aberto para o PostgreSQL. Ele fornece uma interface gráfica que ajuda você a criar, manter e usar objetos de banco de dados. [DBeaver](https://dbeaver.io/)é uma ferramenta de banco de dados universal.
## Práticas recomendadas
A consulta Oracle tem o tipo `CAST` como padrão ao usar a função `JSON_TABLE`. Uma prática recomendada é usar `CAST` no PostgreSQL também, usando caracteres duplos maiores que caracteres (`>>`).
Para obter mais informações, consulte *Postgres\$1SQL\$1Read\$1JSON* na seção *Informações adicionais*.
## Épicos
### Gere os dados JSON nos bancos de dados Oracle e PostgreSQL
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Armazene os dados JSON no banco de dados Oracle. | Crie uma tabela no banco de dados Oracle e armazene os dados JSON na coluna `CLOB`. Use o *Oracle\$1Table\$1Creation\$1Insert\$1Script* que está na seção *Informações adicionais*. | Engenheiro de migração |
| Armazene os dados JSON no banco de dados PostgreSQL. | Crie uma tabela no banco de dados PostgreSQL e armazene os dados JSON na coluna `TEXT`. Use o *Postgres\$1Table\$1Creation\$1Insert\$1Script* que está na seção *Informações adicionais*. | Engenheiro de migração |
### Converta o JSON em formato ROW
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Converta os dados JSON no banco de dados Oracle. | Escreva uma consulta Oracle SQL para ler os dados JSON no formato ROW. Para obter mais detalhes e exemplos de sintaxe, consulte *Oracle\$1SQL\$1Read\$1JSON* na seção *Informações adicionais*. | Engenheiro de migração |
| Converta os dados JSON no banco de dados PostgreSQL. | Escreva uma consulta PostgreSQL para ler os dados JSON no formato ROW. Para obter mais detalhes e exemplos de sintaxe, consulte *Postgres\$1SQL\$1Read\$1JSON* na seção *Informações adicionais*. | Engenheiro de migração |
### Converta manualmente os dados JSON usando a consulta SQL e relate a saída no formato JSON
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Execute agregações e validação na consulta Oracle SQL. | Para converter manualmente os dados JSON, execute uma junção, agregação e validação na consulta Oracle SQL e relate a saída no formato JSON. Use o código em *Oracle\$1SQL\$1JSON\$1Aggregation\$1Join* na seção *Informações adicionais*.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/convert-json-oracle-queries-into-postgresql-database-sql.html) | Engenheiro de migração |
| Execute agregações e validação na consulta Postgres SQL. | Para converter manualmente os dados JSON, execute uma junção, agregação e validação na consulta PostgreSQL e relate a saída no formato JSON. Use o código em *Postgres\$1SQL\$1JSON\$1aggregation\$1join* na seção *Informações adicionais*.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/convert-json-oracle-queries-into-postgresql-database-sql.html) | Engenheiro de migração |
### Converta o procedimento Oracle em uma função PostgreSQL que contém consultas JSON
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Converta as consultas JSON no procedimento Oracle em linhas. | Para o exemplo de procedimento Oracle, use a consulta Oracle anterior e o código em *Oracle\$1Procedure\$1with\$1JSON\$1Query* na seção *Informações adicionais*. | Engenheiro de migração |
| Converta as funções do PostgreSQL que têm consultas JSON em dados baseados em linhas. | Para os exemplos de funções do PostgreSQL, use a consulta anterior do PostgreSQL e o código que está em *Postgres\$1Function\$1with\$1JSON\$1Query* na seção *Informações adicionais*. | Engenheiro de migração |
## Recursos relacionados
+ [Funções Oracle JSON](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/adjsn/generation.html)
+ [Funções JSON do PostgreSQL](https://www.postgresql.org/docs/13/functions-json.html)
+ [Exemplos de funções Oracle JSON](https://oracle-base.com/articles/12c/sql-json-functions-12cr2)
+ [Exemplos de funções JSON do PostgreSQL](https://dba.stackexchange.com/questions/69655/select-columns-inside-json-agg)
+ [AWS Schema Conversion Tool](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html)
## Mais informações
Para converter o código JSON do banco de dados Oracle para o banco de dados PostgreSQL, use os scripts a seguir, em ordem.
**1. Oracle\$1Table\$1Creation\$1Insert\$1Script**
```
create table aws_test_table(id number,created_on date default sysdate,modified_on date,json_doc clob);
REM INSERTING into EXPORT_TABLE
SET DEFINE OFF;
Insert into aws_test_table (ID,CREATED_ON,MODIFIED_ON,json_doc)
values (1,to_date('02-AUG-2022 12:30:14','DD-MON-YYYY HH24:MI:SS'),to_date('02-AUG-2022 12:30:14','DD-MON-YYYY HH24:MI:SS'),TO_CLOB(q'[{
"metadata" : {
"upperLastNameFirstName" : "ABC XYZ",
"upperEmailAddress" : "abc@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "032323323",
"displayName" : "Abc, Xyz",
"firstName" : "Xyz",
"lastName" : "Abc",
"emailAddress" : "abc@gmail.com",
"productRegistrationStatus" : "Not registered",
"positionId" : "0100",
"arrayPattern" : " -'",
"a]')
|| TO_CLOB(q'[ccount" : {
"companyId" : "SMGE",
"businessUnitId" : 7,
"accountNumber" : 42000,
"parentAccountNumber" : 32000,
"firstName" : "john",
"lastName" : "doe",
"street1" : "retOdertcaShr ",
"city" : "new york",
"postalcode" : "XY ABC",
"country" : "United States"
},
"products" : [
{
"appUserGuid" : "i0acc4450000001823fbad478e2eab8a0",
"id" : "0000000046",
]')
|| TO_CLOB(q'[ "name" : "ProView",
"domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}]'));
Insert into aws_test_table (ID,CREATED_ON,MODIFIED_ON,json_doc) values (2,to_date('02-AUG-2022 12:30:14','DD-MON-YYYY HH24:MI:SS'),to_date('02-AUG-2022 12:30:14','DD-MON-YYYY HH24:MI:SS'),TO_CLOB(q'[{
"metadata" : {
"upperLastNameFirstName" : "PQR XYZ",
"upperEmailAddress" : "pqr@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "54534343",
"displayName" : "Xyz, pqr",
"firstName" : "pqr",
"lastName" : "Xyz",
"emailAddress" : "pqr@gmail.com",
"productRegistrationStatus" : "Not registered",
"positionId" : "0090",
"arrayPattern" : " -'",
"account" : {
"companyId" : "CARS",
"busin]')
|| TO_CLOB(q'[essUnitId" : 6,
"accountNumber" : 42001,
"parentAccountNumber" : 32001,
"firstName" : "terry",
"lastName" : "whitlock",
"street1" : "UO 123",
"city" : "TOTORON",
"region" : "NO",
"postalcode" : "LKM 111",
"country" : "Canada"
},
"products" : [
{
"appUserGuid" : "ia744d7790000016899f8cf3f417d6df6",
"id" : "0000000014",
"name" : "ProView eLooseleaf",
]')
|| TO_CLOB(q'[ "domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}]'));
commit;
```
**2. Postgres\$1Table\$1Creation\$1Insert\$1Script**
```
create table aws_test_pg_table(id int,created_on date ,modified_on date,json_doc text);
insert into aws_test_pg_table(id,created_on,modified_on,json_doc)
values(1,now(),now(),'{
"metadata" : {
"upperLastNameFirstName" : "ABC XYZ",
"upperEmailAddress" : "abc@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "032323323",
"displayName" : "Abc, Xyz",
"firstName" : "Xyz",
"lastName" : "Abc",
"emailAddress" : "abc@gmail.com",
"productRegistrationStatus" : "Not registered",
"positionId" : "0100",
"arrayPattern" : " -",
"account" : {
"companyId" : "SMGE",
"businessUnitId" : 7,
"accountNumber" : 42000,
"parentAccountNumber" : 32000,
"firstName" : "john",
"lastName" : "doe",
"street1" : "retOdertcaShr ",
"city" : "new york",
"postalcode" : "XY ABC",
"country" : "United States"
},
"products" : [
{
"appUserGuid" : "i0acc4450000001823fbad478e2eab8a0",
"id" : "0000000046",
"name" : "ProView",
"domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}');
insert into aws_test_pg_table(id,created_on,modified_on,json_doc)
values(2,now(),now(),'{
"metadata" : {
"upperLastNameFirstName" : "PQR XYZ",
"upperEmailAddress" : "pqr@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "54534343",
"displayName" : "Xyz, pqr",
"firstName" : "pqr",
"lastName" : "Xyz",
"emailAddress" : "a*b**@h**.k**",
"productRegistrationStatus" : "Not registered",
"positionId" : "0090",
"arrayPattern" : " -",
"account" : {
"companyId" : "CARS",
"businessUnitId" : 6,
"accountNumber" : 42001,
"parentAccountNumber" : 32001,
"firstName" : "terry",
"lastName" : "whitlock",
"street1" : "UO 123",
"city" : "TOTORON",
"region" : "NO",
"postalcode" : "LKM 111",
"country" : "Canada"
},
"products" : [
{
"appUserGuid" : "ia744d7790000016899f8cf3f417d6df6",
"id" : "0000000014",
"name" : "ProView eLooseleaf",
"domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}');
```
**3. Oracle\$1SQL\$1Read\$1JSON**
Os blocos de código a seguir mostram como converter dados Oracle JSON em formato de linha.
*Exemplo de consulta e sintaxe*
```
SELECT JSON_OBJECT(
'accountCounts' VALUE JSON_ARRAYAGG(
JSON_OBJECT(
'businessUnitId' VALUE business_unit_id,
'parentAccountNumber' VALUE parent_account_number,
'accountNumber' VALUE account_number,
'totalOnlineContactsCount' VALUE online_contacts_count,
'countByPosition' VALUE
JSON_OBJECT(
'taxProfessionalCount' VALUE tax_count,
'attorneyCount' VALUE attorney_count,
'nonAttorneyCount' VALUE non_attorney_count,
'clerkCount' VALUE clerk_count
) ) ) ) FROM
(SELECT tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab_data.position_id = '0095' THEN 1 ELSE 0 END) tax_count,
SUM(CASE WHEN tab_data.position_id = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab_data.position_id = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab_data.position_id = '0050' THEN 1 ELSE 0 END) clerk_count
FROM aws_test_table scco,JSON_TABLE ( json_doc, '$' ERROR ON ERROR COLUMNS (
parent_account_number NUMBER PATH
'$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId' )
) AS tab_data
INNER JOIN JSON_TABLE ( '{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}', '$.accounts[*]' ERROR ON ERROR
COLUMNS (
parent_account_number PATH '$.parentAccountNumber',
account_number PATH '$.accountNumber',
business_unit_id PATH '$.businessUnitId')
) static_data
ON ( static_data.parent_account_number = tab_data.parent_account_number
AND static_data.account_number = tab_data.account_number
AND static_data.business_unit_id = tab_data.business_unit_id )
GROUP BY
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number );
```
O documento JSON armazena os dados como coleções. Cada coleção pode ter pares de `KEY` e `VALUE`. Todos os `VALUE` podem ter pares de `KEY` e `VALUE` aninhados. A tabela a seguir fornece informações sobre como ler o `VALUE` específico do documento JSON.
|
|
| CHAVE | HIERARCHY ou PATH a ser usado para obter o VALUE | VALUE |
| --- |--- |--- |
| `profileType` | `metadata` -> `profileType` | "P" |
| `positionId` | `data` -> `positionId` | "0100" |
| `accountNumber` | `data` -> account -> `accountNumber` | 42000 |
Na tabela anterior, o `KEY` `profileType` é um `VALUE` dos `metadata` `KEY`. O `KEY` `positionId` é um `VALUE` da `data` `KEY`. O `KEY` `accountNumber` é um `VALUE` da `account` `KEY`, e a `account` `KEY` é um `VALUE` da `data` `KEY`.
*Exemplo de documento JSON*
```
{
"metadata" : {
"upperLastNameFirstName" : "ABC XYZ",
"upperEmailAddress" : "abc@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "032323323",
"displayName" : "Abc, Xyz",
"firstName" : "Xyz",
"lastName" : "Abc",
"emailAddress" : "abc@gmail.com",
"productRegistrationStatus" : "Not registered",
"positionId" : "0100",
"arrayPattern" : " -",
"account" : {
"companyId" : "SMGE",
"businessUnitId" : 7,
"accountNumber" : 42000,
"parentAccountNumber" : 32000,
"firstName" : "john",
"lastName" : "doe",
"street1" : "retOdertcaShr ",
"city" : "new york",
"postalcode" : "XY ABC",
"country" : "United States"
},
"products" : [
{
"appUserGuid" : "i0acc4450000001823fbad478e2eab8a0",
"id" : "0000000046",
"name" : "ProView",
"domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}
```
*Consulta SQL usada para obter os campos selecionados do documento JSON*
```
select parent_account_number,account_number,business_unit_id,position_id from aws_test_table aws,JSON_TABLE ( json_doc, '$' ERROR ON ERROR
COLUMNS (
parent_account_number NUMBER PATH '$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId'
)) as sc
```
Na consulta anterior, `JSON_TABLE` é uma função embutida no Oracle que converte os dados JSON em formato de linha. A função JSON\$1TABLE espera parâmetros no formato JSON.
Cada item em `COLUMNS` tem um `PATH` predefinido, e um `VALUE` apropriado para uma determinada `KEY` é retornado em formato de linha.
*Resultado da consulta anterior*
|
|
| PARENT\$1ACCOUNT\$1NUMBER | ACCOUNT\$1NUMBER | BUSINESS\$1UNIT\$1ID | POSITION\$1ID |
| --- |--- |--- |--- |
| 32000 | 42000 | 7 | 0100 |
| 32001 | 4/2001 | 6 | 0090 |
**4. Postgres\$1SQL\$1Read\$1JSON**
** ***Exemplo de consulta e sintaxe*
```
select *
from (
select (json_doc::json->'data'->'account'->>'parentAccountNumber')::INTEGER as parentAccountNumber,
(json_doc::json->'data'->'account'->>'accountNumber')::INTEGER as accountNumber,
(json_doc::json->'data'->'account'->>'businessUnitId')::INTEGER as businessUnitId,
(json_doc::json->'data'->>'positionId')::VARCHAR as positionId
from aws_test_pg_table) d ;
```
No Oracle, o `PATH` é usado para identificar o `KEY` e `VALUE` específicos. No entanto, o PostgreSQL usa um modelo `HIERARCHY` para leitura de `KEY` e `VALUE` a partir do JSON. Os mesmos dados JSON mencionados abaixo de `Oracle_SQL_Read_JSON` são usados nos exemplos a seguir.
*Consulta SQL com tipo CAST não permitida*
(Se você forçar o tipo `CAST`, a consulta falhará com um erro de sintaxe.)
```
select *
from (
select (json_doc::json->'data'->'account'->'parentAccountNumber') as parentAccountNumber,
(json_doc::json->'data'->'account'->'accountNumber')as accountNumber,
(json_doc::json->'data'->'account'->'businessUnitId') as businessUnitId,
(json_doc::json->'data'->'positionId')as positionId
from aws_test_pg_table) d ;
```
Usar um único operador maior que (`>`) retornará o `VALUE` definido para essa `KEY`. Por exemplo, `KEY`: `positionId`, e `VALUE`: `"0100"`.
O tipo `CAST` não é permitido quando você usa o único operador maior que (`>`).
*Consulta SQL com tipo CAST permitida*
```
select *
from (
select (json_doc::json->'data'->'account'->>'parentAccountNumber')::INTEGER as parentAccountNumber,
(json_doc::json->'data'->'account'->>'accountNumber')::INTEGER as accountNumber,
(json_doc::json->'data'->'account'->>'businessUnitId')::INTEGER as businessUnitId,
(json_doc::json->'data'->>'positionId')::varchar as positionId
from aws_test_pg_table) d ;
```
Para usar o tipo `CAST`, você deve usar o operador duplo maior que. Se você usar o único operador maior que, a consulta retornará o `VALUE` definido (por exemplo `KEY`: `positionId` e `VALUE`: `"0100"`). Usar o operador duplo maior que (`>>`) retornará o valor real definido para essa `KEY` (por exemplo, `KEY`: `positionId` e `VALUE`: `0100`, sem aspas duplas).
No caso anterior, o `parentAccountNumber` é do tipo `CAST` para `INT`, `accountNumber` é do tipo `CAST` para `INT`, `businessUnitId` é do tipo `CAST` para `INT` e `positionId` é do tipo `CAST` para `VARCHAR`.
As tabelas a seguir mostram os resultados da consulta que explicam o papel do único operador maior que (`>`) e do operador duplo maior que (`>>`).
Na primeira tabela, a consulta usa o único operador maior que (`>`). Cada coluna está no tipo JSON e não pode ser convertida em outro tipo de dados.
|
|
| parentAccountNumber | accountNumber | businessUnitId | positionId |
| --- |--- |--- |--- |
| 2003565430 | 2003564830 | 7 | "0100" |
| 2005 284042 | 2005 284042 | 6 | “0090” |
| 2000272719 | 2000272719 | 1 | "0100" |
Na segunda tabela, a consulta usa o operador duplo maior que (`>>`). Cada coluna oferece suporte ao tipo `CAST` com base no valor da coluna. Por exemplo, `INTEGER` neste contexto.
|
|
| parentAccountNumber | accountNumber | businessUnitId | positionId |
| --- |--- |--- |--- |
| 2003565430 | 2003564830 | 7 | 0100 |
| 2005 284042 | 2005 284042 | 6 | 0090 |
| 2000272719 | 2000272719 | 1 | 0100 |
**5. Oracle\$1SQL\$1JSON\$1Aggregation\$1Join**
*Consulta de exemplo*
```
SELECT
JSON_OBJECT(
'accountCounts' VALUE JSON_ARRAYAGG(
JSON_OBJECT(
'businessUnitId' VALUE business_unit_id,
'parentAccountNumber' VALUE parent_account_number,
'accountNumber' VALUE account_number,
'totalOnlineContactsCount' VALUE online_contacts_count,
'countByPosition' VALUE
JSON_OBJECT(
'taxProfessionalCount' VALUE tax_count,
'attorneyCount' VALUE attorney_count,
'nonAttorneyCount' VALUE non_attorney_count,
'clerkCount' VALUE clerk_count
) ) ) )
FROM
(SELECT
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab_data.position_id = '0095' THEN 1 ELSE 0 END) tax_count,
SUM(CASE WHEN tab_data.position_id = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab_data.position_id = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab_data.position_id = '0050' THEN 1 ELSE 0 END) clerk_count
FROM aws_test_table scco,JSON_TABLE ( json_doc, '$' ERROR ON ERROR COLUMNS (
parent_account_number NUMBER PATH
'$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId' )
) AS tab_data
INNER JOIN JSON_TABLE ( '{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}', '$.accounts[*]' ERROR ON ERROR
COLUMNS (
parent_account_number PATH '$.parentAccountNumber',
account_number PATH '$.accountNumber',
business_unit_id PATH '$.businessUnitId')
) static_data
ON ( static_data.parent_account_number = tab_data.parent_account_number
AND static_data.account_number = tab_data.account_number
AND static_data.business_unit_id = tab_data.business_unit_id )
GROUP BY
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number
);
```
Para converter os dados em nível de linha no formato JSON, o Oracle tem funções integradas como `JSON_OBJECT`, `JSON_ARRAY`, `JSON_OBJECTAGG` e `JSON_ARRAYAGG`.
+ `JSON_OBJECT` aceita dois parâmetros: `KEY` e `VALUE`. O parâmetro `KEY` deve ser codificado ou de natureza estática. O parâmetro `VALUE` é derivado da saída da tabela.
+ O `JSON_ARRAYAGG` aceita `JSON_OBJECT` como parâmetro. Isso ajuda a agrupar o conjunto de elementos `JSON_OBJECT` como uma lista. Por exemplo, se você tiver um elemento `JSON_OBJECT` que tenha vários registros (vários pares de `KEY` e `VALUE` no conjunto de dados), o `JSON_ARRAYAGG` anexa o conjunto de dados e cria uma lista. De acordo com a linguagem Data Structure, `LIST` é um grupo de elementos. Nesse contexto, `LIST` é um grupo de elementos `JSON_OBJECT`.
O exemplo a seguir mostra um elemento `JSON_OBJECT`.
```
{
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
```
O próximo exemplo mostra dois elementos `JSON_OBJECT`, com `LIST` indicado por colchetes (`[ ]`).
```
[
{
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
,
{
"taxProfessionalCount": 2,
"attorneyCount": 1,
"nonAttorneyCount": 3,
"clerkCount":4
}
]
```
*Exemplo de consulta SQL*
```
SELECT
JSON_OBJECT(
'accountCounts' VALUE JSON_ARRAYAGG(
JSON_OBJECT(
'businessUnitId' VALUE business_unit_id,
'parentAccountNumber' VALUE parent_account_number,
'accountNumber' VALUE account_number,
'totalOnlineContactsCount' VALUE online_contacts_count,
'countByPosition' VALUE
JSON_OBJECT(
'taxProfessionalCount' VALUE tax_count,
'attorneyCount' VALUE attorney_count,
'nonAttorneyCount' VALUE non_attorney_count,
'clerkCount' VALUE clerk_count
)
)
)
)
FROM
(SELECT
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab_data.position_id = '0095' THEN 1 ELSE 0 END
) tax_count,
SUM(CASE WHEN tab_data.position_id = '0100' THEN 1 ELSE 0 END
) attorney_count,
SUM(CASE WHEN tab_data.position_id = '0090' THEN 1 ELSE 0 END
) non_attorney_count,
SUM(CASE WHEN tab_data.position_id = '0050' THEN 1 ELSE 0 END
) clerk_count
FROM
aws_test_table scco, JSON_TABLE ( json_doc, '$' ERROR ON ERROR
COLUMNS (
parent_account_number NUMBER PATH '$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId' )
) AS tab_data
INNER JOIN JSON_TABLE ( '{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}', '$.accounts[*]' ERROR ON ERROR
COLUMNS (
parent_account_number PATH '$.parentAccountNumber',
account_number PATH '$.accountNumber',
business_unit_id PATH '$.businessUnitId')
) static_data ON ( static_data.parent_account_number = tab_data.parent_account_number
AND static_data.account_number = tab_data.account_number
AND static_data.business_unit_id = tab_data.business_unit_id )
GROUP BY
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number
);
```
*Exemplo de saída da consulta SQL anterior*
```
{
"accountCounts": [
{
"businessUnitId": 6,
"parentAccountNumber": 32001,
"accountNumber": 42001,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
},
{
"businessUnitId": 7,
"parentAccountNumber": 32000,
"accountNumber": 42000,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 1,
"nonAttorneyCount": 0,
"clerkCount": 0
}
}
]
}
```
**6. Postgres\$1SQL\$1JSON\$1Aggregation\$1Join**
As funções incorporadas do PostgreSQL `JSON_BUILD_OBJECT` e `JSON_AGG` convertem os dados em nível de LINHA no formato JSON. A `JSON_BUILD_OBJECT` e `JSON_AGG` do PostgreSQL são equivalentes à `JSON_OBJECT` e `JSON_ARRAYAGG` do Oracle.
*Consulta de exemplo*
```
select
JSON_BUILD_OBJECT ('accountCounts',
JSON_AGG(
JSON_BUILD_OBJECT ('businessUnitId',businessUnitId
,'parentAccountNumber',parentAccountNumber
,'accountNumber',accountNumber
,'totalOnlineContactsCount',online_contacts_count,
'countByPosition',
JSON_BUILD_OBJECT (
'taxProfessionalCount',tax_professional_count
,'attorneyCount',attorney_count
,'nonAttorneyCount',non_attorney_count
,'clerkCount',clerk_count
)
)
)
)
from (
with tab as (select * from (
select (json_doc::json->'data'->'account'->>'parentAccountNumber')::INTEGER as parentAccountNumber,
(json_doc::json->'data'->'account'->>'accountNumber')::INTEGER as accountNumber,
(json_doc::json->'data'->'account'->>'businessUnitId')::INTEGER as businessUnitId,
(json_doc::json->'data'->>'positionId')::varchar as positionId
from aws_test_pg_table) a ) ,
tab1 as ( select
(json_array_elements(b.jc -> 'accounts') ->> 'accountNumber')::integer accountNumber,
(json_array_elements(b.jc -> 'accounts') ->> 'businessUnitId')::integer businessUnitId,
(json_array_elements(b.jc -> 'accounts') ->> 'parentAccountNumber')::integer parentAccountNumber
from (
select '{
"accounts": [{
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}, {
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}]
}'::json as jc) b)
select
tab.businessUnitId::text,
tab.parentAccountNumber::text,
tab.accountNumber::text,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab.positionId::text = '0095' THEN 1 ELSE 0 END) tax_professional_count,
SUM(CASE WHEN tab.positionId::text = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab.positionId::text = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab.positionId::text = '0050' THEN 1 ELSE 0 END) clerk_count
from tab1,tab
where tab.parentAccountNumber::INTEGER=tab1.parentAccountNumber::INTEGER
and tab.accountNumber::INTEGER=tab1.accountNumber::INTEGER
and tab.businessUnitId::INTEGER=tab1.businessUnitId::INTEGER
GROUP BY tab.businessUnitId::text,
tab.parentAccountNumber::text,
tab.accountNumber::text) a;
```
*Exemplo de saída da consulta anterior*
A saída do Oracle e do PostgreSQL é exatamente a mesma.
```
{
"accountCounts": [
{
"businessUnitId": 6,
"parentAccountNumber": 32001,
"accountNumber": 42001,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
},
{
"businessUnitId": 7,
"parentAccountNumber": 32000,
"accountNumber": 42000,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 1,
"nonAttorneyCount": 0,
"clerkCount": 0
}
}
]
}
```
**7.Oracle\$1procedure\$1with\$1JSON\$1Query**
Esse código converte o procedimento Oracle em uma função PostgreSQL que tem consultas SQL JSON. Mostra como a consulta transpõe o JSON em linhas e vice-versa.
```
CREATE OR REPLACE PROCEDURE p_json_test(p_in_accounts_json IN varchar2, p_out_accunts_json OUT varchar2)
IS
BEGIN
/*
p_in_accounts_json paramter should have following format:
{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}
*/
SELECT
JSON_OBJECT(
'accountCounts' VALUE JSON_ARRAYAGG(
JSON_OBJECT(
'businessUnitId' VALUE business_unit_id,
'parentAccountNumber' VALUE parent_account_number,
'accountNumber' VALUE account_number,
'totalOnlineContactsCount' VALUE online_contacts_count,
'countByPosition' VALUE
JSON_OBJECT(
'taxProfessionalCount' VALUE tax_count,
'attorneyCount' VALUE attorney_count,
'nonAttorneyCount' VALUE non_attorney_count,
'clerkCount' VALUE clerk_count
) ) ) )
into p_out_accunts_json
FROM
(SELECT
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab_data.position_id = '0095' THEN 1 ELSE 0 END) tax_count,
SUM(CASE WHEN tab_data.position_id = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab_data.position_id = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab_data.position_id = '0050' THEN 1 ELSE 0 END) clerk_count
FROM aws_test_table scco,JSON_TABLE ( json_doc, '$' ERROR ON ERROR
COLUMNS (
parent_account_number NUMBER PATH '$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId' )
) AS tab_data
INNER JOIN JSON_TABLE ( p_in_accounts_json, '$.accounts[*]' ERROR ON ERROR
COLUMNS (
parent_account_number PATH '$.parentAccountNumber',
account_number PATH '$.accountNumber',
business_unit_id PATH '$.businessUnitId')
) static_data
ON ( static_data.parent_account_number = tab_data.parent_account_number
AND static_data.account_number = tab_data.account_number
AND static_data.business_unit_id = tab_data.business_unit_id )
GROUP BY
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number
);
EXCEPTION
WHEN OTHERS THEN
raise_application_error(-20001,'Error while running the JSON query');
END;
/
```
*Executando o procedimento*
O bloco de código a seguir explica como você pode executar o procedimento Oracle criado anteriormente com um exemplo de entrada JSON para o procedimento. Também fornece o resultado ou a saída desse procedimento.
```
set serveroutput on;
declare
v_out varchar2(30000);
v_in varchar2(30000):= '{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}';
begin
p_json_test(v_in,v_out);
dbms_output.put_line(v_out);
end;
/
```
*Saída do procedimento*
```
{
"accountCounts": [
{
"businessUnitId": 6,
"parentAccountNumber": 32001,
"accountNumber": 42001,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
},
{
"businessUnitId": 7,
"parentAccountNumber": 32000,
"accountNumber": 42000,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 1,
"nonAttorneyCount": 0,
"clerkCount": 0
}
}
]
}
```
**8.Postgres\$1function\$1with\$1JSON\$1Query**
*Exemplos de função*
```
CREATE OR REPLACE FUNCTION f_pg_json_test(p_in_accounts_json text)
RETURNS text
LANGUAGE plpgsql
AS
$$
DECLARE
v_out_accunts_json text;
BEGIN
SELECT
JSON_BUILD_OBJECT ('accountCounts',
JSON_AGG(
JSON_BUILD_OBJECT ('businessUnitId',businessUnitId
,'parentAccountNumber',parentAccountNumber
,'accountNumber',accountNumber
,'totalOnlineContactsCount',online_contacts_count,
'countByPosition',
JSON_BUILD_OBJECT (
'taxProfessionalCount',tax_professional_count
,'attorneyCount',attorney_count
,'nonAttorneyCount',non_attorney_count
,'clerkCount',clerk_count
))))
INTO v_out_accunts_json
FROM (
WITH tab AS (SELECT * FROM (
SELECT (json_doc::json->'data'->'account'->>'parentAccountNumber')::INTEGER AS parentAccountNumber,
(json_doc::json->'data'->'account'->>'accountNumber')::INTEGER AS accountNumber,
(json_doc::json->'data'->'account'->>'businessUnitId')::INTEGER AS businessUnitId,
(json_doc::json->'data'->>'positionId')::varchar AS positionId
FROM aws_test_pg_table) a ) ,
tab1 AS ( SELECT
(json_array_elements(b.jc -> 'accounts') ->> 'accountNumber')::integer accountNumber,
(json_array_elements(b.jc -> 'accounts') ->> 'businessUnitId')::integer businessUnitId,
(json_array_elements(b.jc -> 'accounts') ->> 'parentAccountNumber')::integer parentAccountNumber
FROM (
SELECT p_in_accounts_json::json AS jc) b)
SELECT
tab.businessUnitId::text,
tab.parentAccountNumber::text,
tab.accountNumber::text,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab.positionId::text = '0095' THEN 1 ELSE 0 END) tax_professional_count,
SUM(CASE WHEN tab.positionId::text = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab.positionId::text = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab.positionId::text = '0050' THEN 1 ELSE 0 END) clerk_count
FROM tab1,tab
WHERE tab.parentAccountNumber::INTEGER=tab1.parentAccountNumber::INTEGER
AND tab.accountNumber::INTEGER=tab1.accountNumber::INTEGER
AND tab.businessUnitId::INTEGER=tab1.businessUnitId::INTEGER
GROUP BY tab.businessUnitId::text,
tab.parentAccountNumber::text,
tab.accountNumber::text) a;
RETURN v_out_accunts_json;
END;
$$;
```
*Execução da função*
```
select f_pg_json_test('{
"accounts": [{
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}, {
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}]
}') ;
```
*Saída da função*
A saída a seguir é semelhante à saída do procedimento Oracle. A diferença é que essa saída está no formato de texto.
```
{
"accountCounts": [
{
"businessUnitId": "6",
"parentAccountNumber": "32001",
"accountNumber": "42001",
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
},
{
"businessUnitId": "7",
"parentAccountNumber": "32000",
"accountNumber": "42000",
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 1,
"nonAttorneyCount": 0,
"clerkCount": 0
}
}
]
}
```
# Copie tabelas do Amazon DynamoDB entre contas usando AWS Backup
*Ramkumar Ramanujam, Amazon Web Services*
## Resumo
Ao trabalhar com o Amazon DynamoDB AWS em, um caso de uso comum é copiar ou sincronizar tabelas do DynamoDB em ambientes de desenvolvimento, teste ou preparação com os dados da tabela que estão no ambiente de produção. Como prática padrão, cada ambiente usa uma Conta da AWS diferente.
AWS Backup suporta backup e restauração de dados entre regiões e entre contas para DynamoDB, Amazon Simple Storage Service (Amazon S3) e outros. Serviços da AWS Esse padrão fornece as etapas para usar o backup e a restauração AWS Backup entre contas para copiar tabelas do DynamoDB entre elas. Contas da AWS
## Pré-requisitos e limitações
**Pré-requisitos **
+ Dois ativos Contas da AWS que pertencem à mesma organização em AWS Organizations
+ Permissões para criar tabelas do DynamoDB em ambas as contas
+ AWS Identity and Access Management Permissões (IAM) para criar e usar AWS Backup cofres
**Limitações**
+ A origem e o destino Contas da AWS devem fazer parte da mesma organização em AWS Organizations.
## Arquitetura
**Pilha de tecnologias de destino**
+ AWS Backup
+ Amazon DynamoDB
**Arquitetura de destino**
![\[A descrição da cópia de tabelas entre cofres de backup segue o diagrama.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/ef6e7393-edb6-4744-be26-43f1cbff9de9/images/fa9f3f2f-7a01-4093-9bd5-fc355e57ba67.png)
1. Crie o backup da tabela do DynamoDB no cofre de backup AWS Backup na conta de origem.
1. Copie o backup para o cofre de backup na conta de destino.
1. Restaure a tabela do DynamoDB na conta de destino usando o backup presente no cofre destinado a backups da conta de destino.
**Automação e escala**
Você pode usar AWS Backup para programar backups para serem executados em intervalos específicos.
## Ferramentas
+ [AWS Backup](https://docs.aws.amazon.com/aws-backup/latest/devguide/whatisbackup.html)é um serviço totalmente gerenciado para centralizar e automatizar a proteção de dados na nuvem e no local. Serviços da AWS Usando esse serviço, você pode configurar políticas de backup e monitorar a atividade de seus AWS recursos em um só lugar. O serviço permite automatizar e consolidar tarefas de backup que antes eram realizadas serviço por serviço, eliminando a necessidade de criar scripts personalizados e de processos manuais.
+ O [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) é um serviço de banco de dados NoSQL totalmente gerenciado que fornece uma performance rápida e previsível com escalabilidade integrada.
## Épicos
### Ativar AWS Backup recursos nas contas de origem e de destino
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Ative os atributos avançados para o DynamoDB e o backup entre contas. | Tanto na origem quanto no destino Contas da AWS, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, engenheiro de migração |
### Crie cofres de backup nas contas de origem e de destino
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Crie cofres de backup | Tanto na origem quanto no destino Contas da AWS, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html)Os cofres ARNs de backup de origem e de destino serão necessários quando você copiar o backup da tabela do DynamoDB entre as contas de origem e de destino. | AWS DevOps, engenheiro de migração |
### Execute backup e restauração usando cofres de backup
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Na conta de origem, crie uma tabela do DynamoDB. | Para criar um backup para a tabela do DynamoDB na conta de origem, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html)Uma nova tarefa de backup é criada. Para monitorar o status da tarefa de backup, na página AWS Backup **Trabalhos**, escolha a guia **Trabalhos de Backup**. Todos os trabalhos de backup ativos, em andamento e concluídos são listados nessa guia. | AWS DevOps, DBA, engenheiro de migração |
| Copie o backup da conta de origem para a conta de destino. | Depois que o trabalho de backup for concluído, copie o backup da tabela do DynamoDB do cofre de backup na conta de origem para o cofre de backup na conta de destino.Para copiar o cofre de backup, na conta de origem, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, engenheiro de migração, DBA |
| Restaure o backup na conta de destino. | No alvo Conta da AWS, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, DBA, engenheiro de migração |
## Recursos relacionados
+ [Usando AWS Backup com o DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/backuprestore_HowItWorksAWS.html)
+ [Criação de cópias de backup em Contas da AWS](https://docs.aws.amazon.com/aws-backup/latest/devguide/create-cross-account-backup.html)
+ [AWS Backup preços](https://aws.amazon.com/backup/pricing/)
# Copiar tabelas do Amazon DynamoDB entre contas usando uma implementação personalizada
*Ramkumar Ramanujam, Amazon Web Services*
## Resumo
Ao trabalhar com o Amazon DynamoDB no Amazon Web Services (AWS), um caso de uso comum é copiar ou sincronizar tabelas do DynamoDB em ambientes de desenvolvimento, teste ou preparação com os dados da tabela que estão no ambiente de produção. Como prática padrão, cada ambiente usa uma conta diferente da AWS.
O DynamoDB agora fornece suporte ao backup entre contas usando o AWS Backup. Para obter informações sobre os custos de armazenamento associados ao uso do AWS Backup, consulte os [Preços do AWS Backup](https://aws.amazon.com/backup/pricing/). Quando você usa o AWS Backup para copiar entre contas, as contas de origem e de destino devem fazer parte de uma organização do AWS Organizations. Existem outras soluções para backup e restauração entre contas usando os serviços da AWS, como o AWS Glue. O uso dessas soluções, no entanto, aumenta o espaço ocupado pelo aplicativo porque há mais serviços da AWS para implantar e manter.
Você também pode usar o Amazon DynamoDB Streams para registrar alterações na tabela na conta de origem. Em seguida, você pode iniciar uma função do AWS Lambda e fazer as alterações correspondentes na tabela de destino na conta de destino. Mas essa solução se aplica a casos de uso nos quais as tabelas de origem e destino devem sempre ser mantidas em sincronia. Isso talvez não se aplique a ambientes de desenvolvimento, teste e preparação em que os dados são atualizados com frequência.
Esse padrão fornece etapas para implementar uma solução personalizada para copiar uma tabela do Amazon DynamoDB de uma conta para outra. Esse padrão pode ser implementado usando linguagens de programação comuns, como C\$1, Java e Python. Recomendamos usar uma linguagem compatível com um [AWS SDK](https://aws.amazon.com/tools/).
## Pré-requisitos e limitações
**Pré-requisitos **
+ Duas contas da AWS ativas
+ Tabelas do DynamoDB em ambas as contas
+ Conhecimento do perfil e política do AWS Identity and Access Management (IAM)
+ Informações sobre como acessar tabelas do Amazon DynamoDB usando qualquer linguagem de programação comum, como C\$1, Java ou Python
**Limitações**
Esse padrão se aplica às tabelas do DynamoDB com cerca de 2 GB ou menos. Com lógica adicional para lidar com interrupções de conexão ou sessão, controle de utilização, falhas e novas tentativas, ele pode ser usado para tabelas maiores.
A operação de verificação do DynamoDB, que lê itens da tabela de origem, pode buscar somente até 1 MB de dados em uma única chamada. Para tabelas maiores, superiores a 2 GB, essa limitação pode aumentar o tempo total para a realização de uma cópia completa.
## Arquitetura
O diagrama apresentado a seguir ilustra a implementação personalizada entre as contas da AWS de origem e de destino. As políticas do IAM e os tokens de segurança são usados na implementação personalizada. Os dados são lidos do Amazon DynamoDB na conta de origem e gravados no DynamoDB na conta de destino.
![\[Arquitetura das contas de origem e de destino para a cópia usando a implementação personalizada.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/ba8175be-9809-4c2e-b2d1-6b9180ed056c/images/d9d4c2c8-ff04-443f-9137-e37b8e23ccb5.png)
**Automação e escala**
Esse padrão se aplica às tabelas do DynamoDB com cerca de 2 GB ou menos.
Para aplicar esse padrão a tabelas maiores, resolva os seguintes problemas:
+ Durante a operação de cópia da tabela, duas sessões ativas são mantidas usando tokens de segurança diferentes. Se a operação de cópia da tabela demorar mais do que os prazos de expiração do token, você deverá implementar uma lógica para atualizar os tokens de segurança.
+ Se unidades de capacidade de leitura (RCUs) e unidades de capacidade de gravação (WCUs) suficientes não forem provisionadas, as leituras ou gravações na tabela de origem ou de destino poderão ser limitadas. Certifique-se de identificar e lidar com essas exceções.
+ Lide com quaisquer outras falhas ou exceções e implemente um mecanismo de repetição para tentar novamente ou continuar do ponto no qual a operação de cópia falhou.
## Ferramentas
**Ferramentas**
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html): o Amazon DynamoDB é um serviço de banco de dados NoSQL totalmente gerenciado que fornece uma performance rápida e previsível com escalabilidade integrada.
+ As ferramentas adicionais necessárias serão diferentes com base na linguagem de programação que você escolher para a implementação. Por exemplo, se você usa C\$1, precisará do Microsoft Visual Studio e dos seguintes NuGet pacotes:
+ `AWSSDK`
+ `AWSSDK.DynamoDBv2`
**Código **
O trecho de código Python a seguir exclui e recria uma tabela do DynamoDB usando a biblioteca do Boto3.
Não use o `AWS_ACCESS_KEY_ID` e a `AWS_SECRET_ACCESS_KEY` de um usuário do IAM porque são credenciais de longo prazo que devem ser evitadas para acesso programático aos serviços da AWS. Para obter mais informações sobre as credenciais temporárias, consulte a seção *Práticas recomendadas*.
O `AWS_ACCESS_KEY_ID`, a `AWS_SECRET_ACCESS_KEY` e o `TEMPORARY_SESSION_TOKEN` usados no trecho de código a seguir são credenciais temporárias obtidas do AWS Security Token Service (AWS STS).
```
import boto3
import sys
import json
#args = input-parameters = GLOBAL_SEC_INDEXES_JSON_COLLECTION, ATTRIBUTES_JSON_COLLECTION, TARGET_DYNAMODB_NAME, TARGET_REGION, ...
#Input param: GLOBAL_SEC_INDEXES_JSON_COLLECTION
#[{"IndexName":"Test-index","KeySchema":[{"AttributeName":"AppId","KeyType":"HASH"},{"AttributeName":"AppType","KeyType":"RANGE"}],"Projection":{"ProjectionType":"INCLUDE","NonKeyAttributes":["PK","SK","OwnerName","AppVersion"]}}]
#Input param: ATTRIBUTES_JSON_COLLECTION
#[{"AttributeName":"PK","AttributeType":"S"},{"AttributeName":"SK","AttributeType":"S"},{"AttributeName":"AppId","AttributeType":"S"},{"AttributeName":"AppType","AttributeType":"N"}]
region = args['TARGET_REGION']
target_ddb_name = args['TARGET_DYNAMODB_NAME']
global_secondary_indexes = json.loads(args['GLOBAL_SEC_INDEXES_JSON_COLLECTION'])
attribute_definitions = json.loads(args['ATTRIBUTES_JSON_COLLECTION'])
# Drop and create target DynamoDB table
dynamodb_client = boto3.Session(
aws_access_key_id=args['AWS_ACCESS_KEY_ID'],
aws_secret_access_key=args['AWS_SECRET_ACCESS_KEY'],
aws_session_token=args['TEMPORARY_SESSION_TOKEN'],
).client('dynamodb')
# Delete table
print('Deleting table: ' + target_ddb_name + ' ...')
try:
dynamodb_client.delete_table(TableName=target_ddb_name)
#Wait for table deletion to complete
waiter = dynamodb_client.get_waiter('table_not_exists')
waiter.wait(TableName=target_ddb_name)
print('Table deleted.')
except dynamodb_client.exceptions.ResourceNotFoundException:
print('Table already deleted / does not exist.')
pass
print('Creating table: ' + target_ddb_name + ' ...')
table = dynamodb_client.create_table(
TableName=target_ddb_name,
KeySchema=[
{
'AttributeName': 'PK',
'KeyType': 'HASH' # Partition key
},
{
'AttributeName': 'SK',
'KeyType': 'RANGE' # Sort key
}
],
AttributeDefinitions=attribute_definitions,
GlobalSecondaryIndexes=global_secondary_indexes,
BillingMode='PAY_PER_REQUEST'
)
waiter = dynamodb_client.get_waiter('table_exists')
waiter.wait(TableName=target_ddb_name)
print('Table created.')
```
## Práticas recomendadas
**Credenciais temporárias**
Como prática recomendada de segurança, ao acessar serviços da AWS programaticamente, evite usar `AWS_ACCESS_KEY_ID` e o `AWS_SECRET_ACCESS_KEY` de um usuário do IAM, pois são credenciais de longo prazo. Sempre tente usar credenciais temporárias para acessar os serviços da AWS de forma programática.
Por exemplo, um desenvolvedor codifica o `AWS_ACCESS_KEY_ID` e a `AWS_SECRET_ACCESS_KEY` de um usuário do IAM no aplicativo durante o desenvolvimento, mas não consegue remover os valores codificados antes de enviar as alterações para o repositório de códigos. Essas credenciais expostas podem ser usadas por usuários mal-intencionados ou maliciosos, o que pode ter sérias implicações (principalmente se as credenciais expostas tiverem privilégios de administrador). Essas credenciais expostas devem ser desativadas ou excluídas imediatamente usando o console do IAM ou a AWS Command Line Interface (AWS CLI).
Sempre tente usar credenciais temporárias para acessar os serviços da AWS de forma programática. As credenciais temporárias são válidas somente pelo tempo especificado (de 15 minutos a 36 horas). A duração máxima permitida de credenciais temporárias varia de acordo com fatores como configurações de função e encadeamento de funções. Para obter mais informações sobre a AWS STS, consulte a [documentação](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html).
## Épicos
### Configurar tabelas do DynamoDB
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Crie uma tabela do DynamoDB. | Crie tabelas do DynamoDB, com índices, nas contas de origem e de destino da AWS.Defina o provisionamento de capacidade como modo sob demanda, o que permite que o DynamoDB read/write escale as capacidades dinamicamente com base na carga de trabalho. Como alternativa, você pode usar a capacidade provisionada com 4000 RCUs e 4000. WCUs | Desenvolvedor de aplicativos, DBA, engenheiro de migração |
| Preencha a tabela de origem. | Preencha a tabela do DynamoDB na conta de origem com dados de teste. Ter pelo menos 50 MB ou mais de dados de teste ajuda você a ver o pico e a média RCUs consumidos durante a cópia da tabela. Em seguida, você pode alterar o provisionamento de capacidade conforme necessário. | Desenvolvedor de aplicativos, DBA, engenheiro de migração |
### Configurar credenciais para acessar as tabelas do DynamoDB
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Crie perfis do IAM para acessar as tabelas de origem e destino do DynamoDB. | Crie um perfil do IAM na conta de origem com permissões para acessar (ler) a tabela do DynamoDB na conta de origem.Adicione a conta de origem como uma entidade confiável para esse perfil.Crie um perfil do IAM na conta de destino com permissões para acessar (criar, ler, atualizar, excluir) a tabela do DynamoDB na conta de destino. Adicione a conta de destino como uma entidade confiável para esse perfil. | Desenvolvedor de aplicativos, AWS DevOps |
### Copiar dados da tabela de uma conta para outra
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Obtenha credenciais temporárias para os perfis do IAM. | Obtenha credenciais temporárias para o perfil do IAM criado na conta de origem.Obtenha credenciais temporárias para o perfil do IAM criado na conta de destino.Uma forma de obter as credenciais temporárias para o perfil do IAM é usar o AWS STS da AWS CLI.aws sts assume-role --role-arn arn:aws:iam::Use o perfil apropriado da AWS (correspondente à conta de origem ou de destino).Para obter mais informações sobre as credenciais de segurança temporárias, consulte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html) | Desenvolvedor de aplicativos, engenheiro de migração | | Inicialize os clientes DynamoDB para acesso ao DynamoDB de origem e de destino. | Inicialize os clientes DynamoDB, que são fornecidos pelo AWS SDK, para as tabelas de origem e de destino do DynamoDB.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html)Para obter mais informações sobre como fazer solicitações usando credenciais temporárias do IAM, consulte a [documentação da AWS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/AuthUsingTempSessionToken.html). | Desenvolvedor de aplicativos | | Solte e recrie a tabela de destino. | Exclua e recrie a tabela do DynamoDB de destino (junto com os índices) na conta de destino usando o cliente DynamoDB da conta de destino.Excluir todos os registros de uma tabela do DynamoDB é uma operação cara porque consome provisionados. WCUs Excluir e recriar a tabela evita esses custos extras.Você pode adicionar índices a uma tabela depois de criá-la, mas isso leva de dois a cinco minutos a mais. Criar índices durante a criação da tabela, transferindo a coleção de índices para a chamada `createTable`, é mais eficiente. | Desenvolvedor de aplicativos | | Execute a cópia da tabela. | Repita as etapas a seguir até que todos os dados sejam copiados:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html)Para obter mais informações, consulte a implementação de referência em C\$1 (para eliminar, criar e preencher tabelas) na seção *Anexos*. Um exemplo de arquivo de notação de JavaScript objeto de configuração de tabela (JSON) também está anexado. | Desenvolvedor de aplicativos | ## Recursos relacionados + [Documentação do Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) + [Criação de um usuário do IAM na sua conta da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html) + [AWS SDKs](https://aws.amazon.com/tools/) + [Uso de credenciais temporárias com recursos da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) ## Mais informações Esse padrão foi implementado usando C\$1 para copiar uma tabela do DynamoDB com 200.000 itens (tamanho médio do item de 5 KB e tamanho da tabela de 250 MB). A tabela de destino do DynamoDB foi configurada com capacidade provisionada de 4000 e 4000. RCUs WCUs A operação completa de cópia da tabela (da conta de origem para a conta de destino), incluindo a remoção e a recriação da tabela, levou cinco minutos. Total de unidades de capacidade consumidas: 30.000 RCUs e aproximadamente WCUs 400.000. Para obter mais informações sobre os modos de capacidade do DynamoDB, consulte [Modo de capacidade de leitura/gravação](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html) na documentação da AWS. ## Anexos Para acessar o conteúdo adicional associado a este documento, descompacte o seguinte arquivo: [ attachment.zip](samples/p-attach/ba8175be-9809-4c2e-b2d1-6b9180ed056c/attachments/attachment.zip) # Crie relatórios detalhados de custos e uso para o Amazon RDS e o Amazon Aurora *Lakshmanan Lakshmanan e Sudarshan Narasimhan, Amazon Web Services* ## Resumo Este padrão mostra como rastrear os custos de uso dos clusters Amazon Relational Database Service (Amazon RDS) ou Amazon Aurora configurando [tags de alocação de custos definidas pelo usuário](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/custom-tags.html). Você pode usar essas tags para criar relatórios detalhados de custo e uso no Explorador de Custos da AWS para clusters em várias dimensões. Por exemplo, você pode rastrear os custos de uso no nível da equipe, do projeto ou do centro de custo, e, em seguida, analisar os dados no Amazon Athena. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Uma ou mais instâncias do [Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateDBInstance.html) ou [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.CreateInstance.html) **Limitações** Para restrições de tags, consulte o [Guia do usuário do AWS Billing](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/allocation-tag-restrictions.html). ## Arquitetura **Pilha de tecnologias de destino** + Amazon RDS ou Amazon Aurora + Relatório de custos e uso da AWS + AWS Cost Explorer + Amazon Athena **Fluxo de trabalho e arquitetura** O fluxo de trabalho de marcação e análise consiste nas seguintes etapas: 1. Um engenheiro de dados, administrador de banco de dados ou administrador da AWS cria tags de alocação de custos definidas pelo usuário para os clusters do Amazon RDS ou Aurora. 1. Um administrador da AWS ativa as tags. 1. As tags reportam metadados para o Explorador de Custos da AWS. 1. Um engenheiro de dados, administrador de banco de dados ou administrador da AWS cria um [relatório mensal de alocação de custos](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/configurecostallocreport.html#allocation-viewing). 1. Um engenheiro de dados, administrador de banco de dados ou administrador da AWS analisa o relatório mensal de alocação de custos usando o Amazon Athena. O diagrama a seguir mostra como aplicar tags para monitorar os custos de uso das instâncias do Amazon RDS ou do Aurora. ![\[Aplicação de tags para rastrear os custos de uso de instâncias e clusters de banco de dados\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/eab5001d-5115-4aa6-bdd2-23063b08b262/images/63292b18-01d6-4523-b8ac-2c3b12b11b84.png) O diagrama de arquitetura a seguir mostra como o relatório de alocação de custos é integrado ao Amazon Athena para análise. ![\[Consulta de relatórios de alocação de custos no Athena\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/eab5001d-5115-4aa6-bdd2-23063b08b262/images/9c028405-1e93-4f6a-a0e5-36154e2b8eab.png) O relatório de alocação de custos mensal é armazenado em um bucket do Amazon S3 que você especificar. Quando você configura o Athena com o CloudFormation modelo da AWS, conforme descrito na seção *Epics*, o modelo fornece vários recursos adicionais, incluindo um rastreador do AWS Glue, um banco de dados do AWS Glue, um evento do Amazon Simple Notification System (Amazon SNS), funções do AWS Lambda e funções do AWS Identity and Access Management (IAM) para as funções do Lambda. À medida que novos arquivos de dados de custo chegam ao bucket do S3, as notificações de eventos são usadas para encaminhar esses arquivos a uma função do Lambda para processamento. A função do Lambda inicia uma tarefa de crawler do AWS Glue para criar ou atualizar a tabela no catálogo de dados do AWS Glue. Em seguida, essa tabela é usada para consultar dados no Athena. ## Ferramentas + O [Amazon Athena](https://aws.amazon.com/athena/) é um serviço de consultas interativas que facilita a análise de dados no Amazon S3 usando SQL padrão. + O [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) é um mecanismo de banco de dados relacional totalmente gerenciado que é construído para a nuvem e compatível com o MySQL e o PostgreSQL. + O [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) ajuda você a configurar, operar e escalar um banco de dados relacional na Nuvem AWS. + CloudFormationA [AWS](https://aws.amazon.com/cloudformation/) é um serviço de infraestrutura como código (IaC) que permite modelar, provisionar e gerenciar facilmente recursos da AWS e de terceiros. + O [Explorador de Custos da AWS](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/ce-what-is.html) permite que você visualize e analise seus custos e uso. ## Épicos ### Crie e ative tags para seus clusters do Amazon RDS e Aurora | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie tags de alocação de custos definidas pelo usuário para seus clusters do Amazon RDS ou Aurora. | Para adicionar tags a um cluster novo ou existente do Amazon RDS ou do Aurora, siga as instruções em [Adição, listagem e remoção de tags](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html#Tagging.HowTo) no *Guia do usuário do Amazon Aurora*.Para obter informações sobre como configurar um cluster do Amazon Aurora, consulte as instruções para [MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.Aurora.html) e [PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.AuroraPostgreSQL.html) no *Guia do usuário do Amazon Aurora*. | Administrador da AWS, engenheiro de dados, DBA | | Ativar as tags de alocação de custos definidas pelo usuário. | Siga as instruções em [Ativação de tags de alocação de custos definidas pelo usuário](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/activating-tags.html) no Guia do usuário do *AWS Billing*. | Administrador da AWS | ### Criação de relatórios de custos e uso | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie e configure relatórios de custo e uso para seus clusters. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/create-detailed-cost-and-usage-reports-for-amazon-rds-and-amazon-aurora.html)Os dados estarão disponíveis em 24 horas. | Proprietário do aplicativo, administrador da AWS, DBA, AWS geral, engenheiro de dados | ### Analisar dados do relatório de custos e uso | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Analisar dados do relatório de custos e uso. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/create-detailed-cost-and-usage-reports-for-amazon-rds-and-amazon-aurora.html):role/ --role-session-name --profile
select status from cost_and_usage_data_statusPara obter mais informações, consulte [Como executar consultas no Amazon Athena](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-run.html) no *Guia do usuário dos Relatórios de Custos e Uso do AWS*.Quando você executar a consulta SQL, certifique-se de que o banco de dados correto esteja selecionado na lista suspensa. | Proprietário do aplicativo, administrador da AWS, DBA, AWS geral, engenheiro de dados | ## Recursos relacionados **Referências** + [Configurar o Athena usando CloudFormation modelos da AWS (recomendado](https://docs.aws.amazon.com/cur/latest/userguide/use-athena-cf.html)) + [Configuração manual do Athena](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-manual.html) + [Execução de consultas do Amazon Athena](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-run.html) + [Carregar dados do relatório para outros recursos](https://docs.aws.amazon.com/cur/latest/userguide/cur-query-other.html) **Tutoriais e vídeos** + [Analise relatórios de custo e uso usando o Amazon Athena (vídeo](https://youtu.be/KEeJEZTYE8E)) YouTube # Implante instâncias de cluster de failover do SQL Server na Amazon EC2 e na Amazon FSx usando o Terraform *Mark Hudson e Matt Burgess, Amazon Web Services* ## Resumo Esse padrão usa o Terraform para implantar instâncias de cluster de failover do SQL Server (FCIs) em nós do Windows Server Failover Cluster (WSFC) no Amazon Elastic Compute Cloud (Amazon). EC2 Além disso, o padrão usa o armazenamento FSx compartilhado da Amazon para dados e arquivos de log. Quando os bancos de dados do SQL Server são migrados para AWS, a primeira opção é o Amazon RDS for SQL Server. No entanto, às vezes o Amazon RDS for SQL Server não é adequado e o SQL Server deve ser implantado na EC2 Amazon em uma arquitetura altamente disponível. Nessa solução, o SQL Server FCIs é instalado nos nós do WSFC. O módulo Terraform incluído nesse padrão provisiona até duas instâncias EC2 do Amazon SQL Server. Um sistema de arquivos Amazon FSx para Windows File Server atua como testemunha do quórum e armazena dados compartilhados e arquivos de log. Independentemente do número de instâncias configuradas, os nós da instância do SQL Server sempre criarão e ingressarão em um cluster de FCI para garantir a paridade do ambiente. (Normalmente, uma instância é configurada para desenvolvimento e duas instâncias para ambientes de produção.) Para configurações que usam dois nós para alta disponibilidade, um Network Load Balancer interno é provisionado. O Network Load Balancer usa uma sonda de integridade configurada no cluster de FCI para identificar qual nó é o principal. ## Pré-requisitos e limitações **Pré-requisitos ** + Um ativo Conta da AWS. + A Amazon Virtual Private Cloud (Amazon VPC) com duas sub-redes em zonas de disponibilidade separadas. + [Conjunto de opções de DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/DHCPOptionSet.html) da Amazon VPC. Configure o nome de domínio para resolver seu nome de domínio do Active Directory e o domínio e os servidores de nomes NetBIOS para apontar para seus controladores de domínio do Active Directory. Para obter mais informações, consulte *Configuração da VPC* em [Informações adicionais](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). + AWS Directory Service for Microsoft Active Directory (AWS Managed Microsoft AD). + Imagem de máquina da Amazon (AMI) personalizada. Para obter mais detalhes, consulte *Configuração da AMI* em [Informações adicionais](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). + O Bucket do Amazon Simple Storage Service (Amazon S3) que contém a imagem ISO do SQL Server. Esse pré-requisito só é necessário se você estiver usando o [EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html) com o `component.yaml` arquivo fornecido para criar a AMI personalizada. + AWS Key Management Service (AWS KMS) chave de criptografia. + Por padrão, o SQL Server é instalado usando uma chave de produto da edição para desenvolvedores. Espera-se que os sistemas de produção usem uma chave de produto válida passada para o módulo pela variável relevante. **Limitações** + Essa solução exige o AWS Managed Microsoft AD. No entanto, se preferir, é possível usar uma implementação autogerenciada do Active Directory. Para fazer isso, modifique o módulo Amazon FSx Terraform incluído para remover o `active_directory_id` atributo. Em seguida, adicione os quatro atributos necessários para o Active Directory autogerenciado, conforme mostrado na [documentação do Terraform](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/fsx_windows_file_system). + O SQL Server está configurado para usar a autenticação de modo misto. Caso prefira, é possível usar a autenticação somente para Windows. Para isso, no script de dados do usuário fornecido, remova os parâmetros `/SECURITYMODE` e `/SAPWD` fornecidos para o comando `setup.exe`. Você pode remover o arquivo `sql_accounts.tf` e modificar o arquivo `instances.tf` para remover a entrada `sql_sa_password`. + Ao excluir um cluster implantado, você deve remover os objetos do computador virtual correspondentes e os objetos do computador individuais no Active Directory. Para remover os objetos, use as ferramentas administrativas do Active Directory. + Alguns Serviços da AWS não estão disponíveis em todos Regiões da AWS. Para conferir a disponibilidade de uma região, consulte [AWS Services by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para endpoints específicos, consulte [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e clique no link correspondente ao serviço desejado. **Versões do produto** Essa solução foi testada com as seguintes versões: + Windows Server 2019 + SQL Server 2019 + [Terraform v0.13.0](https://developer.hashicorp.com/terraform/language/v1.1.x/upgrade-guides/0-13) ## Arquitetura **Pilha de tecnologia de origem** + SQL Server **Pilha de tecnologias de destino** + SQL Server FCI em nós WSFC usando Amazon EC2 + Servidor FSx de arquivos Amazon para Windows + Bucket do Amazon S3. + AWS Secrets Manager + AWS Managed Microsoft AD + AWS KMS + AWS Identity and Access Management (IAM) **Arquitetura de destino** O diagrama apresentado a seguir ilustra a arquitetura para esta solução. ![\[Arquitetura para implantar instâncias de cluster de failover do SQL Server em nós de cluster de failover do Windows Server na Amazon. EC2\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/45f3ab19-d240-4353-ab6e-f6e565f537a4/images/0bff16f2-94e7-4e86-91ea-7ab5f3725620.png) O diagrama mostra o seguinte: + Uma função do IAM que fornece às EC2 instâncias acesso ao Secrets Manager AWS KMS e ao Secrets Manager + Dois nós do SQL Server implantados em EC2 instâncias da Amazon em sub-redes privadas em duas zonas de disponibilidade + Um Network Load Balancer para facilitar as conexões com a instância ativa do SQL Server (não implantado ao configurar um cluster de nó único) + Sistema de arquivos Amazon FSx para Windows File Server implantado em ambas as sub-redes privadas para armazenamento compartilhado pelos nós do SQL Server + O Secrets Manager para armazenar as credenciais e as configurações do Active Directory e do SQL Server + O bucket do Amazon S3 para armazenar a imagem de instalação do SQL Server + AWS Managed Microsoft AD para autenticação do Windows + AWS KMS para criar a chave de criptografia **Automação e escala** [Você pode automatizar a implantação da arquitetura de destino usando os módulos do Terraform que estão no GitHub repositório.](https://github.com/aws-samples/cluster-amazon-elastic-compute-cloud-amazon-fsx-microsoft-sql-server) Você deve modificar o arquivo `terraform.tfvars` para incluir valores de variáveis específicos do seu ambiente. O bucket, os AWS Managed Microsoft AD componentes, a chave de AWS KMS criptografia e alguns segredos do Amazon S3 são pré-requisitos para essa implantação e não estão incluídos no código do Terraform. ## Ferramentas **Serviços da AWS** + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)permite que suas cargas de trabalho e AWS recursos com reconhecimento de diretório usem o Microsoft Active Directory no. Nuvem AWS Nesse padrão, AWS Managed Microsoft AD é usado para autenticação do Windows Server e SQL Server e para DNS. + [O Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) fornece capacidade de computação escalável no. Nuvem AWS Você poderá iniciar quantos servidores virtuais precisar e escalá-los na vertical rapidamente. Nesse padrão, as instâncias do cluster de failover do SQL Server são instaladas nas EC2 instâncias da Amazon. + EC2 O [Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html) ajuda você a automatizar a criação, o gerenciamento e a implantação de imagens personalizadas do servidor. + [O Amazon FSx para Windows File Server](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) fornece armazenamento compartilhado totalmente gerenciado no Windows Server. Nesse padrão, FSx para Windows, o File Server fornece armazenamento compartilhado para dados e arquivos de log do SQL Server e para a testemunha do quórum. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ajuda você a gerenciar com segurança o acesso aos seus AWS recursos controlando quem está autenticado e autorizado a usá-los. + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) ajuda você a criar e controlar chaves criptográficas para ajudar a proteger seus dados. Nesse padrão, ele é usado para criptografar segredos do Secrets Manager, o armazenamento do SQL Server nos volumes do Amazon Elastic Block Store (Amazon EBS) e o sistema de arquivos do FSx Windows File Server. + O [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) ajuda a substituir credenciais codificadas, incluindo senhas, por uma chamada de API ao Secrets Manager para recuperar o segredo por programação. Neste padrão, as credenciais do Active Directory para instalar e executar o SQL Server, as credenciais do usuário `sa` e as informações de conexão do banco de dados são armazenadas no Secrets Manager. + O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objetos baseado na nuvem que ajuda você a armazenar, proteger e recuperar qualquer quantidade de dados. Este padrão usa um bucket do Amazon S3 para armazenar a imagem de instalação do SQL Server. + [A Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) ajuda você a lançar AWS recursos em uma rede virtual que você definiu. Essa rede virtual é semelhante a uma rede tradicional que você operaria no próprio datacenter, com os benefícios de usar a infraestrutura escalável da AWS. ** ****Outras ferramentas** + [O Microsoft SQL Server FCIs](https://learn.microsoft.com/en-us/sql/sql-server/failover-clusters/windows/always-on-failover-cluster-instances-sql-server?view=sql-server-ver15) é instalado nos nós de cluster do Windows Server. Além disso, eles podem ser instalados em várias sub-redes. Neste padrão, as instâncias FCI do SQL Server são instaladas nos nós do WSFC. + O [Terraform](https://www.terraform.io/) é uma ferramenta de infraestrutura como código (IaC) que ajuda a provisionar e gerenciar recursos e infraestrutura de nuvem por meio de código. Neste padrão, o Terraform é usado para criar os recursos e configurar as instâncias FCI do SQL Server. + O [cluster de failover do Windows Server](https://learn.microsoft.com/en-us/sql/sql-server/failover-clusters/windows/windows-server-failover-clustering-wsfc-with-sql-server?view=sql-server-ver15) fornece recursos de infraestrutura que oferecem suporte à alta disponibilidade de aplicações de servidor hospedadas, como o SQL Server. Neste padrão, os nós FCI usam a funcionalidade do WSFC para fornecer alta disponibilidade local por meio de redundância no nível da instância. **Repositório de código** O código desse padrão está disponível no repositório GitHub [cluster-amazon-elastic-compute- cloud-amazon-fsx-microsoft -sql-server](https://github.com/aws-samples/cluster-amazon-elastic-compute-cloud-amazon-fsx-microsoft-sql-server). Os seguintes recursos estão disponíveis no repositório: + Um arquivo `README.md` que fornece uma visão geral da solução e informações adicionais de instalação e uso + Um conjunto básico de arquivos de configuração do Terraform e um módulo FSx específico da Amazon para provisionar os componentes desse padrão + Um script de configuração de instância que é executado como um script de dados EC2 do usuário da Amazon + Um arquivo `component.yam`l que o Image Builder pode usar para criar uma AMI personalizada ## Práticas recomendadas **Segurança e patches** + As instalações e configurações pré-requisitos da AMI são os requisitos mínimos para implantar clusters de FCI do SQL Server. Software e configurações adicionais podem ser necessários para atender aos padrões e os requisitos de segurança da sua organização. + Após a implantação, corrija o Windows continuamente. Corrija diretamente as instâncias em execução ou crie uma nova AMI com os patches mais recentes do Windows e substitua as instâncias (uma por vez) usando a nova AMI. AWS lança AMIs mensalmente o novo Windows que contém os patches, drivers e agentes de lançamento mais recentes do sistema operacional. Recomendamos verificar se está usando a AMI mais recente ao executar novas instâncias ou ao criar suas próprias imagens personalizadas. + As EC2 instâncias da Amazon são configuradas para permitir todo o tráfego de saída. Quando implantado em um ambiente de produção, as regras de saída no grupo de segurança devem ser implementadas para restringir esse tráfego aos destinos necessários. + O sistema FSx de arquivos do Windows File Server pode registrar automaticamente os registros de auditoria para compartilhamento de arquivos e acesso a arquivos e pastas e enviá-los para o destino desejado, se isso for um requisito em seu ambiente. + Alterne os segredos do Secrets Manager regularmente e de maneira automática. Para o par de chaves de EC2 instância da Amazon, considere uma solução de rotação automatizada, conforme descrito em [Como usar o AWS Secrets Manager para armazenar e alternar pares de chaves SSH com segurança](https://aws.amazon.com/blogs/security/how-to-use-aws-secrets-manager-securely-store-rotate-ssh-key-pairs/). Para as credenciais do Active Directory e os segredos da credencial `sa` do SQL Server, configure a rotação automática de acordo com suas políticas de gerenciamento de senhas. **Gerenciamento do Active Directory** + Como parte do cluster de FCI, o Windows gera um objeto de nome de computador (CNO) no Active Directory. O CNO responde às solicitações de DNS e encaminha o tráfego para o nó do SQL ativo. *Não* recomendamos o uso desse DNS fornecido pelo Active Directory. O TTL é muito alto para fornecer um tempo razoável de failover e geralmente leva mais de cinco minutos para refletir o novo endereço IP primário. Por outro lado, para instalações de alta disponibilidade, o Network Load Balancer interno é configurado para failover em 30 segundos. + É necessário um administrador de domínio do Active Directory para criar o cluster. Esse requisito se deve às permissões elevadas necessárias para criar os objetos de cluster e modificar as permissões no Active Directory. No entanto, os serviços do SQL Server não precisam ser executados como administrador de domínio. Por isso, recomendamos criar um segundo usuário do Active Directory para essa finalidade. No entanto, você pode eliminar esse usuário se os serviços forem executados como usuário administrador do domínio. Nesse caso, o usuário administrador do domínio deve ser adicionado ao grupo de administradores do Active Directory criado como parte deste padrão. ## Épicos ### Configurar credenciais de cluster | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie os grupos do Active Directory. | Em AWS Managed Microsoft AD, crie os seguintes grupos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Para obter mais detalhes, consulte [Criação de um AWS Managed Microsoft AD grupo](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_create_group.html) na AWS documentação. | Administrador do AD | | Crie os usuários do Active Directory. | Em AWS Managed Microsoft AD, crie os seguintes usuários[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Para obter mais detalhes, consulte [Criação de um AWS Managed Microsoft AD usuário](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_manage_users_groups_create_user.html) na AWS documentação. | Administrador do AD | | Adicione as credenciais do Active Directory aos segredos. | Use o Secrets Manager para criar quatro segredos para armazenar as seguintes informações:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Para obter mais detalhes, consulte [Criar um AWS Secrets Manager segredo](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) na AWS documentação. | Administrador da AWS | ### Prepare o ambiente | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie a AMI do Windows. | Crie uma AMI personalizada do Windows que inclua o software e as configurações pré-requisitos. Para obter mais detalhes, consulte [Informações adicionais](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). | Administrador da AWS, AWS DevOps | | Instale o Terraform. | Para instalar o Terraform, siga as instruções no site do [Terraform](https://learn.hashicorp.com/tutorials/terraform/install-cli). | AWS DevOps | | Clonar o repositório. | Clone o [repositório](https://github.com/aws-samples/cluster-amazon-elastic-compute-cloud-amazon-fsx-microsoft-sql-server) deste padrão. Para obter mais detalhes, consulte [Clonar um repositório](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) no GitHub site. | AWS DevOps | ### Instalar o cluster | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Modifique as variáveis do Terraform. | Atualize o arquivo `terraform.tfvars` fornecido para definir todas as variáveis com os valores apropriados para seu ambiente.Por exemplo, atualize as variáveis `domain_group_administrators` e `domain_group_rdp_users` para usar seu nome de domínio do Active Directory e o nome dos grupos do Active Directory criados anteriormente. | AWS DevOps | | Inicializar o Terraform. | Para ver a implantação proposta, navegue até a raiz do repositório. Use a interface de linha de comandos (CLI) do Terraform para executar `terraform init` e depois execute `terraform plan`. | AWS DevOps | | Implante os recursos. | Para implantar o cluster do SQL e os recursos associados, use a CLI do Terraform para executar `terraform apply`. | AWS DevOps, administrador da AWS | | Valide a implantação. | Para validar a implantação, siga as etapas abaixo:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html) | DBA, administrador de sistemas da AWS | ## Solução de problemas | Problema | Solução | | --- | --- | | O provisionamento do Terraform foi concluído, mas o gerenciador de cluster de failover do Windows não mostra que um cluster foi criado ou que o cluster está em um estado inoperável. | Toda a instalação dos recursos e a configuração dos clusters podem levar de 45 a 60 minutos. Depois que o Terraform for concluído, o script de dados do usuário deverá ser executado até a conclusão, o que requer várias reinicializações. Para monitorar o progresso, você pode usar o diretório `Checkpoints` na unidade `C:\` e os logs de instalação do SQL Server em `C:\Program Data\Microsoft SQL Server\150\Log`. Ao terminar, a mensagem **Instalação concluída** estará disponível no arquivo `C:\ProgramData\Amazon\EC2-Windows\Launch\Log\UserdataExecution.log`. | | Depois de provisionar um cluster em funcionamento, o uso do Terraform para excluir e recriar o cluster não é bem-sucedido. O Terraform é concluído, mas o cluster não está configurado corretamente. | Parte do processo de provisionamento envolve o registro de máquinas e objetos virtuais no Active Directory e no DNS do Active Directory. Quando existem nomes de computador para os nós do EC2 cluster da Amazon e para o nó do cluster, o FCI não pode inicializar corretamente e falhará no provisionamento.Para resolver esse problema, execute as seguintes etapas: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html) | ## Recursos relacionados **AWS documentação** + [Crie imagens personalizadas com o Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-images.html) + [Criar uma chave KMS](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) + [Criação de um balde de uso geral](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) + [Criação de uma política chave](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) + [Criando seu AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html) ## Mais informações **Informações do módulo do Terraform** Este módulo usa uma combinação de configuração de AMI e configuração de dados do usuário para obter uma boa combinação de tempo de provisionamento e estabilidade. Durante o provisionamento, o Windows exige várias reinicializações e esperas. Um método de pontos de verificação foi implementado para proteger contra loops infinitos durante as reinicializações dos dados persistentes do usuário. Os dados do usuário estão configurados para serem persistentes. Portanto, os scripts de configuração de dados do usuário devem continuar sendo desenvolvidos para serem idempotentes. A idempotência simplifica o processo de atualização, permitindo que as instâncias sejam trocadas durante um ciclo de atualização sem configuração manual para reingressar ou recriar clusters do FCI. **Strings de conexão e cluster de failover do SQL Server** O módulo publicará um segredo contendo o endereço do endpoint que deve ser usado nas strings de conexão desse banco de dados. O nome do segredo segue o formato `{environment_name}/sqlserver/{cluster_name}/endpoint`. Para instalações em que apenas um nó é usado, você pode esperar que esse seja o endereço IP da interface do SQL Server da EC2 instância Amazon. Para instalações de alta disponibilidade (duas instâncias), você pode esperar que esse seja o nome do DNS do Network Load Balancer interno. O agrupamento virtual de failover IPs não é suportado neste módulo. Um IP virtual deve permanecer na mesma sub-rede para funcionar. Em AWS, uma única sub-rede não pode abranger várias zonas de disponibilidade. Portanto, o uso do virtual IPs eliminaria a capacidade desse módulo ser considerado altamente disponível. Cada EC2 instância da Amazon recebe três endereços IP privados. Seu uso é o seguinte: + **IP primário para tráfego de rede**: o IP de origem para tráfego de saída. + **Comunicações de FCI**: usadas para manter o estado e a sincronização do cluster de failover. + **SQL Server (porta TCP 1433)**: receptor e também escuta o tráfego de pulsação para determinar qual instância é primária. **Configuração de VPC** Os [pré-requisitos](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-prereqs) listam um conjunto de opções de DHCP configurado para usar o Active Directory para resolução de DNS. No entanto, esse pré-requisito não é um requisito difícil. O requisito básico é que as EC2 instâncias sejam capazes de resolver seu nome de domínio do Active Directory. Atender a esse requisito pode ser feito de outras formas, como usando Amazon Route 53 Resolver endpoints. Para obter mais informações, consulte [Integrando a resolução de DNS do seu serviço de diretório com os resolvedores do Amazon Route 53](https://aws.amazon.com/blogs/networking-and-content-delivery/integrating-your-directory-services-dns-resolution-with-amazon-route-53-resolvers/) (AWS postagem no blog). **Configuração da AMI** A AMI usada neste padrão deve conter os seguintes pré-requisitos de software e configurações: 1. Baixe e expanda os arquivos de instalação do SQL Server 2019 para `C:\SQL_Install_media`. 1. Instale os seguintes recursos do Windows: + `Install-WindowsFeature Failover-Clustering` + `Install-WindowsFeature RSAT-AD-PowerShell` + `Install-WindowsFeature RSAT-AD-Tools` + `Install-WindowsFeature RSAT-Clustering-Mgmt` + `Install-WindowsFeature RSAT-Clustering-PowerShell` + `Install-WindowsFeature RSAT-Clustering-CmdInterface` 1. Desabilite o firewall do Windows da seguinte maneira: + `Get-NetFirewallProfile | Set-NetFirewallProfile -Enabled False` 1. Habilite o método de autenticação CredSSP (substitua `
DECLARE| DBA | | Execute o PL/SQL quarteirão. | Execute o PL/SQL bloco de origem no Oracle. Se houver lacunas entre os valores dos índices de uma matriz associativa, nenhum dado será armazenado nessas lacunas. Isso permite que o loop da Oracle itere apenas pelas posições de índice. | DBA | | Revise a saída. | Cinco elementos foram inseridos na matriz (`cc`) em intervalos não consecutivos. A contagem da matriz é mostrada na saída a seguir:
TYPE country_codes IS TABLE OF VARCHAR2(100) INDEX BY pls_integer;
cc country_codes;
cc_idx NUMBER := NULL;
BEGIN
cc(7) := 'India';
cc(3) := 'UK';
cc(5) := 'USA';
cc(0) := 'China';
cc(-2) := 'Invalid';
dbms_output.put_line('cc_length:' || cc.COUNT);
IF (cc.COUNT > 0) THEN
cc_idx := cc.FIRST;
FOR i IN 1..cc.COUNT LOOP
dbms_output.put_line('cc_idx:' || cc_idx || ' country:' || cc(cc_idx));
cc_idx := cc.next(cc_idx);
END LOOP;
END IF;
END;
cc_length:5| DBA | ### Comportamento de matrizes associativas do PostgreSQL (destino) | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um PL/pgSQL bloco de destino no PostgreSQL. | Crie um PL/pgSQL bloco de destino no PostgreSQL que use a seguinte matriz associativa:
cc_idx:-2 country:Invalid
cc_idx:0 country:China
cc_idx:3 country:UK
cc_idx:5 country:USA
cc_idx:7 country:India
DO $$| DBA | | Execute o PL/pgSQL quarteirão. | Execute o PL/pgSQL bloco de destino no PostgreSQL. Se houver lacunas entre os valores dos índices de uma matriz associativa, nenhum dado será armazenado nessas lacunas. Isso permite que o loop da Oracle itere apenas pelas posições de índice. | DBA | | Revise a saída. | O comprimento da matriz é maior que cinco porque o valor `NULL` é armazenado nas lacunas entre as posições de índice. Como mostrado na saída a seguir, o loop realiza dez iterações para recuperar cinco valores na matriz.
DECLARE
cc character varying(100)[];
cc_idx integer := NULL;
BEGIN
cc[7] := 'India';
cc[3] := 'UK';
cc[5] := 'USA';
cc[0] := 'China';
cc[-2] := 'Invalid';
RAISE NOTICE 'cc_length: %', ARRAY_LENGTH(cc, 1);
IF (ARRAY_LENGTH(cc, 1) > 0) THEN
FOR i IN ARRAY_LOWER(cc, 1)..ARRAY_UPPER(cc, 1)
LOOP
RAISE NOTICE 'cc_idx:% country:%', i, cc[i];
END LOOP;
END IF;
END;
$$;
cc_length:10| DBA | ### Simulação do comportamento de matrizes associativas da Oracle | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um PL/pgSQL bloco de destino com uma matriz e um tipo definido pelo usuário. | Para otimizar a performance e corresponder à funcionalidade da Oracle, podemos criar um tipo definido pelo usuário que armazena tanto as posições de índice quanto os dados correspondentes. Essa abordagem reduz iterações desnecessárias ao manter associações diretas entre os índices e os valores.
cc_idx:-2 country:Invalid
cc_idx:-1 country:
cc_idx:0 country:China
cc_idx:1 country:
cc_idx:2 country:
cc_idx:3 country:UK
cc_idx:4 country:
cc_idx:5 country:USA
cc_idx:6 country:
cc_idx:7 country:India
DO $$| DBA | | Execute o PL/pgSQL quarteirão. | Execute o PL/pgSQL bloco alvo. Se houver lacunas entre os valores dos índices de uma matriz associativa, nenhum dado será armazenado nessas lacunas. Isso permite que o loop da Oracle itere apenas pelas posições de índice. | DBA | | Revise a saída. | Como mostrado na saída a seguir, o tipo definido pelo usuário armazena apenas elementos de dados preenchidos, o que significa que o comprimento da matriz corresponde ao número de valores. Como resultado, as iterações do `LOOP` são otimizadas para processar apenas dados existentes, eliminando a necessidade de monitorar posições vazias.
DECLARE
cc country_codes[];
cc_append country_codes := NULL;
i record;
BEGIN
cc_append.idx = 7;
cc_append.val = 'India';
cc := array_append(cc, cc_append);
cc_append.idx = 3;
cc_append.val = 'UK';
cc := array_append(cc, cc_append);
cc_append.idx = 5;
cc_append.val = 'USA';
cc := array_append(cc, cc_append);
cc_append.idx = 0;
cc_append.val = 'China';
cc := array_append(cc, cc_append);
cc_append.idx = - 2;
cc_append.val = 'Invalid';
cc := array_append(cc, cc_append);
RAISE NOTICE 'cc_length: %', ARRAY_LENGTH(cc, 1);
IF (ARRAY_LENGTH(cc, 1) > 0) THEN
FOR i IN (
SELECT
*
FROM
unnest(cc)
ORDER BY
idx)
LOOP
RAISE NOTICE 'cc_idx:% country:%', i.idx, i.val;
END LOOP;
END IF;
END;
$$;
cc_length:5| DBA | ## Recursos relacionados **AWS documentação** + [AWS blog de banco de dados](https://aws.amazon.com/blogs/database/) + [Manual de migração da Oracle para o Aurora PostgreSQL](https://docs.aws.amazon.com/dms/latest/oracle-to-aurora-postgresql-migration-playbook/chap-oracle-aurora-pg.html) **Outras documentações** + [Oracle associative arrays](https://docs.oracle.com/en/database/oracle/oracle-database/23/lnpls/associative-arrays.html#GUID-8060F01F-B53B-48D4-9239-7EA8461C2170) + [PostgreSQL array functions and operators](https://www.postgresql.org/docs/current/functions-array.html) + [PostgreSQL user-defined types](https://www.postgresql.org/docs/current/sql-createtype.html) # Habilite conexões criptografadas para instâncias de banco de dados PostgreSQL no Amazon RDS *Rohit Kapoor, Amazon Web Services* ## Resumo O Amazon Relational Database Service (Amazon RDS) é compatível com a criptografia SSL para instâncias de banco de dados PostgreQL. Por meio do SSL, você pode criptografar uma conexão do PostgreSQL entre seus aplicativos e suas instâncias de banco de dados do Amazon RDS para PostgreSQL. Por padrão, o Amazon RDS for SSL/TLS PostgreSQL usa e espera que todos os clientes se conectem usando criptografia. SSL/TLS O Amazon RDS para PostgreSQL oferece suporte às versões 1.1, e 1.2 do TLS. Esse padrão descreve como você pode habilitar conexões criptografadas para uma instância de banco de dados do Amazon RDS para PostgreSQL. Você pode usar o mesmo processo para habilitar conexões criptografadas para o Amazon Aurora Edição Compatível com PostgreSQL. ## Pré-requisitos e limitações + Uma conta AWS ativa + Uma [instância de banco de dados Amazon RDS para PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_RDS_Configuring.html) + Um [pacote SSL](https://www.postgresql.org/docs/current/ssl-tcp.html) ## Arquitetura ![\[Habilitando conexões criptografadas para instâncias de banco de dados PostgreSQL no Amazon RDS\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/4f87c6a3-b4ff-4248-96d3-a4a498659735/images/ccc5c880-1191-4c12-a255-6908b96b96a5.png) ## Ferramentas + O [pgAdmin](https://www.pgadmin.org/) é uma plataforma de administração e desenvolvimento de código aberto para o PostgreSQL. Você pode usar o pgAdmin no Linux, Unix, macOS e Windows para gerenciar seus objetos de banco de dados no PostgreSQL 10 e versões posteriores. + Os [editores do PostgreSQL](https://wiki.postgresql.org/wiki/PostgreSQL_Clients) fornecem uma interface mais fácil de usar para ajudá-lo a criar, desenvolver e executar consultas e a editar o código de acordo com seus requisitos. ## Práticas recomendadas + Monitore conexões de banco de dados não seguras. + Audite direitos de acesso ao banco de dados. + Garanta que os backups e os instantâneos sejam criptografados em repouso. + Monitore o acesso ao banco de dados. + Evite grupos de acesso irrestrito. + Melhore suas notificações com a [Amazon GuardDuty](https://docs.aws.amazon.com/guardduty/latest/ug/what-is-guardduty.html). + Monitore a adesão à política regularmente. ## Épicos ### Baixe um certificado confiável e importe-o para sua loja confiável | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Carregue um certificado confiável no seu computador. | Para adicionar certificados ao armazenamento das Autoridades de Certificação Raiz Confiáveis do seu computador, siga estas etapas. (Essas instruções usam o Windows Server como exemplo.)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html) | DevOps engenheiro, engenheiro de migração, DBA | ### Forçar conexões SSL | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um grupo de parâmetros e defina o parâmetro rds.force\$1ssl. | Se a instância de banco de dados PostgreSQL tiver um grupo de parâmetros personalizado, edite o grupo de parâmetros e altere `rds.force_ssl` para 1.Se a instância de banco de dados usar o grupo de parâmetros padrão que não tem `rds.force_ssl` habilitado, crie um novo grupo de parâmetros. Você pode modificar o novo grupo de parâmetros usando a API do Amazon RDS ou manualmente, conforme as instruções a seguir.para criar um novo grupo de parâmetros:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Para associar o novo grupo de parâmetros de banco de dados à sua instância de banco de dados:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Para obter mais informações, consulte a [documentação do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithDBInstanceParamGroups.html). | DevOps engenheiro, engenheiro de migração, DBA | | Força conexões SSL. | Conecte-se à sua instância de banco de dados do Amazon RDS para PostgreSQL de origem. As tentativas de conexão que não usam SSL são rejeitadas com uma mensagem de erro. Para obter mais informações, consulte a [documentação do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html#PostgreSQL.Concepts.General.SSL.Requiring). | DevOps engenheiro, engenheiro de migração, DBA | ### Instalar extensão SSL | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Instale a extensão SSL. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Para obter mais informações, consulte a [documentação do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html). | DevOps engenheiro, engenheiro de migração, DBA | ### Configure seu cliente PostgreSQL para SSL | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Configure um cliente para SSL. | Usando SSL, você pode iniciar o servidor PostgreSQL com suporte para conexões criptografadas que usam protocolos TLS. O servidor recebe as conexões padrão e SSL na mesma porta TCP e negocia com qualquer cliente conectado se deve usar SSL ou não. Por padrão, essa é uma opção cliente.Se estiver usando o cliente psql:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Para outros clientes do PostgreSQL:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Examine as páginas a seguir para esses clientes:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html) | DevOps engenheiro, engenheiro de migração, DBA | ## Solução de problemas | Problema | Solução | | --- | --- | | Não é possível baixar o certificado SSL. | Verifique sua conexão com o site e tente baixar novamente o certificado em seu computador local. | ## Recursos relacionados + [Documentação do Amazon RDS para PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) + [Usando SSL com uma instância de banco de dados PostgreSQL (documentação do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html)) + [ TCP/IP Conexões seguras com SSL (documentação](https://www.postgresql.org/docs/9.1/ssl-tcp.html) do PostgreSQL) + [Usando SSL (documentação](https://jdbc.postgresql.org/documentation/ssl/) do JDBC) # Criptografe uma instância de banco de dados Amazon RDS para PostgreSQL existente *Piyush Goyal, Shobana Raghu e Yaser Raja, Amazon Web Services* ## Resumo Este padrão explica como criptografar uma instância de banco de dados do Amazon Relational Database Service (Amazon RDS) para PostgreSQL existente na Nuvem AWS com tempo de inatividade mínimo. Esse processo também funciona para instâncias de banco de dados do Amazon RDS para MySQL. Você só pode habilitar a criptografia para uma instância de banco de dados do Amazon RDS ao criá-la, e não após a sua criação. No entanto, você pode adicionar criptografia a uma instância de banco de dados não criptografada criando um snapshot da instância de banco de dados e depois criando uma cópia criptografada desse snapshot. Em seguida, você pode restaurar uma instância de banco de dados a partir do snapshot criptografado, você terá uma cópia criptografada da sua instância de banco de dados original. Se seu projeto permitir tempo de inatividade (pelo menos para transações de gravação) durante essa atividade, isso é tudo o que você precisa fazer. Quando a nova cópia criptografada da instância de banco de dados estiver disponível, você poderá direcionar seus aplicativos para o novo banco de dados. No entanto, se seu projeto não permitir um tempo de inatividade significativo para essa atividade, você precisará de uma abordagem alternativa que ajude a minimizar o tempo de inatividade. Esse padrão usa o AWS Database Migration Service (AWS DMS) para migrar e replicar continuamente os dados para que a substituição para o novo banco de dados criptografado possa ser feita com o mínimo de tempo de inatividade. As instâncias de banco de dados criptografadas do Amazon RDS usam o algoritmo de criptografia AES-256 padrão da indústria para criptografar os dados no servidor que hospeda as instâncias do Amazon RDS DB. Após a criptografia dos seus dados, o Amazon RDS lida com a autenticação do acesso e a decodificação dos seus dados de forma transparente com um mínimo impacto sobre o desempenho. Você não precisa modificar suas aplicações cliente de banco de dados para usar a criptografia. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Uma instância de banco de dados do Amazon RDS para PostgreSQL + Experiência em trabalhar com (criar, modificar ou interromper) tarefas do AWS DMS (consulte [Trabalho com tarefas do AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.html) na documentação do AWS DMS) + Familiaridade com o AWS Key Management Service (AWS KMS) para criptografar bancos de dados (consulte a documentação do AWS [KMS](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)) **Limitações** + Você só pode habilitar a criptografia para uma instância de banco de dados do Amazon RDS ao criá-la, e não após a sua criação. + Os dados em [tabelas não registradas](https://www.postgresql.org/docs/current/sql-createtable.html) não serão restaurados usando instantâneos. Para obter mais informações, consulte [Melhores práticas para trabalhar com PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_BestPractices.html#CHAP_BestPractices.PostgreSQL). + Não é possível ter uma réplica de leitura criptografada de uma instância de banco de dados não criptografada nem uma réplica de leitura não criptografada de uma instância de banco de dados criptografada. + Não é possível restaurar um backup ou um snapshot não criptografado em uma instância de banco de dados criptografada. + O AWS DMS não transfere automaticamente as sequências, portanto, etapas adicionais são necessárias para lidar com isso. Para obter mais informações, consulte [Limitações das instâncias de banco de dados criptografadas do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html#Overview.Encryption.Limitations) na documentação do Amazon RDS. ## Arquitetura **Arquitetura de origem** + Instância de banco de dados do RDS não criptografada **Arquitetura de destino** + Instância de banco de dados do RDS criptografada + A instância de banco de dados RDS de destino é criada restaurando a cópia do DB snapshot da instância de banco de dados RDS de origem. + Uma chave do AWS KMS é usada para criptografia durante a restauração do snapshot. + Uma tarefa de replicação do AWS DMS é usada para migrar os dados. ![\[O processo usa o AWS DMS para criptografar uma instância existente do Amazon RDS para PostgreSQL em um novo banco de dados.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/820d17c0-0eed-4ed9-9f43-cbada081d924/images/44dd8420-d89d-466e-b7fb-1bdafab8f7f9.png) ## Ferramentas **Ferramentas usadas para habilitar a criptografia:** + Chave do AWS KMS para criptografia: ao criar uma instância de banco de dados criptografada, você pode escolher uma chave gerenciada pelo cliente ou a chave gerenciada pela AWS para que o Amazon RDS criptografe a sua instância de banco de dados. Se você não especificar o identificador de chave para uma chave gerenciada pelo cliente, o Amazon RDS usará a chave gerenciada pela AWS para a sua nova instância de banco de dados. O Amazon RDS cria uma chave gerenciada pela AWS CMK gerenciada para o Amazon RDS para sua conta da . Sua conta da AWS tem uma chave gerenciada pela AWS diferente para Amazon RDS para cada região da AWS. Para obter mais informações sobre o uso de chaves KMS para criptografia do Amazon RDS, consulte [Criptografando recursos do Amazon](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html) RDS. **Ferramentas usadas para replicação contínua:** + AWS DMS: você pode usar o AWS Database Migration Service (AWS DMS) para replicar as alterações do banco de dados de origem para o banco de dados de destino. É importante manter o banco de dados de origem e de destino sincronizados para reduzir ao mínimo o tempo de inatividade. Para obter informações sobre como configurar o AWS DMS e criar tarefas, consulte a documentação do [AWS DMS.](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) ## Épicos ### Crie um snapshot da instância de banco de dados de origem e criptografe-a | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Verificar os detalhes da instância de banco de dados PostgreSQL de origem. | No console do Amazon RDS, escolha a instância de banco de dados PostgreSQL de origem. Na guia **Configuração**, verifique se a criptografia não está habilitada para a instância. Para ver uma ilustração de tela, consulte a seção [Informações adicionais](#encrypt-an-existing-amazon-rds-for-postgresql-db-instance-additional). | DBA | | Crie um snapshot de banco de dados. | Crie um snapshot do banco de dados da instância que deseja criptografar. O tempo necessário para criar um snapshot depende do tamanho do seu banco de dados. Para obter instruções, consulte [Criação de um DB snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html) na documentação do Amazon RDS. | DBA | | Criptografe o instantâneo. | No painel de navegação do console Amazon RDS, escolha **Snapshots** e selecione o DB snapshot que você criou. Para **Actions (Ações)**, escolha **Copy Snapshot (Copiar snapshot)**. Forneça a região da AWS de destino e o nome da cópia do DB snapshot nos campos correspondentes. Marque a caixa de seleção **Ativar criptografia**. Em **Master Key (Chave mestre)**, especifique o identificador de chave do KMS a ser usado para criptografar a cópia do snapshot de banco de dados. Escolha **Copy Snapshot (Copiar snapshot)**. Para obter informações, consulte [Cópia de um snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CopySnapshot.html) na documentação do Amazon RDS. | DBA | ### Prepare a instância de banco de dados de destino | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Restaure o snapshot de banco de dados. | No console do Amazon RDS, selecione a guia **Snapshots**. Escolha o instantâneo criptografado que você criou. Em **Actions (Ações)**, escolha **Restore Snapshot (Restaurar snapshot)**. Em **Identificador da instância de banco de dados**, insira um nome exclusivo de sua instância de banco de dados. Revise os detalhes da instância e escolha **Restaurar instância de banco de dados**. Uma nova instância de banco de dados criptografada será criada a partir do seu snapshot. Para obter mais informações, consulte [Restaurar um snapshot de banco de dados](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_RestoreFromSnapshot.html) na documentação do Amazon RDS. | DBA | | Migrar dados usando o AWS DMS | No console do AWS DMS, crie uma tarefa do AWS DMS. Para **Migration type** escolha **Migrate existing data and replication ongoing changes (Migrar dados existentes e replicar alterações contínuas)**. Em **Configurações da tarefa**, no **modo de preparação da tabela de destino**, escolha **Truncar**. Para obter mais informações consulte [Criação de uma tarefa](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html), consulte a documentação do DMS. | DBA | | Ativar a validação de dados | Em **Configurações da tarefa**, escolha **Habilitar validação**. Isso permite comparar os dados de origem com os dados de destino para verificar se os dados foram migrados com precisão. | DBA | | Desabilite as restrições na instância de banco de dados de destino. | [Desative quaisquer gatilhos e restrições de chave estrangeira](https://www.postgresql.org/docs/current/sql-altertable.html) na instância de banco de dados de destino e, em seguida, inicie a tarefa do AWS DMS. [Para obter mais informações sobre a desativação de acionadores e restrições de chave estrangeira, consulte a documentação do AWS DMS.](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.PostgreSQL.html) | DBA | | Verificar os dados. | Depois que o carregamento completo estiver concluído, verifique os dados na instância de banco de dados de destino para ver se eles correspondem aos dados de origem. Para obter mais informações, consulte [Validação de dados](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Validating.html) na documentação do AWS DMS. | DBA | ### Vá para a instância de banco de dados de destino | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Interrompa as operações de gravação na instância de banco de dados de origem. | Pare as operações de gravação na instância de banco de dados de origem para que o tempo de inatividade do aplicativo possa começar. Verifique se o AWS DMS concluiu a replicação dos dados no pipeline. Habilite gatilhos e chaves estrangeiras na instância de banco de dados de destino. | DBA | | Atualizar sequências do banco de dados | Se o banco de dados de origem contiver números de sequência, verifique e atualize as sequências no banco de dados de destino. | DBA | | Configure o endpoint da aplicação. | Configure as conexões do aplicativo para usar os novos endpoints de instância de banco de dados do Amazon RDS. A instância de banco de dados já está criptografada. | DBA, proprietário do aplicativo | ## Recursos relacionados + [Criar uma tarefa do AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) + [Monitorando tarefas de replicação usando a Amazon CloudWatch](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Monitoring.html#CHAP_Monitoring.CloudWatch) + [Monitoramento de tarefas do AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Monitoring.html) + [Atualização da chave de criptografia do Amazon RDS](https://aws.amazon.com/premiumsupport/knowledge-center/update-encryption-key-rds/) ## Mais informações Verificar a criptografia da instância de banco de dados PostgreSQL de origem: ![\[A página Resumo da instância do banco de dados de origem do PostgreSQL mostra que a criptografia não está habilitada para o armazenamento.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/820d17c0-0eed-4ed9-9f43-cbada081d924/images/d53d1dab-b5c2-452d-b823-ba3d6508ad15.png) Notas adicionais para esse padrão: + Ative a replicação no PostgreSQL `rds.logical_replication` definindo o parâmetro como 1. **Observação importante:** os slots de replicação retêm os arquivos de registro antecipado de gravação (WAL) até que os arquivos sejam consumidos externamente — por exemplo, por`pg_recvlogical`; por trabalhos de extração, transformação e carregamento (ETL); ou pelo AWS DMS. Quando você define o valor do `rds.logical_replication` parâmetro como 1, o AWS DMS define os parâmetros `wal_level`, `max_wal_senders`, `max_replication_slots`, e `max_connections`. Se houver slots de replicação lógica, mas não houver consumidor para os arquivos WAL retidos pelo slot de replicação, você poderá observar um aumento no uso do disco do log de transações e uma diminuição constante no espaço livre de armazenamento. Para obter mais informações e etapas para resolver esse problema, consulte o artigo [Como posso identificar o que está causando o erro “Não há espaço restante no dispositivo” ou "DiskFull" no Amazon RDS for](https://aws.amazon.com/premiumsupport/knowledge-center/diskfull-error-rds-postgresql/) PostgreSQL? no Centro de conhecimento do AWS Support. + Qualquer alteração de esquema que você fizer na instância de banco de dados de origem depois de criar o DB snapshot não estará presente na instância de banco de dados de destino. + Após criar uma instância de banco de dados criptografada, não será possível alterar a chave do KMS usada por essa instância de banco de dados. Certifique-se de determinar os requisitos da chave do KMS antes de criar a instância de banco de dados criptografada. + Você deve desativar os gatilhos e as chaves estrangeiras na instância de banco de dados de destino antes de executar a tarefa do AWS DMS. É possível reabilitá-los quando a tarefa for concluída. # Aplique a marcação automática dos bancos de dados do Amazon RDS no lançamento *Susanne Kangnoh e Archit Mathur, Amazon Web Services* ## Resumo O Amazon Relational Database Service (Amazon RDS) é um serviço Web que facilita a configuração, operação e dimensionamento de um banco de dados relacional na Nuvem do Amazon Web Services (AWS). Ele fornece capacidade econômica e redimensionável para um banco de dados relacional padrão do setor e gerencia tarefas comuns de administração de banco de dados. As tags permitem categorizar seus recursos da AWS de maneiras diferentes. A marcação de banco de dados relacional é útil quando você tem muitos recursos em sua conta e deseja identificar rapidamente um recurso específico baseado nas tags. Você pode usar tags do Amazon RDS para adicionar metadados personalizados às instâncias de banco de dados do RDS. Cada tag consiste em um valor e em uma chave definida pelo usuário. Recomendamos criar um conjunto consistente de tags para atender às necessidades da sua organização. Esse padrão fornece um CloudFormation modelo da AWS para ajudá-lo a monitorar e marcar instâncias de banco de dados do RDS. O modelo cria um evento da Amazon CloudWatch Events que acompanha o DBInstance evento AWS CloudTrail **Create**. (CloudTrail captura chamadas de API para o Amazon RDS como eventos.) Quando detecta esse evento, ela chama uma função do Lambda da AWS que aplica automaticamente as chaves e os valores de tag definidos por você. O modelo também envia uma notificação de que a instância foi marcada, usando o Amazon Simple Notification Service (Amazon SNS). ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Um bucket do Amazon Simple Storage Service (Amazon S3) para carregar o código Lambda. + Um endereço de e-mail no qual você deseja receber notificações de marcação. **Limitações** + A solução oferece suporte à CloudTrail **criação** de DBInstance eventos. Ela não cria notificações para nenhum outro evento. ## Arquitetura **Arquitetura de fluxo de trabalho** ![\[Workflow diagram showing Serviços da AWS interaction for RDS instance creation and notification.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/5541bc1e-e00f-4b5a-94b7-bb1808b5591a/images/ec0bcf92-f986-4af3-bfe7-d2c5e04051c5.png) **Automação e escala** + Você pode usar o CloudFormation modelo da AWS várias vezes para diferentes regiões e contas da AWS. Você precisa executar o modelo somente uma vez em cada região ou conta. ## Ferramentas **Serviços da AWS** + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html) — CloudTrail A AWS é um serviço da AWS que ajuda você com a governança, a conformidade e a auditoria operacional e de risco da sua conta da AWS. As ações realizadas por um usuário, função ou serviço da AWS são registradas como eventos em CloudTrail. + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html) — O Amazon CloudWatch Events fornece um fluxo quase em tempo real de eventos do sistema que descrevem mudanças nos recursos da AWS. CloudWatch Os eventos ficam cientes das mudanças operacionais à medida que elas ocorrem e tomam medidas corretivas conforme necessário, enviando mensagens para responder ao ambiente, ativando funções, fazendo alterações e capturando informações de estado. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html): o AWS Lambda é um serviço de computação que oferece suporte à execução de código sem a necessidade de provisionar ou gerenciar servidores. O Lambda executa o código somente quando necessário e dimensiona automaticamente, desde algumas solicitações por dia até milhares por segundo. Você paga apenas pelo tempo de computação consumido. Não haverá cobranças quando o código não estiver em execução. + [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html): o Amazon Simple Storage Service (Amazon S3) é um serviço de armazenamento de objetos altamente escalável que pode ser usado para uma ampla variedade de soluções de armazenamento, incluindo sites, aplicativos móveis, backups e data lakes. + [Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html): o Amazon Simple Notification Service (Amazon SNS) é um serviço web que permite que aplicativos, usuários finais e dispositivos enviem e recebam notificações da nuvem instantaneamente. **Código ** Esse padrão inclui um anexo com dois arquivos: + `index.zip` é um arquivo compactado que inclui o código do Lambda para esse padrão. + `rds.yaml`é um CloudFormation modelo que implanta o código Lambda. Consulte a seção *Tópicos* para obter informações sobre como usar esses arquivos. ## Épicos ### Implantar o código do Lambda | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Faça upload do código para um bucket do S3. | Crie um novo bucket do S3 ou use um bucket do S3 existente para carregar o arquivo `index.zip` anexado (código do Lambda). Esse bucket deve estar na mesma região da AWS que os recursos (instâncias de banco de dados do RDS) que você deseja monitorar. | Arquiteto de nuvem | | Implante o CloudFormation modelo. | Abra o console do Cloudformation na mesma região da AWS do bucket S3 e implante o arquivo `rds.yaml` fornecido no anexo. No próximo épico, forneça valores para os parâmetros do modelo. | Arquiteto de nuvem | ### Preencha os parâmetros no CloudFormation modelo | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Dar o nome do bucket do S3. | Insira o nome do bucket do S3 que você criou ou selecionou no primeiro épico. Esse bucket do S3 contém o arquivo.zip do código Lambda e deve estar na mesma região da AWS que o CloudFormation modelo e as instâncias de banco de dados do RDS que você deseja monitorar. | Arquiteto de nuvem | | Fornecer a chave do S3. | Forneça a localização do arquivo .zip do código Lambda em seu bucket do S3, sem barras iniciais (por exemplo, `index.zip` ou `controls/index.zip`). | Arquiteto de nuvem | | Fornecer um endereço de e-mail. | Forneça um endereço de e-mail ativo no qual você deseja receber notificações de violação. | Arquiteto de nuvem | | Especifique um nível de log. | Especifique o nível de registro em log e a verbosidade. `Info` designa mensagens informativas detalhadas sobre o progresso do aplicativo e deve ser usado somente para depuração. `Error` designa eventos de erro que ainda podem permitir que o aplicativo continue em execução. `Warning` designa situações potencialmente prejudiciais. | Arquiteto de nuvem | | Insira as chaves e os valores das tags para suas instâncias de banco de dados do RDS. | Insira as chaves de tag e os valores necessários que você deseja aplicar automaticamente à instância do RDS. Para obter mais informações, consulte [Marcar recursos do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html) na documentação da AWS. | Arquiteto de nuvem | ### Confirmar a assinatura | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Confirme a assinatura por e-mail. | Quando o CloudFormation modelo é implantado com sucesso, ele envia uma mensagem de e-mail de assinatura para o endereço de e-mail que você forneceu. Para receber notificações quando suas instâncias forem marcadas, você deve confirmar essa assinatura de e-mail. | Arquiteto de nuvem | ## Recursos relacionados + [Criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html) (documentação do Amazon S3) + [Marcação de recursos do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html) (documentação do Amazon Aurora) + [Carregando objetos](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html) (documentação do Amazon S3) + [Criação de uma regra de CloudWatch eventos que é acionada em uma chamada de API da AWS usando a AWS (documentação da CloudTrail](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-CloudTrail-Rule.html) Amazon CloudWatch ) ## Anexos Para acessar o conteúdo adicional associado a este documento, descompacte o seguinte arquivo: [ attachment.zip](samples/p-attach/5541bc1e-e00f-4b5a-94b7-bb1808b5591a/attachments/attachment.zip) # Expressa o custo de uma tabela do DynamoDB para capacidade sob demanda *Moinul Al-Mamun, Amazon Web Services* ## Resumo O [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) é um banco de dados transacional NoSQL que fornece latência de milissegundos de um dígito, mesmo em escala de petabytes. Essa oferta de tecnologia sem servidor da Amazon Web Services (AWS) está se tornando popular por causa do seu desempenho e escalabilidade consistentes. Não é necessário provisionar a infraestrutura subjacente. Sua única tabela pode crescer para até petabytes. Com o modo de capacidade sob demanda, você paga por solicitação pelas leituras e gravações de dados que seu aplicativo executa nas tabelas. As cobranças da AWS são baseadas nas unidades de solicitação de leitura (RRUs) e unidades de solicitação de gravação (WRUs) acumuladas em um mês. O DynamoDB monitora continuamente o tamanho da sua tabela durante todo o mês para determinar suas cobranças de armazenamento. Ele suporta backup contínuo com point-in-time-recovery (PITR). O DynamoDB monitora continuamente o tamanho de suas tabelas habilitadas para PITR durante todo o mês para determinar suas cobranças de backup. Para estimar o custo do DynamoDB para um projeto, é importante calcular quanto RRU, WRU e armazenamento serão consumidos em diferentes estágios do ciclo de vida do produto. Para uma estimativa aproximada de custos, você pode usar a [Calculadora de Preços da AWS](https://calculator.aws/#/createCalculator/DynamoDB), mas deve fornecer um número aproximado de RRUs, WRUs, e requisitos de armazenamento para sua tabela. Isso pode ser difícil de estimar no início do projeto. A calculadora de preços da AWS não considera a taxa de crescimento de dados nem o tamanho do item, nem considera o número de leituras e gravações da tabela base e dos índices secundários globais (GSIs) separadamente. Para usar a calculadora de preços da AWS, você deve estimar todos esses aspectos para presumir valores aproximados de WRU, RRU e tamanho de armazenamento para obter sua estimativa de custo. Esse padrão fornece um mecanismo e um modelo reutilizável do Microsoft Excel para estimar os fatores de custo básicos do DynamoDB, como gravação, leitura, armazenamento, backup e custo de recuperação, para o modo de capacidade sob demanda. Ela é mais granular do que a Calculadora de Preços da AWS e considera a tabela base e GSIs os requisitos de forma independente. Ele também considera a taxa mensal de crescimento dos dados do item e prevê custos por três anos. ## Pré-requisitos e limitações **Pré-requisitos ** + Conhecimento básico do DynamoDB e do design do modelo de dados do DynamoDB + Conhecimento básico sobre preços, WRU, RRU, armazenamento, backup e recuperação do DynamoDB (para obter mais informações, consulte [Preços da capacidade sob demanda](https://aws.amazon.com/dynamodb/pricing/on-demand/)) + Conhecimento de seus dados, modelo de dados e tamanho do item no DynamoDB + Conhecimento do DynamoDB GSIs **Limitações** + O modelo fornece um cálculo aproximado, mas não é apropriado para todas as configurações. Para obter uma estimativa mais precisa, você deve medir o tamanho individual do item para cada item na tabela base GSIs e. + Para uma estimativa mais precisa, você deve considerar o número esperado de gravações (inserir, atualizar e excluir) e leituras para cada item em um mês médio. + Esse padrão permite estimar somente os custos de gravação, leitura, armazenamento, backup e recuperação para os próximos anos, com base em suposições fixas de crescimento de dados. ## Ferramentas **Serviços da AWS** + O [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) é um serviço de banco de dados NoSQL totalmente gerenciado que fornece performance rápida, previsível e escalável. **Outras ferramentas** + A [Calculadora de preços da AWS](https://calculator.aws/#/createCalculator/DynamoDB) é uma ferramenta de planejamento baseada na web que você pode usar para criar estimativas para seus casos de uso da AWS. ## Práticas recomendadas Para ajudar a manter os custos baixos, considere as seguintes práticas recomendadas de design do DynamoDB. + [Design de chave de partição](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-partition-key-uniform-load.html): use uma chave de partição de alta cardinalidade para distribuir a carga uniformemente. + [Padrão de design da lista de adjacências](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-adjacency-graphs.html) — Use esse padrão de design para gerenciamento one-to-many e many-to-many relacionamentos. + Índice [esparso — Use um índice](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-indexes-general-sparse-indexes.html) esparso para o seu. GSIs Ao criar um GSI, você especifica uma chave de partição e, opcionalmente, uma chave de classificação. Somente itens na tabela base que contêm uma chave de partição GSI correspondente aparecem no índice esparso. Isso ajuda a manter o GSIs tamanho menor. + [Sobrecarga de índice](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-gsi-overloading.html): use o mesmo GSI para indexar vários tipos de itens. + [Fragmentação de gravação de GSI](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-indexes-gsi-sharding.html): fragmente de forma inteligente para distribuir dados entre as partições para permitir consultas mais rápidas e eficientes. + [Itens grandes](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-use-s3-too.html): armazene somente metadados dentro da tabela, salve o blob no Amazon S3 e mantenha a referência no DynamoDB. Divida itens grandes em vários itens e indexe com eficiência usando chaves de classificação. Para obter mais conhecer mais práticas recomendadas consulte o [Guia do desenvolvedor do Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html). ## Épicos ### Extraia as informações do item do seu modelo de dados do DynamoDB | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Obtenha o tamanho do item. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Engenheiro de dados | | Faça uma estimativa do custo de gravação. | Para estimar o custo de gravação no modo de capacidade sob demanda, primeiro você precisa medir quantos WRUs serão consumidos em um mês. Para isso, você precisa considerar os seguintes fatores:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html)Para obter mais informações, consulte a seção *Informações adicionais*. | Engenheiro de dados | | Estime o custo de leitura. | Para estimar o custo de leitura no modo sob demanda, primeiro você precisa medir quantos RRUs serão consumidos em um mês. Para isso, você precisa considerar os seguintes fatores: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Engenheiro de dados, desenvolvedor de aplicativos | | Estime o tamanho e o custo do armazenamento. | Primeiro, estime a necessidade média mensal de armazenamento com base no tamanho do item na tabela. Em seguida, calcule o custo de armazenamento multiplicando o tamanho do armazenamento pelo preço de armazenamento por GB para sua região da AWS. Se você já inseriu dados para estimar o custo de gravação, não precisará inseri-los novamente para calcular o tamanho do armazenamento. Caso contrário, para estimar o tamanho do armazenamento, você precisa considerar os seguintes fatores: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Engenheiro de dados | ### Insira as informações do item e do objeto no modelo do Excel | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Baixe o modelo do Excel na seção Anexos e ajuste-o para sua tabela de casos de uso. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Engenheiro de dados | | Insira as informações no modelo do Excel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html)No modelo, há três itens ou entidades: informações, metadados e relacionamento. Há dois GSIs. Para seu caso de uso, se precisar de mais itens, crie novas linhas. Se precisar de mais GSIs, copie um bloco GSI existente e cole para criar quantos blocos GSI você precisar. Em seguida, ajuste os cálculos das colunas SOMA e TOTAL. | Engenheiro de dados | ## Recursos relacionados **Referências** + [Preços do Amazon DynamoDB para capacidade sob demanda](https://aws.amazon.com/dynamodb/pricing/on-demand/) + [Calculadora de preços da AWS para DynamoDB](https://calculator.aws/#/createCalculator/DynamoDB) + [Práticas recomendadas de design e arquitetura com o DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html) + [Conceitos básicos do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) **Guias e padrões** + [Modelagem de dados com Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-data-modeling/) + [Estime os custos de armazenamento de uma tabela do Amazon DynamoDB](https://apg-library.amazonaws.com/content/9b74399d-9655-47ee-b9b3-de46b65bc4e3) ## Mais informações **Escreva um exemplo de cálculo de custos** O design do modelo de dados do DynamoDB mostra três itens para um produto e um tamanho médio de item de 4 KB. Quando você adiciona um novo produto à tabela base do DynamoDB, ele consome o número de itens \$1 (tamanho do item/unidade de gravação de 1 KB) = 3 \$1 (4/1) = 12 WRU. Neste exemplo, para gravar 1 KB, o produto consome 1 WRU. **Leia o exemplo de cálculo de custos** Para obter a estimativa de RRU, considere a média de quantas vezes cada item será lido em um mês. Por exemplo, o item de informação será lido, em média, 10 vezes em um mês, e o item de metadados será lido duas vezes, e o item de relacionamento será lido cinco vezes. No modelo de exemplo, RRU total para todos os componentes = número de novos componentes criados a cada mês \$1 RRU por componente por mês = 10 milhões \$1 17 RRU = 170 milhões de RRU por mês. Todos os meses, novidades (componentes ou produtos serão adicionados, e o número total de produtos aumentará com o tempo. Portanto, os requisitos de RRU também crescerão com o tempo. + Para o primeiro mês de RRU, o consumo será de 170 milhões. + No segundo mês, o consumo de RRU será de 2 x 170 milhões = 340 milhões. + No terceiro mês, o consumo de RRU será de 3 x 170 milhões = 510 milhões. O gráfico a seguir mostra o consumo mensal de RRU e a previsão de custos. ![\[O consumo de RRU está aumentando mais do que o custo.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/1797b48f-a183-4f25-811f-44921c3a48ee/images/3505bfc8-694d-4acc-8585-cd71258fa315.png) Observe que os preços no gráfico são apenas para fins ilustrativos. Para criar previsões precisas para seu caso de uso, verifique a página de preços da AWS e use esses preços na planilha do Excel. **Exemplos de cálculo de custos de armazenamento, backup e recuperação** O armazenamento, o backup e a restauração do DynamoDB estão todos conectados entre si. O backup está diretamente conectado ao armazenamento e a recuperação está diretamente conectada ao tamanho do backup. À medida que o tamanho da tabela aumenta, os custos correspondentes de armazenamento, backup e restauração aumentarão proporcionalmente. *Tamanho e custo do armazenamento* O custo de armazenamento aumentará com o tempo com base na sua taxa de crescimento de dados. Por exemplo, suponha que o tamanho médio de um componente ou produto na tabela base GSIs seja de 11 KB e que 10 milhões de novos produtos sejam adicionados todos os meses à tabela do banco de dados. Nesse caso, o tamanho da tabela do DynamoDB aumentou (11 KB \$1 10 milhões) /1024/1024 = 105 GB por mês. No primeiro mês, o tamanho do armazenamento da tabela será de 105 GB, no segundo mês será de 105 \$1 105 = 210 GBs e assim por diante. + No primeiro mês, o custo de armazenamento será de 105 GB\$1 por GB para sua região da AWS. + No segundo mês, o custo de armazenamento será de 210 GB\$1 por GB para sua região. + No terceiro mês, o custo de armazenamento será de 315 GB\$1 por GB para sua região. Para saber o tamanho e o custo do armazenamento para os próximos três anos, consulte a seção *Tamanho e previsão do armazenamento*. *Custo do backup* O custo do backup aumentará com o tempo, com base na sua taxa de crescimento de dados. Quando você ativa o backup contínuo com point-in-time-recovery (PITR), as cobranças de backup contínuo são baseadas na média de GB de armazenamento por mês. Em um mês civil, o tamanho médio do backup seria igual ao tamanho do armazenamento da tabela, embora o tamanho real pudesse ser um pouco diferente. À medida que novos produtos forem adicionados a cada mês, o tamanho total do armazenamento e o tamanho do backup aumentarão com o tempo. Por exemplo, no primeiro mês, o tamanho médio do backup de 105 GB pode aumentar para 210 GB no segundo mês. + No primeiro mês, o custo do backup será de 105 GB/mês\$1 preço de backup contínuo por GB para sua região da AWS. + No segundo mês, o custo do backup será de 210 GB/mês\$1 preço de backup contínuo por GB para sua região. + No terceiro mês, o custo do backup será de 315 GB/mês\$1 preço de backup contínuo por GB para sua região. + e assim por diante O custo do backup está incluído no gráfico na seção *Tamanho do armazenamento e previsão de custos*. *Custo de recuperação* Quando você está fazendo backup contínuo com a PITR ativada, as cobranças da operação de recuperação são baseadas no tamanho da restauração. Cada vez que você restaura, você paga com base em gigabytes de dados restaurados. Se o tamanho da sua tabela for grande e você realizar a restauração várias vezes em um mês, será caro. Para estimar o custo da restauração, este exemplo pressupõe que você realize uma recuperação de PITR uma vez por mês no final do mês. O exemplo usa o tamanho médio mensal do backup como o tamanho dos dados de restauração desse mês. No primeiro mês, o tamanho médio do backup é 105 GB e, para a recuperação no final do mês, o tamanho dos dados de restauração seria 105 GB. No segundo mês, seria 210 e GBs assim por diante. O custo de recuperação aumentará com o tempo com base na taxa de crescimento de seus dados. + No primeiro mês, o custo de recuperação será de 105 GB\$1 de preço de restauração por GB para sua região da AWS. + No segundo mês, o custo de recuperação será de 210 GB\$1 de preço de restauração por GB para sua região. + No terceiro mês, o custo de recuperação será de 315 GB\$1 preço de restauração por GB para sua região. Para obter mais informações, consulte a guia Armazenamento, backup e recuperação no modelo do Excel e o gráfico na seção a seguir. *Previsão de tamanho e custo de armazenamento* No modelo, o tamanho real do armazenamento faturável é calculado subtraindo o nível gratuito de 25 GB por mês para a classe de tabela Standard. Na planilha, você obterá um gráfico de previsão dividido em valores mensais. O gráfico de exemplo a seguir prevê o tamanho do armazenamento mensal em GB, o custo de armazenamento faturável, o custo de backup sob demanda e o custo de recuperação para os próximos 36 meses corridos. Todos os custos estão em USD. No gráfico, fica claro que os custos de armazenamento, backup e recuperação aumentam proporcionalmente aos aumentos no tamanho do armazenamento. ![\[O tamanho do armazenamento está subindo acima de três mil, enquanto os custos são inferiores a mil.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/1797b48f-a183-4f25-811f-44921c3a48ee/images/fd9f06d0-bc9c-4b4e-8cbd-3e527fe09e88.png) Observe que os preços usados no gráfico são apenas para fins ilustrativos. Para criar preços precisos para seu caso de uso, consulte a página de preços da AWS e use esses preços no modelo do Excel. ## Anexos Para acessar o conteúdo adicional associado a este documento, descompacte o seguinte arquivo:[ attachment.zip](samples/p-attach/1797b48f-a183-4f25-811f-44921c3a48ee/attachments/attachment.zip) # Estime os custos de armazenamento de uma tabela do Amazon DynamoDB *Moinul Al-Mamun, Amazon Web Services* ## Resumo O Amazon DynamoDB é um banco de dados transacional NoSQL que fornece latência de milissegundos de um dígito, mesmo em escala de petabytes. Essa popular oferta sem servidor da AWS fornece desempenho e escalabilidade consistentes. Você não precisa se preocupar com o provisionamento de armazenamento, e sua tabela única pode expandir até petabytes. O DynamoDB monitora o tamanho da sua tabela continuamente durante todo o mês para determinar suas cobranças de armazenamento. AWS em seguida, cobra pelo tamanho médio do armazenamento em gigabytes. Quanto mais sua mesa crescer com o tempo, mais seu custo de armazenamento aumentará. Para calcular o custo de armazenamento, você pode usar a [Calculadora de AWS Preços](https://calculator.aws/#/createCalculator/DynamoDB), mas precisa fornecer o tamanho aproximado da tabela, incluindo índices secundários globais (GSIs), que são muito difíceis de estimar no início do projeto. Além disso, a Calculadora de AWS Preços não considera a taxa de crescimento dos dados. Esse padrão fornece um mecanismo e um modelo reutilizável do Microsoft Excel para calcular o tamanho e o custo do armazenamento do DynamoDB. Ele considera os requisitos de armazenamento para a tabela base e a GSIs independente. Calcula o tamanho do armazenamento considerando o tamanho de seus itens individuais e a taxa de crescimento de dados ao longo do tempo. Para obter uma estimativa, insira duas informações no modelo: + O tamanho do item individual em kilobytes para a tabela base e GSIs + Quantos novos objetos ou produtos poderiam ser adicionados à tabela, em média, em um mês (por exemplo, 10 milhões) O modelo gera um gráfico de previsão de armazenamento e de custos para os próximos três anos, como mostrado no exemplo a seguir. ![\[A linha inferior de custo sobe lentamente e a linha superior de armazenamento sobe mais rapidamente.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/9b74399d-9655-47ee-b9b3-de46b65bc4e3/images/c0436252-cc42-4ea3-ac50-c0455aece39d.png) ## Pré-requisitos e limitações **Pré-requisitos ** + Noções básicas sobre o DynamoDB, incluindo o armazenamento e os preços do DynamoDB + Conhecimento de seus dados, modelo de dados e tamanho do item no DynamoDB + Conhecimento dos índices secundários globais do DynamoDB () GSIs **Limitações** + O modelo fornece um cálculo aproximado, mas não é apropriado para todas as configurações. Para obter uma estimativa mais precisa, você deve medir o tamanho individual do item para cada item na tabela base GSIs e. + Esse padrão permite estimar somente o tamanho e o custo do armazenamento para os próximos anos, com base em suposições fixas de crescimento de dados. ## Ferramentas **Serviços da AWS** + O [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) é um serviço de banco de dados NoSQL totalmente gerenciado que fornece performance rápida, previsível e escalável. **Outras ferramentas** + AWS A [Calculadora de Preços](https://docs.aws.amazon.com/pricing-calculator/latest/userguide/what-is-pricing-calculator.html) é uma ferramenta de planejamento baseada na web que você pode usar para criar estimativas para seus casos de AWS uso. ## Épicos ### Extraia as informações do item do seu modelo de dados do DynamoDB | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Obtenha o tamanho do item. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Engenheiro de dados | | Veja o número de objetos adicionados em um mês. | Estime quantos componentes ou objetos serão adicionados à tabela do DynamoDB, em média, em um mês. | Engenheiro de dados | ### Insira as informações do item e do objeto no modelo do Excel | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Faça o download e ajuste a planilha do Excel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Engenheiro de dados | | Insira as informações no modelo do Excel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Engenheiro de dados | ## Recursos relacionados + [Preço para capacidade sob demanda](https://aws.amazon.com/dynamodb/pricing/on-demand/) para o Amazon DynamoDB + [AWS Calculadora de preços para DynamoDB](https://calculator.aws/#/createCalculator/DynamoDB) ## Mais informações Observe que o modelo em anexo prevê somente o tamanho e o custo do armazenamento para a classe de tabela de armazenamento padrão. Com base na previsão dos custos de armazenamento e considerando o tamanho do item individual e a taxa de crescimento do produto ou do objeto, você pode estimar o seguinte: + Custo de exportação de dados + Custo de backup e recuperação + Requisitos de armazenamento de dados **Custo de armazenamento de dados do Amazon DynamoDB** O DynamoDB monitora continuamente o tamanho de suas tabelas para determinar suas cobranças de armazenamento. O DynamoDB mede o tamanho dos dados faturáveis adicionando o tamanho do byte bruto dos dados mais uma sobrecarga de armazenamento por item que depende dos atributos ativados. Para obter mais informações, consulte o [Guia do desenvolvedor do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/CapacityUnitCalculations.html). O preço do armazenamento de dados depende da classe da sua tabela. Os primeiros 25 GB armazenados por mês são gratuitos se você estiver usando a classe de tabela padrão do DynamoDB. Para obter mais informações sobre os custos de armazenamento das classes de tabela de acesso padrão e padrão de acesso infrequente em diferentes classes Regiões da AWS, consulte [Preços da capacidade sob demanda](https://aws.amazon.com/dynamodb/pricing/on-demand/). ## Anexos Para acessar o conteúdo adicional associado a este documento, descompacte o seguinte arquivo:[ attachment.zip](samples/p-attach/9b74399d-9655-47ee-b9b3-de46b65bc4e3/attachments/attachment.zip) # Estime o tamanho do mecanismo Amazon RDS para um banco de dados Oracle usando relatórios AWR *Abhishek Verma e Eduardo Valentim, Amazon Web Services* ## Resumo Quando você migra um banco de dados Oracle para o Amazon Relational Database Service (Amazon RDS) ou o Amazon Aurora, computar a CPU, a memória e o I/O disco do banco de dados de destino é um requisito fundamental. Você pode estimar a capacidade necessária do banco de dados de destino analisando os relatórios do Oracle Automatic Workload Repository (AWR). Esse padrão explica como usar relatórios AWR para estimar esses valores. O banco de dados Oracle de origem pode estar no local ou hospedado em uma instância do Amazon Elastic Compute Cloud (Amazon EC2), ou pode ser uma instância de banco de dados Amazon RDS for Oracle. O banco de dados de destino pode ser qualquer banco de dados Amazon RDS ou Aurora. **nota** As estimativas de capacidade serão mais precisas se o mecanismo de banco de dados de destino for o Oracle. Para outros bancos de dados do Amazon RDS, o tamanho do mecanismo pode variar devido às diferenças na arquitetura do banco de dados. Recomendamos que você execute o teste de desempenho antes de migrar seu banco de dados Oracle. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma licença do Oracle Database Enterprise Edition e uma licença do Oracle Diagnostics Pack para baixar relatórios AWR. **Versões do produto** + Todas as edições do banco de dados do Oracle para versões 11g (versões 11.2.0.3.v1 e posteriores) e até 12.2 e 18c, 19c + Esse padrão não abrange o Oracle Engineered Systems ou o Oracle Cloud Infrastructure (OCI). ## Arquitetura **Pilha de tecnologia de origem** Um dos seguintes: + Um banco de dados Oracle on-premises + Um banco de dados Oracle em uma EC2 instância + Instância de banco de dados do Amazon RDS para Oracle **Pilha de tecnologias de destino** + Qualquer banco de dados Amazon RDS ou Amazon Aurora **Arquitetura de destino** Para obter informações sobre o processo completo de migração, consulte o padrão [Migrar um banco de dados Oracle para o Aurora PostgreSQL usando o AWS DMS e o AWS SCT](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-aurora-postgresql-using-aws-dms-and-aws-sct.html). **Automação e escala** Se você tiver vários bancos de dados Oracle para migrar e quiser usar métricas de desempenho adicionais, poderá automatizar o processo seguindo as etapas descritas na postagem do blog [Instâncias do Amazon RDS do tamanho certo em escala com base nas métricas de desempenho da Oracle](https://aws.amazon.com/blogs/database/right-sizing-amazon-rds-instances-at-scale-based-on-oracle-performance-metrics/). ## Ferramentas + O [Oracle Automatic Workload Repository (AWR)](https://docs.oracle.com/en-us/iaas/performance-hub/doc/awr-report-ui.html) é um repositório incorporado aos bancos de dados Oracle. Ele coleta e armazena periodicamente a atividade do sistema e os dados da workload, que são então analisados pelo Automatic Database Diagnostic Monitor (ADDM). O AWR tira snapshots dos dados de desempenho do sistema periodicamente (por padrão, a cada 60 minutos) e armazena as informações (por padrão, até 8 dias). Você pode usar visualizações e relatórios do AWR para analisar esses dados. ## Práticas recomendadas + Para calcular os requisitos de recursos para seu banco de dados de destino, você pode usar um único relatório AWR, vários relatórios AWR ou visualizações dinâmicas do AWR. Recomendamos que você use vários relatórios AWR durante o período de pico de carga para estimar os recursos necessários para lidar com esses picos de carga. Além disso, as exibições dinâmicas fornecem mais pontos de dados que ajudam a calcular os requisitos de recursos com mais precisão. + Você deve estimar o IOPS somente para o banco de dados que planeja migrar, não para outros bancos de dados e processos que usam o disco. + Para calcular o quanto I/O está sendo usado pelo banco de dados, não use as informações na seção Perfil de carga do relatório AWR. Em vez disso, use a seção I/O Perfil, se estiver disponível, ou vá para a seção Estatísticas de atividade da instância e veja os valores totais das operações físicas de leitura e gravação. + Ao estimar a utilização da CPU, recomendamos que você use o método de métricas do banco de dados em vez das estatísticas do sistema operacional (SO), porque ele se baseia na CPU usada somente pelos bancos de dados. (As estatísticas do SO também incluem o uso da CPU por outros processos.) Você também deve verificar as recomendações relacionadas à CPU no relatório ADDM para melhorar o desempenho após a migração. + Considere os limites de taxa de I/O transferência ― taxa de transferência do Amazon Elastic Block Store (Amazon EBS) e taxa de transferência de rede ― para o tamanho específico da instância ao determinar o tipo certo de instância. + Execute o teste de desempenho antes da migração para validar o tamanho do mecanismos. ## Épicos ### Crie um relatório AWR | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Ative o relatório AWR. | Para ativar o relatório, siga as instruções na [documentação da Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/18/tgdba/gathering-database-statistics.html#GUID-26D359FA-F809-4444-907C-B5AFECD9AE29). | DBA | | Verifique o período de retenção. | Para verificar o período de retenção do relatório do AWR, use a consulta a seguir.
cc_idx:-2 country:Invalid
cc_idx:0 country:China
cc_idx:3 country:UK
cc_idx:5 country:USA
cc_idx:7 country:India
SQL> SELECT snap_interval,retention FROM dba_hist_wr_control;| DBA | | Gere o snapshot. | Se o intervalo do snapshot do AWR não for granular o suficiente para capturar o pico da workload, você poderá gerar o relatório do AWR manualmente. Para gerar o snapshot manual do AWR, use a consulta a seguir.
SQL> EXEC dbms_workload_repository.create_snapshot;| DBA | | Confira os snapshots recentes. | Para verificar snapshots recentes do AWR, use a consulta a seguir.
SQL> SELECT snap_id, to_char(begin_interval_time,'dd/MON/yy hh24:mi') Begin_Interval,| DBA | ### Estime os I/O requisitos de disco | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Escolha um método. | O IOPS é a medida padrão das operações de entrada e saída por segundo em um dispositivo de armazenamento e inclui operações de leitura e gravação. Se você estiver migrando um banco de dados local para a AWS, precisará determinar o pico de disco I/O usado pelo banco de dados. Você pode usar os seguintes métodos para estimar o disco do I/O seu banco de dados de destino:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)As etapas a seguir descrevem esses quatro métodos. | DBA | | Opção 1: use o perfil de carga. | A tabela a seguir mostra um exemplo da seção Perfil de carga do relatório AWR.Para obter informações mais precisas, recomendamos que você use a opção 2 (perfis de E/S) ou a opção 3 (estatísticas de atividade da instância), em vez do perfil de carga.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Com base nessas informações, você pode calcular IOPs e gerar a taxa de transferência da seguinte forma:*IOPS = Solicitações de leitura: \$1 I/O Solicitações de gravação I/O = 3.586,8 \$1 574,7 = 4134,5** Throughput = leitura física (blocos) \$1 Gravação física (blocos) = 13.575,1 \$1 3.467,3 = 17.042,4*Como o tamanho do bloco no Oracle é de 8 KB, você pode calcular a throughput total da seguinte forma:* A throughput total em MB é 17.042,4 \$1 8 \$1 1024/1024/1024 = 133,2 MB*Não use o perfil de carga para estimar o tamanho da instância. Não é tão preciso quanto as estatísticas ou os I/O perfis de atividades da instância. | DBA | | Opção 2: use estatísticas de atividade da instância. | Se você estiver usando uma versão do banco de dados Oracle anterior à 12c, poderá usar a seção Estatísticas de atividade da instância do relatório AWR para estimar o IOPS e a throughput. A tabela a seguir mostra um exemplo dessa seção.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Com base nessas informações, você pode calcular o total de IOPs e a throughput da seguinte forma:* IOPS total = 3.610,28 \$1 757,11 = 4.367** Total de Mbps = 114.482.426,26 \$1 36.165.631,84 = 150.648.058,1/1024/1024 = 143 Mbps* | DBA | | Opção 3: usar I/O perfis. | No Oracle Database 12c, o relatório AWR inclui uma seção de I/O Perfis que apresenta todas as informações em uma única tabela e fornece dados mais precisos sobre o desempenho do banco de dados. A tabela a seguir mostra um exemplo dessa seção.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Essa tabela fornece os seguintes valores de throughput e IOPS total:* Throughput = 143 MBPS (da quinta linha, rotulada como Total, segunda coluna)** IOPS = 4.367,4 (da primeira linha, chamada Total de solicitações, segunda coluna)* | DBA | | Opção 4: usar visualizações AWR. | Você pode ver as mesmas informações de IOPS e throughput usando visualizações do AWR. Para obter essas informações, use a seguinte consulta:
to_char(end_interval_time,'dd/MON/yy hh24:mi') End_Interval
FROM dba_hist_snapshot
ORDER BY 1;
break on report| DBA | | | Por Segundo | Por Transação | Por Executivo | Por Chamada | | --- |--- |--- |--- |--- | | **Tempo(s) de banco de dados:** | 26,6 | 0.2 | 0,00 | 0,02 | | **CPU(s) de banco de dados:** | 18,0 | 0.1 | 0,00 | 0,01 | | **CPU(s) de fundo:** | 0.2 | 0.0 | 0,00 | 0,00 | | **Tamanho do redo (bytes):** | 2.458.539,9 | 17.097,5 | | | | **Leitura lógica (blocos):** | 3.371.931,5 | 23.449,6 | | | | **Bloquear alterações:** | 21.643,5 | 150,5 | | | | **Leitura física (blocos):** | 13.575,1 | 94,4 | | | | **Gravação física (blocos):** | 3.467,3 | 24,1 | | | | **Leia as solicitações de IO:** | 3.586,8 | 24,9 | | | | **Solicitações de gravação:** | 574,7 | 4,0 | | | | **IO de leitura (MB):** | 106.1 | 0.7 | | | | **Escreva IO (MB):** | 27.1 | 0.2 | | | | **Linhas de verificação de mensagens instantâneas:** | 0.0 | 0.0 | | | | **Mensagem instantânea de leitura lógica da sessão:** | | | | | | **Chamadas de usuários** | 1.245,7 | 8.7 | | | | **Análises (SQL):** | 4.626,2 | 32.2 | | | | **Análises físicas (SQL):** | 8.9 | 0.1 | | | | **Área de trabalho SQL (MB):** | 824,9 | 5.7 | | | | **Log on:** | 1,7 | 0.0 | | | | **Executa (SQL):** | 136.656,5 | 950,4 | | | | **Reversões:** | 22,9 | 0.2 | | | | **Transações:** | 143,8 | | | | | Estatística | Total | por Segundo | por Trans | | --- |--- |--- |--- | | **leitura física total de solicitações de E/S** | 2.547.333.217 | 3.610,28 | 25.11 | | **total de bytes de leitura física** | 80.776.296.124.928 | 114.482.426,26 | 796.149,98 | | **gravação física total de solicitações de E/S** | 534.198.208 | 757,11 | 5.27 | | **total de bytes de gravação física** | 25.517.678.849.024 | 36.165.631,84 | 251.508,18 | | | Leitura \$1 gravação por segundo | Leituras por Segundo | Gravações por Segundo | | --- |--- |--- |--- | | **Total de solicitações:** | 4.367,4 | 3.610,3 | 757,1 | | **Solicitações de banco de dados:** | 4.161,5 | 3.586,8 | 574,7 | | **Solicitações otimizadas:** | 0.0 | 0.0 | 0.0 | | **Solicitações para refazer:** | 179,3 | 2.8 | 176,6 | | **Total (MB):** | 143,7 | 109.2 | 34,5 | | **Banco de dados (MB):** | 133.1 | 106.1 | 27.1 | | **Total otimizado (MB):** | 0.0 | 0.0 | 0.0 | | **Refazer (MB):** | 7.6 | 2.7 | 4,9 | | **Banco de dados (blocos):** | 17.042,4 | 13.575,1 | 3.467,3 | | **Por meio do Buffer de Cache (blocos):** | 5.898,5 | 5.360,9 | 537,6 | | **Direto (blocos):** | 11.143,9 | 8.214,2 | 2.929,7 | ### Estime os requisitos de CPU | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Escolha um método. | Você pode estimar a CPU necessária para o banco de dados de destino de três maneiras:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Se você estiver analisando núcleos utilizados, recomendamos usar o método de métricas do banco de dados em vez das estatísticas do SO, pois ele se baseia na CPU usada somente pelos bancos de dados que você planeja migrar. (As estatísticas do SO também incluem o uso da CPU por outros processos.) Você também deve verificar as recomendações relacionadas à CPU no relatório ADDM para melhorar o desempenho após a migração.Você também pode estimar os requisitos com base na geração da CPU. Se você estiver usando diferentes gerações de CPU, poderá estimar a CPU necessária do banco de dados de destino seguindo as instruções no whitepaper [Desmistificando o número de v CPUs para um desempenho ideal da carga de](https://d1.awsstatic.com/whitepapers/Demystifying_vCPUs.df200b766578b75009ad8d15c72e493d6408c68a.pdf) trabalho. | DBA | | Opção 1: estimar os requisitos com base nos núcleos disponíveis. | Nos relatórios do AWR:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Você pode estimar os núcleos disponíveis de duas maneiras:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)**Para estimar os núcleos disponíveis usando comandos do sistema operacional**Use o comando a seguir para contar os núcleos no processador.
compute sum of Value on report
select METRIC_NAME,avg(AVERAGE) as "Value"
from dba_hist_sysmetric_summary
where METRIC_NAME in ('Physical Read Total IO Requests Per Sec','Physical Write Total IO Requests Per Sec')
group by metric_name;
$ cat /proc/cpuinfo |grep "cpu cores"|uniqUse o comando a seguir para contar os soquetes no processador.
cpu cores : 4
cat /proc/cpuinfo | egrep "core id|physical id" | tr -d "\n" | sed s/physical/\\nphysical/g | grep -v ^$ | sort | uniq | wc -l
grep "physical id" /proc/cpuinfo | sort -uNão recomendamos o uso de comandos do sistema operacional, como **nmon** e **sar**, para extrair a utilização da CPU. Isso ocorre porque esses cálculos incluem a utilização da CPU por outros processos e podem não refletir a CPU real usada pelo banco de dados.**Para estimar os núcleos disponíveis usando o relatório AWR**Você também pode derivar a utilização da CPU na primeira seção do relatório AWR. Veja um trecho do relatório.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Neste exemplo, a CPUs contagem é 80, o que indica que elas são lógicas (virtuais) CPUs. Você também pode ver que essa configuração tem dois soquetes, um processador físico em cada soquete (para um total de dois processadores físicos) e 40 núcleos para cada processador ou soquete físico. | DBA | | Opção 2: estimar a utilização da CPU usando estatísticas do sistema operacional. | Você pode verificar as estatísticas de uso da CPU do sistema operacional diretamente no sistema operacional (usando **sar** ou outro utilitário do SO host) ou revisando os valores de IDLE/ (IDLE\$1BUSY) na seção Estatísticas do sistema operacional do relatório AWR. Você pode ver os segundos de CPU consumidos diretamente de **v\$1osstat**. Os relatórios AWR e Statspack também mostram esses dados na seção Estatísticas do sistema operacional.Se houver vários bancos de dados na mesma caixa, todos eles terão os mesmos valores de **v\$1osstat** para BUSY\$1TIME.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Se não houver outros grandes consumidores de CPU no sistema, use a fórmula a seguir para calcular a porcentagem de utilização da CPU:* Utilização = Tempo de ocupação/Tempo total** Tempo ocupado = requisitos = v\$1OSStat.BUSY\$1TIME** C = Tempo total (ocupado \$1 ocioso)** C = capacidade = v\$1ostat.BUSY\$1TIME \$1 v\$1ostat.IDLE\$1TIME** Utilização = BUSY\$1TIME/(BUSY\$1TIME \$1 IDLE\$1TIME)** = -1.305.569.937/(1.305.569.937 \$1 4.312.718.839)** = 23% utilizados* | DBA | | Opção 3: estimar a utilização da CPU usando métricas de banco de dados. | Se vários bancos de dados estiverem em execução no sistema, você poderá usar as métricas do banco de dados que aparecem no início do relatório.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Para obter métricas de utilização da CPU, use esta fórmula:* Uso da CPU do banco de dados (porcentagem da energia da CPU disponível) = tempo de CPU/NUM\$1CPUS/tempo decorrido*onde o uso da CPU é descrito pelo *tempo da CPU* e representa o tempo gasto na CPU, não o tempo de espera pela CPU. Esse cálculo resulta em:* = 312.625,40/11.759,64/80 = 33% da CPU está sendo usada** Número de núcleos (33%) \$1 80 = 26,4 núcleos** Total de núcleos = 26,4 \$1 (120%) = 31,68 núcleos*Você pode usar o maior desses dois valores para calcular a utilização da CPU da instância de banco de dados Amazon RDS ou Aurora.No IBM AIX, a utilização calculada não corresponde aos valores do sistema operacional ou do banco de dados. Esses valores coincidem em outros sistemas operacionais. | DBA | | Nome do banco de dados | ID do banco de dados | Instância | Insira um número | Horário de início | Versão | RAC | | --- |--- |--- |--- |--- |--- |--- | | XXXX |
physical id : 0
physical id : 1
call mysql.rds_set_configuration('binlog retention hours', XX)Confirme a configuração executando o seguinte comando.call mysql.rds_show_configuration;Bancos de dados compatíveis com MySQL gerenciados pela AWS eliminam os logs binários o mais rápido possível. Portanto, o período de retenção deve ser longo o suficiente para garantir que os logs não sejam eliminados antes que a tarefa do AWS DMS seja executada. Um valor de 24 horas geralmente é suficiente, mas o valor deve ser baseado no tempo necessário para configurar a tarefa do AWS DMS na região de DR. | DBA | ### Atualize a tarefa existente do AWS DMS na região principal | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Registre o ARN da tarefa do AWS DMS. | Use o nome do recurso da Amazon (ARN) para obter o nome da tarefa do AWS DMS para uso posterior. Para recuperar o ARN da tarefa do AWS DMS, visualize a tarefa no console ou execute o comando a seguir.
aws dms describe-replication-tasksUm ARN se parece com o seguinte.
arn:aws:dms:us-east-1:Os caracteres após os dois últimos pontos correspondem ao nome da tarefa usado em uma etapa posterior. | Administrador da AWS | | Modifique a tarefa existente do AWS DMS para registrar o ponto de verificação. | O AWS DMS cria pontos de verificação que contêm informações para que o mecanismo de replicação conheça o ponto de recuperação para o fluxo de alterações. Para registrar as informações do ponto de verificação, execute as seguintes etapas no console:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html) | Administrador da AWS | | Valide as informações do ponto de verificação. | Usando um cliente MySQL conectado ao endpoint do gravador do cluster, consulte a nova tabela de metadados no cluster do banco de dados do relator para verificar se ela existe e contém as informações do estado de replicação. Execute o comando a seguir.:task:AN6HFFMPM246XOZVEUHCNSOVF7MQCLTOZUIRAMY
select * from awsdms_control.awsdms_txn_state;O nome da tarefa do ARN deve ser encontrado nessa tabela na coluna `Task_Name`. | DBA | ### Expanda os dois clusters do Amazon Aurora para uma região de DR | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma infraestrutura básica na região de DR. | Crie os componentes básicos necessários para a criação e o acesso aos clusters do Amazon Aurora:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html)Certifique-se de que a configuração de ambos os grupos de parâmetros corresponda à configuração na região primária. | Administrador da AWS | | Adicione a região de DR aos dois clusters do Amazon Aurora. | Adicione uma região secundária (a região de DR) aos clusters principal e relator do Amazon Aurora. Para obter mais informações, consulte [Adicionar uma região da AWS a um banco de dados global do Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html#aurora-global-database-attaching). | Administrador da AWS | ### Execute o failover | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Interrompa a tarefa do AWS DMS. | A tarefa do AWS DMS na região principal não funcionará adequadamente após a ocorrência do failover e deverá ser interrompida para evitar erros. | Administrador da AWS | | Execute um failover gerenciado. | Execute um failover gerenciado do cluster de banco de dados principal para a região de DR. Para ver as instruções, consulte [Failover planejado gerenciado para Amazon Aurora Global Databases](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-disaster-recovery.html#aurora-global-database-disaster-recovery.managed-failover). Após a conclusão do failover no cluster de banco de dados principal, execute a mesma atividade no cluster de banco de dados do relator. | Administrador da AWS, DBA | | Carregue dados no banco de dados principal. | Insira dados de teste no nó gravador do banco de dados principal no cluster de banco de dados DR. Esses dados serão usados para validar se a replicação está funcionando adequadamente. | DBA | | Crie a instância de replicação do AWS DMS. | Para criar a instância de replicação do AWS DMS na região de DR, consulte [Criação de uma instância de replicação](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.Creating.html). | Administrador da AWS, DBA | | Criação de endpoints do AWS DMS de origem e de destino. | Para criar os endpoints de origem e destino do AWS DMS na região de DR, consulte [Criação de endpoints de origem e destino](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Endpoints.Creating.html). A origem deve apontar para a instância do gravador do cluster de banco de dados principal. O destino deve apontar para a instância do gravador do cluster de banco de dados do relator. | Administrador da AWS, DBA | | Obtenha o ponto de verificação de replicação. | Para obter o ponto de verificação de replicação, use um cliente MySQL para consultar a tabela de metadados executando o seguinte no nó gravador no cluster de banco de dados repórter na região DR.
select * from awsdms_control.awsdms_txn_state;Na tabela, encontre o valor task\$1name que corresponde ao ARN da tarefa do AWS DMS que existe na região principal que você obteve no segundo épico. | DBA | | Crie uma tarefa do AWS DMS. | Usando o console, crie uma tarefa do AWS DMS na região DR. Na tarefa, especifique um método de migração de **Replicar somente alterações de dados**. Para obter mais informações, consulte [Criar uma tarefa](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html). [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html)Defina a configuração da tarefa do AWS DMS **Iniciar a tarefa de migração** como **Automaticamente ao criar**. | Administrador da AWS, DBA | | Registre o ARN da tarefa do AWS DMS. | Use o ARN para obter o nome da tarefa do AWS DMS para uso posterior. Para recuperar o ARN da tarefa do AWS DMS, execute o comando a seguir.
aws dms describe-replication-tasks| Administrador da AWS, DBA | | Valide os dados replicados. | Consulte o cluster de banco de dados do relator na região de DR para confirmar se os dados de teste que você carregou no cluster de banco de dados principal foram replicados. | DBA | ### Execute o failback | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Interrompa a tarefa do AWS DMS. | A tarefa do AWS DMS na região DR não funcionará adequadamente após a ocorrência do failback e deverá ser interrompida para evitar erros. | Administrador da AWS | | Execute um failback gerenciado. | Faça o failback do cluster de banco de dados principal para a região primária. Para ver as instruções, consulte [Failover planejado gerenciado para Amazon Aurora Global Databases](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-disaster-recovery.html#aurora-global-database-disaster-recovery.managed-failover). Após a conclusão do failback no cluster de banco de dados principal, execute a mesma atividade no cluster de banco de dados do relator. | Administrador da AWS, DBA | | Obtenha o ponto de verificação de replicação. | Para obter o ponto de verificação de replicação, use um cliente MySQL para consultar a tabela de metadados executando o seguinte no nó gravador no cluster de banco de dados repórter na região DR.
select * from awsdms_control.awsdms_txn_state;Na tabela, encontre o valor `task_name` que corresponde ao ARN da tarefa do AWS DMS que existe na região de DR que você obteve no quarto épico. | DBA | | Atualização de endpoints do AWS DMS de origem e de destino. | Depois que os clusters do banco de dados falharem, verifique os clusters na região primária para determinar quais nós são as instâncias do gravador. Em seguida, verifique se os endpoints existentes de origem e destino do AWS DMS na região primária estão apontando para as instâncias do gravador. Caso contrário, atualize os endpoints com os nomes do Sistema de Nomes de Domínio (DNS) da instância do gravador. | Administrador da AWS | | Crie uma tarefa do AWS DMS. | Usando o console, crie uma tarefa do AWS DMS na região primária. Na tarefa, especifique um método de migração de **Replicar somente alterações de dados**. Para obter mais informações, consulte [Criar uma tarefa](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html). [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html) | Administrador da AWS, DBA | | Registre o nome do recurso da Amazon (ARN) da tarefa do AWS DMS. | Use o ARN para obter o nome da tarefa do AWS DMS para uso posterior. Para recuperar o ARN da tarefa do AWS DMS, execute o comando a seguir:
aws dms describe-replication-tasksO nome da tarefa será necessário ao realizar outro failover gerenciado ou durante um cenário de DR. | Administrador da AWS, DBA | | Exclua as tarefas do AWS DMS. | Exclua a tarefa original (atualmente interrompida) do AWS DMS na região principal e a tarefa existente do AWS DMS (atualmente interrompida) na região secundária. | Administrador da AWS | ## Recursos relacionados + [Configuração do cluster de banco de dados do Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraSettingUp.html) + [Usar bancos de dados globais do Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html) + [Como trabalhar com o Amazon Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraMySQL.html) + [Trabalhando com instância de replicação do AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.html) + [Trabalhando com endpoints do AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Endpoints.html) + [Trabalhando com tarefas do AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.html) + [O que é a AWS CloudFormation?](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) ## Mais informações Os bancos de dados globais Amazon Aurora são usados neste exemplo para DR porque fornecem um objetivo de tempo de recuperação (RTO) efetivo de 1 segundo e um objetivo de ponto de recuperação (RPO) de menos de 1 minuto, ambos inferiores às soluções replicadas tradicionais e ideais para cenários de DR. Os bancos de dados globais Amazon Aurora oferecem muitas outras vantagens, incluindo as seguintes: + Leituras globais com latência local: consumidores globais podem acessar informações em uma região local, com latência local. + Clusters de banco de dados secundários escaláveis do Amazon Aurora: os clusters secundários podem ser escalados de forma independente, adicionando até 16 réplicas somente para leitura. + Replicação rápida de clusters de banco de dados do Amazon Aurora primários para secundários: a replicação tem pouco impacto na performance no cluster primário. Isso ocorre na camada de armazenamento, com latências de replicação entre regiões típicas de menos de 1 segundo. Esse padrão também usa o AWS DMS para replicação. Os bancos de dados Amazon Aurora oferecem a capacidade de criar réplicas de leitura, o que pode simplificar o processo de replicação e a configuração de DR. No entanto, o AWS DMS geralmente é usado para replicar quando são necessárias transformações de dados ou quando o banco de dados de destino exige índices adicionais que o banco de dados de origem não tem. # Migre funções e procedimentos do Oracle que tenham mais de 100 argumentos para o PostgreSQL *Srinivas Potlachervoo, Amazon Web Services* ## Resumo Este padrão mostra como migrar funções e procedimentos do Oracle que tenham mais de 100 argumentos para o PostgreSQL. Por exemplo, você pode usar esse padrão para migrar funções e procedimentos Oracle para um dos seguintes serviços de banco de dados da AWS compatíveis com PostgreSQL: + Amazon Relational Database Service (Amazon RDS) para PostgreSQL + Amazon Aurora Edição Compatível com PostgreSQL O PostgreSQL não suporta funções ou procedimentos que tenham mais de 100 argumentos. Como solução alternativa, você pode definir um novo tipo de dados que tenha campos de tipo que correspondam aos argumentos da função de origem. Em seguida, você pode criar e executar uma PL/pgSQL função que usa o tipo de dados personalizado como argumento. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Uma [instância de banco de dados Oracle do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) + Uma [instância de banco de dados Amazon RDS para PostgreSQL](https://aws.amazon.com/getting-started/hands-on/create-connect-postgresql-db/) ou uma [instância de banco de dados Aurora compatível com PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.AuroraPostgreSQL.html) **Versões do produto** + Instância de banco de dados Oracle do Amazon RDS, versões 10.2 e posteriores + Instância de banco de dados PostgreSQL do Amazon RDS, versões 9.4 e posteriores, ou instâncias de banco de dados compatíveis com o Aurora PostgreSQL, versões 9.4 e posteriores + Oracle SQL Developer versão 18 e posteriores + pgAdmin versão 4 e posterior ## Arquitetura **Pilha de tecnologia de origem** + Instância de banco de dados Oracle do Amazon RDS, versões 10.2 e posteriores **Pilha de tecnologias de destino** + Instância de banco de dados PostgreSQL do Amazon RDS, versões 9.4 e posteriores, ou instâncias de banco de dados compatíveis com o Aurora PostgreSQL, versões 9.4 e posteriores ## Ferramentas **Serviços da AWS** + O [Amazon Relational Database Service (Amazon RDS) para PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) ajuda você a configurar, operar e escalar um banco de dados relacional PostgreSQL na Nuvem AWS. + O [Amazon Aurora Edição Compatível com PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) é um mecanismo de banco de dados relacional totalmente gerenciado que ajuda você a configurar, operar e escalar as implantações de PostgreSQL. **Outros serviços** + O [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) é um ambiente de desenvolvimento integrado que simplifica o desenvolvimento e o gerenciamento de bancos de dados Oracle em implantações tradicionais e baseadas em nuvem. + O [pgAdmin](https://www.pgadmin.org/) é uma ferramenta de gerenciamento de software livre para PostgreSQL. Ele fornece uma interface gráfica que ajuda você a criar, manter e usar objetos de banco de dados. ## Práticas recomendadas Certifique-se de que o tipo de dados criado corresponda aos campos de tipo incluídos na função ou procedimento de origem do Oracle. ## Épicos ### Execute uma função ou procedimento Oracle que tenha mais de 100 argumentos | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie ou identifique uma Oracle/PLSQL função ou procedimento existente que tenha mais de 100 argumentos. | Crie uma Oracle/PLSQL função ou procedimento que tenha mais de 100 argumentos.- ou -Identifique uma Oracle/PLSQL função ou procedimento existente que tenha mais de 100 argumentos.Para obter mais informações, consulte as seções [14.7 Instrução CREATE FUNCTION](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/lnpls/CREATE-FUNCTION-statement.html#GUID-B71BC5BD-B87C-4054-AAA5-213E856651F2) e [14.11 CREATE PROCEDURE](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/lnpls/CREATE-PROCEDURE-statement.html#GUID-5F84DB47-B5BE-4292-848F-756BF365EC54) na documentação do Oracle Database. | Conhecimento em Oracle/PLSQL | | Compile a Oracle/PLSQL função ou o procedimento. | Compile a Oracle/PLSQL função ou o procedimento.Para ter mais informações, consulte [Compilar uma função](https://docs.oracle.com/cd/E37097_01/doc.42/e35128/GUID-6B7B6F82-616D-4915-82BE-D4AE7F59CF37.htm#AEUTL165) na documentação do Oracle Database. | Conhecimento em Oracle/PLSQL | | Execute a Oracle/PLSQL função. | Execute a Oracle/PLSQL função ou o procedimento. Em seguida, salve a saída. | Conhecimento em Oracle/PLSQL | ### Defina um novo tipo de dados que corresponda aos argumentos da função de origem ou do procedimento | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Defina um novo tipo de dados no PostgreSQL. | Defina um novo tipo de dados no PostgreSQL que inclua todos os mesmos campos que aparecem nos argumentos da função ou do procedimento Oracle de origem.Para ter mais informações, consulte [CREATE TYPE](https://www.postgresql.org/docs/current/sql-createtype.html) na documentação do PostgreSQL. | Conhecimento em PostgreSQL PL/pgSQL | ### Crie uma função PostgreSQL que inclua o novo argumento TYPE | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma função do PostgreSQL que inclua o novo tipo de dados. | Crie uma função do PostgreSQL que inclua o novo argumento `TYPE`.Para analisar um exemplo de função, consulte a seção **Informações adicionais** desse padrão. | Conhecimento em PostgreSQL PL/pgSQL | | Compile a função PostgreSQL. | Compile a função no PostgreSQL. Se os novos campos de tipo de dados corresponderem aos argumentos da função de origem ou do procedimento, a função será compilada com êxito. | Conhecimento em PostgreSQL PL/pgSQL | | Execute a função PostgreSQL. | Execute a função PostgreSQL. | Conhecimento em PostgreSQL PL/pgSQL | ## Solução de problemas | Problema | Solução | | --- | --- | | A função retorna o seguinte erro:**ERROR: syntax error near “
hdbnsutil -sr_enable --name=siteA| Administração do SAP Basis | | Registre o banco de dados SAP HANA de destino como um sistema secundário. | Para registrar o banco de dados SAP HANA de destino como um sistema secundário de origem para o SAP HSR, escolha a replicação **assíncrona**.
(sid)adm $> HDB stopComo alternativa, você pode escolher a opção `–online` de se registrar. Nesse caso, você não precisa parar e iniciar o banco de dados SAP HANA. | Administração do SAP Basis | | Valide a sincronização. | No banco de dados SAP HANA de origem, verifique se todos os logs estão aplicados no sistema de destino (porque é uma replicação assíncrona).Para verificar a replicação, na origem, execute os comandos a seguir.
(sid)adm $> hdbnsutil -sr_register –name=siteB –remotehost=hdbhost /
--remoteInstance=00 –replicationMode=async –operationMode=logreplay
(sid)adm $> HDB start
(sid)adm $> cdpy| Administração do SAP Basis | | Encerre o aplicativo SAP de origem e o banco de dados SAP HANA. | Durante a substituição da migração, desligue o sistema de origem (o aplicativo SAP e o banco de dados SAP HANA). | Administração do SAP Basis | | Execute uma aquisição no destino. | Para realizar uma aquisição no alvo na AWS, execute o comando `hdbnsutil -sr_takeover`. | Administração do SAP Basis | | No banco de dados SAP HANA de destino, desative a replicação. | Para limpar os metadados de replicação, interrompa a replicação no sistema de destino executando o comando `hdbnsutil -sr_disable`. Isto está de acordo com a SAP Note 2693441, que corresponde à falha ao renomear um sistema do SAP HANA devido a erro. | Administração do SAP Basis | | Faça backup do banco de dados SAP HANA de destino. | Depois que a aquisição for bem-sucedida, recomendamos realizar um backup completo do banco de dados SAP HANA. | Administração do SAP Basis | ### Reverta para o nome do host original no sistema de destino | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Reverta o nome do host de destino do banco de dados SAP HANA para o original. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-sap-hana-to-aws-using-sap-hsr-with-the-same-hostname.html)Você pode validar outras opções conforme necessário. No entanto, certifique-se de não misturar a renomeação do host com uma alteração de SID (nota do SAP nº 2598814 – hdblcm: falha na renomeação do SID). | Administração do SAP Basis | | Ajuste hdbuserstore. | Adapte os detalhes `hdbuserstore` apontando para os detalhes `schema/user` da origem. Para obter etapas detalhadas, consulte a [Documentação do SAP](https://help.sap.com/viewer/b3ee5778bc2e4a089d3299b82ec762a7/2.0.02/en-US/ddbdd66b632d4fe7b3c2e0e6e341e222.html?q=hdbuserstore). Para validar essa etapa, execute o comando `R3trans -d`. O resultado deve refletir uma conexão bem-sucedida com o banco de dados SAP HANA. | Administração do SAP Basis | | Inicie as conexões do cliente. | No ambiente de destino, ligue os servidores de aplicativos SAP e outras conexões de clientes. | Administração do SAP Basis | ## Recursos relacionados **Referências do SAP** As referências da documentação do SAP são frequentemente atualizadas pela SAP. Para se manter atualizado, consulte a nota do SAP nº 2407186 – Guias de instruções e documentos técnicos sobre a alta disponibilidade do SAP HANA. *Notas adicionais do SAP* + 2550327 – Como renomear um sistema SAP HANA + 1999880 – Perguntas frequentes: Replicação do sistema SAP HANA + 2078425 – Nota de solução de problemas para a ferramenta de gerenciamento do ciclo de vida da plataforma SAP HANA hdblcm + 2592227 – Alteração do sufixo FQDN em sistemas HANA + 2048681 – Executando tarefas de administração do gerenciamento do ciclo de vida da plataforma SAP HANA em sistemas de vários hosts sem SSH ou credenciais raiz *Documentos SAP* + [System Replication Network Connection](https://help.sap.com/docs/SAP_HANA_PLATFORM/4e9b18c116aa42fc84c7dbfd02111aba/47190b425eb1433697b026ecd46ff5f9.html) + [Resolução de nome de host para replicação do sistema](https://help.sap.com/viewer/eb3777d5495d46c5b2fa773206bbfb46/1.0.12/en-US/c0cba1cb2ba34ec89f45b48b2157ec7b.html) **AWS referências** + [Migrando o SAP HANA de outras plataformas para AWS](https://docs.aws.amazon.com/sap/latest/sap-hana/migrating-hana-hana-to-aws.html) ## Mais informações As alterações realizadas por `hdblcm` como parte da atividade de renomeação do nome do host são consolidadas no seguinte log detalhado. ![\[Código que mostra os processos interrompidos em temp-host, iniciados em hdbhost e o sistema de banco de dados do SAP HANA renomeado.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/004781c1-96df-43dd-a52e-ed1db5bdf9ef/images/9e0c11ca-6555-484f-9639-107f60f725f5.png) # Migre o grupo de disponibilidade Always On do Microsoft SQL Server usando AWS Application Migration Service *Sreenivas Nettem, Bharath Kumar Pammi Ramesh, Anantharaman Seshadri e Gireesh Sreekantan, Amazon Web Services* ## Resumo AWS Application Migration Service (AWS MGN) é a ferramenta preferida para rehospedar ambientes existentes no Nuvem AWS, o que permite que os clientes se afastem dos data centers locais. Esse padrão descreve o processo de uso do AWS MGN para migrar clusters do Windows com grupos de disponibilidade do Microsoft SQL Server Always On. ## Pré-requisitos e limitações **Pré-requisitos ** + Um ativo Conta da AWS. + Uma função AWS Identity and Access Management (IAM) para a orquestração AWS do MGN. + Acesso aos servidores do banco de dados de origem (grupo de disponibilidade Always On do SQL Server). + Active Directory em uma AWS landing zone para reter nomes DNS. + Uma sub-rede de preparação com comunicação de rede restrita ao Active Directory. + Sub-redes de destino que podem se comunicar com o Active Directory. + Dois endereços IP reservados para o cluster do Windows em uma sub-rede de destino (um em cada zona de disponibilidade). + Dois endereços IP reservados para o receptor Always On do SQL em uma sub-rede de destino (um em cada zona de disponibilidade). **Versões do produto** + Windows Server 2012 ou posterior + SQL Server 2012 ou posterior ## Arquitetura **Pilha de tecnologia de origem** Cluster do Microsoft Windows (máquina física ou virtual on-premises) com grupo de disponibilidade Always On do Microsoft SQL Server **Pilha de tecnologias de destino** Instância EC2 do Amazon Windows **Arquitetura de destino** ![\[Arquitetura da AWS para migração de grupos de disponibilidade Always On do SQL Server usando o AWS MGN.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/aa94040b-5ecf-42f9-90e3-929d0fa5e715/images/0b85c613-51df-475b-9598-3da3f9cd47c6.png) ## Ferramentas *Serviços da AWS* + [O Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) fornece capacidade de computação escalável no. Nuvem AWS Você poderá iniciar quantos servidores virtuais precisar e escalá-los na vertical rapidamente. + [AWS Application Migration Service](https://docs.aws.amazon.com/mgn/latest/ug/what-is-application-migration-service.html)ajuda você a rehospedar (elevar e deslocar) aplicativos Nuvem AWS sem alterações e com o mínimo de tempo de inatividade. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ajuda você a gerenciar com segurança o acesso aos seus AWS recursos controlando quem está autenticado e autorizado a usá-los. *Outras ferramentas* + [O Microsoft SQL Server Management Studio (SSMS)](https://learn.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms) é uma ferramenta para gerenciar o SQL Server, incluindo acesso, configuração e administração de componentes do SQL Server. ## Práticas recomendadas Para AWS MGN, consulte [Melhores práticas para AWS Application Migration Service](https://docs.aws.amazon.com/mgn/latest/ug/best_practices_mgn.html). ## Épicos ### Preparação da conta de destino | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Inicialize o AWS MGN. | Inicialize o AWS MGN no alvo. Região da AWS Esse processo cria as políticas e os perfis do IAM necessários. Para obter mais informações, consulte [Initializing Application Migration Service with the console](https://docs.aws.amazon.com/mgn/latest/ug/mgn-initialize-console.html). | Administrador de nuvem | | Crie os modelos de replicação e de inicialização. | Configure os modelos de replicação e lançamento para uso com o AWS MGN. Para obter mais informações, consulte [Configurando os modelos](https://docs.aws.amazon.com/mgn/latest/ug/mgn-initialization-templates.html) na AWS documentação. | Administrador de nuvem | | Permita as portas de comunicação. | Para habilitar as comunicações de rede para o AWS MGN, permita o tráfego pelas portas TCP 443 e 1500. Para obter mais informações, consulte [Requisitos de rede para o Application Migration Service](https://docs.aws.amazon.com/mgn/latest/ug/Network-Requirements.html) na AWS documentação. | Administrador de rede e administrador de nuvem | ### Preparação do servidor de origem | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Verifique os AWS pré-requisitos do MGN. | Verifique se os servidores de origem atendem aos pré-requisitos para a instalação do agente AWS MGN. Para obter mais informações, consulte [os requisitos de instalação](https://docs.aws.amazon.com/mgn/latest/ug/installation-requirements.html) na AWS documentação. | Engenheiro de migração | | Instale o agente AWS MGN. | Instale o agente AWS MGN nos servidores de origem. Durante a instalação, escolha para Região da AWS onde os servidores serão migrados. Após a instalação, o agente se comunica com o serviço e inicia a replicação. Para obter mais informações, consulte [Instalando o Agente AWS de Replicação em servidores Windows](https://docs.aws.amazon.com/mgn/latest/ug/windows-agent.html). | Engenheiro de migração | | Verifique o status dos servidores de origem. | No console AWS MGN, verifique o status dos servidores de origem. Quando a replicação começa, os servidores exibem o status **Pronto para teste**.Se você encontrar algum erro, consulte [Solução de problemas de comunicação](https://docs.aws.amazon.com/mgn/latest/ug/Troubleshooting-Communication-Errors.html) na documentação do AWS MGN. | Administrador de nuvem e engenheiro de migração | | Otimize as configurações de replicação. | Os clusters do SQL Always On usam alta replicação I/O síncrona do servidor primário para o servidor secundário. Para otimizar a replicação e evitar atrasos, use um [servidor de replicação dedicado](https://docs.aws.amazon.com/mgn/latest/ug/replication-settings-template.html) para cada servidor Always On do SQL.Se o tamanho do banco de dados for superior a 5 TB, considere optar por uma instância de servidor de replicação maior, como **m5.large**, em vez da instância padrão **t3.small**. | Administrador de nuvem e engenheiro de migração | | Atualize o modelo de inicialização. | Atualize as [configurações de inicialização](https://docs.aws.amazon.com/mgn/latest/ug/launch-settings.html) e escolha as sub-redes para os servidores Always On do SQL. Os servidores de cluster SQL Always On estão espalhados Zonas de disponibilidade da AWS por diferentes para oferecer alta disponibilidade. | Engenheiro de migração, líder de migração | | Atualize as configurações de inicialização. | Com base em seus requisitos de tamanho e desempenho, atualize o tipo de instância e input/output as operações por segundo (IOPS) nas configurações de execução.(Opcional) Selecione uma interface de rede elástica existente nas configurações de inicialização. | Engenheiro de migração, líder de migração | ### Substituição de teste | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Verifique os servidores de origem. | No console AWS MGN, verifique se o status do servidor de origem é **Pronto para teste**. | Administrador de nuvem e engenheiro de migração | | Inicie as instâncias de teste. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | Administrador de nuvem e engenheiro de migração | | Teste a conectividade e a integridade do banco de dados. | Teste a conectividade e a integridade do banco de dados das instâncias de teste. Em seguida, marque os servidores de origem como **Prontos para transferência no console** AWS MGN. | Administrador de nuvem e engenheiro de migração | ### Tarefas antes da migração | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Teste a integridade do banco de dados. | Isso ajuda a garantir que não haja problemas de integridade no banco de dados de origem antes da migração. Execute `DBCC CHECKDB` e especifique `WITH_PHYSICAL_ONLY`. Executar esta verificação sem `WITH_PHYSICAL_ONLY` pode causar problemas de performance na origem. Para manter a integridade do banco de dados, realize uma verificação completa semanalmente.Esses comandos verificam a integridade lógica e física do banco de dados, detectando possíveis problemas de corrupção. A verificação analisa a estrutura do banco de dados, abrangendo páginas, linhas, índices e as tabelas do sistema. | Engenheiro de dados, DBA | | Teste as conexões com os servidores vinculados. | Teste as conexões entre todos os servidores existentes e documente os status. Esse procedimento contribui para garantir que os servidores vinculados continuem funcionando como planejado depois da migração. | Engenheiro de dados, DBA | | Verifique os backups. | Confirme a integridade dos backups de origem. | Engenheiro de dados, DBA | ### AWS Transição de MGN | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Interrompa os serviços do SQL Server e do cluster. | Interrompa os serviços do SQL Server e do cluster da Microsoft em todos os nós do cluster do SQL. | DBA, Engenheiro de migração | | Verifique os servidores. | **No console do AWS MGN, verifique se o status dos servidores de origem é **Pronto para transferência e se o status** da replicação de dados está íntegro.** | Engenheiro de migração | | Inicie a substituição. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html)Para obter mais informações, consulte Como [iniciar uma instância de transição na documentação](https://docs.aws.amazon.com/mgn/latest/ug/launch-cutover-gs.html) do AWS MGN. | Engenheiro de migração | | Teste os servidores inicializados. | Faça login nas EC2 instâncias da Amazon lançadas e valide a integridade do cluster. Verifique se os servidores estão nas sub-redes corretas, se o tamanho da instância e as configurações de E/S estão corretos e se o servidor testemunha pode ser acessado. | DBA, Engenheiro de migração | ### Tarefas do banco de dados após a substituição | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Atualize o endereço IP do cluster. | Atualize o endereço IP do cluster para o cluster do Windows usando os dois endereços IP reservados nas sub-redes de destino. Para obter mais informações, consulte [Alterar o endereço IP de uma instância do cluster de failover](https://learn.microsoft.com/en-us/sql/sql-server/failover-clusters/windows/change-the-ip-address-of-a-failover-cluster-instance?view=sql-server-2016). | DBA, Engenheiro de migração | | Atualize o ouvinte IPs do grupo de disponibilidade Always On. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | DBA, Engenheiro de migração | | Verifique a conexão. | Usando o SSMS, conecte-se ao receptor do grupo de disponibilidade Always On e confirme se a conexão foi estabelecida com sucesso. | DBA, Engenheiro de migração | | Verifique a integridade do grupo de disponibilidade Always On. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | DBA, Engenheiro de migração | | Verifique o log de erros. | Abra o log de erros e verifique quaisquer erros registrados para a instância do SQL Server. Certifique-se de que a recuperação de todos os bancos de dados esteja concluída. | DBA, Engenheiro de migração | | Teste os servidores vinculados. | Teste a conectividade de quaisquer servidores vinculados. Em caso de problemas de conectividade, certifique-se de que o servidor de destino e a porta possam ser acessados. | DBA, Engenheiro de migração | ### Finalização da substituição | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Finalize a substituição. | Depois de validar os clusters SQL Always On de destino, [finalize](https://docs.aws.amazon.com/mgn/latest/ug/launch-cutover-gs.html#revert-finalize-cutover-gs) a transição por meio do console MGN. AWS Essa ação interrompe a replicação de dados dos servidores de origem e descarta os dados do servidor de replicação. Além disso, remove o servidor de replicação e os recursos associados. | Administrador de nuvem e engenheiro de migração | ## Solução de problemas | Problema | Solução | | --- | --- | | AWS Solução de problemas do MGN | Para problemas e resoluções comuns, consulte as seções [Solução de problemas](https://docs.aws.amazon.com/mgn/latest/ug/troubleshooting.html) e [perguntas frequentes](https://docs.aws.amazon.com/mgn/latest/ug/FAQ.html) na documentação do AWS MGN. | ## Recursos relacionados *AWS recursos* + [Opção 1 Rehospedar - () AWS Application Migration ServiceAWS](https://catalog.us-east-1.prod.workshops.aws/workshops/c6bdf8dc-d2b2-4dbd-b673-90836e954745/en-US/04-application-migration/01-mgn) + [O que é AWS Application Migration Service?](https://docs.aws.amazon.com/mgn/latest/ug/what-is-application-migration-service.html) *Recursos do SQL Server* + [What is SQL Server Management Studio (SSMS)?](https://learn.microsoft.com/en-us/ssms/sql-server-management-studio-ssms) ## Mais informações Para obter os requisitos de segurança padrão para migrar cargas de trabalho para o Nuvem AWS, consulte [as melhores práticas de segurança, identidade e conformidade](https://aws.amazon.com/architecture/security-identity-compliance/) no AWS site. # Migre o SQL Server para a AWS usando grupos de disponibilidade distribuídos *Praveen Marthala, Amazon Web Services* ## Resumo Os grupos de disponibilidade do Microsoft SQL Server Always On fornecem uma solução de alta disponibilidade (HA) e recuperação de desastres (DR) para o SQL Server. Um grupo de disponibilidade consiste em uma réplica primária que aceita read/write tráfego e até oito réplicas secundárias que aceitam tráfego de leitura. Um grupo de disponibilidade é configurado em um cluster de failover do Windows Server (WSFC) com dois ou mais nós. Os grupos de disponibilidade distribuídos do Microsoft SQL Server Always On fornecem uma solução para configurar dois grupos de disponibilidade separados entre dois grupos independentes WFSCs. Os grupos de disponibilidade que fazem parte do grupo de disponibilidade distribuída não precisam estar no mesmo datacenter. Um grupo de disponibilidade pode estar no local e o outro grupo de disponibilidade pode estar na nuvem da Amazon Web Services (AWS) em instâncias da Amazon Elastic Compute Cloud (Amazon EC2) em um domínio diferente. Esse padrão descreve as etapas para usar um grupo de disponibilidade distribuído para migrar bancos de dados SQL Server locais que fazem parte de um grupo de disponibilidade existente para o SQL Server com grupos de disponibilidade configurados na Amazon. EC2 Seguindo esse padrão, você pode migrar os bancos de dados para a Nuvem AWS com o mínimo de tempo de inatividade durante a substituição. Os bancos de dados estão altamente disponíveis na AWS imediatamente após a substituição. Você também pode usar esse padrão para alterar o sistema operacional subjacente on-premises para a AWS, mantendo a mesma versão do SQL Server. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + AWS Direct Connect ou AWS Site-to-Site VPN + A mesma versão do SQL Server instalada on-premises e nos dois nós da AWS **Versões do produto** + SQL Server versão 2016 e posterior + SQL Server Enterprise Edition ## Arquitetura **Pilha de tecnologia de origem** + Banco de dados do Microsoft SQL Server com grupos de disponibilidade Always On on-premises **Pilha de tecnologias de destino** + Banco de dados Microsoft SQL Server com grupos de disponibilidade Always On na Amazon EC2 na nuvem da AWS **Arquitetura de migração** ![\[SQL Server com replicação síncrona em grupos de disponibilidade, tanto on-premises quanto na AWS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/6e229e30-9b11-4ccb-bccd-cbe6601139c0/images/79ee7911-d68f-4db7-9b94-113dcf09c28b.png) *Terminologia* + WSFC 1 – WSFC on-premises + WSFC 2 – WSFC na Nuvem AWS + AG 1 – Primeiro grupo de disponibilidade, que está no WSFC 1 + AG 2 – Segundo grupo de disponibilidade, que está no WSFC 2 + Réplica primária do SQL Server – nó no AG 1 que é considerado o principal global para todas as gravações + Encaminhador do SQL Server – nó no AG 2 que recebe dados de forma assíncrona da réplica primária do SQL Server + Réplica secundária do SQL Server – nós no AG 1 ou AG 2 que recebem dados de forma síncrona da réplica primária ou do encaminhador ## Ferramentas + [AWS Direct Connect](https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html): o AWS Direct Connect vincula sua rede interna a um local do AWS Direct Connect por meio de um cabo de fibra óptica de Ethernet padrão. Com essa conexão, você pode criar *interfaces virtuais* diretamente para serviços públicos da AWS, ignorando provedores de serviço da internet no caminho da sua rede. + [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/concepts.html) — A Amazon Elastic Compute Cloud (Amazon EC2) fornece capacidade de computação escalável na Nuvem AWS. Você pode usar EC2 a Amazon para lançar quantos servidores virtuais precisar e pode expandir ou aumentar a escala. + [AWS Site-to-Site VPN](https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html) — O AWS Site-to-Site VPN suporta a criação de uma rede privada site-to-site virtual (VPN). Você pode configurar o VPN para transmitir tráfego entre instâncias que você executa na AWS e sua própria rede remota. + [Microsoft SQL Server Management Studio](https://docs.microsoft.com/en-us/sql/ssms/sql-server-management-studio-ssms?view=sql-server-ver15): o Microsoft SQL Server Management Studio (SSMS) é um ambiente integrado para o gerenciamento de uma infraestrutura do SQL Server. Ele fornece uma interface de usuário e um grupo de ferramentas com editores de scripts avançados que interagem com o SQL Server. ## Épicos ### Configure um segundo grupo de disponibilidade na AWS | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um WSFC na AWS. | Crie o WSFC 2 em EC2 instâncias da Amazon com dois nós para HA. Você usará esse cluster de failover para criar o segundo grupo de disponibilidade (AG 2) na AWS. | Administrador de sistemas, SysOps administrador | | Crie o segundo grupo de disponibilidade no WSFC 2. | Usando o SSMS, crie o AG 2 em dois nós no WSFC 2. O primeiro nó no WSFC 2 atuará como encaminhador. O segundo nó no WSFC 2 atuará como a réplica secundária do AG 2.Neste estágio, nenhum banco de dados está disponível no AG 2. Esse é o ponto de partida para configurar o grupo de disponibilidade distribuído. | DBA, Desenvolvedor | | Crie bancos de dados sem opção de recuperação no AG 2. | Faça backup dos bancos de dados no grupo de disponibilidade on-premises (AG 1). Restaure os bancos de dados tanto para o encaminhador quanto para a réplica secundária do AG 2 sem opção de recuperação. Ao restaurar os bancos de dados, especifique um local com espaço em disco suficiente para os arquivos de dados do banco de dados e os arquivos de log.Nesse estágio, os bancos de dados estão em estado de restauração. Eles não fazem parte do AG 2 ou do grupo de disponibilidade distribuída e não estão sincronizando. | DBA, Desenvolvedor | ### Configurar o grupo de disponibilidade distribuído | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie o grupo de disponibilidade distribuída no AG 1. | Para criar o grupo de disponibilidade distribuído no AG 1, use o `CREATE AVAILABILITY GROUP` com a opção `DISTRIBUTED`.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html) | DBA, Desenvolvedor | | Crie o grupo de disponibilidade distribuída no AG 2. | Para criar o grupo de disponibilidade distribuído no AG 2, use o `ALTER AVAILABILITY GROUP` com a opção `DISTRIBUTED`.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html)O grupo de disponibilidade distribuída é criado entre o AG 1 e o AG 2.Os bancos de dados no AG 2 ainda não estão configurados para participar do fluxo de dados do AG 1 para o AG 2. | DBA, Desenvolvedor | | Adicione bancos de dados ao encaminhador e à réplica secundária no AG 2. | Adicione os bancos de dados ao grupo de disponibilidade distribuído usando `ALTER DATABASE` com a opção `SET HADR` `AVAILABILITY GROUP` no encaminhador e na réplica secundária no AG 2. Isso inicia o fluxo de dados assíncrono entre bancos de dados no AG 1 e no AG 2. O primário global faz gravações, envia dados de forma síncrona para a réplica secundária no AG 1 e envia os dados de forma assíncrona para o encaminhador no AG 2. O encaminhador no AG 2 envia dados de forma síncrona para a réplica secundária no AG 2. | DBA, Desenvolvedor | ### Monitore o fluxo de dados assíncrono entre o AG 1 e o AG 2 | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Registros de uso DMVs e do SQL Server. | Monitore o status do fluxo de dados entre dois grupos de disponibilidade usando visualizações de gerenciamento dinâmico (DMVs) e registros do SQL Server. DMVs que são de interesse para monitoramento incluem `sys.dm_hadr_availability_replica_states` `sys.dm_hadr_automatic_seeding` e.Para saber o status da sincronização do encaminhador, monitore o *estado sincronizado* no log do SQL Server no encaminhador. | DBA, Desenvolvedor | ### Execute atividades de substituição para a migração final | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Interrompa todo o tráfego para a réplica primária. | Interrompa o tráfego de entrada para a réplica primária no AG 1 para que nenhuma atividade de gravação ocorra nos bancos de dados e os bancos de dados estejam prontos para a migração. | Proprietário do aplicativo, desenvolvedor | | Altere o modo de disponibilidade do grupo de disponibilidade distribuída no AG 1. | Na réplica primária, defina o modo de disponibilidade do grupo de disponibilidade distribuído como síncrono. Depois de alterar o modo de disponibilidade para síncrono, os dados são enviados de forma síncrona da réplica primária no AG 1 para o encaminhador no AG 2. | DBA, Desenvolvedor | | Verifique LSNs nos dois grupos de disponibilidade. | Verifique os últimos números de sequência de log (LSNs) no AG 1 e no AG 2. Como nenhuma gravação está acontecendo na réplica primária no AG 1, os dados são sincronizados e os últimos LSNs para os dois grupos de disponibilidade devem corresponder. | DBA, Desenvolvedor | | Atualize o AG 1 para a função secundária. | Quando você atualiza o AG 1 para a função secundária, o AG 1 perde a função de réplica principal e não aceita gravações, e o fluxo de dados entre dois grupos de disponibilidade é interrompido. | DBA, Desenvolvedor | ### Faça o failover para o segundo grupo de disponibilidade | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Faça o failover manual para o AG 2. | No encaminhador no AG 2, altere o grupo de disponibilidade distribuído para permitir a perda de dados. Como você já verificou e confirmou que os últimos LSNs no AG 1 e no AG 2 coincidem, a perda de dados não é uma preocupação.Quando você permite a perda de dados no encaminhador no AG 2, as funções do AG 1 e do AG 2 mudam:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html) | DBA, Desenvolvedor | | Altere o modo de disponibilidade do grupo de disponibilidade distribuída no AG 2. | Na réplica primária no AG 2, altere o modo de disponibilidade para assíncrono.Isso altera a movimentação de dados do AG 2 para o AG 1, de síncrono para assíncrono. Essa etapa é necessária para evitar a latência de rede entre o AG 2 e o AG 1, se houver, e não afetará o desempenho do banco de dados. | DBA, Desenvolvedor | | Comece a enviar tráfego para a nova réplica primária. | Atualize a cadeia de conexão para usar o endpoint de URL do receptor no AG 2 para enviar tráfego para os bancos de dados.O AG 2 agora aceita gravações e envia dados para o encaminhador no AG 1, além de enviar dados para sua própria réplica secundária no AG 2. Os dados são movidos de forma assíncrona do AG 2 para o AG 1. | Proprietário do aplicativo, desenvolvedor | ### Realizar atividades pós-substituição | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Descarte o grupo de disponibilidade distribuída no AG 2. | Monitore a migração pelo período de tempo planejado. Em seguida, descarte o grupo de disponibilidade distribuída no AG 2 para remover a configuração do grupo de disponibilidade distribuída entre o AG 2 e o AG 1. Isso remove a configuração do grupo de disponibilidade distribuído e o fluxo de dados do AG 2 para o AG 1 é interrompido. Neste momento, o AG 2 está altamente disponível na AWS, com uma réplica primária que recebe gravações e uma réplica secundária no mesmo grupo de disponibilidade. | DBA, Desenvolvedor | | Desative os servidores on-premises. | Desative os servidores on-premises no WSFC 1 que fazem parte do AG 1. | Administrador de sistemas, SysOps administrador | ## Recursos relacionados + [Grupos de disponibilidade distribuídos](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-sql-server/distributed-groups.html) + [SQL Docs: grupos de disponibilidade distribuídos](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/distributed-availability-groups?view=sql-server-ver15) + [SQL Docs: grupos de disponibilidade Always On: uma solução de alta disponibilidade e recuperação de desastres](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/always-on-availability-groups-sql-server?view=sql-server-ver15) # Migre um banco de dados relacional para o MongoDB Atlas em AWS *Battulga Purevragchaa e Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Resumo Este padrão descreve as etapas necessárias para migrar de um banco de dados relacional, como SQL Server, MySQL ou PostgreSQL, para o MongoDB Atlas na Nuvem AWS. O padrão usa o [MongoDB Relational Migrator](https://www.mongodb.com/products/relational-migrator) para ajudar a acelerar a migração de dados dos bancos de dados relacionais para o MongoDB Atlas. O padrão acompanha o guia [Migrating to MongoDB Atlas no site Prescriptive](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) Guidance. AWS AWS Ele fornece as etapas de implementação para um dos cenários de migração abordados nesse guia. Para cenários adicionais de migração, consulte os seguintes padrões no site da Orientação AWS Prescritiva: + [Migre um ambiente MongoDB auto-hospedado para o MongoDB Atlas em AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud.html) + [Transmita dados do IBM Db2, SAP, Sybase e outros bancos de dados para o MongoDB Atlas em AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/stream-data-from-ibm-db2-to-mongodb-atlas.html) O padrão é destinado aos [parceiros e AWS usuários do AWS System Integrator (SI)](https://aws.amazon.com/managed-services/partners/). ## Pré-requisitos e limitações **Pré-requisitos ** + Um banco de dados relacional de origem (Oracle Database, SQL Server, PostgreSQL, SAP/Sybase MySQL, ASE e outros) para migrar para o MongoDB Atlas. + Familiaridade com bancos de dados relacionais, MongoDB Atlas e. Serviços da AWS Esse padrão explica, de forma geral, algumas das etapas da migração. Detalhes adicionais serão incluídos em versões futuras. **Versões do produto** + MongoDB versão 5.0 ou posterior ## Arquitetura O diagrama apresentado a seguir ilustra a migração de um banco de dados de um sistema de gerenciamento de banco de dados relacional (RDBMS, na sigla em inglês) para o MongoDB Atlas na AWS. ![\[Arquitetura para a migração de um RDBMS para o MongoDB Atlas na AWS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/4e3ea0f1-21e8-4641-a9ee-732355f20baf/images/8eacf3ec-f480-4912-9002-6a50800fe9bf.png) Para arquiteturas de referência do MongoDB Atlas que oferecem suporte a diferentes cenários de uso, consulte [Migração para o MongoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) Atlas no site Prescriptive Guidance. AWS AWS ## Ferramentas + O [MongoDB](https://www.mongodb.com/atlas) Atlas é um banco de dados como serviço DBaa (S) totalmente gerenciado para implantar e gerenciar bancos de dados MongoDB na nuvem. + O [MongoDB Relational Migrator](https://www.mongodb.com/products/relational-migrator) possibilita a realização de uma migração de dados de bancos de dados relacionais tradicionais para o MongoDB de maneira eficiente. O serviço auxilia na automatização do processo de conversão e transforma o modelo de dados estruturado dos bancos de dados relacionais em um formato flexível de documentos fornecido pelo MongoDB. Com o Relational Migrator, a integridade e os relacionamentos dos dados são preservados, tornando a migração mais simples. As organizações podem aproveitar os benefícios de escalabilidade, performance e versatilidade que o MongoDB oferece, mantendo a familiaridade com os dados existentes. ## Práticas recomendadas [Para obter as melhores práticas para usar o MongoDB AWS no, consulte as postagens no AWS blog do Partner Network.](https://aws.amazon.com/blogs/apn/tag/mongodb-atlas/) ## Épicos ### Descoberta e avaliação | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Determine os parâmetros e o tamanho do banco de dados relacional. | Calcule uma estimativa do tamanho do conjunto de trabalho com base nas recomendações do Relational Migrator e nos dados de `db.stats()` relativos ao espaço total de índices. Suponha que uma porcentagem do seu espaço de dados seja acessada com frequência. Essa tarefa deve levar aproximadamente uma semana. Para obter mais informações e exemplos sobre esta e outras histórias deste épico, consulte a seção [Recursos relacionados](#migrate-relational-database-to-mongodb-atlas-resources). | Proprietário do aplicativo, DBA | | Estime os requisitos de largura de banda da rede. | Para estimar seus requisitos de largura de banda da rede, multiplique o tamanho médio dos documentos pelo número de documentos processados por segundo. Considere o tráfego máximo que qualquer nó do seu cluster suportará como base. Para calcular as taxas de transferência de dados downstream do seu cluster para os aplicativos cliente, use a soma do total de documentos retornados em determinado período. Se seus aplicativos fizerem a leitura a partir de nós secundários, divida esse número total de documentos pelo número de nós que podem processar operações de leitura. Para descobrir o tamanho médio dos documentos de um banco de dados, use o comando `db.stats().avgObjSize`. Essa tarefa normalmente leva um dia. | DBA | | Selecione a camada do Atlas. | Siga as instruções apresentadas na [documentação do MongoDB](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) para selecionar o nível mais adequado do cluster no Atlas. | DBA | | Planeje a substituição. | Planeje a substituição do aplicativo. | DBA, proprietário do aplicativo | ### Configure um novo ambiente MongoDB Atlas em AWS | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um novo cluster MongoDB Atlas em. AWS | No MongoDB Atlas, escolha **Criar um cluster**. Na caixa de diálogo **Criar novo cluster**, selecione AWS como provedor de nuvem. | DBA | | Selecione Regiões da AWS uma configuração global do cluster. | Selecione na lista de disponíveis Regiões da AWS para seu cluster Atlas. Configure clusters globais, se necessário. | DBA | | Selecione o nível cluster. | Selecione o nível de cluster de sua preferência. Sua seleção de camadas determina fatores como memória, armazenamento e especificação de IOPS. | DBA | | Configurar definições adicionais de cluster. | Definir configurações adicionais de cluster, como opções de versão, backup e criptografia do MongoDB. Para obter mais informações sobre essas opções, consulte a seção [Recursos relacionados](#migrate-relational-database-to-mongodb-atlas-resources). | DBA | ### Configure a segurança e a conformidade | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Configure a lista de acesso. | Para estabelecer conexão com o cluster do Atlas, você deve adicionar uma entrada à lista de acesso do projeto. O Atlas usa TLS/SSL para criptografar as conexões com a nuvem privada virtual (VPC) do seu banco de dados. Para configurar a lista de acesso para o projeto e obter mais informações sobre as histórias deste épico, consulte a seção [Recursos relacionados](#migrate-relational-database-to-mongodb-atlas-resources). | DBA | | Autentique e autorize usuários. | Você deve criar e autenticar os usuários do banco de dados que acessarão os clusters MongoDB Atlas. Para acessar clusters em um projeto, os usuários devem pertencer a esse projeto e podem pertencer a vários projetos. | DBA | | Criar funções personalizadas. | (Opcional) É possível criar perfis personalizados no Atlas quando as permissões de usuário padrão incorporadas no banco de dados do Atlas não contemplam todas as permissões que você deseja. | DBA | | Configurar o emparelhamento de VPC. | (Opcional) O Atlas oferece suporte ao emparelhamento de [VPC](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) com outros. VPCs AWS | Administrador da AWS | | Configure um AWS PrivateLink endpoint. | (Opcional) Você pode configurar endpoints privados AWS usando AWS PrivateLink. Para obter mais informações, consulte a [documentação da Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html). | Administrador da AWS | | Ative a autenticação de dois fatores. | (Opcional) O Atlas fornece suporte à autenticação de dois fatores (2FA) para ajudar os usuários a controlar o acesso às suas contas do Atlas. | Administrador da AWS | | Configure a autenticação e autorização do usuário com o LDAP. | (Opcional) O Atlas fornece suporte à autenticação e autorização do usuário com o Lightweight Directory Access Protocol (LDAP). | DBA | | Configure o AWS acesso unificado. | (Opcional) Alguns recursos do Atlas, incluindo o Atlas Data Lake e a criptografia em repouso usando o gerenciamento de chaves do cliente, usam funções AWS Identity and Access Management (IAM) para autenticação. | Administrador da AWS | | Configure a criptografia em repouso usando AWS KMS. | (Opcional) O Atlas suporta o uso de AWS Key Management Service (AWS KMS) para criptografar mecanismos de armazenamento e backups de provedores de nuvem. | Administrador da AWS | | Configurar criptografia em nível de campo do lado do cliente. | (Opcional) O Atlas fornece suporte à criptografia em nível de campo do lado do cliente, incluindo criptografia automática de campos. | Administrador da AWS | ### Migrar dados | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Adicione o MongoDB Relational Migrator à lista de acesso. | Adicione o Relational Migrator à lista de acesso do seu banco de dados de origem. Isso ajuda a preparar o ambiente de origem para se conectar ao cluster Atlas de destino. | DBA | | Avalie os objetos do banco de dados relacional. | Execute o MongoDB Relational Migrator e estabeleça conexão com o banco de dados relacional. Inicie a avaliação. | DBA | | Aceite os padrões de migração ou opte por alterá-los de acordo com as necessidades do seu negócio. | Aceite os padrões de banco de dados recomendados pelo Relational Migrator com base na avaliação inicial e nos parâmetros de performance, ou opte por alterá-los de acordo com os requisitos do seu negócio. | DBA | | Execute seu conjunto de réplicas de destino no MongoDB Atlas. | Execute seu conjunto de réplicas de destino no MongoDB Atlas. No Relational Migrator, selecione **Estou com tudo pronto para a migração**. | DBA | ### Configurar integração operacional | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Conecte-se ao cluster MongoDB Atlas. | Certifique-se de que a conectividade do cluster do MongoDB Atlas está funcionando conforme o esperado. | Proprietário do App | | Interaja com os dados do cluster. | Verifique os dados do cluster. | DBA | | Monitore seus clusters. | Verifique se os clusters estão configurados corretamente. | DBA | | Faça backup e restaure os dados do cluster. | Programe backups com uma frequência periódica para os dados do cluster. | DBA | ## Recursos relacionados Exceto quando indicado, todos os links abaixo direcionam para páginas na documentação do MongoDB. **Guia de migração** + [Migrando para o MongoDB AWS Atlas](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) em (orientação prescritiva)AWS **Descoberta e avaliação** + [Memória](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Exemplo de dimensionamento com conjuntos de dados de amostra do Atlas](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Exemplo de dimensionamento para aplicativos móveis](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Tráfego de rede](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Ajuste de escala automático de cluster](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Modelo de dimensionamento do Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Configurar a segurança e a conformidade** + [Configurar entradas da lista de acesso via IP](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Configure Database Users](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Configurar acesso à UI do Atlas](https://docs.atlas.mongodb.com/organizations-projects/) + [Configurar papéis personalizados do banco de dados](https://docs.atlas.mongodb.com/security-add-mongodb-roles) + [Configure Database Users](https://docs.atlas.mongodb.com/security-add-mongodb-users/#atlas-user-privileges) + [Configurar uma conexão de emparelhamento de rede](https://docs.atlas.mongodb.com/security-vpc-peering/) + [Aprenda sobre endpoints privados no Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Gerencie suas opções de autenticação multifator](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Configurar a autenticação e autorização do usuário com o LDAP](https://docs.atlas.mongodb.com/security-ldaps/) + [Atlas Data Lake](https://docs.mongodb.com/datalake/) + [Criptografia em repouso usando o gerenciamento de chaves do cliente](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Métodos para assumir um perfil](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (documentação do IAM) + [Criptografia em nível de campo do lado do cliente](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Criptografia automática](https://docs.mongodb.com/manual/core/security-automatic-client-side-encryption) + [MongoDB Atlas Security Controls](https://webassets.mongodb.com/_com_assets/cms/MongoDB_Atlas_Security_Controls-v7k3rbhi3p.pdf) + [Central de confiabilidade do MongoDB](https://www.mongodb.com/cloud/trust) + [Configurar recursos de segurança para Clusters](https://docs.atlas.mongodb.com/setup-cluster-security/) **Como configurar um novo ambiente do MongoDB Atlas na ****AWS** + [Provedores de nuvem e regiões](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Gerenciar clusters globais](https://docs.atlas.mongodb.com/global-clusters/) + [Selecione o nível de cluster](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Configurar configurações adicionais](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Comece a usar o Atlas](https://docs.atlas.mongodb.com/getting-started/) + [Configurar acesso à UI do Atlas](https://docs.atlas.mongodb.com/organizations-projects/) **Migração de dados** + [Migre ou importe dados](https://www.mongodb.com/docs/atlas/import/) **Clusters de monitoramento** + [Monitore seus clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) **Integração de operações** + [Conectar-se a um cluster](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interaja com seus dados](https://docs.atlas.mongodb.com/data-explorer/) + [Monitore seus clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Fazer backup, restaurar e arquivar dados](https://docs.atlas.mongodb.com/backup-restore-cluster/) # Migre um ambiente MongoDB auto-hospedado para o MongoDB Atlas em AWS *Battulga Purevragchaa e Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Resumo Este padrão descreve as etapas necessárias para migrar de um ambiente autogerenciado do MongoDB (incluindo MongoDB Community Server, Enterprise Server, Enterprise Advanced, mLab ou qualquer cluster gerenciado do MongoDB) para o MongoDB Atlas na Nuvem AWS. Ele usa o [Atlas Live Migration Service](https://www.mongodb.com/cloud/atlas/migrate) para ajudar a acelerar a migração de dados do MongoDB para o MongoDB Atlas. O padrão acompanha o guia [Migrating to MongoDB Atlas no site Prescriptive](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) Guidance. AWS AWS Ele fornece as etapas de implementação para um dos cenários de migração abordados nesse guia. Para cenários adicionais de migração, consulte os seguintes padrões no site da Orientação AWS Prescritiva: + [Migre um banco de dados relacional para o MongoDB Atlas em AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-relational-database-to-mongodb-atlas.html) + [Transmita dados do IBM Db2, SAP, Sybase e outros bancos de dados para o MongoDB Atlas em AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/stream-data-from-ibm-db2-to-mongodb-atlas.html) O padrão é destinado a [parceiros e AWS usuários do AWS Systems Integrator (SI)](https://aws.amazon.com/managed-services/partners/). ## Pré-requisitos e limitações **Pré-requisitos ** + Um ambiente do MongoDB Enterprise Advanced, Community Server ou outro ambiente autogerenciado de origem do MongoDB destinado à migração para o MongoDB Atlas. + Familiaridade com MongoDB, MongoDB Atlas e. Serviços da AWS Esse padrão explica, de forma geral, algumas das etapas da migração. Detalhes adicionais serão incluídos em versões futuras. **Versões do produto** + MongoDB versão 6.0.13 ou posterior ## Arquitetura O diagrama apresentado a seguir ilustra o Atlas Live Migration Service, usado para migrar dados de um banco de dados do MongoDB Enterprise Advanced e de um banco de dados do MongoDB Community para o MongoDB Atlas na AWS. Use este serviço quando for necessário migrar bancos de dados grandes e complexos para o MongoDB Atlas com tempo de inatividade mínimo e sincronização contínua de dados. Este padrão usa o Atlas Live Migration Service. ![\[Migração de dados com o MongoDB Atlas Live Migration Service.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/52cdb923-64ff-4ee2-b129-93b9a139e24b/images/372134c4-ba47-4e48-bd0d-8b43017773b8.png) O diagrama a seguir mostra o serviço de espelho do MongoDB `mongomirror` () que você também pode usar para migrar dados de um banco de dados MongoDB Enterprise Advanced e de um banco de dados MongoDB Community para o MongoDB Atlas por meio de uma conexão segura. AWS [AWS PrivateLink](https://aws.amazon.com/privatelink/) Use o serviço `mongomirror` para obter uma replicação contínua de dados entre o MongoDB on-premises e o MongoDB Atlas. A ferramenta é ideal para a recuperação de desastres ou para migrações em etapas, mas está fora do escopo deste padrão. ![\[Migração de dados usando a ferramenta mongomirror.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/52cdb923-64ff-4ee2-b129-93b9a139e24b/images/53488a9b-2210-4b3d-b517-b618c1e0182c.png) Para obter mais arquiteturas de referência do MongoDB Atlas que oferecem suporte a diferentes cenários de uso, consulte [Migração para o MongoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) Atlas no site Prescriptive Guidance. AWS AWS ## Ferramentas + O [MongoDB Atlas](https://www.mongodb.com/atlas) é um banco de dados como serviço (DBaaS) totalmente gerenciado para implantar e gerenciar bancos de dados do MongoDB na nuvem. + O [Atlas Live Migration Service](https://www.mongodb.com/cloud/atlas/migrate) é um utilitário gratuito do MongoDB que auxilia na migração de bancos de dados para o Atlas. Este serviço mantém o banco de dados de origem sincronizado com o banco de dados de destino até a substituição. Quando for o momento de realizar a substituição, você irá interromper as instâncias do aplicativo, direcioná-las para o cluster Atlas de destino e reinicializá-las. Para acessar este serviço, selecione **Opções de banco de dados** no cluster do MongoDB Atlas. + O [mongomirror](https://www.mongodb.com/docs/atlas/import/mongomirror/) é uma ferramenta destinada à migração manual de dados de um conjunto de réplicas do MongoDB existente para um conjunto de réplicas do MongoDB Atlas. O `mongomirror` não requer o desligamento do conjunto de réplicas ou das aplicações existentes, a importação de dados de usuários ou de perfis, nem cópia do banco de dados de configuração. É possível fazer o download do `mongomirror` da [documentação do MongoDB](https://www.mongodb.com/docs/atlas/import/mongomirror/#download-mongomirror). ## Práticas recomendadas [Para obter as melhores práticas para usar o MongoDB AWS no, consulte as postagens no AWS blog do Partner Network.](https://aws.amazon.com/blogs/apn/tag/mongodb-atlas/) ## Épicos ### Descoberta e avaliação | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Determine o tamanho do cluster. | Calcule uma estimativa do tamanho do conjunto de trabalho com base nos dados de `db.stats()` relativos ao espaço total de índices. Suponha que uma porcentagem do seu espaço de dados seja acessada com frequência. Ou você pode estimar seus requisitos de memória com base em suas próprias suposições. Essa tarefa deve levar aproximadamente uma semana. Para obter mais informações e exemplos sobre esta e outras histórias deste épico, consulte a seção [Recursos relacionados](#migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud-resources). | DBA, proprietário do aplicativo | | Estime os requisitos de largura de banda da rede. | Para estimar seus requisitos de largura de banda da rede, multiplique o tamanho médio dos documentos pelo número de documentos processados por segundo. Considere o tráfego máximo que qualquer nó do seu cluster suportará como base. Para calcular as taxas de transferência de dados downstream do seu cluster para os aplicativos cliente, use a soma do total de documentos retornados em determinado período. Se seus aplicativos fizerem a leitura a partir de nós secundários, divida esse número total de documentos pelo número de nós que podem processar operações de leitura. Para descobrir o tamanho médio dos documentos de um banco de dados, use o comando `db.stats().avgObjSize`. Essa tarefa normalmente leva um dia. | DBA | | Selecione a camada do Atlas. | Siga as instruções apresentadas na [documentação do MongoDB](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) para selecionar o nível mais adequado do cluster no Atlas. | DBA | | Planeje a substituição. | Planeje a substituição do aplicativo. | DBA, proprietário do aplicativo | ### Configure um novo ambiente MongoDB Atlas na AWS | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um novo cluster MongoDB Atlas em. AWS | Faça login no Atlas e abra a página **Visão Geral** do projeto. Clique no botão **Criar** para criar um cluster. Para obter mais informações, consulte a [ documentação do MongoDB](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/). | DBA | | Selecione Regiões da AWS uma configuração global do cluster. | Selecione na lista de disponíveis Regiões da AWS para seu cluster Atlas. Configure clusters globais, se necessário. Para obter mais informações, consulte a [ documentação do MongoDB](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/#select-your-preferred-region.). | DBA | | Selecione o nível cluster. | Selecione o nível de cluster de sua preferência. Sua seleção de camadas determina fatores como memória, armazenamento e especificação de IOPS. | DBA | | Configurar definições adicionais de cluster. | Definir configurações adicionais de cluster, como opções de versão, backup e criptografia do MongoDB. Para obter mais informações sobre essas opções, consulte a seção [Recursos relacionados](#migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud-resources). | DBA | ### Configure a segurança e a conformidade | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Autentique e autorize usuários. | Você deve criar e autenticar os usuários do banco de dados que acessarão os clusters MongoDB Atlas. Para acessar clusters em um projeto, os usuários devem pertencer a esse projeto e podem pertencer a vários projetos. O Atlas também oferece suporte à autenticação baseada em AWS Identity and Access Management (IAM). Para obter mais informações, consulte a [ documentação do MongoDB](https://www.mongodb.com/docs/atlas/security/aws-iam-authentication/#set-up-authentication-with-aws-iam). | DBA | | Criar funções personalizadas. | (Opcional) É possível criar perfis personalizados no Atlas quando as permissões de usuário padrão incorporadas no banco de dados do Atlas não contemplam todas as permissões que você deseja. | DBA | | Configurar o emparelhamento de VPC. | (Opcional) O Atlas oferece suporte ao emparelhamento de [nuvem privada virtual (VPC)](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) com outras. VPCs AWS | Administrador da AWS | | Configure um AWS PrivateLink endpoint. | (Opcional) Você pode configurar endpoints privados AWS usando AWS PrivateLink. Para obter mais informações, consulte a [documentação da Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html). | Administrador da AWS | | Ative a autenticação de dois fatores. | (Opcional) O Atlas fornece suporte à autenticação de dois fatores (2FA) para ajudar os usuários a controlar o acesso às suas contas do Atlas. | Administrador da AWS | | Configure a autenticação e autorização do usuário com o LDAP. | (Opcional) O Atlas fornece suporte à autenticação e autorização do usuário com o Lightweight Directory Access Protocol (LDAP). | Administrador da AWS | | Configure o AWS acesso unificado. | (Opcional) Alguns recursos do Atlas, como o Atlas Data Lake e a criptografia em repouso com gerenciamento de chaves do cliente, usam perfis do IAM para autenticação. | Administrador da AWS | | Configure a criptografia em repouso usando AWS KMS. | (Opcional) O Atlas suporta o uso de AWS Key Management Service (AWS KMS) para criptografar mecanismos de armazenamento e backups de provedores de nuvem. | Administrador da AWS | | Configurar criptografia em nível de campo do lado do cliente. | (Opcional) O Atlas fornece suporte à criptografia em nível de campo do lado do cliente, incluindo criptografia automática de campos. | Administrador da AWS | ### Migrar dados | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Selecione o conjunto de réplicas de destino no MongoDB Atlas. | Acesse o cluster de destino do Atlas e clique no botão de reticências (...). Na lista de clusters, o botão é mostrado logo abaixo do nome do cluster. Nos detalhes do cluster, o botão aparece à direita, ao lado dos botões **Conectar** e **Configuração**. Para obter mais informações, consulte a [ documentação do MongoDB](https://www.mongodb.com/docs/atlas/import/c2c-pull-live-migration/#procedure). | DBA | | Adicione o Atlas Live Migration Service à lista de acesso. | Adicione o Atlas Live Migration Service à lista de acesso em seu cluster de AWS origem. Isso ajuda a preparar o ambiente de origem para se conectar ao cluster Atlas de destino. | DBA | | Execute a migração com o Atlas Live Migration Service. | Selecione **Iniciar migração**. Quando o botão **Preparar para substituição** ficar verde, realize a substituição. Analise as métricas de desempenho do cluster Atlas. Considere atualizar a conexão com o banco de dados em todas as camadas da aplicação para direcionar para o novo banco de dados. | DBA | ### Configurar integração operacional | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Conecte-se ao cluster MongoDB Atlas. | Certifique-se de que a conectividade do cluster do MongoDB Atlas está funcionando conforme o esperado. | Proprietário do App | | Interaja com os dados do cluster. | Teste os dados do cluster. | DBA | | Monitore seus clusters. | Verifique se os clusters estão configurados corretamente. | DBA | | Faça backup e restaure os dados do cluster. | Programe backups com uma frequência periódica para os dados do cluster. | DBA | ## Solução de problemas | Problema | Solução | | --- | --- | | Erro: não foi possível acessar a origem especificada | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud.html) | | Erro: não foi possível resolver o nome do host | Nenhum endereço IP foi encontrado para o nome do host fornecido. Confirme se o nome do host fornecido está correto e se é publicamente acessível. | | Demais erros | Se você encontrar qualquer outro erro, consulte [Troubleshoot Live Migration (Pull)](https://www.mongodb.com/docs/atlas/import/live-import-troubleshooting/) na documentação do MongoDB. | ## Recursos relacionados Exceto quando indicado, todos os links abaixo direcionam para páginas na documentação do MongoDB. **Guia de migração** + [Migrando para o MongoDB AWS Atlas](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) em (orientação prescritiva)AWS **Migração legada** + [Migration of older versions of MongoDB](https://www.mongodb.com/docs/atlas/legacy-migration/) **Descoberta e avaliação** + [Memória](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Exemplo de dimensionamento com conjuntos de dados de amostra do Atlas](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Exemplo de dimensionamento para aplicativos móveis](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Tráfego de rede](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Ajuste de escala automático de cluster](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Modelo de dimensionamento do Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Configurar a segurança e a conformidade** + [Configurar entradas da lista de acesso via IP](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Configure Database Users](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Configurar acesso à UI do Atlas](https://docs.atlas.mongodb.com/organizations-projects/) + [Configurar papéis personalizados do banco de dados](https://docs.atlas.mongodb.com/security-add-mongodb-roles) + [Configure Database Users](https://docs.atlas.mongodb.com/security-add-mongodb-users/#atlas-user-privileges) + [Configurar uma conexão de emparelhamento de rede](https://docs.atlas.mongodb.com/security-vpc-peering/) + [Aprenda sobre endpoints privados no Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Gerencie suas opções de autenticação multifator](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Configurar a autenticação e autorização do usuário com o LDAP](https://docs.atlas.mongodb.com/security-ldaps/) + [Atlas Data Lake](https://docs.mongodb.com/datalake/) + [Criptografia em repouso usando o gerenciamento de chaves do cliente](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Métodos para assumir um perfil](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (documentação do IAM) + [Criptografia em nível de campo do lado do cliente](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Criptografia automática](https://docs.mongodb.com/manual/core/security-automatic-client-side-encryption) + [MongoDB Atlas Security Controls](https://webassets.mongodb.com/_com_assets/cms/MongoDB_Atlas_Security_Controls-v7k3rbhi3p.pdf) + [Central de confiabilidade do MongoDB](https://www.mongodb.com/cloud/trust) + [Configurar recursos de segurança para Clusters](https://docs.atlas.mongodb.com/setup-cluster-security/) **Como configurar um novo ambiente do MongoDB Atlas na ****AWS** + [Provedores de nuvem e regiões](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Gerenciar clusters globais](https://docs.atlas.mongodb.com/global-clusters/) + [Selecione o nível de cluster](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Configurar configurações adicionais](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Comece a usar o Atlas](https://docs.atlas.mongodb.com/getting-started/) + [Configurar acesso à UI do Atlas](https://docs.atlas.mongodb.com/organizations-projects/) **Migração de dados** + [Migre ou importe dados](https://www.mongodb.com/docs/atlas/import/) **Clusters de monitoramento** + [Monitore seus clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) **Integração de operações** + [Conectar-se a um cluster](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interaja com seus dados](https://docs.atlas.mongodb.com/data-explorer/) + [Monitore seus clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Fazer backup, restaurar e arquivar dados](https://docs.atlas.mongodb.com/backup-restore-cluster/) **Treinamento** + [Live Migration with MongoDB Atlas](https://learn.mongodb.com/courses/live-migration-with-mongodb-atlas) ## Mais informações Para obter mais informações, consulte os seguintes tópicos na documentação do MongoDB: + Para mover dados para uma instância sem servidor, [use o Compass para exportar e importar dados, ou migre dados](https://www.mongodb.com/docs/compass/current/import-export/) com ferramentas autogerenciadas. Para saber mais, consulte [Serverless Instance Limitations](https://www.mongodb.com/docs/atlas/reference/serverless-instance-limitations/). + Para carregar dados em um novo cluster no Atlas, consulte [Carregar dados no Atlas](https://www.mongodb.com/docs/atlas/sample-data/#std-label-sample-data). + Para criar uma cópia do seu cluster para fins de teste, consulte [Backup Methods for a Self-Managed Deployment](https://www.mongodb.com/docs/manual/core/backups/). + Se a aplicação que você deseja migrar requer um tempo de atividade praticamente contínuo, entre em contato com a [equipe de suporte do MongoDB](https://www.mongodb.com/docs/atlas/support/#std-label-request-support) e compartilhe seus requisitos de tempo de atividade e de configuração do cluster. + Para obter informações adicionais, consulte [Migre ou importe dados](https://www.mongodb.com/docs/atlas/import/). # Migrar um banco de dados Oracle para o Amazon DynamoDB usando AWS DMS *Rambabu Karnena, Amazon Web Services* ## Resumo Esse padrão orienta você pelas etapas de migração de um banco de dados Oracle para o [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) usando o AWS Database Migration Service ([AWS DMS](https://aws.amazon.com/dms/)). Ele abrange três tipos de bancos de dados de origem: + Bancos de dados Oracle on-premises. + Bancos de dados Oracle na Amazon Elastic Compute Cloud ([Amazon EC2](https://aws.amazon.com/ec2/)) + Amazon Relational Database Service ([Amazon RDS](https://aws.amazon.com/rds/)) para instâncias do banco de dados do Oracle Nessa prova de conceito, esse padrão se concentra na migração de uma instância de banco de dados do Amazon RDS para Oracle. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Um aplicativo que se conecta a um banco de dados do Amazon RDS para Oracle + Uma tabela criada no banco de dados de origem Amazon RDS para Oracle com uma chave primária e dados de amostra **Limitações** + Objetos de banco de dados Oracle, como procedimentos, funções, pacotes e gatilhos, não são considerados para migração porque o Amazon DynamoDB não oferece suporte a esses objetos de banco de dados. **Versões do produto** + Esse padrão se aplica a todas as edições e versões dos bancos de dados Oracle que são compatíveis com o AWS DMS. Para obter mais informações, consulte Como usar um [banco de dados Oracle como origem para o AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html) e usar um [banco de dados do Amazon DynamoDB como destino para o AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.DynamoDB.html). Recomendamos que você use as versões mais recentes do AWS DMS para obter o suporte mais abrangente de versões e atributos. ## Arquitetura **Pilha de tecnologia de origem** + Amazon RDS para instâncias de banco de dados Oracle, Oracle na EC2 Amazon ou bancos de dados Oracle locais **Pilha de tecnologias de destino** + Amazon DynamoDB **Arquitetura de migração de dados da AWS** ![\[Os dados são movidos do banco de dados Oracle para o AWS DMS e para o Amazon DynamoDB.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/463fc7d4-ec8d-473b-8c7f-1df31800ee03/images/180e7340-3887-455d-a591-b5850e22770a.png) ## Ferramentas + O [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) ajuda você a migrar armazenamentos de dados para a Nuvem AWS ou entre combinações de configurações na nuvem e on-premises. + O [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) é um serviço de banco de dados NoSQL totalmente gerenciado que fornece performance rápida, previsível e escalável. + O [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) ajuda você a configurar, operar e escalar um banco de dados relacional na Nuvem AWS. Esse padrão usa o Amazon RDS para Oracle. ## Épicos ### Planejar a migração | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma VPC. | Crie uma nuvem privada virtual (VPC) e uma sub-rede privada na conta da AWS. | Administrador de sistemas | | Criar grupos de segurança e listas de controle de acesso à rede. | Para obter mais informações, consulte a [documentação da AWS](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html). | Administrador de sistemas | | Configurar e iniciar a instância de banco de dados Amazon RDS para Oracle | Para obter mais informações, consulte a [documentação da AWS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html). | DBA, administrador de sistemas | ### Migrar dados | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Para criar um perfil do IAM para acesso ao DynamoDB. | No console do AWS Identity and Access Management (IAM) crie a função, anexe a política `AmazonDynamoDBFullAccess to it`, e selecione o AWS DMS como o serviço. | Administrador de sistemas | | Crie uma instância de replicação do AWS DMS para migração. | A instância de replicação deve estar na mesma zona de disponibilidade e VPC que o banco de dados de origem. | Administrador de sistemas | | Criação de endpoints no AWS DMS de origem e de destino. | Para criar o endpoint do banco de dados de origem, você tem duas opções:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.html)Para criar o endpoint do banco de dados de destino, escolha a função nome do recurso da Amazon (ARN) na tarefa anterior para acessar o DynamoDB. | Administrador de sistemas | | Crie uma tarefa do AWS DMS para carregar as tabelas de origem do banco de dados Oracle no DynamoDB. | Escolha os nomes dos endpoints de origem e destino e a instância de replicação nas etapas anteriores. O tipo pode ser carga total. Escolha o esquema Oracle e especifique**%** para selecionar todas as tabelas. | Administrador de sistemas | | Valide as tabelas no DynamoDB. | Para ver os resultados da migração, escolha **Tabelas** no painel de navegação esquerdo no console do DynamoDB. | DBA | ### Migrar o aplicativo | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Modifique o código do aplicativo | Para se conectar e recuperar dados do DynamoDB, atualize o código do aplicativo. | Proprietário do aplicativo, DBA, administrador de sistemas | ### Substituir | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Troque os clientes do aplicativo para usar o DynamoDB. | | DBA, proprietário do aplicativo, administrador de sistemas | ### Fechar o projeto | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Desligar recursos da AWS | Por exemplo, o desligamento da instância Amazon RDS para Oracle, DynamoDB e da instância de replicação do AWS DMS. | DBA, administrador de sistemas | | Colete métricas. | As métricas incluem o tempo de migração, as porcentagens do trabalho manual e do trabalho realizado pela ferramenta e a economia de custos. | DBA, proprietário do aplicativo, administrador de sistemas | ## Recursos relacionados + [AWS Database Migration Service e Amazon DynamoDB: o que você precisa saber](https://aws.amazon.com/blogs/database/aws-database-migration-service-and-amazon-dynamodb-what-you-need-to-know/) (postagem do blog) + [Uso de um banco de dados Oracle como origem para o AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html) + [Uso do banco de dados Amazon DynamoDB como destino para o AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.DynamoDB.html) + [Melhores práticas para migrar do RDBMS para o Amazon DynamoDB ](https://docs.aws.amazon.com/whitepapers/latest/best-practices-for-migrating-from-rdbms-to-dynamodb/welcome.html)(whitepaper) # Migre do Oracle 8i ou 9i para o Amazon RDS for Oracle usando o AWS DMS SharePlex *Ramu Jagini, Amazon Web Services* ## Resumo Esse padrão descreve como migrar um banco de dados Oracle 8i ou 9i on-premises para um banco de dados do Amazon Relational Database Service (Amazon RDS) para Oracle. Você pode usar esse padrão para concluir sua migração com tempo de inatividade reduzido usando o Quest SharePlex para replicação síncrona. Você deve usar uma instância de banco de dados do Oracle intermediária para sua migração porque o AWS Database Migration Service (AWS DMS) não oferece suporte ao Oracle 8i ou 9i como ambiente de origem. Você pode usar a [SharePlex versão 7.6.3](https://www.quest.com/community/shareplex/f/forum/20700/where-can-download-7-6-3-or-support-9i-shareplex) para replicar de versões anteriores do banco de dados Oracle para versões posteriores do banco de dados Oracle. A instância intermediária do banco de dados Oracle é compatível como destino para a SharePlex versão 7.6.3 e suportada como fonte para o AWS DMS ou versões mais recentes do. SharePlex Esse suporte permite a replicação contínua de dados para o ambiente de destino do Amazon RDS para Oracle. Considere que vários tipos de dados e atributos obsoletos podem afetar a migração do Oracle 8i ou 9i para a versão mais recente do Oracle Database. Para mitigar esse impacto, esse padrão usa o Oracle 11.2.0.4 como uma versão intermediária do banco de dados para ajudar a otimizar o código do esquema antes da migração para o ambiente de destino do Amazon RDS para Oracle. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Um banco de dados de origem do Oracle 8i ou 9i em um ambiente on-premises + [Oracle Database 12c versão 2](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/index.html) (12CR2) para armazenamento temporário no Amazon Elastic Compute Cloud (Amazon) EC2 + Quest SharePlex 7.6.3 (nível comercial) **Limitações** + [Limitações do RDS for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Oracle.Concepts.limitations.html) **Versões do produto** + Oracle 8i ou 9i para o banco de dados de origem + Oracle 12 CR2 para o banco de dados de teste (deve corresponder à versão do Amazon RDS for Oracle) + Oracle 12 CR2 ou posterior para o banco de dados de destino (Amazon RDS for Oracle) ## Arquitetura **Pilha de tecnologia de origem** + Banco de dados do Oracle 8i ou 9i + SharePlex **Pilha de tecnologias de destino** + Amazon RDS para Oracle **Arquitetura de migração** O diagrama a seguir mostra como migrar um banco de dados Oracle 8i ou 9i de um ambiente on-premises para uma instância de banco de dados do Amazon RDS para Oracle na Nuvem AWS. ![\[Fluxo de trabalho para a migração de um banco de dados da Oracle on-premises para o Amazon RDS na AWS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/6e07d586-fd74-4f3d-8e81-79dd55c445c3/images/36e1a5ff-908b-4cb7-96f7-997eb105f1d6.png) O diagrama mostra o seguinte fluxo de trabalho: 1. Ative o banco de dados de origem Oracle com o modo de registro de arquivamento, registro forçado e registro suplementar. 1. [Restaure o banco de dados intermediário Oracle a partir do banco de dados de origem Oracle usando a recuperação do Recovery Manager (RMAN) e o point-in-time FLASHBACK\$1SCN.](https://docs.oracle.com/database/121/SUTIL/GUID-D408B112-1A81-4F68-BEFF-7403A9588DDB.htm#SUTIL849) 1. Configure SharePlex para ler redo logs do banco de dados de origem Oracle usando `FLASHBACK_SCN` (usado no RMAN). 1. Inicie a SharePlex replicação para sincronizar dados do banco de dados de origem Oracle com o banco de dados intermediário Oracle. 1. Restaure o banco de dados de destino do Amazon RDS para Oracle usando EXPDP e IMPDP com `FLASHBACK_SCN`. 1. Configure o AWS DMS e suas tarefas de origem como o banco de dados intermediário Oracle e o Amazon RDS para Oracle como o banco de dados de destino usando `FLASHBACK_SCN` (usado no EXPDP). 1. Inicie tarefas do AWS DMS para sincronizar dados do banco de dados intermediário da Oracle com o banco de dados de destino da Oracle. ## Ferramentas + O [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) ajuda você a configurar, operar e escalar um banco de dados relacional na Nuvem AWS. + O [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) ajuda você a migrar armazenamentos de dados para a Nuvem AWS ou entre combinações de configurações na nuvem e on-premises. + SharePlexA [Quest](https://support.quest.com/shareplex/11.0/technical-documents) é uma ferramenta Oracle-to-Oracle de replicação de dados para mover dados com o mínimo de tempo de inatividade e sem perda de dados. + O [Recovery Manager (RMAN)](https://docs.oracle.com/cd/E11882_01/backup.112/e10642/rcmquick.htm) é um cliente de banco de dados do Oracle que executa tarefas de backup e recuperação em seus bancos de dados. Isso simplifica imensamente o backup, a restauração e a recuperação de arquivos de banco de dados. + O [Data Pump Export](https://docs.oracle.com/cd/E11882_01/server.112/e22490/dp_export.htm#SUTIL823) ajuda você a carregar dados e metadados em um conjunto de arquivos do sistema operacional chamado conjunto de arquivos de despejo. O conjunto de arquivos de despejo só pode ser importado pelo utilitário [Data Pump Import](https://docs.oracle.com/cd/E11882_01/server.112/e22490/dp_import.htm#SUTIL300) (Importação do Data Pump) ou pelo pacote [DBMS\$1DATAPUMP](https://docs.oracle.com/database/121/ARPLS/d_datpmp.htm#ARPLS356). ## Épicos ### Configurar SharePlex e instalar o banco de dados de teste da Oracle na Amazon EC2 | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma EC2 instância. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html) | Administração do Oracle | | Prepare o banco de dados de preparação. | Prepare o banco de dados intermediário Oracle para restauração como um upgrade no Oracle 12 CR2 usando o backup RMAN do ambiente de origem do banco de dados Oracle 8i ou 9i.Para obter mais informações, consulte o [Guia do usuário do Oracle 9i Recovery Manager](https://docs.oracle.com/cd/B10500_01/server.920/a96566/toc.htm) e o [Guia do usuário de backup e recuperação do banco de dados](https://docs.oracle.com/database/121/BRADV/rcmcomre.htm#BRADV8005) na documentação do Oracle. | Administração do Oracle | | Configurar SharePlex. | Configure a SharePlex origem como um banco de dados Oracle 8i ou 9i local e configure o destino como o banco de dados intermediário Oracle 12 CR2 hospedado na Amazon. EC2 | SharePlex, administração da Oracle | ### Configure o Amazon RDS para Oracle como seu ambiente de destino | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma instância de banco de dados Oracle. | Crie um banco de dados Amazon RDS for Oracle e, em seguida, conecte o Oracle CR2 12 ao banco de dados.Para obter mais informações, consulte [Criar uma instância de banco de dados Oracle e conectar-se a um banco de dados em uma instância de banco de dados Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.Oracle.html) na documentação do Amazon RDS. | DBA | | Restaure o Amazon RDS para Oracle a partir do banco de dados de teste. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html)Para obter mais informações, consulte [54 DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/21/arpls/DBMS_DATAPUMP.html#GUID-AEA7ED80-DB4A-4A70-B199-592287206348) na documentação da Oracle. | DBA | ### Configurar o AWS DMS | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie endpoints para os bancos de dados. | Crie um endpoint de origem para o banco de dados intermediário Oracle e um endpoint de destino para o banco de dados do Amazon RDS para Oracle.Para obter mais informações, consulte [Como criar endpoints de origem ou de destino usando o AWS DMS?](https://aws.amazon.com/premiumsupport/knowledge-center/create-source-target-endpoints-aws-dms/) no Centro de Conhecimentos da AWS. | DBA | | Criação de uma instância de replicação. | Use o AWS DMS para iniciar uma instância de replicação do banco de dados intermediário Oracle para o banco de dados do Amazon RDS para Oracle.Para obter mais informações, consulte [Como criar uma instância de replicação do AWS DMS?](https://aws.amazon.com/premiumsupport/knowledge-center/create-aws-dms-replication-instance/) no Centro de Conhecimentos da AWS. | DBA | | Crie e inicie tarefas de replicação. | Crie tarefas de replicação do AWS DMS para captura de dados de alterações (CDC) usando o EXPDP (já que a carga total de `FLASHBACK_SCN` já aconteceu por meio do EXPDP).Para obter mais informações, consulte [Criar uma tarefa](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) na documentação do AWS DMS. | DBA | ### Substituição para o Amazon RDS para Oracle | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Interrompa o workload do aplicativo. | Interrompa os servidores de aplicativos e seus aplicativos durante a janela de substituição planejada. | Desenvolvedor de aplicativos, DBA | | Valide a sincronização do banco de dados temporário local da Oracle com a instância. EC2 | Confirme se todas as mensagens foram publicadas para tarefas de replicação da instância de SharePlex replicação no banco de dados de teste Oracle na Amazon EC2 executando algumas mudanças de log no banco de dados de origem local.Para obter mais informações, consulte [6.4.2 Alternar um arquivo de log](https://docs.oracle.com/database/121/ADMQS/GUID-E30B4C65-2AC7-4A44-A58C-D3C121EB152F.htm#ADMQS12075) na documentação do Oracle. | DBA | | Valide a sincronização do banco de dados intermediário do Oracle com o banco de dados do Amazon RDS para Oracle. | Confirme se todas as suas tarefas do AWS DMS não têm atrasos nem erros e, em seguida, verifique o estado de validação das tarefas. | DBA | | Pare a replicação do SharePlex Amazon RDS. | Se as replicações do AWS DMS SharePlex e do AWS não estiverem mostrando nenhum erro, interrompa as duas replicações. | DBA | | Remapeie o aplicativo para o Amazon RDS. | Compartilhe os detalhes do endpoint do Amazon RDS para Oracle com o servidor de aplicativos e seus aplicativos e, em seguida, inicie o aplicativo para retomar as operações comerciais. | Desenvolvedor de aplicativos, DBA | ### Teste o ambiente de destino da AWS | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Teste o ambiente de banco de dados de teste da Oracle na AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html) | SharePlex, administração da Oracle | | Teste o ambiente do Amazon RDS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html)Para obter mais informações, consulte o [Amazon RDS para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) na documentação do Amazon RDS. | Administração do Oracle | ## Recursos relacionados + [Migre com confiança](https://aws.amazon.com/cloud-migration/) + [Amazon EC2](https://aws.amazon.com/ec2/) + [Amazon RDS para Oracle](https://aws.amazon.com/rds/oracle/) + [AWS Database Migration Service](https://aws.amazon.com/dms/) + [Como depurar suas migrações do AWS DMS: o que fazer quando as coisas dão errado (Parte 1)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-1/) + [Como depurar suas migrações do AWS DMS: o que fazer quando as coisas dão errado (Parte 2)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-2/) + [Como depurar suas migrações do AWS DMS: o que fazer quando as coisas dão errado? (Parte 3)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-3/) + [SharePlex para replicação de banco de dados](https://aws.amazon.com/marketplace/pp/B07943W4MJ) + [SharePlex: replicação de banco de dados para qualquer ambiente](https://www.youtube.com/watch?v=ygS_ouUaNus) # Migre um banco de dados MySQL on-premises para o Amazon EC2 *Lorenzo Mota, Amazon Web Services* ## Resumo Esse padrão fornece orientações para migrar um banco de dados MySQL on-premises para um banco de dados MySQL em uma instância do Amazon Elastic Compute Cloud (Amazon EC2). O padrão discute o uso de AWS Database Migration Service (AWS DMS) ou ferramentas nativas do MySQL, **como** mysqldump, para a migração. Ele se concentra na migração completa do banco de dados para uma instância de banco de dados do MySQL. O padrão é principalmente para DBAs arquitetos de soluções. Ele pode ser utilizado em projetos de pequeno ou grande porte, tanto na fase de testes quanto na fase final de migração. Recomendamos que você execute pelo menos um ciclo de testes antes de usar este padrão em um ambiente de produção. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Um banco de dados de origem do MySQL em um datacenter on-premises **Versões do produto** + MySQL, na versão 5.5 e em versões posteriores + [Um sistema operacional de destino suportado pelo Amazon EC2; consulte Amazon EC2 FAQs](https://aws.amazon.com/ec2/faqs/) ## Arquitetura **Pilha de tecnologia de origem** + Um banco de dados MySQL on-premises. **Pilha de tecnologias de destino** + Uma instância de banco de dados MySQL no Amazon EC2 **Métodos de migração de dados da AWS** + AWS DMS + [Ferramentas nativas do MySQL, como [mysqldump](https://dev.mysql.com/doc/refman/en/mysqldump.html), ou ferramentas de terceiros, como Percona XtraBackup](https://www.percona.com/mysql/software/percona-xtrabackup) **Arquitetura de destino** O diagrama apresentado a seguir ilustra a implementação do Amazon EC2 de destino após a substituição. ![\[Uma instância de banco de dados do MySQL no Amazon EC2 com replicação para uma instância de banco de dados do MySQL em espera.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/34cab6f9-9107-4c3b-98ec-a6d7fa9f298a.png) **Arquitetura de migração de dados AWS** *Usando o AWS DMS:* O diagrama a seguir ilustra o fluxo de trabalho de migração de dados com base no envio AWS DMS de alterações completas e incrementais ao banco de dados MySQL de destino até a transição. A conexão de rede local para AWS depende dos requisitos do cliente SQL e está fora do escopo desse padrão. ![\[Uso do AWS DMS para enviar dados para um banco de dados do MySQL de destino no Amazon EC2.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/c906c45d-fac5-4bb9-b8c8-55e2f9f05fd8.png) *Como usar outras ferramentas do MySQL:* O diagrama apresentado a seguir ilustra o fluxo de trabalho de migração de dados com base no uso de ferramentas do MySQL para gerar arquivos de despejo para exportação do banco de dados on-premises. Esses arquivos são movidos para o Amazon Simple Storage Service (Amazon S3) e, posteriormente, importados para o banco de dados do MySQL de destino antes da substituição. A conexão de rede local para AWS depende dos requisitos do cliente SQL e está fora do escopo desse padrão. ![\[Uso de ferramentas nativas do MySQL para enviar dados para um banco de dados do MySQL de destino no Amazon EC2.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/18e88877-7879-4a99-b985-25c56bf7c35f.png) Observações: + Dependendo das considerações sobre o tempo de inatividade e do tamanho do banco de dados para a transição final, você pode usar AWS DMS ou outra ferramenta de captura de dados de alteração (CDC) para minimizar o tempo de transição. Ao usar uma ferramenta do CDC AWS DMS, como a, você pode migrar para o banco de dados de destino em minutos. + Uma estratégia off-line com **mysqldump** pode funcionar se o tamanho do banco de dados e a latência da rede forem compatíveis com uma breve janela para a substituição de migração. (Recomendamos que você faça testes para obter um tempo aproximado.) + Normalmente, uma estratégia de CDC AWS DMS requer mais monitoramento e complexidade do que uma opção off-line. ## Ferramentas **AWS serviços** + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) suporta vários bancos de dados de origem e destino. Para obter informações sobre bancos de dados de origem e destino do MySQL suportados pelo AWS DMS, consulte [Usando um banco de dados compatível com MySQL como fonte para AWS DMS e [Usando um banco de dados compatível com MySQL](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.MySQL.html) como destino para](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.MySQL.html). AWS DMS Se seu banco de dados de origem não for compatível com AWS DMS, você deverá escolher outro método para migrar seus dados. **Outras ferramentas** + O [mysqldump](https://dev.mysql.com/doc/refman/8.0/en/mysqldump.html) é um utilitário em MySQL que cria um arquivo de despejo usando um banco de dados do MySQL para fins de backup ou de migração. + [O Percona XtraBackup é um](https://www.percona.com/mysql/software/percona-xtrabackup) utilitário de código aberto para realizar backups sem bloqueio em bancos de dados MySQL. ## Épicos ### Planejar a migração | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Valide as versões do banco de dados. | Valide as versões dos bancos de dados de origem e de destino. Para obter informações sobre as versões do MySQL suportadas pelo AWS DMS, consulte [Sources for AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.Sources.html) and [Targets for AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.Targets.html) na AWS DMS documentação. | DBA | | Identifique o sistema operacional de destino. | Determine a versão do sistema operacional de destino. Para obter uma lista dos sistemas operacionais de destino suportados pelo Amazon EC2, consulte Amazon [EC2](https://aws.amazon.com/ec2/faqs/). FAQs | DBA, administrador de sistemas | | Identificar os requisitos de hardware. | Determine os requisitos de hardware para a [instância do servidor de destino](https://aws.amazon.com/rds/instance-types/) com base na lista de compatibilidade do MySQL e nos requisitos de capacidade. | DBA, administrador de sistemas | | Identifique os requisitos de armazenamento. | Determine o tipo e a capacidade de armazenamento do banco de dados de destino. | DBA, administrador de sistemas | | Identificar os requisitos de rede. | Determine os requisitos de rede, como a latência e a largura de banda. | DBA, administrador de sistemas | | Escolha o tipo de instância de destino. | Escolha o [tipo de instância de destino](https://aws.amazon.com/rds/instance-types/) com base na capacidade, nos recursos de armazenamento e nos recursos de rede. | DBA, administrador de sistemas | | Identificar os requisitos de segurança. | Determine os requisitos de segurança de acesso à rede ou ao host para os bancos de dados de origem e de destino. | DBA, administrador de sistemas | | Identifique os usuários. | Determine a lista de usuários do sistema operacional para a instalação do software do MySQL. Para ter mais informações, consulte [ a documentação do MySQL](https://dev.mysql.com/doc/mysql-security-excerpt/en/access-control.html). | DBA, administrador de sistemas | | Determine uma estratégia de backup. | | DBA | | Determine os requisitos de disponibilidade. | | DBA | | Identifique a migração de aplicativos e a estratégia de transição. | | DBA, administrador de sistemas | ### Configurar a infraestrutura | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Criar uma nuvem privada virtual (VPC) e sub-redes. | Configure tabelas de rotas, gateway da internet, gateways NAT e sub-redes. Para obter mais informações, consulte as [opções de configuração da VPC](https://docs.aws.amazon.com/vpc/latest/userguide/create-vpc-options.html) na documentação da Amazon VPC. | Administrador de sistemas | | Crie grupos de segurança e listas de controle de acesso à rede (ACLs). | Configure portas (o padrão para MySQL é 3306) e intervalos CIDR ou específicos IPs , dependendo de seus requisitos. | Administrador de sistemas | | Configurar e iniciar uma instância do EC2. | Para obter instruções, consulte [Iniciar uma instância do EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/LaunchingAndUsingInstances.html) na documentação do Amazon EC2. | Administrador de sistemas | ### Instalar o software MySQL | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie usuários e grupos. | Crie os usuários e grupos do sistema operacional que precisam acessar o servidor e o banco de dados. Para obter mais informações, consulte [ Access Control and Account Management](https://dev.mysql.com/doc/refman/en/access-control.html) na documentação do MySQL. | DBA, administrador de sistemas | | Faça o download do MySQL. | Faça o download do software MySQL. Para obter instruções e arquivos binários, consulte a seção [Installing MySQL](https://dev.mysql.com/doc/refman/en/installing.html) na documentação do MySQL. | DBA, administrador de sistemas | | Instale o MySQL na instância do EC2 e configure o servidor. | Conecte-se à sua instância do EC2 e instale o software MySQL. Para obter mais informações, consulte [Conexão com a instância do EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect.html) na documentação do Amazon EC2. | DBA, administrador de sistemas | ### Migração de dados: opção 1 | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Migre os dados com ferramentas nativas do MySQL ou de terceiros. | Esta opção emprega ferramentas nativas do MySQL ou de terceiros para migrar objetos e dados do banco de dados. Para obter instruções, consulte a documentação do [mysqldump](https://dev.mysql.com/doc/refman/en/mysqldump.html) ou do [Percona XtraBackup (para migração física](https://docs.percona.com/percona-xtrabackup/2.4/index.html)). Para obter mais informações sobre o uso dessas ferramentas, consulte a postagem do AWS blog [Opções de migração do MySQL para o Amazon RDS for MySQL ou Amazon Aurora MySQL](https://aws.amazon.com/blogs/database/migration-options-for-mysql-to-amazon-rds-for-mysql-or-amazon-aurora-mysql/). | DBA | ### Migração de dados: opção 2 | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Migre dados com AWS DMS. | Para obter mais informações, consulte [Visão de alto nível AWS DMS da](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.HighLevelView.html) AWS DMS documentação. | DBA | ### Preparação para a substituição | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Colete a contagem de objetos. | Colete a contagem de objetos do banco de dados de origem e dos novos bancos de dados de destino. Corrija quaisquer discrepâncias no banco de dados de destino. | DBA | | Verifique dependências. | Confirme se as dependências (links) para e de outros bancos de dados ainda são válidas e funcionam corretamente. | DBA | | Realize o teste. | Se for um ciclo de testes, realize os testes de consulta, colete as métricas e corrija quaisquer problemas. | DBA | ### Substituir | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Transfira os clientes. | Mude os clientes do aplicativo para a nova infraestrutura. | DBA, proprietário do aplicativo, administrador de sistemas | | Forneça suporte. | Forneça suporte durante os testes funcionais da aplicação. | DBA | ### Fechar o projeto | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Desligar recursos. | Encerre a instância AWS DMS de replicação e outros AWS recursos temporários. | DBA, administrador de sistemas | | Revise e valide os documentos do projeto. | Revise e valide os documentos do projeto. | DBA, proprietário do aplicativo, administrador de sistemas | | Colete as métricas. | Colete as métricas, como o tempo de migração, a porcentagem de alterações manuais em comparação com as alterações auxiliadas por ferramentas e a economia de custos. | DBA, proprietário do aplicativo, administrador de sistemas | | Finalize o projeto. | Finalize o projeto de migração e forneça feedback. | DBA, proprietário do aplicativo, administrador de sistemas | | Descomissione o banco de dados de origem. | Descomissione o banco de dados do MySQL on-premises. | DBA, administrador de sistemas | ## Recursos relacionados **Referências** + [Documentação do Amazon EC2](https://docs.aws.amazon.com/ec2/) + [AWS DMS documentação](https://docs.aws.amazon.com/dms/) + [Definição de preços do Amazon EC2](https://aws.amazon.com/ec2/pricing/) + [AWS DMS Step-by-Step Demonstrações](https://docs.aws.amazon.com/dms/latest/sbs/DMS-SBS-Welcome.html) + [mysqldump](https://dev.mysql.com/doc/refman/8.0/en/mysqldump.html) + [Percona XtraBackup](https://www.percona.com/mysql/software/percona-xtrabackup) **Tutoriais e vídeos** + [Começando com AWS DMS](https://aws.amazon.com/dms/getting-started/) + [Introduction to Amazon EC2 – Elastic Cloud Server & Hosting with AWS](https://www.youtube.com/watch?v=TsRBftzZsQo) (vídeo) # Monitore o Amazon Aurora em busca de instâncias sem criptografia *Mansi Suratwala, Amazon Web Services* ## Resumo Esse padrão fornece um CloudFormation modelo da Amazon Web Services (AWS) que você pode implantar para configurar notificações automáticas quando uma instância do Amazon Aurora é criada sem a criptografia ativada. O Aurora é um mecanismo de banco de dados relacional gerenciado compatível com o MySQL e o PostgreSQL. Com algumas workloads, o Aurora pode oferecer até cinco vezes o throughput do MySQL e até três vezes o throughput do PostgreSQL, sem exigir alterações na maioria das aplicações existentes. O CloudFormation modelo cria um evento Amazon CloudWatch Events e uma função do AWS Lambda. O evento usa CloudTrail a AWS para monitorar qualquer criação de instância do Aurora ou uma restauração pontual de uma instância existente. O evento Cloudwatch Events inicia a função do Lambda, que verifica se a criptografia está ativada. Se a criptografia não estiver ativada, a função do Lambda enviará uma notificação do Amazon Simple Notification Service (Amazon SNS) informando você sobre a violação. ## Pré-requisitos e limitações **Pré-requisitos**** ** + Uma conta AWS ativa **Limitações** + Esse controle de serviço funciona somente com instâncias do Amazon Aurora. Ele não é compatível com outras instâncias do Amazon Relational Database Service (Amazon RDS). + O CloudFormation modelo deve ser implantado somente para `CreateDBInstance` **`RestoreDBClusterToPointInTim`****e.** **Versões do produto** + Versões do PostgreSQL que são compatíveis no Amazon Aurora + Versões do MySQL que são compatíveis com o Amazon Aurora ## Arquitetura **Pilha de tecnologias de destino** + Amazon Aurora + AWS CloudTrail + Amazon CloudWatch + AWS Lambda + Amazon Simple Storage Service (Amazon S3) + Amazon SNS **Arquitetura de destino** ![\[O Aurora é lançado sem invocação de criptografia CloudTrail, Eventos CloudWatch , Lambda e uma mensagem SNS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/de1528b8-a5a4-4c66-8ab3-7d9863572cbc/images/7dcab41a-d805-4bb0-99d1-1dcef37c4e55.png) **Automação e escala** Você pode usar o CloudFormation modelo várias vezes para diferentes regiões e contas. Você precisa executá-lo apenas uma vez em cada região ou conta. ## Ferramentas **Ferramentas** + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html): o Amazon Aurora é um mecanismo de banco de dados relacional gerenciado compatível com o MySQL e o PostgreSQL. + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html) — CloudTrail A AWS ajuda você a gerenciar a governança, a conformidade e a auditoria operacional e de risco da sua conta da AWS. As ações realizadas por um usuário, uma função ou um serviço da AWS são registradas como eventos em CloudTrail. + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html) — O Amazon CloudWatch Events fornece um near-real-time fluxo de eventos do sistema que descrevem as mudanças nos recursos da AWS. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html): o AWS Lambda é um serviço de computação que permite a execução do código sem provisionar ou gerenciar servidores O Lambda executa o código somente quando necessário e dimensiona automaticamente, desde algumas solicitações por dia até milhares por segundo. + [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/gsg/GetStartedWithS3.html): o Amazon Simple Storage Service (Amazon S3) é um serviço de armazenamento de objetos altamente escalável que você pode usar para uma ampla variedade de soluções de armazenamento, incluindo sites, aplicativos móveis, backups e data lakes. + [Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html): o Amazon Simple Notification Service (Amazon SNS) é um serviço gerenciado que fornece entrega de mensagens usando Lambda, HTTP, e-mail, notificações push móveis e mensagens de texto móveis (SMS). **Código ** Um arquivo .zip do projeto está disponível como anexo. ## Épicos ### Crie o bucket do S3 para o script do Lambda | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Defina o bucket do S3. | Abra o console do Amazon S3, escolha ou crie um bucket do S3. Esse bucket do S3 hospedará o arquivo.zip do código Lambda. Seu bucket do S3 precisa estar na mesma região da que o Aurora. O nome do bucket do S3 não pode conter barras iniciais. | Arquiteto de nuvem | ### Carregar o código do Lambda para o bucket do S3 | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Faça o upload do código do Lambda. | Faça upload do arquivo .zip do código Lambda fornecido na seção *Anexos* para o bucket do S3 que você definiu. | Arquiteto de nuvem | ### Implante o CloudFormation modelo | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Implante o CloudFormation modelo. | No CloudFormation console, implante o `RDS_Aurora_Encryption_At_Rest.yml` CloudFormation modelo fornecido como anexo a esse padrão. No próximo épico, forneça valores para os parâmetros do modelo. | Arquiteto de nuvem | ### Preencha os parâmetros no CloudFormation modelo | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Dê o nome do bucket do S3. | Insira o nome do bucket do S3 que você criou ou escolheu no primeiro épico. | Arquiteto de nuvem | | Forneça a chave do S3. | Forneça a localização do arquivo .zip do código Lambda em seu bucket do S3, sem barras iniciais (por exemplo, `
(sidadm $> python systemReplicationStatus.py
sudo yum install -y awslogs| AWS geral | | Edite os arquivos de configuração do agente. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | AWS geral | | Inicie o CloudWatch agente. | Para iniciar o agente, use o seguinte comando.
$ sudo service awslogsd startDepois de iniciar o agente, você pode visualizar o grupo de registros no CloudWatch console. O fluxo de logs terá o conteúdo do arquivo. | AWS geral | ### Etapa 6. Crie filtros métricos para o grupo de logs | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie filtros de métricas para as palavras-chave ABEND e STOPPED. | Quando você cria filtros métricos para o grupo de logs, sempre que os filtros são identificados no registro de erros, ele inicia um alarme e envia uma notificação por e-mail com base na configuração do Amazon SNS.Para criar um filtro de métricas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | CloudWatch | ### Etapa 7. Configuração do Amazon SNS | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Criar um tópico do SNS. | Nesta etapa, você configura o Amazon SNS para criar alarmes para os filtros métricos.Para criar um tópico do SNS:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | Amazon SNS | | Crie uma assinatura. | Crie uma assinatura para o tópico:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html)O Amazon SNS abre seu navegador da Web e exibe uma confirmação de assinatura com seu ID de assinatura. | Amazon SNS | ### Etapa 8. Crie um alarme para enviar notificações para os filtros métricos | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um alarme para o tópico do SNS. | Para criar um alarme com base em um filtro de métrica de grupo de logs:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html)Após essas etapas, sempre que esses padrões forem detectados no arquivo de log de GoldenGate erros (`ggserr.log`) que você está monitorando, você receberá uma notificação por e-mail. | CloudWatch | ## Solução de problemas | Problema | Solução | | --- | --- | | O fluxo de log do registro GoldenGate de erros não flui para dentro CloudWatch. | Verifique o `/etc/awslogs/awslogs.conf` arquivo para verificar o nome do arquivo, o nome do grupo de registros e o date/time formato. Você deve especificar o date/time para corresponder ao formato de data em`ggserror.log`. Caso contrário, o fluxo de log não fluirá para dentro CloudWatch. | ## Recursos relacionados + [ CloudWatch Documentação da Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) + [Coleta de métricas e registros com o CloudWatch agente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) + [Documentação do Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) # Redefinir a plataforma do Oracle Database Enterprise Edition para o Standard Edition 2 no Amazon RDS para Oracle *Lane (Lan-Ray) showunmi e Tarun Chawla, da Amazon Web Services* ## Resumo O Oracle Database Enterprise Edition (EE) é uma escolha popular em muitas empresas para executar aplicativos. Em alguns casos, no entanto, os aplicativos usam poucos ou nenhum atributo do Oracle Database EE, portanto, não há justificativa para incorrer em enormes custos de licenciamento. Você pode obter economia de custos fazendo o downgrade desses bancos de dados para o Oracle Database Standard Edition 2 (SE2) ao migrar para o Amazon RDS. Esse padrão descreve como fazer o downgrade do Oracle Database EE para o Oracle Database SE2 ao migrar do local para o [Amazon RDS](https://aws.amazon.com/rds/oracle/) for Oracle. As etapas apresentadas nesse padrão também se aplicam se seu banco de dados EE Oracle já estiver em execução no Amazon RDS ou em uma instância do [Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) EC2 (Amazon). Para obter mais informações, consulte o guia Recomendações da AWS sobre como [avaliar o downgrade de bancos de dados Oracle para a Standard](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/welcome.html) Edition 2 na AWS. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Oracle Database Enterprise Edition + Uma ferramenta cliente, como [Oracle SQL Developer](https://www.oracle.com/database/sqldeveloper/) ou SQL\$1Plus, para conectar e executar comandos SQL no banco de dados Oracle + Usuário do banco de dados para realizar a avaliação; por exemplo, um dos seguintes: + Usuário com [privilégios](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Source.Oracle.html#CHAP_Source.Oracle.Permissions) suficientes para executar a avaliação do [AWS Schema Conversion Tool (AWS SCT)](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html) + Usuário com privilégios suficientes para executar consultas SQL nas tabelas do dicionário do banco de dados Oracle + Usuário do banco de dados para realizar a migração do banco de dados; por exemplo, um dos seguintes: + Usuário com [privilégios](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html#CHAP_Source.Oracle.Self-Managed) suficientes para executar o [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) + Usuário com [privilégios suficientes para realizar a exportação e importação do Oracle Data Pump](https://docs.oracle.com/database/121/SUTIL/GUID-8B6975D3-3BEC-4584-B416-280125EEC57E.htm#SUTIL807) + Usuário com [privilégios suficientes para executar o Oracle GoldenGate](https://docs.oracle.com/goldengate/1212/gg-winux/GIORA/user_assignment.htm#GIORA546) **Limitações** + O Amazon RDS para Oracle tem um tamanho máximo para banco de dados. Para obter mais informações, consulte Armazenamento de instâncias de banco de dados do Amazon RDS. **Versões do produto** A lógica geral descrita nesse documento se aplica às versões do Oracle a partir da 9i. Para ver as versões compatíveis dos bancos de dados autogerenciados e do Amazon RDS para Oracle, consulte a [documentação do AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html). Para identificar o uso de atributo nos casos em que não há suporte ao AWS SCT , execute consultas SQL no banco de dados de origem. Para migrar de versões anteriores do Oracle em que o AWS DMS e o Oracle Data Pump não são compatíveis, use os utilitários de [exportação e importação da Oracle](https://docs.oracle.com/cd/B19306_01/server.102/b14215/exp_imp.htm). Para obter uma lista atual das versões e edições compatíveis, consulte [Oracle no Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) na documentação da AWS. Para obter detalhes sobre preços e classes de instâncias compatíveis, consulte [Amazon RDS para Oracle Edition Enterprise Edition](https://aws.amazon.com/rds/oracle/pricing/). ## Arquitetura **Pilha de tecnologia de origem** + Oracle Database Enterprise Edition em execução no local ou na Amazon EC2 **Pilha de tecnologias de destino usando ferramentas nativas da Oracle** + Amazon RDS for Oracle executando o Oracle Database SE2 ![\[Processo de três etapas para migrar do banco de dados Oracle local para o Amazon RDS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/a1b28050-9bab-4de6-b2a9-b97b3e5070bd/images/bf765c5b-4b12-4a8c-b27c-c5e0bd605dd1.png) 1. Exporte dados usando o Oracle Data Pump. 1. Copie arquivos de despejo para o Amazon RDS por meio de um link de banco de dados. 1. Importe arquivos de despejo para o Amazon RDS usando o Oracle Data Pump. **Pilha de tecnologias de destino usando o AWS DMS** + Amazon RDS for Oracle executando o Oracle Database SE2 + AWS DMS ![\[Processo de quatro etapas para migrar do banco de dados Oracle local para o Amazon RDS usando o AWS DMS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/a1b28050-9bab-4de6-b2a9-b97b3e5070bd/images/fef4eced-1acb-4303-baaa-5c1c29650935.png) 1. Exporte dados usando o Oracle Data Pump com FLASHBACK\$1SCN. 1. Copie arquivos de despejo para o Amazon RDS por meio de um link de banco de dados. 1. Importe arquivos de despejo para o Amazon RDS usando o Oracle Data Pump. 1. Use [captura de dados de alteração (CDC)](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Task.CDC.html) do AWS DMS. ## Ferramentas **Serviços da AWS** + O [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) ajuda você a migrar armazenamentos de dados para a Nuvem AWS ou entre combinações de configurações na nuvem e on-premises. + O [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) ajuda você a configurar, operar e escalar um banco de dados relacional na Nuvem AWS. Esse padrão usa o Amazon RDS para Oracle. + O [AWS SCT ](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html)** ** fornece uma interface de usuário baseada em projetos para avaliar automaticamente, converter e copiar o esquema do banco de dados do seu banco de dados Oracle de origem em um formato compatível com o Amazon RDS para Oracle. O AWS SCT permite que você analise as economias de custo que podem ser obtidas alterando o tipo de licença do Oracle de Enterprise para Standard Edition. A seção **License Evaluation and Cloud Support** do relatório AWS SCT fornece informações detalhadas sobre os atributos da Oracle em uso para que você possa tomar uma decisão informada ao migrar para o Amazon RDS para Oracle. **Outras ferramentas** + Os utilitários nativos de importação e exportação da Oracle suportam mover dados da Oracle para dentro e para fora dos bancos de dados Oracle. A Oracle oferece dois tipos de utilitários de importação e exportação de banco de dados: [Original Export and Import](https://docs.oracle.com/cd/B19306_01/server.102/b14215/exp_imp.htm) (para versões anteriores) e [Oracle Data Pump Export and Import](https://docs.oracle.com/cd/B19306_01/server.102/b14215/part_dp.htm#CEGJCCHC) (disponível no Oracle Database 10g versão 1 e superiores). + GoldenGateA [Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.OracleGoldenGate.html) oferece recursos de replicação em tempo real para que você possa sincronizar seu banco de dados de destino após um carregamento inicial. Essa opção pode ajudar a reduzir o tempo de inatividade da aplicação durante a colocação em funcionamento no ambiente de produção. ## Épicos ### Faça uma avaliação pré-migração | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Valide os requisitos de banco de dados para seus aplicativos. | Garanta que seus aplicativos sejam certificados para execução no Oracle Database SE2. Consulte diretamente o fornecedor do software, desenvolvedor ou documentação de inscrição. | Desenvolvedor de aplicativos, DBA, proprietário do aplicativo | | Investigue o uso dos atributos de EE diretamente no banco de dados. | Para determinar o uso do atributo EE, siga um destes procedimentos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.html) | Proprietário do aplicativo, DBA, desenvolvedor do aplicativo | | Identifique o uso dos atributos de EE para atividades operacionais. | Às vezes, os administradores de bancos de dados ou aplicativos confiam em atributos exclusivos do EE para atividades operacionais. Exemplos comuns incluem atividades de manutenção on-line (recompilação de índice, movimentação de tabelas) e uso de paralelismo feitos por trabalhos em lote.Essas dependências podem ser mitigadas modificando suas operações sempre que possível. Identifique o uso desses atributos e tome uma decisão com base no custo comparado aos benefícios.Use a tabela [Comparando o Oracle Database EE e os SE2 recursos](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/compare-features.html) como guia para identificar os recursos que estão disponíveis no Oracle Database SE2. | Desenvolvedor de aplicativos, DBA, proprietário do aplicativo | | Analise os padrões de workload do banco de dados EE Oracle. | O Oracle Database restringe SE2 automaticamente o uso a um máximo de 16 threads de CPU a qualquer momento.Se seu banco de dados Oracle EE estiver licenciado para usar o Oracle Diagnostic Pack, use a ferramenta Automatic Workload Repository (AWR) ou as visualizações DBA\$1HIST\$1\$1 para analisar os padrões de carga de trabalho do banco de dados e determinar se o limite máximo de 16 threads de CPU afetará negativamente os níveis de serviço quando você fizer o downgrade para. SE2Certifique-se de que sua avaliação abranja períodos de pico de atividade, como processamento de final de dia, mês ou ano. | Proprietário do aplicativo, DBA, desenvolvedor do aplicativo | ### Prepare a infraestrutura de destino na AWS | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Implante e configure a infraestrutura de rede. | Crie uma [nuvem privada virtual (VPC) e sub-redes](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html), [grupos de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) e [listas de controle de acesso à rede](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html). | Administrador da AWS, arquiteto de nuvem, administrador de rede, DevOps engenheiro | | Provisione o banco de dados Amazon RDS for SE2 Oracle. | Provisione o banco de dados de destino do [Amazon RDS SE2 for Oracle para](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.Oracle.html) atender aos requisitos de desempenho, disponibilidade e segurança de seus aplicativos. Recomendamos a configuração do Multi-AZ para workloads de produção. No entanto, para melhorar o desempenho da migração, você pode adiar a [ativação do Multi-AZ](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/create-multi-az-db-cluster.html) para depois da migração dos dados. | Administrador de nuvem, arquiteto de nuvem, DBA, DevOps engenheiro, administrador da AWS | | Personalize o ambiente do Amazon RDS. | Configure [parâmetros](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) e [opções](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithOptionGroups.html) personalizados e ative o [monitoramento](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/MonitoringOverview.html) adicional. Para obter mais informações, consulte [Práticas recomendadas de migração para o Amazon RDS para Oracle](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html). | Administrador da AWS, administrador de sistemas da AWS, administrador de nuvem, DBA, arquiteto de nuvem | ### Execute a migração, o dry run e o teste do aplicativo | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Migre os dados (dry run). | Migre dados do banco de dados Oracle EE de origem para a instância do banco de dados Amazon RDS for SE2 Oracle usando a abordagem mais adequada ao seu ambiente específico. Selecione uma estratégia de migração com base em fatores como tamanho, complexidade e a janela de tempo de inatividade disponível. Use um ou uma combinação do seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.html) | DBA | | Valide o banco de dados de destino. | Execute a validação pós-migração do armazenamento do banco de dados e dos objetos de código. Reveja os registros de migração e corrija os problemas identificados. Para obter mais informações, consulte o guia [Migrar bancos de dados Oracle para a Nuvem AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html#post-import). | DBA | | Teste os aplicativos. | Os administradores de aplicativos e bancos de dados devem realizar testes funcionais, de desempenho e operacionais, conforme apropriado. Para obter mais informações, consulte [Práticas recomendadas de migração para o Amazon RDS para Oracle](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html#test-migration).Por fim, obtenha a aprovação dos resultados dos testes das partes interessadas. | Desenvolvedor de aplicativos, proprietário do aplicativo, DBA, engenheiro de migração, líder de migração | ### Substituir | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Atualize os dados do Oracle Database EE. | Selecione uma abordagem de atualização de dados com base no requisito de disponibilidade do aplicativo. Para obter mais informações, consulte os métodos de migração em [Estratégias para migrar bancos de dados Oracle para a AWS](https://docs.aws.amazon.com/whitepapers/latest/strategies-migrating-oracle-db-to-aws/data-migration-methods.html).Por exemplo, você pode alcançar um tempo de inatividade quase zero usando ferramentas como Oracle ou GoldenGate AWS DMS com replicação contínua. Se a janela de tempo de inatividade permitir, você poderá realizar a substituição final de dados usando métodos off-line, como o Oracle Data Pump ou o Original Export-Import. | Proprietário do aplicativo, líder de substituição, DBA, engenheiro de migração, líder de migração | | Aponte os aplicativos para a instância de banco de dados de destino. | Atualize os parâmetros de conexão em aplicativos e outros clientes para apontar para o banco de dados Amazon RDS for SE2 Oracle. | Desenvolvedor de aplicativos, proprietário do aplicativo, engenheiro de migração, líder de migração, líder de substituição | | Realize as atividades pós-migração | Execute tarefas pós-migração de dados, como habilitar o Multi-AZ, validação de dados e outras verificações. | DBA, Engenheiro de migração | | Realize o monitoramento pós-substituição. | Use ferramentas como [Amazon CloudWatch e Amazon](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/monitoring-cloudwatch.html) [RDS Performance Insights](https://aws.amazon.com/rds/performance-insights/) para monitorar o banco de dados Amazon RDS for SE2 Oracle. | Desenvolvedor do aplicativo, proprietário do aplicativo, administrador da AWS, DBA, engenheiro de migração | ## Recursos relacionados **Recomendações da AWS** + [Migrar bancos de dados Oracle para a Nuvem AWS ](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/welcome.html) (guia) + [Avaliar o downgrade dos bancos de dados Oracle para o Standard Edition 2 na AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/welcome.html) (guia) + [Migrate an on-premises Oracle database to Amazon RDS para Oracle](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle.html?did=pg_card&trk=pg_card) (padrão) + [Migrar um banco de dados Oracle on-premises para o Amazon RDS para Oracle usando o Oracle Data Pump](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-using-oracle-data-pump.html?did=pg_card&trk=pg_card) (modelo) **Publicações no blog** + [Migração de bancos de dados Oracle com tempo de inatividade quase zero usando o AWS DMS](https://aws.amazon.com/blogs/database/migrating-oracle-databases-with-near-zero-downtime-using-aws-dms/) + [Analisar o gerenciamento de performance no Oracle SE usando o Amazon RDS para Oracle](https://aws.amazon.com/blogs/database/analyzing-performance-management-in-oracle-se-using-amazon-rds-for-oracle/) + [Gerenciar o plano de SQL no Oracle SE com o Amazon RDS para Oracle](https://aws.amazon.com/blogs/database/managing-your-sql-plan-in-oracle-se-with-amazon-rds-for-oracle/) + [Implementar o particionamento de tabelas no Oracle Standard Edition: Parte 1](https://aws.amazon.com/blogs/database/implementing-table-partitioning-in-oracle-standard-edition-part-1/) # Replique bancos de dados de mainframe para AWS usando o Precisely Connect *Lucio Pereira, Sayantan Giri e Balaji Mohan, Amazon Web Services* ## Resumo Esse padrão descreve as etapas para replicar dados de bancos de dados de mainframe para armazenamentos de dados da Amazon quase em tempo real usando o Precisely Connect. O padrão usa uma arquitetura baseada em eventos com o Amazon Managed Streaming for Apache Kafka (Amazon MSK) e conectores de banco de dados personalizados para melhorar a escalabilidade, a resiliência e o desempenho. O Precisely Connect é uma ferramenta de replicação que captura dados de sistemas de mainframe legados e os integra a ambientes de nuvem. Os dados são replicados dos mainframes para a AWS por meio da captura de dados de alteração (CDC) usando fluxos de mensagens quase em tempo real com pipelines de dados heterogêneos de baixa latência e alto throughput. Esse padrão também abrange uma estratégia de recuperação de desastres para pipelines de dados resilientes com replicação de dados em várias regiões e roteamento por failover. ## Pré-requisitos e limitações **Pré-requisitos ** + Um banco de dados de mainframe existente — por exemplo, IBM DB2, IBM Information Management System (IMS) ou Virtual Storage Access Method (VSAM) — que você deseja replicar para a nuvem da AWS + Uma [conta AWS](https://aws.amazon.com/account/) ativa + [AWS Direct Connect](https://aws.amazon.com/directconnect/) ou [AWS Virtual Private Network (AWS VPN](https://aws.amazon.com/vpn/)) do seu ambiente corporativo para a AWS + Uma [nuvem privada virtual](https://aws.amazon.com/vpc/) com uma sub-rede que pode ser acessada por sua plataforma legada ## Arquitetura **Pilha de tecnologia de origem** Um ambiente de mainframe que inclua pelo menos um dos seguintes bancos de dados: + Banco de dados IBM IMS + Banco de DB2 dados IBM + Arquivos VSAM **Pilha de tecnologias de destino** + Amazon MSK + Amazon Elastic Kubernetes Service (Amazon EKS) e Amazon EKS Anywhere + Docker + Um banco de dados relacional ou NoSQL da AWS, como o seguinte: + Amazon DynamoDB + Amazon Relational Database Service (Amazon RDS) para Oracle, Amazon RDS para PostgreSQL ou Amazon Aurora + Amazon ElastiCache para Redis + Amazon Keyspaces (para Apache Cassandra) **Arquitetura de destino** *Replicação de dados de mainframe para bancos de dados da AWS* O diagrama a seguir ilustra a replicação de dados de mainframe em um banco de dados da AWS, como DynamoDB, Amazon RDS, Amazon ou Amazon Keyspaces. ElastiCache A replicação ocorre quase em tempo real usando o Precisely Capture and Publisher em seu ambiente de mainframe on-premises, o Precisely Dispatcher no Amazon EKS Anywhere em seu ambiente distribuído on-premises e os conectores de banco de dados e do Precisely Apply Engine na nuvem AWS. ![\[Replicação de dados de mainframe para bancos de dados da AWS\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/777dd7da-48ed-4510-b8fa-9041be042671.png) O diagrama mostra o seguinte fluxo de trabalho: 1. O Precisely Capture obtém dados do mainframe dos logs do CDC e mantém os dados em armazenamento temporário interno. 1. O Precisely Publisher escuta as alterações no armazenamento interno de dados e envia os registros do CDC para o Precisely Dispatcher por meio de uma conexão. TCP/IP 1. O Precision Dispatcher recebe os registros do CDC do Publisher e os envia para o Amazon MSK. O Dispatcher cria chaves Kafka com base na configuração do usuário e em várias tarefas de trabalho para enviar dados paralelamente. O Dispatcher envia uma confirmação de volta ao Publisher quando os registros são armazenados no Amazon MSK. 1. O Amazon MSK mantém os registros do CDC no ambiente de nuvem. O tamanho da partição dos tópicos depende dos requisitos do sistema de processamento de transações (TPS) para throughput. A chave Kafka é obrigatória para futuras transformações e pedidos de transações. 1. O Precisely Apply Engine recebe os registros do CDC do Amazon MSK e transforma os dados (por exemplo, filtrando ou mapeando) com base nos requisitos do banco de dados de destino. Você pode adicionar lógica personalizada aos scripts Precisamente SQD. (SQD é a linguagem proprietária do Precisely.) O Precised Apply Engine transforma cada registro do CDC no formato Apache Avro ou JSON e o distribui para diferentes tópicos com base em seus requisitos. 1. Os tópicos de destino do Kafka mantêm registros do CDC em vários tópicos com base no banco de dados de destino, e o Kafka facilita a ordenação de transações com base na chave definida do Kafka. As chaves de partição se alinham com as partições correspondentes para suportar um processo sequencial. 1. Os conectores de banco de dados (aplicativos Java personalizados) recebem os registros CDC do Amazon MSK e os armazenam no banco de dados de destino. 1. Você pode selecionar um banco de dados de destino dependendo das suas necessidades. Esse padrão é compatível com bancos de dados relacionais e NoSQL . *Recuperação de desastres* A continuidade dos negócios é fundamental para o sucesso da organização. A nuvem AWS fornece recursos para alta disponibilidade (HA) e recuperação de desastres (DR), além de oferecer suporte aos planos de failover e fallback da sua organização. Esse padrão segue uma estratégia de active/passive DR e fornece orientação de alto nível para implementar uma estratégia de DR que atenda aos seus requisitos de RTO e RPO. O diagrama a seguir mostra o fluxo de trabalho do DR. ![\[Fluxo de trabalho de recuperação de desastres para replicar dados de mainframe na AWS\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/9cccba7a-7a25-411e-829f-7cd5a7a20ab4.png) O diagrama mostra o seguinte: 1. Um failover semiautomático é necessário se ocorrer alguma falha na Região da AWS 1. No caso de falha na Região 1, o sistema deve iniciar as alterações de roteamento para conectar o Precisely Dispatcher à Região 2. 1. O Amazon MSK replica dados por meio de espelhamento entre regiões. Por esse motivo, durante o failover, o cluster Amazon MSK na Região 2 precisa ser promovido como líder principal. 1. O Precisely Apply Engine e os conectores de banco de dados são aplicativos sem estado que podem funcionar em qualquer região. 1. A sincronização do banco de dados depende do banco de dados de destino. Por exemplo, o DynamoDB pode usar tabelas globais ElastiCache e pode usar datastores globais. *Processamento de baixa latência e alto throughput por meio de conectores de banco de dados* Os conectores de banco de dados são componentes essenciais nesse padrão. Os conectores seguem uma abordagem baseada em receptores para coletar dados do Amazon MSK e enviar transações para o banco de dados por meio de processamento de alto throughput e baixa latência para aplicativos de missão crítica (níveis 0 e 1). O diagrama a seguir ilustra esse processo. ![\[Como usar conectores de banco de dados para replicar dados de mainframe na AWS\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/79479634-becb-4212-bbfc-1a3b17ae1bed.png) Esse padrão é compatível com o desenvolvimento de um aplicativo personalizado com consumo de thread único por meio de um mecanismo de processamento multithread. 1. O encadeamento principal do conector consome registros CDC do Amazon MSK e os envia ao pool de encadeamentos para processamento. 1. Os encadeamentos do pool de encadeamentos processam os registros do CDC e os enviam para o banco de dados de destino. 1. Se todos os encadeamentos estiverem ocupados, os registros do CDC serão mantidos em espera pela fila de encadeamentos. 1. O encadeamento principal espera que todos os registros sejam apagados da fila de encadeamentos e confirma os deslocamentos no Amazon MSK. 1. Os tópicos secundários lidam com falhas. Se ocorrerem falhas durante o processamento, as mensagens com falha serão enviadas para o tópico DLQ (fila de mensagens não entregues). 1. Os threads secundários iniciam atualizações condicionais (consulte [Expressões de condição](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html) na documentação do DynamoDB), com base no timestamp do mainframe, para evitar duplicações ou atualizações no banco de dados. out-of-order Para obter informações sobre como implementar um aplicativo de consumidor do Kafka com recursos de múltiplos encadeamentos, consulte a postagem do blog [Consumo de mensagens com múltiplos encadeamentos](https://www.confluent.io/blog/kafka-consumer-multi-threaded-messaging/) com o consumidor Apache Kafka no site do Confluent. ## Ferramentas **Serviços da AWS** + O [Amazon Managed Streaming for Apache Kafka (Amazon MSK)](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html) é um serviço totalmente gerenciado que ajuda você a criar e executar aplicações que usam o Apache Kafka para processar dados em streaming. + O [Amazon Elastic Kubernetes Service (Amazon EKS)](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) ajuda você a executar o Kubernetes na AWS sem ter que instalar e manter seus próprios nós ou ambiente de gerenciamento do Kubernetes. + O [Amazon EKS Anywhere](https://anywhere.eks.amazonaws.com/docs/) ajuda você a implantar, usar e gerenciar clusters Kubernetes que são executados em seus próprios datacenters. + O [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) é um serviço de banco de dados NoSQL totalmente gerenciado que fornece performance rápida, previsível e escalável. + O [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) ajuda você a configurar, operar e escalar um banco de dados relacional na Nuvem AWS. + ElastiCacheA [Amazon](https://docs.aws.amazon.com/elasticache/) ajuda você a configurar, gerenciar e escalar ambientes distribuídos de cache na memória na nuvem da AWS. + O [Amazon Keyspaces (para Apache Cassandra)](https://docs.aws.amazon.com/keyspaces/latest/devguide/what-is-keyspaces.html) é um serviço de banco de dados gerenciado que ajuda você a migrar, executar e escalar suas workloads do Cassandra na nuvem AWS. **Outras ferramentas** + O [Precisely Connect](https://www.precisely.com/product/precisely-connect/connect) integra dados de sistemas de mainframe antigos, como conjuntos de dados VSAM ou bancos de dados de mainframe IBM, às plataformas de nuvem e dados da próxima geração. ## Práticas recomendadas + Encontrar a melhor combinação de partições Kafka e conectores com múltiplos encadeamentos para equilibrar desempenho e custo ideais. Várias instâncias do Precisely Capture and Dispatcher podem aumentar o custo devido ao maior consumo de MIPS (milhões de instruções por segundo). + Evitar adicionar lógica de manipulação e transformação de dados aos conectores do banco de dados. Para isso, use o Precisely Apply Engine, que fornece tempos de processamento em microssegundos. + Crie chamadas periódicas de solicitação ou verificação de integridade para o banco de dados (*pulsações*) nos conectores do banco de dados para aquecer a conexão com frequência e reduzir a latência. + Implemente a lógica de validação do pool de encadeamentos para entender as tarefas pendentes na fila de encadeamentos e aguarde a conclusão de todos os threads antes da próxima pesquisa do Kafka. Isso ajuda a evitar a perda de dados se um nó, contêiner ou processo falhar. + Exponha métricas de latência por meio de endpoints de integridade para aprimorar os recursos de observabilidade por meio de painéis e mecanismos de rastreamento. ## Épicos ### Preparar o ambiente de origem (on-premises) | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Configurar o processo de mainframe (utilitário em lote ou on-line) para iniciar o processo CDC a partir de bancos de dados de mainframe. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Engenheiro de mainframe | | Ativar os fluxos de log do banco de dados de mainframe. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Especialista em banco de dados de mainframe | | Usar o componente Capturar para capturar registros do CDC. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Engenheiro de mainframe, Precisely Connect SME | | Configurar o componente Publisher para receber o componente Capture. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Engenheiro de mainframe, Precisely Connect SME | | Provisionar o Amazon EKS Anywhere no ambiente distribuído on-premises. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps engenheiro | | Implantar e configurar o componente Dispatcher no ambiente distribuído para publicar os tópicos na Nuvem AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps engenheiro, Precisely Connect SME | ### Preparar o ambiente de destino (AWS) | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Provisionar um cluster Amazon EKS na região da AWS designada. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps engenheiro, administrador de rede | | Provisionar um cluster MSK e configurar os tópicos aplicáveis do Kafka. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps engenheiro, administrador de rede | | Configurar o componente Apply Engine para ser receptor dos tópicos replicados do Kafka. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Conectar PME com precisão | | Provisionar instâncias de banco de dados na nuvem AWS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Engenheiro de dados, DevOps engenheiro | | Configurar e implantar conectores de banco de dados para receber os tópicos publicados pelo Apply Engine. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Desenvolvedor de aplicativos, arquiteto de nuvem, engenheiro de dados | ### Configurar a continuidade dos negócios e a recuperação de desastres | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Definir metas de recuperação de desastres para seus aplicativos de negócios. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Arquiteto de nuvem, engenheiro de dados, proprietário do aplicativo | | Criar estratégias de recuperação de desastres com base em RTO/RPO definido. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Arquiteto de nuvem, engenheiro de dados | | Provisionar clusters e configurações de recuperação de desastres. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps engenheiro, administrador de rede, arquiteto de nuvem | | Testar o pipeline do CDC para recuperação de desastres. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Proprietário do aplicativo, engenheiro de dados, arquiteto de nuvem | ## Recursos relacionados **Recursos da AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) + [Expressões condicionais com o Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html) + [Amazon EKS](https://docs.aws.amazon.com/eks/index.html) + [Amazon EKS Anywhere](https://anywhere.eks.amazonaws.com/docs/) + [Amazon ElasticCache](https://docs.aws.amazon.com/elasticache/index.html) + [Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/?icmpid=docs_homepage_databases) + [ Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html) + [Amazon RDS e Amazon Aurora](https://docs.aws.amazon.com/rds/index.html) + [Amazon VPC](https://docs.aws.amazon.com/vpc/index.html) **Conecte recursos com precisão** + [Visão geral do Precisely Connect](https://www.precisely.com/product/precisely-connect/connect) + [Captura de dados de alteração com o Precie Connect](https://help.precisely.com/r/Connect-CDC-SQData/4.1/en-US/Connect-CDC-SQData-Installation/Connect-CDC-SQData-Architecture) **Recursos confluentes** + [Consumo de mensagens com múltiplos encadeamentos com o Apache Kafka Consumer](https://www.confluent.io/blog/kafka-consumer-multi-threaded-messaging/) # Agendar trabalhos para o Amazon RDS para PostgreSQL e Aurora PostgreSQL usando o Lambda e o Secrets Manager *Yaser Raja, Amazon Web Services* ## Resumo Para bancos de dados locais e bancos de dados hospedados em instâncias do Amazon Elastic Compute Cloud EC2 (Amazon), os administradores de banco de dados geralmente usam o utilitário **cron** para agendar trabalhos. Por exemplo, um trabalho para extração de dados ou um trabalho para limpeza de dados pode ser facilmente agendado usando o **cron**. Para esses trabalhos, as credenciais do banco de dados geralmente passam por codificação rígida ou são armazenadas em um arquivo de propriedades. No entanto, ao migrar para o Amazon Relational Database Service (Amazon RDS) ou edição compatível do Amazon Aurora PostgreSQL, você perde a capacidade de fazer login na instância host para agendar tarefas **cron**. Esse padrão descreve como usar AWS Lambda e programar trabalhos para AWS Secrets Manager o Amazon RDS for PostgreSQL e bancos de dados compatíveis com o Aurora PostgreSQL após a migração. ## Pré-requisitos e limitações **Pré-requisitos ** + Um ativo Conta da AWS + Um banco de dados compatível com Amazon RDS para PostgreSQL ou Aurora compatível com PostgreSQL **Limitações** + Um trabalho deve ser concluído em 15 minutos, que é o limite do tempo limite da função do Lambda. Para outros limites, consulte a [AWS Lambda documentação](https://docs.aws.amazon.com/lambda/latest/dg/limits.html). + O código do trabalho deve ser escrito em uma [linguagem compatível com o Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). ## Arquitetura **Pilha de tecnologia de origem** Essa pilha apresenta trabalhos escritos em linguagens como Bash, Python e Java. As credenciais do banco de dados são armazenadas no arquivo de propriedades e o trabalho é agendado usando o Linux **cron**. **Pilha de tecnologias de destino** Essa pilha tem uma função do Lambda que usa as credenciais armazenadas no Secrets Manager para se conectar ao banco de dados e realizar a atividade. A função Lambda é iniciada no intervalo programado usando o Amazon CloudWatch Events. **Arquitetura de destino** ![\[CloudWatch evento que inicia uma função Lambda que agenda trabalhos para a instância de banco de dados do RDS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/8e0d1c90-0599-4909-a800-26a89b87f686/images/61f9ca34-9157-4565-96ba-5234d389ac2a.png) ## Ferramentas + [A Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html) fornece um fluxo quase em tempo real de eventos do sistema que descrevem mudanças nos AWS recursos. Usando regras simples que você pode configurar rapidamente, você pode combinar eventos e roteá-los para uma ou mais funções ou fluxos de destino. CloudWatch Os eventos ficam cientes das mudanças operacionais à medida que elas ocorrem. Ele responde a essas alterações operacionais e executa a ação corretiva conforme necessário, enviando mensagens para responder ao ambiente, ativando funções, fazendo alterações e capturando informações de estado. **Você também pode usar CloudWatch Eventos para programar ações automatizadas que se iniciam automaticamente em determinados momentos usando expressões **cron** ou rate.** + O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que permite executar código sem o provisionamento ou gerenciamento de servidores. O Lambda executa o código somente quando necessário e dimensiona automaticamente, desde algumas solicitações por dia até milhares por segundo. Você paga somente pelo tempo de computação utilizado; não haverá cobrança quando seu código não estiver em execução. Com o Lambda, é possível executar código para praticamente qualquer tipo de aplicação ou serviço de backend sem precisar de administração. O Lambda executa seu código em uma infraestrutura de computação de alta disponibilidade e gerencia todos os recursos computacionais, incluindo a manutenção de servidores e de sistemas operacionais, o provisionamento de capacidade e o ajuste de escala automático, o monitoramento do código e o registro em log. Tudo o que você precisa fazer é fornecer seu código em uma das [linguagens suportadas pelo Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)ajuda você a proteger segredos para acessar seus aplicativos, serviços e recursos de TI. Você pode alternar, gerenciar e recuperar facilmente credenciais de banco de dados, chaves de API e outros segredos durante seu ciclo de vida. Usuários e aplicativos recuperam segredos chamando o Secrets Manager APIs, o que elimina a necessidade de codificar informações confidenciais em texto simples. O Secrets Manager oferece alternância secreta com integração embutida para o Amazon RDS, o Amazon Redshift e o Amazon DocumentDB. O serviço é extensível a outros tipos de segredos, incluindo chaves e OAuth tokens de API. O Secrets Manager permite que você controle o acesso a segredos usando permissões refinadas e audite centralmente a rotação de segredos em busca de recursos nos serviços de terceiros e no Nuvem AWS local. ## Épicos ### Credenciais de banco de dados no Secrets Manager | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um usuário de banco de dados para a função do Lambda. | É uma boa prática usar usuários de banco de dados separados para diferentes partes do seu aplicativo. Se já existir um usuário de banco de dados separado para seus trabalhos cron, use-o. Caso contrário, crie um novo usuário de banco de dados. Para obter mais informações, consulte [Gerenciando usuários e funções do PostgreSQL](https://aws.amazon.com/blogs/database/managing-postgresql-users-and-roles/)AWS (postagem no blog). | DBA | | Armazene as credenciais de banco de dados como um segredo no Secrets Manager | Siga as instruções em [Criação de um segredo de banco de dados do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_database_secret.html) (documentação do Secrets Manager). | DBA, DevOps | ### Crie o código da função do Lambda. | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Escolha uma linguagem de programação compatível com o Lambda. | Para obter uma lista das linguagens compatíveis, consulte os [Runtimes do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html) (documentação do Lambda). | Desenvolvedor | | Escreva a lógica para buscar as credenciais do banco de dados no Secrets Manager. | Para ver um exemplo de código, consulte [Como fornecer com segurança as credenciais do banco de dados às funções do Lambda usando AWS Secrets Manager](https://aws.amazon.com/blogs/security/how-to-securely-provide-database-credentials-to-lambda-functions-by-using-aws-secrets-manager/) (postagem do blog).AWS | Desenvolvedor | | Grave a lógica para realizar a atividade agendada do banco de dados. | Migre seu código existente para o trabalho de agendamento que você está usando no local para a função Lambda. Para obter mais informações, consulte [Implantar funções do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-deploy-functions.html) (documentação do Lambda). | Desenvolvedor | ### Implante o código e crie a função do Lambda. | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie o pacote de implantação da função do Lambda. | Esse pacote contém o código e suas dependências. Para obter mais informações, consulte [Pacotes de implantação](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) (documentação do Lambda). | Desenvolvedor | | Criar a função do Lambda. | No console Lambda, escolha **Criar função**, insira um nome de função, escolha o ambiente de tempo de execução e, em seguida, escolha **Criar** função. | DevOps | | Faça upload do pacote de implantação. | Escolha a função do Lambda que você criou para abrir sua configuração. Você pode gravar seu código diretamente na seção de código ou fazer o upload do seu pacote de implantação. Para carregar seu pacote, acesse a seção **Código do perfil**, escolha o **Tipo de entrada de código** para carregar um arquivo .zip e selecione o pacote. | DevOps | | Configure a função do Lambda de acordo com seus requisitos. | Por exemplo, você pode definir o parâmetro de **Tempo limite** para a duração que você espera que sua função do Lambda dure. Para obter mais informações, consulte [Configurar as opções da função do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-common.html) (documentação do Lambda). | DevOps | | Defina permissões para o perfil da função do Lambda para acessar o Secrets Manager. | Para obter instruções, consulte [Usar segredos em AWS Lambda funções](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets_lambda.html) (documentação do Secrets Manager). | DevOps | | Testar a função do Lambda. | Inicie a função Lambda manualmente para garantir que ela funcione conforme o esperado. | DevOps | ### Agende a função Lambda usando Eventos CloudWatch | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma regra para executar a função do Lambda em uma programação. | Agende a função Lambda usando CloudWatch Eventos. Para obter instruções, consulte [Programar funções do Lambda usando CloudWatch eventos](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/RunLambdaSchedule.html) (tutorial de CloudWatch eventos). | DevOps | ## Recursos relacionados + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) + [Conceitos básicos do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) + [Criando uma regra de CloudWatch eventos que é acionada em um evento](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-Rule.html) + [AWS Lambda Limites](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) + [Consulte seu AWS banco de dados a partir do seu aplicativo sem servidor](https://aws.amazon.com/blogs/database/query-your-aws-database-from-your-serverless-application/) (postagem no blog) # Envie notificações para uma instância de banco de dados Amazon RDS para SQL Server usando um servidor SMTP on-premises e o Database Mail *Nishad Mankar, Amazon Web Services* ## Resumo O [Database Mail](https://learn.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail?view=sql-server-ver16) (documentação da Microsoft) envia mensagens de e-mail, como notificações ou alertas, de um banco de dados do Microsoft SQL Server usando um servidor SMTP (Simple Mail Transfer Protocol). A documentação do Amazon Relational Database Service (Amazon RDS) para Microsoft SQL Server fornece instruções para usar o Amazon Simple Email Service (Amazon SES) como servidor SMTP para o Database Mail. Para ter mais informações, consulte [Usar o Database Mail no Amazon RDS para SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html). Como configuração alternativa, esse padrão explica como configurar o Database Mail para enviar e-mails de uma instância de banco de dados (DB) do Amazon RDS para SQL Server usando um servidor SMTP on-premises como servidor de e-mail. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma conta AWS ativa + Uma instância de banco de dados do Amazon RDS executando uma edição Standard ou Enterprise do SQL Server + O endereço IP ou nome do host do servidor SMTP on-premises. + Uma [regra de grupo de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html#working-with-security-group-rules) de entrada que permite conexões com a instância de banco de dados Amazon RDS para SQL Server a partir do endereço IP do servidor SMTP + Uma conexão, como uma conexão do [AWS Direct Connect](https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html), entre sua rede on-premises e a nuvem privada virtual (VPC) que contém a instância de banco de dados Amazon RDS **Limitações** + Não há suporte para edições Express do SQL Server. + Para obter mais informações sobre limitações, consulte [Limitações](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html#SQLServer.Concepts.General.FeatureSupport.Limits) no *uso do Database Mail no Amazon RDS para SQL Server* na documentação do Amazon RDS. **Versões do produto** + Edições Standard e Enterprise das [versões do SQL Server suportadas no RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html#SQLServer.Concepts.General.VersionSupport) ## Arquitetura **Pilha de tecnologias de destino** + Instância de banco de dados do Amazon RDS para SQL Server + Regra de redirecionamento do Amazon Route 53 + Correspondência de banco de dados + Servidor SMTP no on-premises + Microsoft SQL Server Management Studio (SSMS) **Arquitetura de destino** A imagem a seguir mostra a arquitetura de destino para esse padrão. Quando ocorre um evento ou ação que inicia uma notificação ou alerta sobre a instância do banco de dados, o Amazon RDS para SQL Server usa o Database Mail para enviar uma notificação por e-mail. O Database Mail usa o servidor SMTP on-premises para enviar o e-mail. ![\[Amazon RDS para SQL Server usando um servidor SMTP on-premises para enviar notificações por e-mail aos usuários.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/e5599724-43cf-4fe1-8c5a-8fca1a424993/images/47efb12f-3505-4a60-ac43-194a176e71c8.png) ## Ferramentas **Serviços da AWS** + O [Amazon Relational Database Service (Amazon RDS) para Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html) ajuda você a configurar, operar e escalar um banco de dados relacional do SQL Server na Nuvem AWS. + O [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) é um serviço web de DNS altamente disponível e escalável. **Outras ferramentas** + O [Database Mail](https://learn.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail) é uma ferramenta que envia mensagens de email, como notificações e alertas, do Mecanismo de Banco de Dados do SQL Server para os usuários. + [O Microsoft SQL Server Management Studio (SSMS)](https://docs.microsoft.com/en-us/sql/ssms/sql-server-management-studio-ssms) é uma ferramenta para gerenciar o SQL Server, incluindo acesso, configuração e administração de componentes do SQL Server. Nesse padrão, você usa o SSMS para executar os comandos SQL para configurar o Database Mail em uma instância de banco de dados Amazon RDS para SQL Server. ## Épicos ### Habilite a conectividade de rede com o servidor SMTP on-premises | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Remover Multi-AZ da instância de banco de dados do RDS. | Se você estiver usando uma instância de banco de dados do Multi-Zone, converta a instância Multi-AZ em uma instância Single-AZ. Ao terminar de configurar o Database Mail, você converterá a instância de banco de dados de volta para uma implantação Multi-AZ. A configuração do Database Mail funciona, então, nos nós primário e secundário. Para obter instruções, consulte [Remover multi-AZ de uma instância de banco de dados do Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerMultiAZ.html#USER_SQLServerMultiAZ.Removing). | DBA | | Crie uma lista de permissões para o endpoint ou endereço IP do Amazon RDS no servidor SMTP on-premises. | O servidor SMTP está fora da rede da AWS. No servidor SMTP local, crie uma lista de permissões que permita que o servidor se comunique com o endpoint de saída ou o endereço IP da instância do Amazon RDS ou da instância do Amazon Elastic Compute Cloud (Amazon EC2) hospedada no Amazon RDS. Esse procedimento varia de organização para organização. Para obter mais informações sobre o endpoint da instância de banco de dados, consulte [Como encontrar o endpoint da instância de banco de dados e o número da porta](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html#sqlserver-endpoint). | DBA | | Remova as restrições da porta 25. | Por padrão, a AWS restringe a porta 25 nas EC2 instâncias. Para remover a restrição da porta 25, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html) | AWS geral | | Adicione uma regra do Route 53 para resolver consultas de DNS para o servidor SMTP. | Use o Route 53 para resolver consultas ao DNS entre seus recursos da AWS e o servidor SMTP on-premises. Você deve criar uma regra que encaminhe as consultas de DNS para o domínio do servidor SMTP, como `example.com`. Para obter instruções, consulte [Criação de regras de encaminhamento](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-rules-managing.html#resolver-rules-managing-creating-rules) na documentação do Route 53. | Administrador de rede | ### Configurar o Database Mail na instância de banco de dados do Amazon RDS para SQL Server | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Habilite o Database Mail. | Crie um grupo de parâmetros para o Database Mail, defina o parâmetro `database mail xps` como `1` e associe o grupo de parâmetros do Database Mail à instância de banco de dados RDS de destino. Para obter instruções, consulte [Habilitando o Database Mail](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html#SQLServer.DBMail.Enable) na documentação do Amazon RDS. Não vá para a seção *Configurando o Database Mail* nestas instruções. A configuração do servidor SMTP on-premises é diferente da do Amazon SES. | DBA | | Conecte-se à instância de banco de dados. | Em um Bastion Host, use o Microsoft SQL Server Management Studio (SSMS - Microsoft SQL Server Management Studio) para conectar-se à instância de banco de dados do Amazon RDS para SQL Server. Para obter instruções, consulte [Conectar-se a uma instância de banco de dados executando o mecanismo de banco de dados Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html). Se você encontrar algum erro, consulte as referências de solução de problemas de conexão na seção [Recursos relacionados](#send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail-resources). | DBA | | Crie o perfil. | Em SSMS, insira a seguinte instrução SQL para criar o perfil Database Mail. Substitua os valores a seguir:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)Para obter mais informações sobre esse procedimento armazenado e seus argumentos, consulte [sysmail\$1add\$1profile\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profile-sp-transact-sql) na documentação da Microsoft.
EXECUTE msdb.dbo.sysmail_add_profile_sp| DBA | | Adicione diretores ao perfil. | Insira a seguinte instrução SQL para adicionar entidades públicas ou privadas ao perfil do Database Mail. Um *principal* é uma entidade que pode solicitar recursos do SQL Server. Substitua os valores a seguir:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)Para obter mais informações sobre esse procedimento armazenado e seus argumentos, consulte [sysmail\$1add\$1principalprofile\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-principalprofile-sp-transact-sql) na documentação da Microsoft.
@profile_name = 'SQL Alerts profile',
@description = 'Profile used for sending outgoing notifications using OM SMTP Server.';
EXECUTE msdb.dbo.sysmail_add_principalprofile_sp| DBA | | Crie a conta. | Digite a seguinte instrução SQL para criar a conta Database Mail. Substitua os valores a seguir:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)Para obter mais informações sobre esse procedimento armazenado e seus argumentos, consulte [sysmail\$1add\$1account\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-account-sp-transact-sql) na documentação da Microsoft.
@profile_name = 'SQL Alerts profile',
@principal_name = 'public',
@is_default = 1 ;
EXECUTE msdb.dbo.sysmail_add_account_sp| DBA | | Adicione a conta ao perfil. | Digite a seguinte instrução SQL para adicionar a conta Database Mail ao perfil Database Mail. Substitua os valores a seguir:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)Para obter mais informações sobre esse procedimento armazenado e seus argumentos, consulte [sysmail\$1add\$1profileaccount\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profileaccount-sp-transact-sql) na documentação da Microsoft.
@account_name = 'SQL Alerts account',
@description = 'Database Mail account for sending outgoing notifications.',
@email_address = 'xyz@example.com',
@display_name = 'xyz@example.com',
@mailserver_name = 'test_smtp.example.com',
@port = 25,
@enable_ssl = 1,
@username = 'SMTP-username',
@password = 'SMTP-password';
EXECUTE msdb.dbo.sysmail_add_profileaccount_sp| DBA | | (Opcional) Adicione Multi-AZ à instância de banco de dados do RDS. | Se você quiser adicionar Multi-AZ com Espelhamento de Banco de Dados (DBM) ou Grupos de Disponibilidade Always On (AGs), consulte as instruções em [Adicionar Multi-AZ a uma instância de banco de dados Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerMultiAZ.html#USER_SQLServerMultiAZ.Adding). | DBA | ## Recursos relacionados + [Uso do Database Mail no Amazon RDS para SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html) (documentação do Amazon RDS) + [Trabalhando com anexos de arquivo](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html#SQLServer.DBMail.MAZ) (documentação do Amazon RDS) + [Solução de problemas de conexões com a instância de banco de dados do SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html#USER_ConnectToMicrosoftSQLServerInstance.Troubleshooting) (documentação do Amazon RDS) + [Não é possível conectar-se à instância de banco de dados do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Troubleshooting.html#CHAP_Troubleshooting.Connecting) (documentação do Amazon RDS) # Configure a recuperação de desastres para SAP no IBM Db2 na AWS *Ambarish Satarkar e Debasis Sahoo, Amazon Web Services* ## Resumo Esse padrão descreve as etapas para configurar um sistema de recuperação de desastres (DR) para workloads do SAP com o IBM Db2 como plataforma de banco de dados, executado na nuvem da Amazon Web Services (AWS). O objetivo é fornecer uma solução de baixo custo para fornecer continuidade de negócios no caso de uma interrupção. O padrão usa a [abordagem de piloto leve](https://aws.amazon.com/blogs/architecture/disaster-recovery-dr-architecture-on-aws-part-iii-pilot-light-and-warm-standby/). Ao implementar o DR de piloto leve na AWS, você pode reduzir o tempo de inatividade e manter a continuidade dos negócios. A abordagem de piloto leve se concentra na configuração de um ambiente mínimo de DR na AWS, incluindo um sistema SAP e um banco de dados DB2 em espera, sincronizados com o ambiente de produção. Essa solução é escalável. Você pode estendê-lo para um ambiente de recuperação de desastres em grande escala, conforme necessário. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma instância SAP em execução em uma instância do Amazon Elastic Compute Cloud (Amazon EC2) + Um banco de dados IBM Db2 + Um sistema operacional compatível com a Product Availability Matrix (PAM – Matriz de Disponibilidade de Produtos) da SAP + Nomes de host de banco de dados físicos diferentes para hosts de banco de dados de produção e de espera + Um bucket do Amazon Simple Storage Service (Amazon S3) em cada região da AWS com [a replicação entre regiões (CRR) habilitada](https://docs.aws.amazon.com/AmazonS3/latest/userguide/replication.html) **Versões do produto** + IBM Db2 Database versão 11.5.7 ou superior ## Arquitetura **Pilha de tecnologias de destino** + Amazon EC2 + Amazon Simple Storage Service (Amazon S3) + Amazon Virtual Private Cloud (Emparelhamento de VPC) + Amazon Route 53 + Recuperação de desastres de alta disponibilidade do IBM Db2 (HADR) **Arquitetura de destino** Essa arquitetura implementa uma solução de DR para workloads do SAP com o Db2 como plataforma de banco de dados. O banco de dados de produção é implantado na Região da AWS 1 e um banco de dados em espera é implantado em uma segunda região. O banco de dados em espera é chamado de sistema DR. O Db2 Database suporta vários bancos de dados em espera (até três). Ele usa o Db2 HADR para configurar o banco de dados de DR e automatizar o envio de registros em log entre os bancos de dados de produção e de espera. No caso de um desastre que torne a Região 1 indisponível, o banco de dados em espera na Região DR assume a função de banco de dados de produção. Os servidores de aplicativos SAP podem ser criados com antecedência ou usando o [AWS Elastic Disaster Recovery](https://aws.amazon.com/disaster-recovery/) ou uma imagem de máquina da Amazon (AMI) para atender aos requisitos do objetivo de tempo de recuperação (RTO). Esse padrão usa uma AMI. O Db2 HADR implementa uma configuração de produção em espera, na qual a produção atua como o servidor primário e todos os usuários estão conectados a ele. Todas as transações são gravadas em arquivos de log, que são transferidos para o servidor em espera usando TCP/IP. O servidor em espera atualiza seu banco de dados local transferindo os registros de log transferidos, o que ajuda a garantir que ele seja mantido em sincronia com o servidor de produção. O emparelhamento de VPC é usado para que as instâncias na região de produção e na região de DR possam se comunicar entre si. O Amazon Route 53 encaminha os usuários finais para aplicativos da Internet. ![\[Db2 na AWS com replicação entre regiões\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/06edfa4c-0827-4d05-95cf-2d2651e74323/images/e77c1e4e-36f3-4af4-89d0-8eec72348f0a.png) 1. [Crie uma AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html#creating-an-ami) do servidor de aplicativos na Região 1 e [copie a AMI](https://repost.aws/knowledge-center/copy-ami-region) para a Região 2. Use a AMI para iniciar servidores na Região 2 no caso de um desastre. 1. Configure a replicação do Db2 HADR entre o banco de dados de produção (na Região 1) e o banco de dados em espera (na Região 2). 1. Altere o tipo de EC2 instância para corresponder à instância de produção no caso de um desastre. 1. Na Região 1, `LOGARCHMETH1` está definido como `db2remote: S3 path`. 1. Na Região 2, `LOGARCHMETH1` está definido como `db2remote: S3 path`. 1. A replicação entre regiões é realizada entre os buckets do S3. ## Ferramentas **Serviços da AWS** + [A Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/ec2/) fornece capacidade de computação escalável na Nuvem AWS. Você poderá iniciar quantos servidores virtuais precisar e escalá-los na vertical rapidamente. + O [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) é um serviço web de DNS altamente disponível e escalável. + O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objetos baseado na nuvem que ajuda você a armazenar, proteger e recuperar qualquer quantidade de dados. + A [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) ajuda a iniciar recursos da AWS em uma rede virtual definida por você. Essa rede virtual é semelhante a uma rede tradicional que você operaria no próprio datacenter, com os benefícios de usar a infraestrutura escalável da AWS. Esse padrão usa o [emparelhamento de VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-peering.html). ## Práticas recomendadas + A rede desempenha um papel fundamental na decisão do modo de replicação do HADR. Para DR em todas as regiões da AWS, recomendamos que você use o modo Db2 HADR ASYNC ou SUPERASYNC. + Para obter mais informações sobre os modos de replicação do Db2 HADR, consulte a [documentação da IBM](https://ibm.github.io/db2-hadr-wiki/hadrSyncMode.html#Description_of_the_Modes). + Você pode usar o Console de Gerenciamento da AWS ou a AWS Command Line Interface (AWS CLI) [para criar uma nova AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html#creating-an-ami) do seu sistema SAP existente. Em seguida, você pode usar a AMI para recuperar seu sistema SAP existente ou criar um clone. + [O AWS Systems Manager Automation](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-automation.html) pode ajudar nas tarefas comuns de manutenção e implantação de EC2 instâncias e outros recursos da AWS. + A AWS fornece vários serviços nativos para monitorar e gerenciar sua infraestrutura e aplicativos na AWS. Serviços como Amazon CloudWatch e AWS CloudTrail podem ser usados para monitorar sua infraestrutura subjacente e operações de API, respectivamente. Para obter mais detalhes, consulte [SAP na AWS – IBM Db2 HADR com Pacemaker](https://docs.aws.amazon.com/sap/latest/sap-AnyDB/sap-ibm-pacemaker.html). ## Épicos ### Prepare o ambiente | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Verifique o sistema e os logs. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador da AWS, administrador do SAP Basis | ### Configurar os servidores e a replicação | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie o SAP e os servidores de banco de dados. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html)O estado pendente de rollforward é definido por padrão depois que o backup completo é restaurado. O estado pendente de rollforward indica que o banco de dados está sendo restaurado e que algumas alterações talvez precisem ser aplicadas. Para obter mais informações, consulte a [documentação da IBM](https://www.ibm.com/docs/en/db2/11.5?topic=commands-rollforward-database). | Administrador do SAP Basis | | Verifique a configuração. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador da AWS, administrador do SAP Basis | | Configure a replicação do banco de dados de produção para o banco de dados de recuperação de desastres (usando o modo ASSÍNCRONO). | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador do SAP Basis | ### Teste tarefas de failover de DR | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Planeje o tempo de inatividade da empresa de produção para o teste de DR. | Certifique-se de planejar o tempo de inatividade comercial necessário no ambiente de produção para testar o cenário de failover de DR. | Administrador do SAP Basis | | Crie um usuário de teste. | Crie um usuário de teste (ou qualquer alteração de teste) que possa ser validado no host de DR para confirmar a replicação do log após o failover de DR. | Administrador do SAP Basis | | No console, interrompa as EC2 instâncias de produção. | O desligamento incorreto é iniciado nesta etapa para imitar um cenário de desastre. | Administrador de sistemas AWS | | Amplie a EC2 instância de DR para atender aos requisitos. | No EC2 console, altere o tipo de instância na região DR.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador do SAP Basis | | Iniciar a aquisição. | No sistema de DR (`host2`), inicie o processo de aquisição e crie o banco de dados de DR como principal.
@profile_name = 'SQL Alerts profile',
@account_name = 'SQL Alerts account',
@sequence_number = 1;
db2 takeover hadr on databaseOpcionalmente, você pode definir os seguintes parâmetros para ajustar automaticamente a alocação de memória do banco de dados com base no tipo de instância. O valor de `INSTANCE_MEMORY` pode ser decidido com base na parte dedicada da memória a ser alocada ao banco de dados Db2.by force
db2 update db cfg forVerifique a alteração usando os comandos a seguir.using INSTANCE_MEMORY IMMEDIATE;
db2 get db cfg for| grep -i DATABASE_MEMORY AUTOMATIC IMMEDIATE;
db2 update db cfg forusing self_tuning_mem ON IMMEDIATE;
db2 get db cfg for| Administrador do SAP Basis | | Inicie o servidor de aplicativos para SAP na região DR. | Usando a AMI que você criou do sistema de produção, [inicie um novo servidor de aplicativos adicional](https://aws.amazon.com/premiumsupport/knowledge-center/launch-instance-custom-ami/) na região de DR. | Administrador do SAP Basis | | Execute a validação antes de iniciar o aplicativo SAP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador da AWS, administrador do SAP Basis | | Inicie o aplicativo SAP no sistema DR. | Inicie o aplicativo SAP no sistema de DR usando o usuário `| grep -i MEMORY
db2 get db cfg for| grep -i self_tuning_mem
sapconrol -nr XX -function StartService| Administrador do SAP Basis | | Execute a validação do SAP. | Isso é realizado como um teste de DR para fornecer evidências ou verificar o sucesso da replicação de dados na região de DR. | Engenheiro de testes | ### Execute tarefas de failback de DR | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Inicie a produção de servidores SAP e de banco de dados. | No console, inicie as EC2 instâncias que hospedam o SAP e o banco de dados no sistema de produção. | Administrador do SAP Basis | | Inicie o banco de dados de produção e configure o HADR. | Faça login no sistema de produção (`host1`) e verifique se o banco de dados está no modo de recuperação usando o comando a seguir.
sapconrol -nr XX -function StartSystem
sapconrol -nr YY -function StartService
sapconrol -nr YY -function StartSystem
db2startVerifique se o status do HADR é `connected`. O status da replicação deve ser `peer`.
db2 start HADR on db P3V as standby
db2 connect to
db2pd -dSe o banco de dados não for inconsistente e não estiver nos status `connected` e `peer`, talvez seja necessário fazer backup e restauração para sincronizar o banco de dados (de `host1`) com o banco de dados atualmente ativo (`host2` na região de DR). Nesse caso, restaure o backup do banco de dados na região de DR `host2` para o banco de dados na região de produção `host1`. | Administrador do SAP Basis | | Retorne o banco de dados para a região de produção. | Em um business-as-usual cenário normal, essa etapa é executada em um tempo de inatividade programado. Os aplicativos em execução no sistema de DR são interrompidos e o banco de dados retorna à região de produção (Região 1) para retomar as operações da região de produção.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador do SAP Basis | | Execute a validação antes de iniciar o aplicativo SAP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador da AWS, administrador do SAP Basis | | Inicie o aplicativo SAP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador do SAP Basis | ## Solução de problemas | Problema | Solução | | --- | --- | | Principais arquivos de log e comandos para solucionar problemas relacionados ao HADR | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | | Nota do SAP para solucionar problemas de HADR no Db2 UDB | Consulte a [Nota SAP 1154013 - DB6: Problemas de banco de dados no ambiente HADR](https://service.sap.com/sap/support/notes/1154013). (Você precisa das credenciais do portal SAP para acessar esta nota.) | ## Recursos relacionados + [Abordagens de recuperação de desastres para bancos de dados Db2 na publicação do (blog da](https://aws.amazon.com/blogs/architecture/disaster-recovery-approaches-for-db2-databases-on-aws/) AWS) + [SAP na AWS – IBM Db2 HADR com Pacemaker](https://docs.aws.amazon.com/sap/latest/sap-AnyDB/sap-ibm-pacemaker.html) + [Procedimento passo a passo para configurar a replicação de HADR entre bancos de dados DB2 ](https://www.ibm.com/support/pages/step-step-procedure-set-hadr-replication-between-db2-databases) + [Wiki do Db2 HARD](https://ibm.github.io/db2-hadr-wiki/index.html) ## Mais informações Usando esse padrão, você pode configurar um sistema de recuperação de desastres para um sistema SAP executado no banco de dados Db2. Em uma situação de desastre, a empresa deve poder continuar dentro dos requisitos definidos de objetivo de tempo de recuperação (RTO) e ao objetivo de ponto de recuperação (RPO): + O **RTO** é o atraso máximo aceitável entre a interrupção e a restauração do serviço. Ele determina o que é considerado uma janela de tempo aceitável quando o serviço não está disponível. + O **RPO** é o período máximo de tempo aceitável desde o último ponto de recuperação de dados. Isso determina o que é considerado uma perda aceitável de dados entre o último ponto de recuperação e a interrupção do serviço. Para informações FAQs relacionadas ao HADR, consulte a [nota SAP \$11612105 - DB6: FAQ on Db2 High Availability Disaster Recovery (HADR](https://launchpad.support.sap.com/#/notes/1612105)). (Você precisa das credenciais do portal SAP para acessar esta nota.) # Configure um CI/CD pipeline para migração de banco de dados usando o Terraform *Dr. Rahul Sharad Gaikwad, Ashish Bhatt, Aniket Dekate, Ruchika Modi, Tamilselvan P, Nadeem Rahaman, Aarti Rajput e Naveen Suthar, Amazon Web Services* ## Resumo Este padrão aborda o estabelecimento de um pipeline de integração e implantação contínuas (CI/CD) para gerenciar migrações de banco de dados de forma confiável e automatizada. O padrão abrange o processo de provisionamento da infraestrutura necessária, a migração de dados e a personalização de alterações no esquema usando o Terraform, uma ferramenta de infraestrutura como código (IaC). Especificamente, o padrão configura um CI/CD pipeline para migrar um banco de dados local do Microsoft SQL Server para o Amazon Relational Database Service (Amazon RDS) em. AWS Além disso, é possível usar este padrão para migrar um banco de dados do SQL Server que esteja em uma máquina virtual (VM) ou em outro ambiente de nuvem para o Amazon RDS. Este padrão trata dos seguintes desafios relacionados ao gerenciamento e à implantação de bancos de dados: + A realização de implantações manuais de banco de dados é um processo demorado, sujeito a erros e não garante consistência entre diferentes ambientes. + A coordenação do provisionamento da infraestrutura, das migrações de dados e das alterações de esquema pode ser complexa e difícil de gerenciar. + A garantia da integridade dos dados e a minimização do tempo de inatividade durante atualizações de banco de dados são essenciais para sistemas de produção. Este padrão oferece os seguintes benefícios: + Simplifica o processo de atualização e implantação de alterações no banco de dados implementando um CI/CD pipeline para migrações de banco de dados. Isso reduz o risco de erros, garante consistência entre os ambientes e minimiza o tempo de inatividade. + Contribui para melhorar a confiabilidade, a eficiência e a colaboração. Possibilita maior rapidez no lançamento de produtos e redução do tempo de inatividade durante as atualizações de banco de dados. + Ajuda você a adotar DevOps práticas modernas de gerenciamento de banco de dados, o que leva a uma maior agilidade, confiabilidade e eficiência em seus processos de entrega de software. ## Pré-requisitos e limitações **Pré-requisitos ** + Um ativo Conta da AWS + Terraform 0.12 ou em versões posteriores instalado na sua máquina local (para obter instruções, consulte a [documentação do Terraform](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli)) + Terraform AWS Provider versão 3.0.0 ou posterior de HashiCorp (consulte o [GitHub repositório deste](https://github.com/hashicorp/terraform-provider-aws) provedor) + Política de privilégios mínimos AWS Identity and Access Management (IAM) (consulte a postagem do blog [Técnicas para escrever políticas de IAM com privilégios mínimos](https://aws.amazon.com/blogs/security/techniques-for-writing-least-privilege-iam-policies/)) ## Arquitetura Este padrão implementa a arquitetura apresentada a seguir, que fornece toda a infraestrutura necessária ao processo de migração de banco de dados. ![\[Arquitetura de pipeline CI/CD para migrar um banco de dados do SQL Server on-premises para o Amazon RDS na AWS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/87845d9f-8e6e-4c51-b9ee-9e7833671d05/images/a1e95458-419a-4de9-85ef-b17d8340700a.png) Nesta arquitetura: + O banco de dados de origem é um SQL Server que está em um ambiente on-premises, em uma máquina virtual (VM) ou hospedado por outro provedor de nuvem. O diagrama assume que o banco de dados de origem encontra-se em um data center on-premises. + O data center local e AWS estão conectados por meio de uma VPN ou AWS Direct Connect conexão. Isso fornece comunicações seguras entre o banco de dados de origem e a AWS infraestrutura. + O banco de dados de destino é um banco de dados do Amazon RDS hospedado dentro da nuvem privada virtual (VPC) com a ajuda de um AWS pipeline de provisionamento de banco de dados. + AWS Database Migration Service (AWS DMS) replica seu banco de dados local para o. AWS O serviço é usado para configurar a replicação do banco de dados de origem para o banco de dados de destino. O diagrama a seguir mostra a infraestrutura configurada com diferentes níveis do processo de migração do banco de dados, que envolve provisionamento, AWS DMS configuração e validação. ![\[Detalhes do pipeline CI/CD do processo de migração de um ambiente on-premises para a AWS.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/87845d9f-8e6e-4c51-b9ee-9e7833671d05/images/3aca17e5-6fd7-4317-b578-ab5e485c6efb.png) Neste processo: + O pipeline de validação realiza todas as verificações. O pipeline integrado avança para a próxima etapa quando todas as validações necessárias forem concluídas. + O pipeline de provisionamento de banco de dados consiste em vários AWS CodeBuild estágios que executam ações do Terraform no código do Terraform fornecido para o banco de dados. Após a conclusão dessas etapas, ele provisiona os recursos na Conta da AWS de destino. + O AWS DMS pipeline consiste em vários CodeBuild estágios que realizam testes e, em seguida, provisionam a AWS DMS infraestrutura para realizar a migração usando o IaC. ## Ferramentas **Serviços da AWS e ferramentas** + [AWS CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html)é um serviço de integração contínua totalmente gerenciado que compila o código-fonte, executa testes e produz pacotes ready-to-deploy de software. + O [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html) é um serviço de entrega contínua totalmente gerenciado que ajuda a automatizar os pipelines de lançamento para atualizações rápidas e confiáveis de aplicações e infraestrutura. + O [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) ajuda você a configurar, operar e escalar um banco de dados relacional na Nuvem AWS. + O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objetos que oferece escalabilidade, disponibilidade de dados, segurança e desempenho. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) ajuda você a migrar armazenamentos de dados para Nuvem AWS ou entre combinações de configurações na nuvem e no local. **Outros serviços** + [O Terraform](https://www.terraform.io/) é uma ferramenta de IaC HashiCorp que ajuda você a criar e gerenciar recursos na nuvem e no local. **Repositório de código** O código desse padrão está disponível no GitHub [Database Migration DevOps Framework usando o repositório de amostras do Terraform](https://github.com/aws-samples/aws-terraform-db-migration-framework-samples). ## Práticas recomendadas + Implemente testes automatizados para a migração de banco de dados a fim de verificar a correção das alterações de esquema e a integridade dos dados. Isso inclui testes de unidade, testes de integração e end-to-end testes. + Implemente uma estratégia robusta de backup e restauração para os bancos de dados, especialmente antes da migração. Isso garante a integridade dos dados e oferece uma opção de fallback em caso de falhas. + Implemente uma estratégia robusta de reversão para desfazer alterações no banco de dados em caso de falhas ou problemas durante a migração. Isso pode envolver a reversão a um estado anterior do banco de dados ou a desfazer scripts de migração individuais. + Configure mecanismos de monitoramento e de registro em log para acompanhar o progresso e o status das migrações de banco de dados. Dessa forma, é possível localizar e solucionar problemas rapidamente. ## Épicos ### Configure sua estação de trabalho local. | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Configure e instale o Git em sua estação de trabalho local. | Instale e configure o Git em sua estação de trabalho local seguindo as instruções apresentadas na [documentação do Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git). | DevOps engenheiro | | Crie uma pasta de projeto e adicione os arquivos do GitHub repositório. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps engenheiro | ### Provisionamento da arquitetura de destino | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Atualize os parâmetros necessários. | O `ssm-parameters.sh` arquivo armazena todos os AWS Systems Manager parâmetros necessários. É possível configurá-los com valores personalizados para o seu projeto.Na `setup/db-ssm-params` pasta da sua estação de trabalho local, abra o `ssm-parameters.sh` arquivo e defina esses parâmetros antes de executar o CI/CD pipeline. | DevOps engenheiro | | Inicialize a configuração do Terraform. | Na pasta `db-cicd-integration`, execute o seguinte comando para inicializar seu diretório de trabalho que contém os arquivos de configuração do Terraform:-hadr
terraform init| DevOps engenheiro | | Visualize o plano do Terraform. | Para criar um plano do Terraform, digite o seguinte comando:
terraform plan -var-file="terraform.sample"O Terraform avalia os arquivos de configuração para determinar o estado de destino dos recursos declarados. Em seguida, ele compara o estado de destino com o estado atual e cria um plano. | DevOps engenheiro | | Verificar o plano. | Analise o plano e confirme se ele configura a arquitetura necessária na sua Conta da AWS de destino. | DevOps engenheiro | | Implante a solução. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps engenheiro | ### Verificar a implantação | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Valide a implantação. | Verifique o status do pipeline `db-cicd-integration` para confirmar que a migração do banco de dados foi concluída.1. Faça login no e Console de gerenciamento da AWS, em seguida, abra o [AWS CodePipeline console](https://console.aws.amazon.com/codesuite/codepipeline/home).2. No painel de navegação, selecione **Pipelines**.3. Selecione o pipeline `db-cicd-integration`.4. Verifique se a execução do pipeline foi concluída com êxito. | DevOps engenheiro | ### Limpar a infraestrutura após o uso | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Limpe a infraestrutura. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps engenheiro | ## Recursos relacionados **AWS documentação** + [Começando com um produto Terraform](https://docs.aws.amazon.com/servicecatalog/latest/adminguide/getstarted-Terraform.html) **Documentação do Terraform** + [Instalação do Terraform](https://learn.hashicorp.com/tutorials/terraform/install-cli) + [Configuração de backend do Terraform](https://developer.hashicorp.com/terraform/language/backend) + [Documentação do Terraform AWS Provider](https://registry.terraform.io/providers/hashicorp/aws/latest/docs) # Configure um cluster de failover do Microsoft SQL Server na Amazon EC2 usando o FSx Windows File Server *Sweta Krishna e Ramesh Babu Donti, Amazon Web Services* ## Resumo A edição Microsoft SQL Server Standard com uma instância de cluster de failover (FCI) pode fornecer uma alternativa mais econômica ao SQL Server Enterprise. A configuração do SQL FCI requer armazenamento compartilhado de arquivos entre os nós, e o [Amazon FSx para Windows File Server](https://aws.amazon.com/fsx/windows/) fornece armazenamento totalmente gerenciado que se replica automaticamente de forma síncrona entre as zonas de disponibilidade. A Amazon FSx reduz os custos de armazenamento usando a desduplicação de dados integrada para compartilhamentos de arquivos de uso geral, o que elimina a necessidade de manter soluções de terceiros. A Amazon FSx também oferece suporte ao seguinte: + Pague somente pelo que você usa, sem custos mínimos ou compromissos antecipados. + Configure o FCI manualmente com FSx como seu armazenamento compartilhado. + Use FSx como testemunha de compartilhamento de arquivos para seu cluster SQL. + O Amazon FSx para Windows File Server oferece suporte ao Server Message Block (SMB) 3.0 para compartilhamentos de arquivos continuamente disponíveis, tornando-o adequado para implantações de FCI do SQL Server. ## Pré-requisitos e limitações **Pré-requisitos ** + Ativo [Conta da AWS](https://aws.amazon.com/account/). + Permissões para criar e gerenciar recursos da Amazon Virtual Private Cloud (Amazon VPC), instância do Amazon Elastic Compute Cloud (Amazon EC2), grupos de segurança e funções AWS Identity and Access Management (IAM). + AWS Managed Microsoft AD ou seu próprio Active Directory local. + Um usuário do domínio do Active Directory com a [permissão necessária](https://learn.microsoft.com/en-us/windows-server/failover-clustering/configure-failover-cluster-accounts) para configurar um cluster de failover. + Regras de grupo de segurança para [portas SQL Server FCI e Microsoft Active Directory](https://docs.aws.amazon.com/whitepapers/latest/access-workspaces-with-access-cards/ip-address-and-port-requirements.html) para conectividade híbrida segura. + Uma [conta de serviço](https://learn.microsoft.com/en-us/sql/database-engine/configure-windows/configure-windows-service-accounts-and-permissions?view=sql-server-ver16#sql-server-failover-cluster-instance) no Active Directory para SQL Server configurada com as permissões apropriadas nos nós do SQL. + Amazon FSx para Windows File Server em um cluster de failover. + Binários de instalação do SQL Server. **Limitações** + Alguns Serviços da AWS não estão disponíveis em todos Regiões da AWS. Para conferir a disponibilidade de uma região, consulte [Serviços da AWS by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para endpoints específicos, consulte a página [Cotas e endpoints de serviços](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e clique no link correspondente ao serviço desejado. **Versões do produto** + Amazon EC2 para Windows Server 2012 R2 ou posterior + Amazon FSx para Windows File Server com todas as versões atuais do Windows Server + Amazon FSx for NetApp ONTAP como alternativa para armazenamento compartilhado + SQL Server 2012/2016/2019/2022 ## Arquitetura **Pilha de tecnologia** + Amazon EC2 + Servidor FSx de arquivos Amazon para Windows + Amazon VPC + AWS Directory Service + AWS Systems Manager + IAM **Arquitetura de destino** O diagrama a seguir mostra a arquitetura de alto nível do Microsoft SQL Server FCI na Amazon usando o EC2 Amazon FSx para Windows File Server. ![\[Diagrama de arquitetura para Microsoft Server FCI na Amazon EC2 usando Amazon FSx para Windows File Server.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/208bf64a-8fef-4019-944a-723372450885/images/ba0c9169-9536-41c3-ae8e-7264dcc3e1ad.png) **infraestrutura de rede** + A Amazon VPC fornece um contêiner de rede que abrange três zonas de disponibilidade. + As sub-redes privadas fornecem sub-redes isoladas em cada zona de disponibilidade para a implantação de recursos. **Camada de computação** + A Amazon EC2 contém um cluster SQL Server node 1, implantado na Zona de Disponibilidade 1 como parte do Windows Server Failover Cluster (WSFC). + A Amazon EC2 contém um cluster SQL Server node 2, implantado na Zona de Disponibilidade 2 como parte do WSFC. + O cluster WSFC conecta os dois nós do SQL Server para capacidade de failover. **Camada de armazenamento para Amazon FSx para Windows File Server** ** FSx Implantação Multi-AZ (abrangendo as zonas de disponibilidade 1 e 2)** + Um sistema de FSx arquivos primário na Zona de Disponibilidade 1 hospeda arquivos de log e dados ativos do SQL Server. + Um sistema de FSx arquivos secundário na Zona de Disponibilidade 2 fornece capacidade de failover automático. + Um compartilhamento de arquivo SMB compartilhado (\$1\$1 fsx.domain\$1 sqlshare), acessível pelos dois nós do cluster para bancos de dados do SQL Server. ** FSx Implantação Single-AZ (em AZ3)** + A testemunha do servidor de FSx arquivos da Amazon na Zona de Disponibilidade 3 serve como testemunha do quórum do cluster. + O file share witness (`\\fsx.domain\witness`) mantém o quorum do cluster e evita cenários de divisão cerebral. **Serviços de diretório** + AWS Managed Microsoft AD fornece serviços de autenticação e domínio do Windows necessários para a funcionalidade do cluster. **Recursos de alta disponibilidade** + Os componentes Multi-AZ oferecem tolerância a falhas em todas as zonas de disponibilidade. + FSx o servidor de arquivos em espera fornece failover automático se o servidor primário falhar. + O File Share Witness fornece gerenciamento de quórum de cluster na Zona de Disponibilidade 3 para ajudar a garantir a operação adequada do cluster durante falhas. + O domínio é integrado AWS Managed Microsoft AD para uma autenticação perfeita do Windows. ## Ferramentas **Serviços da AWS** + [O Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) fornece capacidade de computação escalável no. Nuvem AWS Você poderá iniciar quantos servidores virtuais precisar e escalá-los na vertical rapidamente. + FSxA [Amazon](https://docs.aws.amazon.com/fsx/?id=docs_gateway) fornece sistemas de arquivos que suportam protocolos de conectividade padrão do setor e oferecem alta disponibilidade e replicação em todo o mundo. Regiões da AWS + [A Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) ajuda você a lançar AWS recursos em uma rede virtual que você definiu. Essa rede virtual é semelhante a uma rede tradicional que você operaria no próprio datacenter, com os benefícios de usar a infraestrutura escalável da AWS. + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)permite que suas cargas de trabalho e AWS recursos com reconhecimento de diretório usem o Microsoft Active Directory no. Nuvem AWS + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ajuda você a gerenciar com segurança o acesso aos seus AWS recursos controlando quem está autenticado e autorizado a usá-los. + O [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) ajuda você a gerenciar suas aplicações e infraestrutura em execução na Nuvem AWS. Ele simplifica o gerenciamento de aplicativos e recursos, reduz o tempo para detectar e resolver problemas operacionais e ajuda você a gerenciar seus AWS recursos com segurança em grande escala. ## Práticas recomendadas + Coloque instâncias de banco de dados em sub-redes privadas para protegê-las de serem acessíveis publicamente pela Internet e, ao mesmo tempo, permitir que elas se conectem Serviços da AWS e realizem atualizações. + Para obter as melhores práticas gerais, consulte [Melhores práticas para implantar o Microsoft SQL Server na Amazon EC2](https://docs.aws.amazon.com/prescriptive-guidance/latest/sql-server-ec2-best-practices/welcome.html). + Para usar PowerShell para administrar seu servidor de arquivos Amazon FSx para Windows, consulte [Administração FSx para sistemas de arquivos Windows](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/administering-file-systems.html). ## Épicos ### Crie e configure EC2 nós da Amazon para SQL Server | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Adicione nomes e marcações. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Escolha uma AMI do Windows. | Escolha uma imagem de máquina da Amazon (AMI) para Windows que atenda aos requisitos do SQL Server. | DBA | | Selecione um tipo de instância. | Selecione um tipo de EC2 instância da Amazon que atenda aos seus requisitos. | DBA | | Use um par de chaves. | Você pode usar um par de chaves para se conectar com segurança à sua instância. Certifique-se de ter acesso ao par de chaves selecionado antes de executar a instância. | DBA | | Definir configurações de rede. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Defina as configurações de rede avançadas. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Configure o armazenamento. | Configure o armazenamento total necessário e escolha o tipo de armazenamento necessário. | DBA | | Configure os detalhes avançados e inicie a instância. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Crie o nó 2. | Repita essas etapas para criar e configurar o nó 2. | DBA | ### Instalar e configurar o cluster de failover do Windows Server nos nós 1 e 2 | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Faça o login no nó 1. | Faça login na EC2 instância do Windows Amazon como administrador. | DBA | | Instale os recursos do FCI no nó 1. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html)
Install-WindowsFeature -Name Failover-Clustering -IncludeManagementTools[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Faça o login no nó 2. | Faça login na EC2 instância do Windows Amazon como administrador. | DBA | | Instale os recursos do FCI no nó 2. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html)
Install-WindowsFeature -Name Failover-Clustering -IncludeManagementTools[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Adicione nós ao cluster. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Traga o cluster online. | Para colocar o cluster on-line, atualize os endereços IP estáticos dos dois nós:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Valide o cluster. | Navegue até o **gerenciador de cluster de failover** e verifique se os recursos principais do cluster estão on-line. | DBA | ### Instale o SQL Server nos nós 1 e 2 | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Faça login no servidor. | Faça login na EC2 instância da Amazon como administrador. | DBA | | Monte os binários SQL. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | | | Adicione o nó 2 ao cluster de failover. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | ### Configurar a testemunha de compartilhamento FSx de arquivos da Amazon | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Defina as configurações do quórum. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Recupere os detalhes do DNS. | No FSx console da Amazon, escolha **Managed AD** e, em seguida, **Anexar**. O DNS deve ter o seguinte formato: `\\example.example.net\share` | DBA | | Configure a testemunha de compartilhamento de arquivo. | Escolha o **caminho de compartilhamento FSx de arquivos da Amazon** e, em seguida, **Concluir**. | DBA | ## Recursos relacionados **AWS recursos** + [Servidor de arquivos Amazon FSx para Windows](https://www.youtube.com/watch?v=IMDWTIShlyI) (vídeo) + [Mergulho aprofundado no Amazon FSx para Windows File Server](https://www.youtube.com/watch?v=_x_Geur93oc) (vídeo) + [Como implantar um cluster de failover do SQL Server com o Amazon EBS Multi-Attach no Windows Server](https://aws.amazon.com/blogs/modernizing-with-aws/how-to-deploy-a-sql-server-failover-cluster-with-amazon-ebs-multi-attach-on-windows-server/) (AWS postagem do blog) + [Simplifique suas implantações de alta disponibilidade do Microsoft SQL Server usando o Amazon FSx para Windows File Server](https://aws.amazon.com/blogs/storage/simplify-your-microsoft-sql-server-high-availability-deployments-using-amazon-fsx-for-windows-file-server/) (postagem AWS no blog) + [Implantações de alta disponibilidade do SQL Server usando a Amazon FSx para NetApp ONTAP](https://aws.amazon.com/blogs/modernizing-with-aws/sql-server-high-availability-amazon-fsx-for-netapp-ontap/) (AWS postagem no blog) + [Usando FSx o Windows File Server com o Microsoft SQL Server](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/sql-server.html) + [O que é FSx para o Windows File Server?](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) **Outros recursos** + [Crie um cluster de failover](https://learn.microsoft.com/en-us/windows-server/failover-clustering/create-failover-cluster?pivots=windows-admin-center) ## Mais informações **Configurar a testemunha de compartilhamento de arquivo** Certifique-se de estar conectado ao sistema de arquivos a partir dos dois nós adicionando regras no grupo de FSx segurança da Amazon que permitem conexões de entrada. A porta SMB deve ser permitida. Por exemplo, se o nome DNS for `\\example.example.com\share`, use `\\example.example.com\share`. Use o mesmo valor para a testemunha de compartilhamento de arquivos no cluster de disponibilidade Always On. Conclua as etapas a seguir para configurar a testemunha de compartilhamento de arquivos: 1. Use o RDP para se conectar à sua EC2 instância da Amazon. 1. Navegue até **Gerenciador de cluster de failover**. 1. Abra o menu de contexto (clique com o botão direito do mouse) e selecione **Mais ações**. 1. Escolha **Definir configurações de quorum do cluster**. 1. Escolha **Próximo**. 1. Selecione **Configuração de quórum** e configure uma testemunha de compartilhamento de arquivos. 1. Forneça o nome de DNS. 1. Analise o resumo e, em seguida, escolha **Concluir**. A testemunha do compartilhamento de arquivos deve estar on-line na seção de recursos **principais do cluster**. # Configure uma HA/DR arquitetura para o Oracle E-Business Suite no Amazon RDS Custom com um banco de dados ativo em espera *Simon Cunningham, Jaydeep Nandy e Nitin Saxena, da Amazon Web Services* ## Resumo Esse padrão descreve como você pode arquitetar sua solução Oracle E-Business no Amazon Relational Database Service (Amazon RDS) Custom para alta disponibilidade (HA) e recuperação de desastres (DR) configurando um banco de dados de réplica de leitura do Amazon RDS Custom em outra zona de disponibilidade da Amazon Web Services (AWS) e convertendo-o em um banco de dados ativo em espera. A criação da réplica de leitura do Amazon RDS Custom é totalmente automatizada por meio do Console de Gerenciamento da AWS. Esse padrão não discute as etapas para adicionar camadas adicionais de aplicativos e sistemas de arquivos compartilhados, que também podem fazer parte de uma HA/DR arquitetura. Para obter mais informações sobre esses tópicos, consulte as seguintes notas de suporte da Oracle: 1375769.1, 1375670.1 e 1383621.1 (seção 5, *Opções avançadas de clonagem*). (O acesso requer uma conta [do Oracle Support](https://support.oracle.com/portal/).) Para migrar o sistema E-Business Suite para uma arquitetura Single-AZ de camada única na Amazon Web Services (AWS), consulte o padrão [Migrar o Oracle E-Business Suite para o Amazon RDS Custom](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html). O Oracle E-Business Suite é uma solução de Planejamento de recursos empresariais (ERP - Enterprise Resource Planning) para automatizar processos em toda a empresa, como finanças, recursos humanos, cadeias de suprimentos e manufatura. Ele tem uma arquitetura de três camadas: cliente, aplicação e banco de dados. Anteriormente, você precisava executar seu banco de dados do E-Business Suite em uma [instância autogerenciada do Amazon Elastic Compute Cloud (Amazon EC2),](https://aws.amazon.com/ec2/) mas agora você pode se beneficiar do [Amazon](https://aws.amazon.com/rds/custom/) RDS Custom. ## Pré-requisitos e limitações **Pré-requisitos ** + Uma instalação existente do E-Business Suite no Amazon RDS Custom; veja o padrão [Migrar o Oracle E-Business Suite para o Amazon RDS Custom](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html) + Se você quiser alterar a réplica de leitura para somente leitura e usá-la para transferir os relatórios para o modo de espera, uma [licença de banco de dados Oracle Active Data Guard](https://www.oracle.com/corporate/pricing/) (consulte a *Lista de preços comerciais de tecnologia da Oracle*) **Limitações** + Limitações e configurações não suportadas para [bancos de dados Oracle no Amazon](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.limits) RDS Custom + Limitações associadas às [réplicas de leitura do Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html#custom-rr.limitations) **Versões do produto** Para versões do banco de dados Oracle e classes de instância suportadas pelo Amazon RDS Custom, consulte [Requisitos e limitações do Amazon RDS Custom for Oracle](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html). ## Arquitetura O diagrama a seguir ilustra uma arquitetura representativa do E-Business Suite na AWS que inclui várias zonas de disponibilidade e níveis de aplicativos em uma configuração. active/passive O banco de dados usa uma instância de banco de dados do Amazon RDS Custom e uma réplica de leitura do Amazon RDS Custom. A réplica de leitura usa o Active Data Guard para replicar em outra zona de disponibilidade. Você também pode usar a réplica de leitura para descarregar o tráfego de leitura no banco de dados principal e para fins de geração de relatórios. ![\[Arquitetura Multi-AZ para o Oracle E-Business Suite na AWS\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/a17947e8-56b1-4d92-91df-096c02ff4c19/images/ffdaa2d4-123b-44a0-8d52-b1352a4eee44.png) Para obter mais informações, consulte [Trabalhar com réplicas de leitura do Amazon RDS Custom para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html) na documentação do Amazon RDS. A réplica de leitura do Amazon RDS Custom é criada por padrão como montada. No entanto, se você quiser transferir algumas de suas cargas de trabalho somente para leitura no banco de dados em espera para reduzir a carga no banco de dados principal, você pode alterar manualmente o modo das réplicas montadas para somente leitura seguindo as etapas na seção [Épicos.](#set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database-epics) Um caso de uso típico para isso seria executar seus relatórios a partir do banco de dados em espera. Mudar para somente leitura requer uma licença ativa de banco de dados em espera. Quando você cria uma réplica de leitura na AWS, o sistema usa o agente Oracle Data Guard nos bastidores. Essa configuração é gerada e configurada automaticamente no modo Desempenho Máximo da seguinte forma: ``` DGMGRL> show configuration Configuration - rds_dg Protection Mode: MaxPerformance Members: vis_a - Primary database vis_b - Physical standby database Fast-Start Failover: DISABLED Configuration Status: SUCCESS (status updated 58 seconds ago) ``` ## Ferramentas **Serviços da AWS** + O [Amazon RDS Custom para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/working-with-custom-oracle.html) é um serviço de banco de dados gerenciado para aplicações herdadas, personalizadas e em pacote que exigem acesso ao sistema operacional subjacente e ao ambiente de banco de dados. Ele automatiza tarefas e operações de administração de banco de dados e permite que você, como administrador de banco de dados, acesse e personalize seu ambiente de banco de dados e sistema operacional. **Outras ferramentas** + O Oracle Data Guard é uma ferramenta que ajuda você a criar e gerenciar bancos de dados Oracle standby. Esse padrão usa o Oracle Data Guard para configurar um banco de dados em espera ativo no Amazon RDS Custom. ## Épicos ### Criar uma réplica de leitura | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie uma réplica de leitura da instância de banco de dados do Amazon RDS Custom. | Para criar uma réplica de leitura, siga as instruções na [documentação do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReadRepl.html#USER_ReadRepl.Create) e use a instância de banco de dados do Amazon RDS Custom que você criou (consulte a seção [Pré-requisitos](#set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database-prereqs)) como banco de dados de origem.Por padrão, a réplica de leitura do Amazon RDS Custom é criada como uma espera física e está no estado montado. Isso é intencional para garantir a conformidade com a licença do Oracle Active Data Guard. Siga as próximas etapas para converter a réplica de leitura no modo somente leitura. | DBA | ### Altere a réplica de leitura para um modo de espera ativo somente para leitura | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Conecte-se à réplica de leitura do Amazon RDS Custom. | Use os comandos a seguir para converter seu banco de dados stand-by físico em um banco de dados stand-by ativo. Para executar esses comandos, é necessária uma licença Active Standby da Oracle válida. Para obter uma licença, entre em contato com seu representante da Oracle.
$ sudo su - rdsdb| DBA | | Inicie a recuperação de mídia com a aplicação de registros em tempo real. | Para ativar o atributo de aplicação de log em tempo real, use os comandos a seguir. Eles convertem e validam o standby (réplica de leitura) como um banco de dados em espera ativo, para que você possa se conectar e executar consultas somente para leitura.
-bash-4.2$ sql
SQL> select process,status,sequence# from v$managed_standby;
PROCESS STATUS SEQUENCE#
--------- ------------ ----------
ARCH CLOSING 3956
ARCH CONNECTED 0
ARCH CLOSING 3955
ARCH CLOSING 3957
RFS IDLE 0
RFS IDLE 3958
MRP0 APPLYING_LOG 3958
SQL> select name, database_role, open_mode from v$database;
NAME DATABASE_ROLE OPEN_MODE
--------- ---------------- --------------------
VIS PHYSICAL STANDBY MOUNTED
SQL> alter database recover managed standby database cancel;
Database altered.
Open the standby database
SQL> alter database open;
Database altered.
SQL> select name, database_role, open_mode from v$database;
NAME DATABASE_ROLE OPEN_MODE
--------- ---------------- --------------------
VIS PHYSICAL STANDBY READ ONLY
SQL> alter database recover managed standby database using current logfile disconnect from session;| DBA | | Verifique o status do banco de dados. | Para verificar o status do banco de dados, use o comando a seguir.
Database altered
SQL> select name, database_role, open_mode from v$database;| DBA | | Marque o modo de refazer aplicação. | Para verificar o modo de aplicação de refazer, use o seguinte comando.
NAME DATABASE_ROLE OPEN_MODE
--------- ---------------- --------------------
VIS PHYSICAL STANDBY READ ONLY WITH APPLY
SQL> select process,status,sequence# from v$managed_standby;| DBA | ## Recursos relacionados + [Migre o Oracle E-Business Suite para o Amazon RDS Custom](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html) (Recomendações da AWS) + [Trabalhando com o Amazon RDS Custom](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-custom.html) (documentação do Amazon RDS) + [Trabalhar com réplicas de leitura do Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html) (documentação do Amazon RDS) + [Amazon RDS Custom para Oracle – Novos recursos de controle no ambiente de banco de dados](https://aws.amazon.com/blogs/aws/amazon-rds-custom-for-oracle-new-control-capabilities-in-database-environment/) (blog de notícias da AWS) + [Migração do Oracle E-Business Suite na AWS](https://d1.awsstatic.com/whitepapers/migrate-oracle-e-business-suite.pdf) (whitepaper da AWS) + [Arquitetura do Oracle E-Business Suite na AWS](https://docs.aws.amazon.com/whitepapers/latest/overview-oracle-e-business-suite/oracle-e-business-suite-architecture-on-aws.html) (whitepaper da AWS) # Transmita dados do IBM Db2, SAP, Sybase e outros bancos de dados para o MongoDB Atlas em AWS *Battulga Purevragchaa e Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Resumo Este padrão descreve as etapas necessárias para migrar dados do Db2 da IBM e de outros bancos de dados, como bancos mainframe e Sybase, para o MongoDB Atlas na Nuvem AWS. O [AWS Glue](https://aws.amazon.com/glue/) é usado para agilizar a migração de dados para o MongoDB Atlas. O padrão acompanha o guia [Migrating to MongoDB Atlas no site Prescriptive](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) Guidance. AWS AWS Ele fornece as etapas de implementação para um dos cenários de migração abordados nesse guia. Para cenários adicionais de migração, consulte os seguintes padrões no site da Orientação AWS Prescritiva: + [Migre um ambiente MongoDB auto-hospedado para o MongoDB Atlas em AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud.html) + [Migre bancos de dados relacionais para o MongoDB Atlas em AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-relational-database-to-mongodb-atlas.html) O padrão é destinado a [parceiros e AWS usuários do AWS Managed Services](https://aws.amazon.com/managed-services/partners/). ## Pré-requisitos e limitações **Pré-requisitos ** + Um banco de dados de origem, como SAP, Sybase, Db2 da IBM e outros, para migrar para o MongoDB Atlas. + Familiaridade com bancos de dados como SAP, Sybase, IBM Db2, MongoDB Atlas e. Serviços da AWS **Versões do produto** + MongoDB versão 5.0 ou versões posteriores. ## Arquitetura O diagrama a seguir ilustra o carregamento de dados em lote e o streaming de dados usando o AWS Glue Studio Amazon Kinesis Data Streams e o MongoDB Atlas. Essa arquitetura de referência é usada AWS Glue Studio para criar pipelines de extração, transformação e carregamento (ETL) para migrar dados para o MongoDB Atlas. O An Crawler do AWS Glue se integra ao MongoDB Atlas para facilitar a governança de dados. Os dados podem ser transferidos em lote ou transmitidos continuamente para o MongoDB Atlas com o uso do Amazon Kinesis Data Streams. **Carregamento de dados em lote** ![\[Migração de dados para o MongoDB Atlas no modo em lote.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/805a376f-35f4-44cc-b4b0-8bf4d95c1e5d/images/68d87202-95ba-4e2a-9b3b-27dd6db6165e.png) Para obter mais informações sobre a migração de dados em lote, consulte a [postagem do AWS blog Crie suas tarefas de ETL para o MongoDB Atlas](https://aws.amazon.com/blogs/big-data/compose-your-etl-jobs-for-mongodb-atlas-with-aws-glue/) com. AWS Glue **Streaming de dados** ![\[Migração de dados para o MongoDB Atlas no modo de transferência de dados.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/805a376f-35f4-44cc-b4b0-8bf4d95c1e5d/images/b007a116-f463-418f-9721-647d80177e3b.png) Para arquiteturas de referência do MongoDB Atlas que oferecem suporte a diferentes cenários de uso, consulte [Migração para o MongoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) Atlas no site Prescriptive Guidance. AWS AWS ## Ferramentas ● O [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html) é um serviço totalmente gerenciado para processos ETL. Ele ajuda você a categorizar de forma confiável, limpar, enriquecer e mover dados de forma confiável entre armazenamento de dados e fluxos de dados. ● O [Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/) contribui para a coleta e o processamento de grandes fluxos de dados em tempo real. ● O [MongoDB Atlas](https://www.mongodb.com/atlas) é um banco de dados como serviço (DBaaS) totalmente gerenciado para implantar e gerenciar bancos de dados do MongoDB na nuvem. ## Práticas recomendadas Para obter diretrizes, consulte o [Guia de melhores práticas para o MongoDB no repositório](https://github.com/mongodb-partners/mongodb_atlas_as_aws_bedrock_knowledge_base/blob/main/data/MongoDB_Best_Practices_Guide.pdf) do MongoDB. GitHub ## Épicos ### Descoberta e avaliação | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Determine o tamanho do cluster. | Calcule uma estimativa do tamanho do conjunto de trabalho com base nos dados de `db.stats()` relativos ao espaço total de índices. Suponha que uma porcentagem do seu espaço de dados seja acessada com frequência. Alternativamente, é possível calcular os requisitos de memória considerando suas próprias premissas. Essa tarefa deve levar aproximadamente uma semana. Para obter mais informações e exemplos sobre esta e outras histórias deste épico, consulte os links disponibilizados na seção [Recursos relacionados](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | MongoDB DBA, arquiteto de aplicativos | | Estime os requisitos de largura de banda da rede. | Para estimar seus requisitos de largura de banda da rede, multiplique o tamanho médio dos documentos pelo número de documentos processados por segundo. Considere o tráfego máximo que qualquer nó do seu cluster suportará como base. Para calcular as taxas de transferência de dados downstream do seu cluster para os aplicativos cliente, use a soma do total de documentos retornados em determinado período. Se seus aplicativos fizerem a leitura a partir de nós secundários, divida esse número total de documentos pelo número de nós que podem processar operações de leitura. Para descobrir o tamanho médio dos documentos de um banco de dados, use o comando `db.stats().avgObjSize`. Essa tarefa normalmente leva um dia. | MongoDB DBA | | Selecione a camada do Atlas. | Siga as instruções apresentadas na [documentação do MongoDB](https://www.mongodb.com/docs/atlas/manage-clusters/) para selecionar o nível mais adequado do cluster no Atlas. | MongoDB DBA | | Planeje a substituição. | Planeje a substituição do aplicativo. | MongoDB DBA, arquiteto de aplicativos | ### Configure um novo ambiente MongoDB Atlas na AWS | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um novo cluster MongoDB Atlas em. AWS | No MongoDB Atlas, **escolha Criar um** cluster e AWS selecione como provedor de nuvem. | MongoDB DBA | | Selecione Regiões da AWS uma configuração global do cluster. | Selecione na lista de disponíveis Regiões da AWS para seu cluster Atlas. Configure clusters globais, se necessário. | MongoDB DBA | | Selecione o nível cluster. | Selecione o nível de cluster de sua preferência. Sua seleção de camadas determina fatores como memória, armazenamento e especificação de IOPS. | MongoDB DBA | | Configurar definições adicionais de cluster. | Definir configurações adicionais de cluster, como opções de versão, backup e criptografia do MongoDB. Para obter mais informações sobre essas opções, consulte a seção [Recursos relacionados](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | MongoDB DBA | ### Configure a segurança e a conformidade | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Configure a lista de acesso. | Para estabelecer conexão com o cluster do Atlas, você deve adicionar uma entrada à [lista de acesso do projeto](https://www.mongodb.com/docs/atlas/setup-cluster-security/#configure-security-features-for-clusters). O Atlas usa Transport Layer Security (TLS) / Secure Sockets Layer (SSL) para criptografar as conexões com a nuvem privada virtual (VPC) do seu banco de dados. Para configurar a lista de acesso para o projeto e obter mais informações sobre as histórias deste épico, consulte os links disponibilizados na seção [Recursos relacionados](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | MongoDB DBA | | Autentique e autorize usuários. | Você deve criar e autenticar os usuários do banco de dados que acessarão os clusters MongoDB Atlas. Para acessar os clusters em um projeto, os usuários devem pertencer a esse projeto e podem pertencer a vários projetos. Você também pode ativar a autorização com AWS Identity and Access Management (IAM). Para mais informações, consulte [Set Up Authentication with IAM](https://www.mongodb.com/docs/atlas/security/aws-iam-authentication/#set-up-authentication-with-aws-iam) na documentação do MongoDB. | MongoDB DBA | | Criar funções personalizadas. | (Opcional) O Atlas oferece a possibilidade de criar [perfis personalizados](https://www.mongodb.com/docs/atlas/reference/custom-role-actions/) quando os privilégios incorporados para usuários de banco de dados do Atlas não contemplam todas as permissões desejadas. | MongoDB DBA | | Configurar o emparelhamento de VPC. | (Opcional) O Atlas oferece suporte ao emparelhamento de [VPC](https://www.mongodb.com/docs/atlas/security-vpc-peering/#set-up-a-network-peering-connection) com outras AWS. VPCs | MongoDB DBA | | Configure um AWS PrivateLink endpoint. | (Opcional) Você pode configurar endpoints privados AWS usando [AWS PrivateLink](https://www.mongodb.com/docs/atlas/security-private-endpoint/). | MongoDB DBA | | Ative a autenticação de dois fatores. | (Opcional) O Atlas fornece suporte à autenticação de dois fatores (2FA) para ajudar os usuários a controlar o acesso às suas contas do Atlas. | MongoDB DBA | | Configure a autenticação e autorização do usuário com o LDAP. | (Opcional) O Atlas fornece suporte à autenticação e autorização do usuário com o Lightweight Directory Access Protocol (LDAP). | MongoDB DBA | | Configure o AWS acesso unificado. | (Opcional) Alguns recursos do Atlas, como o Atlas Data Lake e a criptografia em repouso com gerenciamento de chaves do cliente, usam perfis do IAM para autenticação. | MongoDB DBA | | Configure a criptografia em repouso usando AWS KMS o. | (Opcional) O Atlas suporta o uso de AWS Key Management Service (AWS KMS) para criptografar mecanismos de armazenamento e backups de provedores de nuvem. | MongoDB DBA | | Configure a CSFLE. | (Opcional) O Atlas oferece suporte à [criptografia em nível de campos do lado do cliente (CSFLE, na sigla em inglês)](https://www.mongodb.com/docs/upcoming/core/csfle/#client-side-field-level-encryption), incluindo a criptografia automática de campos. | MongoDB DBA | ### Migrar dados | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Execute seu conjunto de réplicas de destino no MongoDB Atlas. | Execute seu conjunto de réplicas de destino no MongoDB Atlas. No Atlas Live Migration Service, selecione **Estou com tudo pronto para a migração**. | MongoDB DBA | | Estabeleça a conexão AWS Glue com o MongoDB Atlas. | Use an Crawler do AWS Glue para se conectar AWS Glue ao MongoDB Atlas (banco de dados de destino). Esta etapa ajuda a preparar o ambiente de destino para a migração. Para obter mais informações, consulte a [documentação do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-connections.html). | MongoDB DBA | | Estabeleça a conexão AWS Glue com o banco de dados de origem ou o fluxo de origem. | Isso ajuda a preparar o ambiente de destino para a migração. | MongoDB DBA | | Configure a transformação de dados. | Defina a lógica de transformação para a migração de dados do esquema estruturado legado para o esquema flexível do MongoDB. | MongoDB DBA | | Migre os dados. | Agende a migração no AWS Glue Studio. | MongoDB DBA | ### Configurar integração operacional | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Conecte-se ao cluster. | Conecte-se ao cluster MongoDB Atlas. | Desenvolvedor de aplicativos | | Interaja com os dados. | Interaja com os dados do cluster. | Desenvolvedor de aplicativos | | Monitore os clusters. | Monitore seus clusters do MongoDB Atlas. | MongoDB DBA | | Faça backup e restaure os dados. | Faça backup e restaure os dados do cluster. | MongoDB DBA | ## Solução de problemas | Problema | Solução | | --- | --- | | Caso encontre algum problema | Consulte [Solução de problemas](https://github.com/mongodb/mongodbatlas-cloudformation-resources/tree/master#troubleshooting) no repositório MongoDB Atlas Resources. CloudFormation | ## Recursos relacionados Exceto quando indicado, todos os links abaixo direcionam para páginas na documentação do MongoDB. **Guia de migração** + [Migrando para o MongoDB AWS Atlas](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) em (orientação prescritiva)AWS **Descoberta e avaliação** + [Memória](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Exemplo de dimensionamento com conjuntos de dados de amostra do Atlas](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Exemplo de dimensionamento para aplicativos móveis](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Tráfego de rede](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Ajuste de escala automático de cluster](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Modelo de dimensionamento do Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Configurar a segurança e a conformidade** + [Configurar entradas da lista de acesso via IP](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Configure Database Users](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Configurar acesso à UI do Atlas](https://docs.atlas.mongodb.com/organizations-projects/) + [Configurar papéis personalizados do banco de dados](https://docs.atlas.mongodb.com/security-add-mongodb-roles) + [Configure Database Users](https://docs.atlas.mongodb.com/security-add-mongodb-users/#atlas-user-privileges) + [Configurar uma conexão de emparelhamento de rede](https://docs.atlas.mongodb.com/security-vpc-peering/) + [Aprenda sobre endpoints privados no Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Gerencie suas opções de autenticação multifator](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Configurar a autenticação e autorização do usuário com o LDAP](https://docs.atlas.mongodb.com/security-ldaps/) + [Atlas Data Lake](https://docs.mongodb.com/datalake/) + [Criptografia em repouso usando o gerenciamento de chaves do cliente](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Métodos para assumir um perfil](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (documentação do IAM) + [Criptografia em nível de campo do lado do cliente](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Criptografia automática](https://docs.mongodb.com/manual/core/security-automatic-client-side-encryption) + [MongoDB Atlas Security Controls](https://webassets.mongodb.com/_com_assets/cms/MongoDB_Atlas_Security_Controls-v7k3rbhi3p.pdf) + [Central de confiabilidade do MongoDB](https://www.mongodb.com/cloud/trust) + [Configurar recursos de segurança para Clusters](https://docs.atlas.mongodb.com/setup-cluster-security/) **Como configurar um novo ambiente do MongoDB Atlas na ****AWS** + [Provedores de nuvem e regiões](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Gerenciar clusters globais](https://docs.atlas.mongodb.com/global-clusters/) + [Selecione o nível de cluster](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Configurar configurações adicionais](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Comece a usar o Atlas](https://docs.atlas.mongodb.com/getting-started/) + [Configurar acesso à UI do Atlas](https://docs.atlas.mongodb.com/organizations-projects/) **Migração de dados** + [Migre ou importe dados](https://www.mongodb.com/docs/atlas/import/) **Clusters de monitoramento** + [Monitore seus clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) **Integração de operações** + [Conectar-se a um cluster](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interaja com seus dados](https://docs.atlas.mongodb.com/data-explorer/) + [Monitore seus clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Fazer backup, restaurar e arquivar dados](https://docs.atlas.mongodb.com/backup-restore-cluster/) **GitHub repositório** + [Transmita dados para o MongoDB Atlas usando AWS Glue](https://github.com/mongodb-partners/Stream_Data_into_MongoDB_AWS_Glue?tab=readme-ov-file#troubleshooting) # Funções de transição para um PeopleSoft aplicativo Oracle no Amazon RDS Custom for Oracle *Sampath Kathirvel, Amazon Web Services* ## Resumo Para executar a solução [Oracle PeopleSoft](https://www.oracle.com/applications/peoplesoft/) Enterprise Resource Planning (ERP) na Amazon Web Services (AWS), você pode usar o [Amazon Relational Database Service (Amazon RDS) ou o Amazon RDS](https://aws.amazon.com/rds/) [Custom for](https://aws.amazon.com/rds/custom/) Oracle, que oferece suporte a aplicativos legados, personalizados e empacotados que exigem acesso ao sistema operacional (SO) e ao ambiente de banco de dados subjacentes. Para ver os principais fatores a serem considerados ao planejar uma migração, consulte as [estratégias de migração do banco de dados Oracle](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/strategies.html) nas Recomendações da AWS. Esse padrão se concentra nas etapas para realizar uma transição de função, ou transição de função, do Oracle Data Guard para um banco de dados de PeopleSoft aplicativos executado no Amazon RDS Custom como o banco de dados principal com um banco de dados de réplica de leitura. O padrão inclui etapas para configurar o [failover de início rápido (FSFO)](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/using-data-guard-broker-to-manage-switchovers-failovers.html#GUID-D26D79F2-0093-4C0E-98CD-224A5C8CBFA4). Durante esse processo, os bancos de dados na configuração do Oracle Data Guard continuam funcionando em suas novas funções. Os casos de uso típicos da transição do Oracle Data Guard são exercícios de recuperação de desastres (DR), atividades de manutenção programada em bancos de dados e patches contínuos [em espera-First Patch Apply](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/upgrading-patching-downgrading-oracle-data-guard-configuration.html#GUID-A5226768-DB6B-4714-BB9A-0A3EF17A01C8). Para obter mais informações, consulte a postagem de blog [Reduza o tempo de inatividade de patch de banco de dados no Amazon RDS Custom](https://aws.amazon.com/blogs/database/reduce-database-patching-downtime-in-amazon-rds-custom-for-oracle-using-oracle-data-guard-standby-first-patch-apply/). ## Pré-requisitos e limitações **Pré-requisitos ** + Conclusão do [Add HA to Oracle PeopleSoft on Amazon RDS Custom usando um padrão de réplica de leitura](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/add-ha-to-oracle-peoplesoft-on-amazon-rds-custom-by-using-a-read-replica.html). **Limitações** + Limitações gerais e configurações incompatíveis para o [RDS Personalizado para Oracle](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.limits) + Limitações associadas às [réplicas de leitura do Amazon RDS Custom para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html#custom-rr.limitations) **Versões do produto** + Para versões do Oracle Database suportadas pelo Amazon RDS Custom, consulte [RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.RDSCustom.html#Concepts.RDS_Fea_Regions_DB-eng.Feature.RDSCustom.ora) + Para classes de instância de banco de dados do Oracle Database suportadas pelo Amazon RDS Custom, consulte [Suporte a classes de instância de banco de dados do RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.instances). ## Arquitetura **Pilha de tecnologia** + Amazon RDS Custom para Oracle **Arquitetura de destino** O diagrama a seguir mostra uma instância de banco de dados do Amazon RDS Custom e uma réplica de leitura personalizada do Amazon RDS Custom. O Oracle Data Guard fornece transição de funções durante o failover para DR. ![\[Transição do Oracle Data Guard para uma instância primária do banco de dados personalizado do RDS com um banco de dados de réplica para leitura.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/da3b011c-1668-4de4-9079-0982888a74b4/images/4e2a2f3b-b5bd-44b7-9b5a-13a663ee3be6.png) Para uma arquitetura representativa usando o Oracle PeopleSoft na AWS, consulte [Configurar uma PeopleSoft arquitetura altamente disponível na AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/set-up-a-highly-available-peoplesoft-architecture-on-aws.html). ## Ferramentas **Serviços da AWS** + O [Amazon RDS Custom para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/working-with-custom-oracle.html) é um serviço de banco de dados gerenciado para aplicativos legados, personalizados e em pacote que exigem acesso ao sistema operacional subjacente e ao ambiente de banco de dados. + O [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) ajuda você a substituir credenciais codificadas em seu código, incluindo senhas, por uma chamada de API ao Secrets Manager para recuperar o segredo programaticamente. Nesse padrão, você recupera as senhas de usuário do banco de dados do Secrets Manager for `RDS_DATAGUARD` com o nome secreto `do-not-delete-rds-custom-+<
PROCESS STATUS SEQUENCE#
--------- ------------ ----------
ARCH CLOSING 3956
ARCH CONNECTED 0
ARCH CLOSING 3955
ARCH CLOSING 3957
RFS IDLE 0
RFS IDLE 3958
MRP0 APPLYING_LOG 3958
SQL> select open_mode from v$database;
OPEN_MODE
--------------------
READ ONLY WITH APPLY
-bash-4.2$ dgmgrl RDS_DATAGUARD@RDS_CUSTOM_ORCL_A**CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Mon Nov 28 20:55:50 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "ORCL_A"
Connected as SYSDG.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 59 seconds ago)
DGMGRL>
CDB-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_A| DBA | | Verifique a função da instância. | Abra o Console de Gerenciamento da AWS e navegue para o console do Amazon RDS. Na seção **Replicação** do banco de dados, na guia **Conectividade e segurança**, verifique a função da instância primária e da réplica.A função primária deve corresponder ao banco de dados primário do Oracle Data Guard, e a função de réplica deve corresponder ao banco de dados físico em espera do Oracle Data Guard. | Administrador de nuvem, DBA | | Executar a transição. | Para realizar a transição, conecte-se a `DGMGRL` a partir do nó primário.**Não CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 18 06:13:07 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_A"
Connected as SYSDG.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 52 seconds ago)
DGMGRL>
DGMGRL> switchover to orcl_d;**CDB**
Performing switchover NOW, please wait...
Operation requires a connection to database "orcl_d"
Connecting ...
Connected to "ORCL_D"
Connected as SYSDG.
New primary database "orcl_d" is opening...
Operation requires start up of instance "ORCL" on database "orcl_a"
Starting instance "ORCL"...
Connected to an idle instance.
ORACLE instance started.
Connected to "ORCL_A"
Database mounted.
Database opened.
Connected to "ORCL_A"
Switchover succeeded, new primary is "orcl_d"
DGMGRL>
DGMGRL> switchover to rdscdb_b| DBA | | Verificar a conexão do Oracle Data Guard. | Após a transição, verifique a conexão do Oracle Data Guard do nó primário com `DGMGRL`.**Não CDB**
Performing switchover NOW, please wait...
New primary database "rdscdb_b" is opening...
Operation requires start up of instance "RDSCDB" on database "rdscdb_a"
Starting instance "RDSCDB"...
Connected to an idle instance.
ORACLE instance started.
Connected to "RDSCDB_A"
Database mounted.
Database opened.
Connected to "RDSCDB_A"
Switchover succeeded, new primary is "rdscdb_b"
DGMGRL> show configuration;**CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_d - Primary database
orcl_a - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 60 seconds ago)
DGMGRL>
DGMGRL> show configuration lag;
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_d - Primary database
orcl_a - Physical standby database
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 44 seconds ago)
DGMGRL>
DGMGRL> show configuration| DBA | | Verificar a função da instância no console do Amazon RDS. | Depois de mudar a função, o console do Amazon RDS mostra as novas funções na seção **Replicação**, na guia **Conectividade e segurança**, em **Bancos de dados**. Pode levar alguns minutos para que o **Estado da Replicação** seja atualizado de vazio para **Replicando**. | DBA | ### Configurar FSFO | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Redefinir a transição. | Definir a transição de volta para o nó primário. | DBA | | Instalar e iniciar o observador. | Um processo observador é um componente cliente `DGMGRL`, normalmente executado em uma máquina diferente dos bancos de dados primário e em espera. A instalação do ORACLE HOME para o observador pode ser uma instalação do Oracle Client Administrator, ou você pode instalar o Oracle Database Enterprise Edition ou o Personal Edition. Para obter mais informações sobre a instalação do observador para sua versão do banco de dados, consulte [Instalar e iniciar o observador](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/using-data-guard-broker-to-manage-switchovers-failovers.html#GUID-11EF3897-8FCA-4A54-B63B-E8C1668AE21B). Para configurar a alta disponibilidade do processo do observador, faça uma das seguintes opções:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/transition-roles-for-an-oracle-peoplesoft-application-on-amazon-rds-custom-for-oracle.html)Para o Oracle 12c liberação 2 e posterior, você pode implantar até três observadores. Um observador é o observador primário e os demais são observadores de backup. Quando o observador primário falha, um dos observadores de backup assume a função primária. | DBA | | Conectar ao DGMGRL a partir do host observador. | O host observador é configurado com `tnsnames.ora` entradas para conectividade de banco de dados primário e em espera. Você pode ativar o FSFO com o modo de proteção de desempenho máximo, desde que a perda de dados esteja dentro da [FastStartFailoverLagLimit](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/oracle-data-guard-broker-properties.html)configuração (valor em segundos). No entanto, você deve usar o modo de proteção de disponibilidade máxima para trabalhar para obter zero perda de dados (RPO = 0).**Não CDB**
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_b - Primary database
rdscdb_a - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 52 seconds ago)
DGMGRL>
DGMGRL> show configuration lag
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_b - Primary database
rdscdb_a - Physical standby database
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 53 seconds ago)
DGMGRL>
DGMGRL> show configuration;**CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 58 seconds ago)
DGMGRL> show configuration lag
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 5 seconds ago)
DGMGRL>
-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_A| DBA | | Modificar o banco de dados em espera para ser o destino do failover. | Conectar do nó primário ou do nó observador a um banco de dados em espera. (Embora sua configuração possa ter vários bancos de dados em espera, você precisa se conectar a somente um no momento.)**Não CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 18 06:55:09 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_A"
Connected as SYSDG.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 18 seconds ago)
DGMGRL>
DGMGRL> edit database orcl_a set property FastStartFailoverTarget='orcl_d';**CDB**
Property "faststartfailovertarget" updated
DGMGRL> edit database orcl_d set property FastStartFailoverTarget='orcl_a';
Property "faststartfailovertarget" updated
DGMGRL> show database orcl_a FastStartFailoverTarget;
FastStartFailoverTarget = 'orcl_d'
DGMGRL> show database orcl_d FastStartFailoverTarget;
FastStartFailoverTarget = 'orcl_a'
DGMGRL>
DGMGRL> edit database orcl_a set property FastStartFailoverTarget='rdscdb_b';| DBA | | Configure FastStartFailoverThreshold para a conexão com o DGMGRL. | O valor padrão é 30 segundos no Oracle 19c e o valor mínimo é 6 segundos. Um valor menor pode reduzir potencialmente o objetivo de tempo de recuperação (RTO) durante o failover. Um valor maior ajuda a reduzir a chance de erros transitórios de failover desnecessários no banco de dados primário.O framework de automação RDS Custom for Oracle monitora a integridade do banco de dados e executa ações corretivas a cada poucos segundos. Portanto, recomendamos FastStartFailoverThreshold definir um valor maior que 10 segundos. O exemplo a seguir configura o valor limite em 35 segundos.**Não CBD ou CDB**
Object "orcl_a" was not found
DGMGRL> edit database rdscdb_a set property FastStartFailoverTarget='rdscdb_b';
Property "faststartfailovertarget" updated
DGMGRL> edit database rdscdb_b set property FastStartFailoverTarget='rdscdb_a';
Property "faststartfailovertarget" updated
DGMGRL> show database rdscdb_a FastStartFailoverTarget;
FastStartFailoverTarget = 'rdscdb_b'
DGMGRL> show database rdscdb_b FastStartFailoverTarget;
FastStartFailoverTarget = 'rdscdb_a'
DGMGRL>
DGMGRL> edit configuration set property FastStartFailoverThreshold=35;| DBA | | Habilitar o FSFO conectando-se ao DGMGRL a partir do nó primário ou observador. | Se o banco de dados não tiver o [Flashback Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/rcmrf/FLASHBACK-DATABASE.html#GUID-584AC79A-40C5-45CA-8C63-DED3BE3A4511) habilitado, a mensagem de aviso `ORA-16827` será exibida. O banco de dados de flashback opcional ajuda a restabelecer automaticamente os bancos de dados primários com falha em um ponto no tempo antes do failover, se a propriedade de [FastStartFailoverAutoReinstate](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/oracle-data-guard-broker-properties.html#GUID-824E97C0-EEB0-4E1B-BD4A-F5AE282CEA28)configuração estiver definida como `TRUE` (que é o padrão).**Não CDB**
Property "faststartfailoverthreshold" updated
DGMGRL> show configuration FastStartFailoverThreshold;
FastStartFailoverThreshold = '35'
DGMGRL>
DGMGRL> enable fast_start failover;**CDB**
Warning: ORA-16827: Flashback Database is disabled
Enabled in Zero Data Loss Mode.
DGMGRL>
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
Warning: ORA-16819: fast-start failover observer not started
orcl_d - (*) Physical standby database
Warning: ORA-16819: fast-start failover observer not started
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
WARNING (status updated 29 seconds ago)
DGMGRL>
DGMGRL> enable fast_start failover;| DBA | | Iniciar o observador para monitoramento do FSFO e verifique o status. | Você pode iniciar o observador antes ou depois de habilitar o FSFO. Se o FSFO já estiver habilitado, o observador imediatamente começará a monitorar o status e as conexões com os bancos de dados em espera primários e de destino. Se o FSFO não estiver habilitado, o observador não iniciará o monitoramento até que o FSFO seja habilitado.Quando você inicia o observador, a configuração primária do banco de dados será exibida sem nenhuma mensagem de erro, conforme evidenciado pelo comando anterior `show configuration`.**Não CDB**
Warning: ORA-16827: Flashback Database is disabled
Enabled in Zero Data Loss Mode.
DGMGRL> show configuration;
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
Warning: ORA-16819: fast-start failover observer not started
rdscdb_b - (*) Physical standby database
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
WARNING (status updated 11 seconds ago)
DGMGRL>
DGMGRL> start observer;**CDB**
[W000 2022-12-01T06:16:51.271+00:00] FSFO target standby is orcl_d
Observer 'ip-10-0-1-89' started
[W000 2022-12-01T06:16:51.352+00:00] Observer trace level is set to USER
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - (*) Physical standby database
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
SUCCESS (status updated 56 seconds ago)
DGMGRL>
DGMGRL> show observer
Configuration - rds_dg
Primary: orcl_a
Active Target: orcl_d
Observer "ip-10-0-1-89" - Master
Host Name: ip-10-0-1-89
Last Ping to Primary: 1 second ago
Last Ping to Target: 1 second ago
DGMGRL>
DGMGRL> start observer;| DBA | | Verifique o failover. | Nesse cenário, um teste de failover pode ser realizado interrompendo manualmente a EC2 instância primária. Antes de interromper a EC2 instância, use o `tail` comando para monitorar o arquivo de log do observador com base na sua configuração. Use `DGMGRL` para iniciar sessão no banco de dados `orcl_d` em espera com o usuário `RDS_DATAGUARD` e verificar o status do Oracle Data Guard. Deve ser mostrado que `orcl_d` é o novo banco de dados primário.Neste cenário de teste de failover, `orcl_d` consiste no banco de dados que não é um CDB.Antes do failover, o banco de dados de flashback foi habilitado em `orcl_a`. Depois que o antigo banco de dados primário retorna on-line e inicia no estado `MOUNT`, o observador o restabelece em um novo banco de dados em espera. O banco de dados restabelecido atua como o destino do FSFO para o novo banco de dados primário. Você pode verificar os detalhes nos logs do observador.
Succeeded in opening the observer file "/home/oracle/fsfo_ip-10-0-1-56.dat".
[W000 2023-01-18T07:31:32.589+00:00] FSFO target standby is rdscdb_b
Observer 'ip-10-0-1-56' started
The observer log file is '/home/oracle/observer_ip-10-0-1-56.log'.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - (*) Physical standby database
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
SUCCESS (status updated 12 seconds ago)
DGMGRL>
DGMGRL> show observer;
Configuration - rds_dg
Primary: rdscdb_a
Active Target: rdscdb_b
Observer "ip-10-0-1-56" - Master
Host Name: ip-10-0-1-56
Last Ping to Primary: 1 second ago
Last Ping to Target: 2 seconds ago
DGMGRL>
DGMGRL> show configurationA seguir, alguns exemplos de saída no `observer.log`.
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_d - Primary database
Warning: ORA-16824: multiple warnings, including fast-start failover-related warnings, detected for the database
orcl_a - (*) Physical standby database (disabled)
ORA-16661: the standby database needs to be reinstated
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
WARNING (status updated 25 seconds ago)
DGMGRL>
$ tail -f /tmp/observer.log| DBA | ### Configurar a conectividade entre o aplicativo Oracle Peoplesoft e o banco de dados | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Criar e iniciar o serviço no banco de dados primário. | Você pode evitar alterações na configuração de aplicativo durante uma transição de função usando uma entrada TNS que contém os endpoints do banco de dados primário e em espera na configuração. Você pode definir dois serviços de banco de dados baseados em funções para suportar ambas as cargas de trabalho read/write e somente para leitura. No exemplo a seguir, `orcl_rw` é o read/write serviço que está ativo no banco de dados principal. `orcl_ro`é o serviço somente para leitura e está ativo no banco de dados stand-by que foi aberto no modo somente leitura.
Unable to connect to database using rds_custom_orcl_a
[W000 2023-01-18T07:50:32.589+00:00] Primary database cannot be reached.
[W000 2023-01-18T07:50:32.589+00:00] Fast-Start Failover threshold has expired.
[W000 2023-01-18T07:50:32.590+00:00] Try to connect to the standby.
[W000 2023-01-18T07:50:32.590+00:00] Making a last connection attempt to primary database before proceeding with Fast-Start Failover.
[W000 2023-01-18T07:50:32.591+00:00] Check if the standby is ready for failover.
[S002 2023-01-18T07:50:32.591+00:00] Fast-Start Failover started...
2023-01-18T07:50:32.591+00:00
Initiating Fast-Start Failover to database "orcl_d"...
[S002 2023-01-18T07:50:32.592+00:00] Initiating Fast-start Failover.
Performing failover NOW, please wait...
Failover succeeded, new primary is "orcl_d"
2023-01-18T07:55:32.101+00:00
[S002 2023-01-18T07:55:32.591+00:00] Fast-Start Failover finished...
[W000 2023-01-18T07:55:32.591+00:00] Failover succeeded. Restart pinging.
[W000 2023-01-18T07:55:32.603+00:00] Primary database has changed to orcl_d.
[W000 2023-01-18T07:55:33.618+00:00] Try to connect to the primary.
[W000 2023-01-18T07:55:33.622+00:00] Try to connect to the primary rds_custom_orcl_d.
[W000 2023-01-18T07:55:33.634+00:00] The standby orcl_a needs to be reinstated
[W000 2023-01-18T07:55:33.654+00:00] Try to connect to the new standby orcl_a.
[W000 2023-01-18T07:55:33.654+00:00] Connection to the primary restored!
[W000 2023-01-18T07:55:35.654+00:00] Disconnecting from database rds_custom_orcl_d.
[W000 2023-01-18T07:55:57.701+00:00] Try to connect to the new standby orcl_a.
ORA-12170: TNS:Connect timeout occurred
SQL> select name,open_mode from v$database;| DBA | | Iniciar o serviço no banco de dados em espera. | Para iniciar o serviço no banco de dados em espera somente leitura, use o código a seguir.
NAME OPEN_MODE
--------- --------------------
ORCL READ WRITE
SQL> exec dbms_service.create_service('orcl_rw','orcl_rw');
PL/SQL procedure successfully completed.
SQL> exec dbms_service.create_service('orcl_ro','orcl_ro');
PL/SQL procedure successfully completed.
SQL> exec dbms_service.start_service('orcl_rw');
PL/SQL procedure successfully completed.
SQL>
SQL> select name,open_mode from v$database;| DBA | | Automatizar a inicialização do serviço quando o banco de dados primário for reiniciado. | Para iniciar automaticamente o serviço no banco de dados primário quando ele for reiniciado, use o código a seguir.
NAME OPEN_MODE
--------- --------------------
ORCL READ ONLY WITH APPLY
SQL> exec dbms_service.start_service('orcl_ro');
PL/SQL procedure successfully completed.
SQL>
SQL> CREATE OR REPLACE TRIGGER TrgDgServices after startup on database| DBA | | Configure uma conexão entre os bancos de dados read/write e os bancos de dados somente para leitura. | Você pode usar o seguinte exemplo de configuração de aplicativo para a conexão read/write e somente leitura.
DECLARE
db_role VARCHAR(30);
db_open_mode VARCHAR(30);
BEGIN
SELECT DATABASE_ROLE, OPEN_MODE INTO db_role, db_open_mode FROM V$DATABASE;
IF db_role = 'PRIMARY' THEN
DBMS_SERV 2 ICE.START_SERVICE('orcl_rw');
END IF;
IF db_role = 'PHYSICAL STANDBY' AND db_open_mode LIKE 'READ ONLY%' THEN
DBMS_SERVICE.START_SERVICE('orcl_ro');
END IF;
END;
/
Trigger created.
SQL>
ORCL_RW = (DESCRIPTION =| DBA | ## Recursos relacionados + [Habilitar a alta disponibilidade com o Data Guard no Amazon RDS Custom para Oracle](https://d1.awsstatic.com/whitepapers/enabling-high-availability-with-data-guard-on-amazon-rds-custom-for-oracle.pdf) (Guia técnico da AWS) + [Configurando o Amazon RDS como um PeopleSoft banco de dados Oracle (whitepaper](https://d1.awsstatic.com/whitepapers/configuring-amazon-rds-as-peoplesoft-database.pdf) da AWS) + [Guia do Oracle Data Guard Broker](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/index.html) (documentação de referência da Oracle) + [Conceitos e administração do Data Guard](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/index.html) (documentação de referência da Oracle) + [Requisitos específicos de configuração de FAN e FCF do Oracle Data Guard](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/using-data-guard-broker-to-manage-switchovers-failovers.html#GUID-DFFDAA2B-A889-49AD-AB85-747D73FF0FF5) (documentação de referência da Oracle) # Descarregamento de dados de um cluster do Amazon Redshift entre contas para o Amazon S3 *Andrew Kamel, Amazon Web Services* ## Resumo Ao testar aplicações, é útil ter dados de produção em seu ambiente de teste. O uso de dados de produção pode fornecer uma avaliação mais precisa da aplicação que você está desenvolvendo. Este padrão extrai dados de um cluster do Amazon Redshift em um ambiente de produção para um bucket do Amazon Simple Storage Service (Amazon S3) em um ambiente de desenvolvimento na Amazon Web Services (AWS). O padrão inclui a configuração de contas DEV e PROD, como o seguinte: + Recursos necessários + AWS Identity and Access Management Funções (IAM) + Ajustes de rede em sub-redes, grupos de segurança e na nuvem privada virtual (VPC) para oferecer suporte à conexão do Amazon Redshift + Um exemplo de AWS Lambda função com um tempo de execução em Python para testar a arquitetura Para conceder acesso ao cluster do Amazon Redshift, o padrão é usado AWS Secrets Manager para armazenar as credenciais relevantes. A vantagem é ter todas as informações necessárias para se conectar diretamente ao cluster do Amazon Redshift sem precisar saber onde o cluster do Amazon Redshift reside. Além disso, você pode [monitorar o uso do segredo](https://docs.aws.amazon.com/secretsmanager/latest/userguide/monitoring.html). O segredo salvo no Secrets Manager inclui o host, o nome do banco de dados, a porta e as credenciais relevantes do cluster do Amazon Redshift. Para obter informações sobre considerações de segurança ao usar esse padrão, consulte a seção [Práticas recomendadas](#unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3-best-practices). ## Pré-requisitos e limitações **Pré-requisitos ** + Um [cluster do Amazon Redshift em execução](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html) na conta PROD + Um [bucket do S3 criado](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) na conta DEV + [Emparelhamento de VPC](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html) entre as contas DEV e PROD, com [tabelas de rotas ajustadas](https://docs.aws.amazon.com/vpc/latest/peering/vpc-peering-routing.html) adequadamente + [Nomes de host DNS e resolução de DNS habilitados](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html) para ambos emparelhados VPCs **Limitações** + Dependendo da quantidade de dados que você deseja consultar, a função do Lambda pode atingir o tempo limite. Se sua execução demorar mais do que o tempo limite máximo do Lambda (15 minutos), use uma abordagem assíncrona para seu código do Lambda. O exemplo de código desse padrão usa a biblioteca [psycopg2](https://github.com/psycopg/psycopg2) para Python, que atualmente não oferece suporte ao processamento assíncrono. + Alguns Serviços da AWS não estão disponíveis em todos Regiões da AWS. Para conferir a disponibilidade de uma região, consulte [Serviços da AWS by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para endpoints específicos, consulte a página [Cotas e endpoints de serviços](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e clique no link correspondente ao serviço desejado. ## Arquitetura O diagrama a seguir mostra a arquitetura de destino, com contas DEV e PROD. ![\[A VPC do Lambda na conta DEV e a VPC do Amazon Redshift na conta PROD.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/fa4d01df-483d-4454-9711-b391ebbe4629.png) O diagrama mostra o seguinte fluxo de trabalho: 1. A função do Lambda na conta DEV assume o perfil do IAM necessário para acessar as credenciais do Amazon Redshift no Secrets Manager na conta PROD. Em seguida, a função do Lambda recupera o segredo do cluster do Amazon Redshift. 1. A função Lambda na conta DEV usa as informações para se conectar ao cluster Amazon Redshift na conta PROD por meio do peering. VPCs Em seguida, a função do Lambda envia um comando de descarregamento para consultar o cluster do Amazon Redshift na conta PROD. 1. O cluster do Amazon Redshift na conta PROD assume o perfil do IAM relevante para acessar o bucket do S3 na conta DEV. O cluster do Amazon Redshift descarrega os dados consultados no bucket do S3 na conta DEV. **Consultar dados do Amazon Redshift** O diagrama a seguir mostra as funções que são usadas para recuperar as credenciais do Amazon Redshift e conectar-se ao cluster do Amazon Redshift. O fluxo de trabalho é iniciado pela função do Lambda. ![\[O processo de três etapas para assumir perfis em todas as contas.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/ab25b72c-773c-4d58-9012-4a3755c181ff.png) O diagrama mostra o seguinte fluxo de trabalho: 1. O `CrossAccount-SM-Read-Role` na conta DEV assume o `SM-Read-Role` na conta PROD. 1. O perfil `SM-Read-Role` usa a política anexada para recuperar o segredo do Secrets Manager. 1. As credenciais são usadas para acessar o cluster do Amazon Redshift. **Carregar dados no Amazon S3** O diagrama a seguir mostra o processo de leitura e gravação entre contas para extrair dados e enviá-los para o Amazon S3. O fluxo de trabalho é iniciado pela função do Lambda. O padrão [encadeia perfis do IAM no Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html#authorizing-redshift-service-chaining-roles). O comando de descarregamento enviado pelo cluster do Amazon Redshift assume o `CrossAccount-S3-Write-Role` e, em seguida, assume o `S3-Write-Role`. Este encadeamento de perfis permite ao Amazon Redshift acessar o Amazon S3. ![\[Os perfis que recebem credenciais, acessam o Amazon Redshift e carregam dados no Amazon S3.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/d2982fc6-1d12-4f9d-9493-a99ce691d693.png) O fluxo de trabalho inclui as seguintes etapas: 1. O `CrossAccount-SM-Read-Role` na conta DEV assume o `SM-Read-Role` na conta PROD. 1. O `SM-Read-Role` recupera as credenciais do Amazon Redshift do Secrets Manager. 1. A função do Lambda se conecta ao cluster do Amazon Redshift e envia uma consulta. 1. O cluster do Amazon Redshift assume o `CrossAccount-S3-Write-Role`. 1. O `CrossAccount-S3-Write-Role` assume o `S3-Write-Role` na conta DEV. 1. Os resultados da consulta são descarregados no bucket do S3 na conta DEV. ## Ferramentas **Serviços da AWS** + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) ajuda você a criar e controlar chaves criptográficas para ajudar a proteger seus dados. + O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que ajuda a executar código sem exigir provisionamento ou gerenciamento de servidores. Ele executa o código somente quando necessário e dimensiona automaticamente, assim, você paga apenas pelo tempo de computação usado. + O [Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html) é um serviço de data warehouse em escala de petabytes gerenciado na Nuvem AWS. + O [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) ajuda a substituir credenciais codificadas, incluindo senhas, por uma chamada de API ao Secrets Manager para recuperar o segredo por programação. + O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objetos baseado na nuvem que ajuda você a armazenar, proteger e recuperar qualquer quantidade de dados. **Repositório de código** O código desse padrão está disponível no repositório GitHub [unload-redshift-to-s3-python](https://github.com/aws-samples/unload-redshift-to-s3-python/). ## Práticas recomendadas **Isenção de responsabilidade de segurança** Antes de implementar essa solução, considere as seguintes recomendações de segurança importantes: + Lembre-se de que conectar as contas de desenvolvimento e produção pode aumentar o escopo e reduzir a postura geral de segurança. Recomendamos implantar essa solução apenas temporariamente, extraindo a parte necessária dos dados e destruindo imediatamente os recursos implantados. Para destruir os recursos, você deve excluir a função do Lambda, remover todas as políticas e perfis do IAM criados para essa solução e revogar qualquer acesso à rede concedido entre as contas. + Consulte suas equipes de segurança e conformidade antes de copiar quaisquer dados dos ambientes de produção para os de desenvolvimento. Informações de identificação pessoal (PII), informações de saúde protegidas (PHI) e outros dados confidenciais ou regulamentados geralmente não devem ser copiados dessa maneira. Copie somente informações não confidenciais disponíveis publicamente (por exemplo, dados públicos do estoque do frontend de uma loja). Considere fazer a tokenização ou anonimização dos dados, ou gerar dados de teste sintéticos, em vez de usar dados de produção sempre que possível. Um dos [princípios de segurança da AWS](https://docs.aws.amazon.com/en_us/wellarchitected/2022-03-31/framework/sec-design.html) é manter as pessoas afastadas dos dados. Em outras palavras, os desenvolvedores não devem realizar operações na conta de produção. + Restrinja o acesso à função do Lambda na conta de desenvolvimento porque ela pode ler dados do cluster do Amazon Redshift no ambiente de produção. + Para evitar a interrupção do ambiente de produção, implemente as seguintes recomendações: + Use uma conta de desenvolvimento separada e dedicada para atividades de teste e desenvolvimento. + Implemente controles rígidos de acesso à rede e limite o tráfego entre contas somente ao necessário. + Monitore e audite o acesso ao ambiente de produção e às fontes de dados. + Implemente controles de acesso com privilégios mínimos para todos os recursos e serviços envolvidos. + Revise e alterne regularmente as credenciais, como AWS Secrets Manager segredos e chaves de acesso à função do IAM. + Consulte a seguinte documentação de segurança para saber mais sobre os serviços usados neste artigo: + [AWS Lambda segurança](https://docs.aws.amazon.com/lambda/latest/dg/lambda-security.html) + [Segurança do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/iam-redshift-user-mgmt.html) + [Segurança do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/security.html) + [AWS Secrets Manager segurança](https://docs.aws.amazon.com/secretsmanager/latest/userguide/security.html) + [Práticas recomendadas de segurança do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) A segurança é a maior prioridade ao acessar dados e recursos de produção. Sempre siga as práticas recomendadas, implemente controles de acesso com privilégios mínimos e revise e atualize regularmente suas medidas de segurança. ## Épicos ### Consultar dados do Amazon Redshift | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um segredo o cluster do Amazon Redshift. | Para criar o segredo do cluster do Amazon Redshift, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps engenheiro | | Crie um perfil para acessar o Secrets Manager. | Para criar o perfil, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps engenheiro | ### Carregar dados no Amazon S3 | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Crie um perfil para acessar o bucket do S3. | Para criar o perfil a fim de acessar o bucket do S3, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps engenheiro | | Crie o perfil do Amazon Redshift. | Para criar o perfil do Amazon Redshift, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps engenheiro | ### Implantar a função do Lambda | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Implante a função do Lambda. | Para implantar uma função do Lambda na VPC emparelhada, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps engenheiro | ### Testar a arquitetura | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Importe os recursos necessários. | Para importar os recursos necessários, execute os seguintes comandos:
(CONNECT_TIMEOUT= 120)(RETRY_COUNT=20)(RETRY_DELAY=3)(TRANSPORT_CONNECT_TIMEOUT=3)
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST=devpsftdb.******.us-west-2.rds.amazonaws.com)(PORT=1521))
(ADDRESS = (PROTOCOL = TCP)(HOST=psftread.******.us-west-2.rds.amazonaws.com)(PORT=1521))
)
(CONNECT_DATA=(SERVICE_NAME = orcl_rw))
)
ORCL_RO = (DESCRIPTION =
(CONNECT_TIMEOUT= 120)(RETRY_COUNT=20)(RETRY_DELAY=3)(TRANSPORT_CONNECT_TIMEOUT=3)
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST=devpsftdb.******.us-west-2.rds.amazonaws.com)(PORT=1521))
(ADDRESS = (PROTOCOL = TCP)(HOST=psftread.******.us-west-2.rds.amazonaws.com)(PORT=1521))
)
(CONNECT_DATA=(SERVICE_NAME = orcl_ro))
)
import ast| Desenvolvedor de aplicativos | | Execute a função de manipulador do Lambda. | A função Lambda usa AWS Security Token Service (AWS STS) para acesso entre contas e gerenciamento temporário de credenciais. A função usa a operação AssumeRole da API para assumir temporariamente as permissões da função `sm_read_role` do IAM.Para executar a função do Lambda, use o seguinte código de exemplo:
import boto3
import psycopg2
import base64
from botocore.exceptions import ClientError
def lambda_handler(event, context):| Desenvolvedor de aplicativos | | Obtenha o segredo. | Para obter o segredo do Amazon Redshift, use o seguinte código de exemplo:
sts_client = boto3.client('sts')
# Secrets Manager Configurations
secret_name = "redshift_creds"
sm_region = "eu-west-1"
sm_read_role = "arn:aws:iam::PROD_ACCOUNT_NUMBER:role/SM-Read-Role"
# S3 Bucket Configurations
s3_bucket_path = "s3://mybucket/"
s3_bucket_region = "eu-west-1"
s3_write_role = "arn:aws:iam::DEV_ACCOUNT_NUMBER:role/S3-Write-Role"
# Redshift Configurations
sql_query = "select * from category"
redshift_db = "dev"
redshift_s3_write_role = "arn:aws:iam::PROD_ACCOUNT_NUMBER:role/CrossAccount-S3-Write-Role"
chained_s3_write_role = "%s,%s" % (redshift_s3_write_role, s3_write_role)
assumed_role_object = sts_client.assume_role(
RoleArn=sm_read_role,
RoleSessionName="CrossAccountRoleAssumption",
ExternalId="YOUR_EXTERNAL_ID",
)
credentials = assumed_role_object['Credentials']
secret_dict = ast.literal_eval(get_secret(credentials, secret_name, sm_region))
execute_query(secret_dict, sql_query, s3_bucket_path, chained_s3_write_role, s3_bucket_region, redshift_db)
return {
'statusCode': 200
}
def get_secret(credentials, secret_name, sm_region):| Desenvolvedor de aplicativos | | Execute o comando de descarregamento. | Para descarregar os dados no bucket do S3, use o código de exemplo a seguir.
# Create a Secrets Manager client
session = boto3.session.Session()
sm_client = session.client(
service_name='secretsmanager',
aws_access_key_id=credentials['AccessKeyId'],
aws_secret_access_key=credentials['SecretAccessKey'],
aws_session_token=credentials['SessionToken'],
region_name=sm_region
)
try:
get_secret_value_response = sm_client.get_secret_value(
SecretId=secret_name
)
except ClientError as e:
print(e)
raise e
else:
if 'SecretString' in get_secret_value_response:
return get_secret_value_response['SecretString']
else:
return base64.b64decode(get_secret_value_response['SecretBinary'])
def execute_query(secret_dict, sql_query, s3_bucket_path, chained_s3_write_role, s3_bucket_region, redshift_db):| Desenvolvedor de aplicativos | ### Limpeza | Tarefa | Description | Habilidades necessárias | | --- | --- | --- | | Exclua a função do Lambda. | Para evitar custos não planejados, remova os recursos e a conexão entre as contas DEV e PROD.Para remover a função do Lambda, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps engenheiro | | Remova as políticas e os perfis do IAM. | Remova as políticas e os perfis do IAM das contas DEV e PROD.Na conta DEV, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html)Na conta PROD, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps engenheiro | | Exclua o segredo no Secrets Manager. | Para excluir o segredo, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps engenheiro | | Remova as regras de emparelhamento de VPC e de grupos de segurança. | Para remover as regras de emparelhamento de VPC e de grupos de segurança, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps engenheiro | | Remova os dados do bucket do S3. | Para remover os dados do Amazon S3, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps engenheiro | | Limpe AWS KMS as chaves. | Se você criou alguma AWS KMS chave personalizada para criptografia, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps engenheiro | | Revise e exclua CloudWatch os registros da Amazon. | Para excluir os CloudWatch registros, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps engenheiro | ## Recursos relacionados + [ CloudWatch Documentação da Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) + [Documentação do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) + [Documentação do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) + [Documentação do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html) + [Documentação do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) + [AWS Secrets Manager documentação](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) + [AWS princípios de segurança](https://docs.aws.amazon.com/en_us/wellarchitected/2022-03-31/framework/sec-design.html) ## Mais informações Depois de descarregar os dados do Amazon Redshift para o Amazon S3, você pode analisá-los usando o Amazon Athena. O [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/getting-started.html) é um serviço de consulta de big data que é útil quando você precisa acessar grandes volumes de dados. Você pode usar o Athena sem precisar provisionar servidores ou bancos de dados. O Athena oferece suporte a consultas complexas, e você pode executá-lo em objetos diferentes. Como acontece com a maioria Serviços da AWS, o principal benefício de usar o Athena é que ele oferece grande flexibilidade na forma como você executa consultas sem a complexidade adicional. Ao usar o Athena, você pode consultar diferentes tipos de dados, como CSV e JSON, no Amazon S3 sem alterar o tipo de dados. Você pode consultar dados de várias fontes, inclusive externas AWS. O Athena reduz a complexidade porque você não precisa gerenciar servidores. O Athena lê dados diretamente do Amazon S3, sem carregar ou alterar os dados antes de você executar a consulta. # Padrões de migração de base de dados por workload **Topics** + [IBM](databases-database-migration-patterns-by-workload-ibm-pattern-list.md) + [Microsoft](databases-database-migration-patterns-by-workload-microsoft-pattern-list.md) + [N/D](databases-database-migration-patterns-by-workload-notapplicable-pattern-list.md) + [Código aberto](databases-database-migration-patterns-by-workload-open-source-pattern-list.md) + [Oracle](databases-database-migration-patterns-by-workload-oracle-pattern-list.md) + [SAP](databases-database-migration-patterns-by-workload-sap-pattern-list.md) # IBM **Topics** + [Migre um banco de dados Db2 da Amazon para o EC2 Aurora MySQL compatível usando o AWS DMS](migrate-a-db2-database-from-amazon-ec2-to-aurora-mysql-compatible-by-using-aws-dms.md) + [Migre o Db2 for LUW para a Amazon EC2 usando o envio de registros para reduzir o tempo de interrupção](migrate-db2-for-luw-to-amazon-ec2-by-using-log-shipping-to-reduce-outage-time.md) + [Migre o Db2 for LUW para o Amazon EC2 com recuperação de desastres de alta disponibilidade](migrate-db2-for-luw-to-amazon-ec2-with-high-availability-disaster-recovery.md) + [Migre do IBM Db2 na Amazon para o EC2 Aurora compatível com PostgreSQL usando o AWS DMS e o AWS SCT](migrate-from-ibm-db2-on-amazon-ec2-to-aurora-postgresql-compatible-using-aws-dms-and-aws-sct.md) + [Migre do IBM WebSphere Application Server para o Apache Tomcat na Amazon EC2](migrate-from-ibm-websphere-application-server-to-apache-tomcat-on-amazon-ec2.md) + [Transmita dados do IBM Db2, SAP, Sybase e outros bancos de dados para o MongoDB Atlas em AWS](stream-data-from-ibm-db2-to-mongodb-atlas.md) # Microsoft **Topics** + [Aceleração da descoberta e da migração de workloads da Microsoft para a AWS](accelerate-the-discovery-and-migration-of-microsoft-workloads-to-aws.md) + [Acesse tabelas locais do Microsoft SQL Server a partir do Microsoft SQL Server na Amazon EC2 usando servidores vinculados](access-on-premises-microsoft-sql-server-tables-from-microsoft-sql-server-on-amazon-ec2-using-linked-servers.md) + [Avaliar o desempenho das consultas para migrar bancos de dados do SQL Server para o MongoDB Atlas na AWS](assess-query-performance-for-migrating-sql-server-databases-to-mongodb-atlas-on-aws.md) + [Automatize tarefas de banco de dados na edição SQL Server Express em execução na Amazon EC2 usando AWS Lambda um Agendador de Tarefas](automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.md) + [Altere os aplicativos Python e Perl para oferecer suporte à migração do banco de dados do Microsoft SQL Server para o Amazon Aurora Edição Compatível com PostgreSQL](change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.md) + [Configurar o roteamento somente leitura em um grupo de disponibilidade Always On (Sempre ativo) no SQL Server na AWS](configure-read-only-routing-in-an-always-on-availability-group-in-sql-server-on-aws.md) + [Configurar a autenticação do Windows para Amazon RDS para Microsoft SQL Server usando AWS Managed Microsoft AD](configure-windows-authentication-for-amazon-rds-using-microsoft-ad.md) + [Crie CloudFormation modelos da AWS para tarefas do AWS DMS usando Microsoft Excel e Python](create-aws-cloudformation-templates-for-aws-dms-tasks-using-microsoft-excel-and-python.md) + [Implante instâncias de cluster de failover do SQL Server na Amazon EC2 e na Amazon FSx usando o Terraform](deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.md) + [Exportar um banco de dados do Microsoft SQL Server para o Amazon S3 usando o AWS DMS](export-a-microsoft-sql-server-database-to-amazon-s3-by-using-aws-dms.md) + [Exporter tabelas do Amazon RDS para SQL Server para um bucket do S3 usando o AWS DMS](export-amazon-rds-for-sql-server-tables-to-an-s3-bucket-by-using-aws-dms.md) + [Implemente SHA1 o hashing para dados de PII ao migrar do SQL Server para o PostgreSQL](implement-sha1-hashing-for-pii-data-when-migrating-from-sql-server-to-postgresql.md) + [Ingira e migre instâncias EC2 do Windows para uma conta do AWS Managed Services](ingest-and-migrate-ec2-windows-instances-into-an-aws-managed-services-account.md) + [Configure um cluster de failover do Microsoft SQL Server na Amazon EC2 usando o FSx Windows File Server](microsoft-sql-failover-cluster-on-amazon-ec2.md) + [Migrar uma fila de mensagens do Microsoft Azure Service Bus para o Amazon SQS](migrate-a-messaging-queue-from-microsoft-azure-service-bus-to-amazon-sqs.md) + [Migre um banco de dados Microsoft SQL Server da Amazon EC2 para o Amazon DocumentDB usando o AWS DMS](migrate-a-microsoft-sql-server-database-from-amazon-ec2-to-amazon-documentdb-by-using-aws-dms.md) + [Migre um banco de dados Microsoft SQL Server para o Aurora MySQL usando o AWS DMS e o AWS SCT](migrate-a-microsoft-sql-server-database-to-aurora-mysql-by-using-aws-dms-and-aws-sct.md) + [Migre uma aplicação .NET do Microsoft Azure App Service para o AWS Elastic Beanstalk](migrate-a-net-application-from-microsoft-azure-app-service-to-aws-elastic-beanstalk.md) + [Migre um banco de dados local do Microsoft SQL Server para a Amazon EC2](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-ec2.md) + [Migrar um banco de dados Microsoft SQL Server on-premises para o Amazon RDS para SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server.md) + [Migrar um banco de dados Microsoft SQL Server on-premises para o Amazon RDS para SQL Server utilizando servidores vinculados](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-linked-servers.md) + [Saiba como migrar um banco de dados Microsoft SQL Server on-premises para o Amazon RDS para SQL Server utilizando backup e restauração nativos.](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-native-backup-and-restore-methods.md) + [Migrar um banco de dados Microsoft SQL Server on-premises para o Amazon Redshift utilizando o AWS DMS](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-dms.md) + [Migre um banco de dados Microsoft SQL Server on-premises para o Amazon Redshift usando agentes de extração de dados da AWS SCT](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.md) + [Migre um banco de dados local do Microsoft SQL Server para o Microsoft SQL Server na Amazon executando Linux EC2](migrate-an-on-premises-microsoft-sql-server-database-to-microsoft-sql-server-on-amazon-ec2-running-linux.md) + [Migre dados do Microsoft Azure Blob para o Amazon S3 usando o Rclone](migrate-data-from-microsoft-azure-blob-to-amazon-s3-by-using-rclone.md) + [Migre aplicativos hospedados no IIS para a Amazon EC2 usando o appcmd.exe](migrate-iis-hosted-applications-to-amazon-ec2-by-using-appcmd.md) + [Migre o grupo de disponibilidade Always On do Microsoft SQL Server usando AWS Application Migration Service](migrate-microsoft-sql-server-always-on-group-using-mgn.md) + [Migre um banco de dados local do Microsoft SQL Server para a Amazon EC2 usando o Application Migration Service](migrate-microsoft-sql-server-to-amazon-ec2-using-aws-mgn.md) + [Migre um banco de dados relacional para o MongoDB Atlas em AWS](migrate-relational-database-to-mongodb-atlas.md) + [Migre o SQL Server para a AWS usando grupos de disponibilidade distribuídos](migrate-sql-server-to-aws-using-distributed-availability-groups.md) + [Migrar certificados SSL do Windows para um Application Load Balancer usando o ACM](migrate-windows-ssl-certificates-to-an-application-load-balancer-using-acm.md) + [Redefinir a hospedagem de workloads on-premises na Nuvem AWS: lista de verificação de migração](rehost-on-premises-workloads-in-the-aws-cloud-migration-checklist.md) + [Resolva erros de conexão após migrar o Microsoft SQL Server para a Nuvem AWS](resolve-connection-errors-after-migrating-microsoft-sql-server-to-the-aws-cloud.md) + [Envie notificações para uma instância de banco de dados Amazon RDS para SQL Server usando um servidor SMTP on-premises e o Database Mail](send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.md) + [Configure um CI/CD pipeline para migração de banco de dados usando o Terraform](set-up-ci-cd-pipeline-for-db-migration-with-terraform.md) + [Configure a infraestrutura Multi-AZ para um SQL Server Always On FCI usando a Amazon FSx](set-up-multi-az-infrastructure-for-a-sql-server-always-on-fci-by-using-amazon-fsx.md) # N/D **Topics** + [Crie um processo de aprovação para solicitações de firewall durante uma migração de rehospedagem para AWS](create-an-approval-process-for-firewall-requests-during-a-rehost-migration-to-aws.md) + [Criptografe uma instância de banco de dados Amazon RDS para PostgreSQL existente](encrypt-an-existing-amazon-rds-for-postgresql-db-instance.md) + [Estime os custos de armazenamento de uma tabela do Amazon DynamoDB](estimate-storage-costs-for-an-amazon-dynamodb-table.md) + [Implemente a recuperação de desastres entre regiões com o AWS DMS e o Amazon Aurora](implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.md) # Código aberto **Topics** + [Geração automática de um modelo do PynamoDB e funções de CRUD para o Amazon DynamoDB por meio de uma aplicação do Python](automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.md) + [Conecte-se usando um túnel SSH no pgAdmin](connect-by-using-an-ssh-tunnel-in-pgadmin.md) + [Crie usuários e funções do aplicativo no Aurora compatível com PostgreSQL](create-application-users-and-roles-in-aurora-postgresql-compatible.md) + [Habilite conexões criptografadas para instâncias de banco de dados PostgreSQL no Amazon RDS](enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.md) + [Migre o Amazon RDS for Oracle para o Amazon AWS SCT RDS for PostgreSQL com e usando e AWS DMS AWS CLI CloudFormation](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-with-aws-sct-and-aws-dms-using-aws-cli-and-aws-cloudformation.md) + [Migre um banco de dados MariaDB on-premises para o Amazon RDS para MariaDB usando ferramentas nativas](migrate-an-on-premises-mariadb-database-to-amazon-rds-for-mariadb-using-native-tools.md) + [Migre um banco de dados MySQL on-premises para o Amazon EC2](migrate-an-on-premises-mysql-database-to-amazon-ec2.md) + [Migrar um banco de dados MySQL on-premises para o Amazon RDS para MySQL](migrate-an-on-premises-mysql-database-to-amazon-rds-for-mysql.md) + [Migrar um banco de dados MySQL on-premises para o Aurora MySQL](migrate-an-on-premises-mysql-database-to-aurora-mysql.md) + [Migrar um banco de dados PostgreSQL on-premises para o Aurora PostgreSQL](migrate-an-on-premises-postgresql-database-to-aurora-postgresql.md) + [Migrar um banco de dados do Couchbase Server para a Amazon EC2](migrate-couchbase-server-ec2.md) + [Migre do IBM WebSphere Application Server para o Apache Tomcat na Amazon EC2 com o Auto Scaling](migrate-from-ibm-websphere-application-server-to-apache-tomcat-on-amazon-ec2-with-auto-scaling.md) + [Migre do Oracle 8i ou 9i para o Amazon RDS for Oracle usando o AWS DMS SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.md) + [Migre do PostgreSQL na Amazon para o EC2 Amazon RDS for PostgreSQL usando pglogical](migrate-from-postgresql-on-amazon-ec2-to-amazon-rds-for-postgresql-using-pglogical.md) + [Migrar aplicações Java on-premises para a AWS usando o App2Container da AWS](migrate-on-premises-java-applications-to-aws-using-aws-app2container.md) + [Migre bancos de dados MySQL locais para o Aurora MySQL usando XtraBackup Percona, Amazon EFS e Amazon S3](migrate-on-premises-mysql-databases-to-aurora-mysql-using-percona-xtrabackup-amazon-efs-and-amazon-s3.md) + [Migre tabelas externas da Oracle para a compatibilidade com o Amazon Aurora PostgreSQL](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md) + [Migre funções e procedimentos do Oracle que tenham mais de 100 argumentos para o PostgreSQL](migrate-oracle-functions-and-procedures-that-have-more-than-100-arguments-to-postgresql.md) + [Migre cargas de trabalho do Redis para o Redis Enterprise Cloud na AWS](migrate-redis-workloads-to-redis-enterprise-cloud-on-aws.md) + [Monitore o Amazon Aurora em busca de instâncias sem criptografia](monitor-amazon-aurora-for-instances-without-encryption.md) + [Reinicie o AWS Replication Agent automaticamente sem desativá-lo SELinux após a reinicialização de um servidor de origem RHEL](restart-the-aws-replication-agent-automatically-without-disabling-selinux-after-rebooting-a-rhel-source-server.md) + [Agendar trabalhos para o Amazon RDS para PostgreSQL e Aurora PostgreSQL usando o Lambda e o Secrets Manager](schedule-jobs-for-amazon-rds-for-postgresql-and-aurora-postgresql-by-using-lambda-and-secrets-manager.md) + [Transporte bancos de dados PostgreSQL entre duas instâncias de banco de dados Amazon RDS usando pg\$1transport](transport-postgresql-databases-between-two-amazon-rds-db-instances-using-pg-transport.md) + [Descarregamento de dados de um cluster do Amazon Redshift entre contas para o Amazon S3](unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.md) # Oracle **Topics** + [Adicione HA ao Oracle PeopleSoft no Amazon RDS Custom usando uma réplica de leitura](add-ha-to-oracle-peoplesoft-on-amazon-rds-custom-by-using-a-read-replica.md) + [Converta consultas JSON Oracle em SQL do banco de dados PostgreSQL](convert-json-oracle-queries-into-postgresql-database-sql.md) + [Converter VARCHAR2 (1) tipo de dados para Oracle para tipo de dados booleano para Amazon Aurora PostgreSQL](convert-varchar2-1-data-type-for-oracle-to-boolean-data-type-for-amazon-aurora-postgresql.md) + [Emule o Oracle DR usando um banco de dados global Aurora compatível com PostgreSQL](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md) + [Emule matrizes PL/SQL associativas Oracle no Amazon Aurora PostgreSQL e no Amazon RDS for PostgreSQL](emulate-oracle-plsql-associative-arrays-in-aurora-and-rds-postgresql.md) + [Estime o tamanho do mecanismo Amazon RDS para um banco de dados Oracle usando relatórios AWR](estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.md) + [Manipule blocos anônimos em instruções de SQL dinâmico no Aurora PostgreSQL](handle-anonymous-blocks-in-dynamic-sql-statements-in-aurora-postgresql.md) + [Migre incrementalmente do Amazon RDS para Oracle para o Amazon RDS para PostgreSQL usando o Oracle SQL Developer e o AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md) + [Faça o upload de arquivos BLOB em TEXT usando a codificação de arquivos no Aurora PostgreSQL-Compatible](load-blob-files-into-text-by-using-file-encoding-in-aurora-postgresql-compatible.md) + [Migre o Amazon RDS para Oracle para o Amazon RDS para PostgreSQL no modo SSL usando o AWS DMS](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-in-ssl-mode-by-using-aws-dms.md) + [Migre um banco de dados Amazon RDS for Oracle para Conta da AWS outro Região da AWS e AWS DMS use-o para replicação contínua](migrate-an-amazon-rds-for-oracle-database-to-another-aws-account-and-aws-region-using-aws-dms-for-ongoing-replication.md) + [Migre um banco de dados Oracle local para a Amazon EC2 usando o Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-ec2-by-using-oracle-data-pump.md) + [Migre um banco de dados Oracle local para o Amazon OpenSearch Service usando o Logstash](migrate-an-on-premises-oracle-database-to-amazon-opensearch-service-using-logstash.md) + [Migre um banco de dados Oracle on-premises para o Amazon RDS para MySQL, usando o AWS DMS e o AWS SCT.](migrate-an-on-premises-oracle-database-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migrar um banco de dados Oracle on-premises para o Amazon RDS para Oracle](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle.md) + [Migrar um banco de dados Oracle on-premises para o Amazon RDS para Oracle usando o Oracle Data Pump Import direto em um link de banco de dados](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-by-using-direct-oracle-data-pump-import-over-a-database-link.md) + [Migrar um banco de dados Oracle on-premises para o Amazon RDS para Oracle usando o Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-using-oracle-data-pump.md) + [Migrar um banco de dados Oracle on-premises para o Amazon RDS para PostgreSQL usando um Oracle bystander e o AWS DMS](migrate-an-on-premises-oracle-database-to-amazon-rds-for-postgresql-by-using-an-oracle-bystander-and-aws-dms.md) + [Migre um banco de dados Oracle local para o Oracle na Amazon EC2](migrate-an-on-premises-oracle-database-to-oracle-on-amazon-ec2.md) + [Migre um banco de dados Oracle da Amazon EC2 para o Amazon RDS for MariaDB usando o AWS DMS e o AWS SCT](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-mariadb-using-aws-dms-and-aws-sct.md) + [Migre um banco de dados Oracle da Amazon EC2 para o Amazon RDS for Oracle usando o AWS DMS](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-oracle-using-aws-dms.md) + [Migrar um banco de dados Oracle para o Amazon DynamoDB usando AWS DMS](migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.md) + [Migre um banco de dados Oracle para o Amazon RDS for Oracle usando adaptadores de arquivo simples GoldenGate Oracle](migrate-an-oracle-database-to-amazon-rds-for-oracle-by-using-oracle-goldengate-flat-file-adapters.md) + [Migre um banco de dados Oracle para o Amazon Redshift usando o AWS DMS e o AWS SCT](migrate-an-oracle-database-to-amazon-redshift-using-aws-dms-and-aws-sct.md) + [Migrar um banco de dados Oracle para o Aurora PostgreSQL usando AWS DMS e AWS SCT](migrate-an-oracle-database-to-aurora-postgresql-using-aws-dms-and-aws-sct.md) + [Migre um banco de dados Oracle JD Edwards EnterpriseOne para a AWS usando o Oracle Data Pump e o AWS DMS](migrate-an-oracle-jd-edwards-enterpriseone-database-to-aws-by-using-oracle-data-pump-and-aws-dms.md) + [Migre uma tabela particionada do Oracle para o PostgreSQL usando o AWS DMS](migrate-an-oracle-partitioned-table-to-postgresql-by-using-aws-dms.md) + [Migre um PeopleSoft banco de dados Oracle para a AWS usando o AWS DMS](migrate-an-oracle-peoplesoft-database-to-aws-by-using-aws-dms.md) + [Migrar dados de um banco de dados Oracle on-premises para o Aurora PostgreSQL](migrate-data-from-an-on-premises-oracle-database-to-aurora-postgresql.md) + [Migre do Amazon RDS para Oracle para o Amazon RDS para MySQL](migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-mysql.md) + [Migre do Oracle 8i ou 9i para o Amazon RDS para PostgreSQL usando visões materializadas e o AWS DMS](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-materialized-views-and-aws-dms.md) + [Migre do Oracle 8i ou 9i para o Amazon RDS for PostgreSQL usando o AWS DMS SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-shareplex-and-aws-dms.md) + [Migre do banco de dados Oracle para o Amazon RDS for PostgreSQL usando o Oracle GoldenGate](migrate-from-oracle-database-to-amazon-rds-for-postgresql-by-using-oracle-goldengate.md) + [Migre da Oracle no Amazon EC2 para o Amazon RDS para MySQL usando o AWS DMS e o AWS SCT](migrate-from-oracle-on-amazon-ec2-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migre do Oracle WebLogic para o Apache Tomcat (TomEE) no Amazon ECS](migrate-from-oracle-weblogic-to-apache-tomcat-tomee-on-amazon-ecs.md) + [Migre índices baseados em funções do Oracle para o PostgreSQL](migrate-function-based-indexes-from-oracle-to-postgresql.md) + [Migre aplicativos legados do Oracle Pro\$1C para o ECPG](migrate-legacy-applications-from-oracle-pro-c-to-ecpg.md) + [Migrar valores do Oracle CLOB para linhas individuais no PostgreSQL na AWS](migrate-oracle-clob-values-to-individual-rows-in-postgresql-on-aws.md) + [Migre códigos de erro do banco de dados Oracle para um banco de dados compatível com Amazon Aurora PostgreSQL](migrate-oracle-database-error-codes-to-an-amazon-aurora-postgresql-compatible-database.md) + [Migre funções nativas do Oracle para o PostgreSQL usando extensões](migrate-oracle-native-functions-to-postgresql-using-extensions.md) + [Migre o Oracle PeopleSoft para o Amazon RDS Custom](migrate-oracle-peoplesoft-to-amazon-rds-custom.md) + [Migre a funcionalidade Oracle ROWID para o PostgreSQL na AWS](migrate-oracle-rowid-functionality-to-postgresql-on-aws.md) + [Migrar os pacotes de pragma Oracle SERIALLY\$1REUSABLE para o PostgreSQL](migrate-oracle-serially-reusable-pragma-packages-into-postgresql.md) + [Migre colunas geradas virtualmente do Oracle para o PostgreSQL](migrate-virtual-generated-columns-from-oracle-to-postgresql.md) + [Monitore GoldenGate os logs do Oracle usando a Amazon CloudWatch](monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.md) + [Análise das dependências de objetos em migrações parciais de banco de dados da Oracle para o PostgreSQL](multilevel-object-analysis-for-database-migration-from-oracle-to-postgresql.md) + [Redefinir a plataforma do Oracle Database Enterprise Edition para o Standard Edition 2 no Amazon RDS para Oracle](replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.md) + [Configure uma HA/DR arquitetura para o Oracle E-Business Suite no Amazon RDS Custom com um banco de dados ativo em espera](set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database.md) + [Configure a funcionalidade Oracle UTL\$1FILE no Aurora compatível com PostgreSQL](set-up-oracle-utl_file-functionality-on-aurora-postgresql-compatible.md) + [Funções de transição para um PeopleSoft aplicativo Oracle no Amazon RDS Custom for Oracle](transition-roles-for-an-oracle-peoplesoft-application-on-amazon-rds-custom-for-oracle.md) + [Valide objetos de banco de dados após migrar do Oracle para o Amazon Aurora PostgreSQL](validate-database-objects-after-migrating-from-oracle-to-amazon-aurora-postgresql.md) # SAP **Topics** + [Faça backup automático dos bancos de dados SAP HANA usando o Systems Manager e EventBridge](automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.md) + [Migre do SAP ASE para o Amazon RDS para SQL Server usando o AWS DMS](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md) + [Migre o SAP ASE na Amazon EC2 para o Amazon Aurora compatível com PostgreSQL usando o AWS SCT e o AWS DMS](migrate-sap-ase-on-amazon-ec2-to-amazon-aurora-postgresql-compatible-using-aws-sct-and-aws-dms.md) + [Migre o SAP HANA para a AWS usando o SAP HSR com o mesmo nome de host](migrate-sap-hana-to-aws-using-sap-hsr-with-the-same-hostname.md) + [Configure a recuperação de desastres para SAP no IBM Db2 na AWS](set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.md) # Mais padrões **Topics** + [Acesse um banco de dados Amazon Neptune a partir de um contêiner Amazon EKS](access-amazon-neptune-database-from-amazon-eks-container.md) + [Acesse, consulte e una tabelas do Amazon DynamoDB usando o Athena](access-query-and-join-amazon-dynamodb-tables-using-athena.md) + [Permitir que EC2 as instâncias gravem acesso aos buckets do S3 nas contas do AMS](allow-ec2-instances-write-access-to-s3-buckets-in-ams-accounts.md) + [Analise e visualize dados JSON aninhados com o Amazon Athena e o Amazon Quick Sight](analyze-and-visualize-nested-json-data-with-amazon-athena-and-amazon-quicksight.md) + [Automatize backups para instâncias de banco de dados do Amazon RDS para PostgreSQL usando o AWS Batch](automate-backups-for-amazon-rds-for-postgresql-db-instances-by-using-aws-batch.md) + [Arquivar automaticamente itens no Amazon S3 usando o DynamoDB TTL](automatically-archive-items-to-amazon-s3-using-dynamodb-ttl.md) + [Corrija automaticamente instâncias e clusters de banco de dados Amazon RDS não criptografados](automatically-remediate-unencrypted-amazon-rds-db-instances-and-clusters.md) + [Pare e inicie automaticamente uma instância de banco de dados Amazon RDS usando o Windows AWS Systems Manager de manutenção](automatically-stop-and-start-an-amazon-rds-db-instance-using-aws-systems-manager-maintenance-windows.md) + [Crie uma AWS landing zone que inclua o MongoDB Atlas](build-aws-landing-zone-that-includes-mongodb-atlas.md) + [Crie programas COBOL Db2 usando e AWS Mainframe Modernization AWS CodeBuild](build-cobol-db2-programs-mainframe-modernization-codebuild.md) + [Crie uma malha de dados corporativa com a Amazon DataZone, AWS CDK, e AWS CloudFormation](build-enterprise-data-mesh-amazon-data-zone.md) + [Altere os aplicativos Python e Perl para oferecer suporte à migração do banco de dados do Microsoft SQL Server para o Amazon Aurora Edição Compatível com PostgreSQL](change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.md) + [Converta e descompacte dados EBCDIC em ASCII na AWS usando Python](convert-and-unpack-ebcdic-data-to-ascii-on-aws-by-using-python.md) + [Converta o atributo temporal Teradata NORMALIZE em Amazon Redshift SQL](convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql.md) + [Converter o atributo Teradata RESET WHEN para Amazon Redshift SQL](convert-the-teradata-reset-when-feature-to-amazon-redshift-sql.md) + [Converter VARCHAR2 (1) tipo de dados para Oracle para tipo de dados booleano para Amazon Aurora PostgreSQL](convert-varchar2-1-data-type-for-oracle-to-boolean-data-type-for-amazon-aurora-postgresql.md) + [Crie usuários e funções do aplicativo no Aurora compatível com PostgreSQL](create-application-users-and-roles-in-aurora-postgresql-compatible.md) + [Crie CloudFormation modelos da AWS para tarefas do AWS DMS usando Microsoft Excel e Python](create-aws-cloudformation-templates-for-aws-dms-tasks-using-microsoft-excel-and-python.md) + [Entregue registros do DynamoDB para o Amazon S3 usando o Kinesis Data Streams e o Firehose com AWS CDK](deliver-dynamodb-records-to-amazon-s3-using-kinesis-data-streams-and-amazon-data-firehose-with-aws-cdk.md) + [Implemente um cluster Cassandra na Amazon EC2 com estática privada IPs para evitar o reequilíbrio](deploy-a-cassandra-cluster-on-amazon-ec2-with-private-static-ips-to-avoid-rebalancing.md) + [Implemente um cluster CockroachDB no Amazon EKS usando o Terraform](deploy-cockroachdb-on-eks-using-terraform.md) + [Desenvolva assistentes avançados baseados em bate-papo com IA generativa usando RAG e prompting ReAct](develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.md) + [Emule o Oracle DR usando um banco de dados global Aurora compatível com PostgreSQL](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md) + [Habilite o arquivamento de DB2 logs diretamente no Amazon S3 em um banco de dados IBM Db2](enable-db2-logarchive-directly-to-amazon-s3-in-ibm-db2-database.md) + [Suporte para criptografia de dados transparente no Amazon RDS para SQL Server](enable-transparent-data-encryption-in-amazon-rds-for-sql-server.md) + [Exportar um banco de dados do Microsoft SQL Server para o Amazon S3 usando o AWS DMS](export-a-microsoft-sql-server-database-to-amazon-s3-by-using-aws-dms.md) + [Implemente SHA1 o hashing para dados de PII ao migrar do SQL Server para o PostgreSQL](implement-sha1-hashing-for-pii-data-when-migrating-from-sql-server-to-postgresql.md) + [Migre incrementalmente do Amazon RDS para Oracle para o Amazon RDS para PostgreSQL usando o Oracle SQL Developer e o AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md) + [Faça o upload de arquivos BLOB em TEXT usando a codificação de arquivos no Aurora PostgreSQL-Compatible](load-blob-files-into-text-by-using-file-encoding-in-aurora-postgresql-compatible.md) + [Gerenciar credenciais usando o AWS Secrets Manager](manage-credentials-using-aws-secrets-manager.md) + [Migre um banco de dados Db2 da Amazon para o EC2 Aurora MySQL compatível usando o AWS DMS](migrate-a-db2-database-from-amazon-ec2-to-aurora-mysql-compatible-by-using-aws-dms.md) + [Migre um banco de dados Microsoft SQL Server da Amazon EC2 para o Amazon DocumentDB usando o AWS DMS](migrate-a-microsoft-sql-server-database-from-amazon-ec2-to-amazon-documentdb-by-using-aws-dms.md) + [Migre um banco de dados Microsoft SQL Server para o Aurora MySQL usando o AWS DMS e o AWS SCT](migrate-a-microsoft-sql-server-database-to-aurora-mysql-by-using-aws-dms-and-aws-sct.md) + [Migre o Amazon RDS para Oracle para o Amazon RDS para PostgreSQL no modo SSL usando o AWS DMS](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-in-ssl-mode-by-using-aws-dms.md) + [Migre o Amazon RDS for Oracle para o Amazon AWS SCT RDS for PostgreSQL com e usando e AWS DMS AWS CLI CloudFormation](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-with-aws-sct-and-aws-dms-using-aws-cli-and-aws-cloudformation.md) + [Migrar uma instância do banco de dados Amazon RDS para outra VPC ou outra conta](migrate-an-amazon-rds-db-instance-to-another-vpc-or-account.md) + [Migre um banco de dados Amazon RDS for Oracle para Conta da AWS outro Região da AWS e AWS DMS use-o para replicação contínua](migrate-an-amazon-rds-for-oracle-database-to-another-aws-account-and-aws-region-using-aws-dms-for-ongoing-replication.md) + [Migre um cluster do Amazon Redshift para uma região da AWS na China](migrate-an-amazon-redshift-cluster-to-an-aws-region-in-china.md) + [Migre um banco de dados MariaDB on-premises para o Amazon RDS para MariaDB usando ferramentas nativas](migrate-an-on-premises-mariadb-database-to-amazon-rds-for-mariadb-using-native-tools.md) + [Migre um banco de dados local do Microsoft SQL Server para a Amazon EC2](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-ec2.md) + [Migrar um banco de dados Microsoft SQL Server on-premises para o Amazon RDS para SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server.md) + [Migrar um banco de dados Microsoft SQL Server on-premises para o Amazon RDS para SQL Server utilizando servidores vinculados](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-linked-servers.md) + [Saiba como migrar um banco de dados Microsoft SQL Server on-premises para o Amazon RDS para SQL Server utilizando backup e restauração nativos.](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-native-backup-and-restore-methods.md) + [Migrar um banco de dados Microsoft SQL Server on-premises para o Amazon Redshift utilizando o AWS DMS](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-dms.md) + [Migre um banco de dados Microsoft SQL Server on-premises para o Amazon Redshift usando agentes de extração de dados da AWS SCT](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.md) + [Migre um banco de dados local do Microsoft SQL Server para o Microsoft SQL Server na Amazon executando Linux EC2](migrate-an-on-premises-microsoft-sql-server-database-to-microsoft-sql-server-on-amazon-ec2-running-linux.md) + [Migrar um banco de dados MySQL on-premises para o Amazon RDS para MySQL](migrate-an-on-premises-mysql-database-to-amazon-rds-for-mysql.md) + [Migrar um banco de dados MySQL on-premises para o Aurora MySQL](migrate-an-on-premises-mysql-database-to-aurora-mysql.md) + [Migre um banco de dados Oracle local para a Amazon EC2 usando o Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-ec2-by-using-oracle-data-pump.md) + [Migre um banco de dados Oracle local para o Amazon OpenSearch Service usando o Logstash](migrate-an-on-premises-oracle-database-to-amazon-opensearch-service-using-logstash.md) + [Migre um banco de dados Oracle on-premises para o Amazon RDS para MySQL, usando o AWS DMS e o AWS SCT.](migrate-an-on-premises-oracle-database-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migrar um banco de dados Oracle on-premises para o Amazon RDS para Oracle](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle.md) + [Migrar um banco de dados Oracle on-premises para o Amazon RDS para Oracle usando o Oracle Data Pump Import direto em um link de banco de dados](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-by-using-direct-oracle-data-pump-import-over-a-database-link.md) + [Migrar um banco de dados Oracle on-premises para o Amazon RDS para Oracle usando o Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-using-oracle-data-pump.md) + [Migrar um banco de dados Oracle on-premises para o Amazon RDS para PostgreSQL usando um Oracle bystander e o AWS DMS](migrate-an-on-premises-oracle-database-to-amazon-rds-for-postgresql-by-using-an-oracle-bystander-and-aws-dms.md) + [Migre um banco de dados Oracle local para o Oracle na Amazon EC2](migrate-an-on-premises-oracle-database-to-oracle-on-amazon-ec2.md) + [Migrar um banco de dados PostgreSQL on-premises para o Aurora PostgreSQL](migrate-an-on-premises-postgresql-database-to-aurora-postgresql.md) + [Migre um banco de dados ThoughtSpot Falcon local para o Amazon Redshift](migrate-an-on-premises-thoughtspot-falcon-database-to-amazon-redshift.md) + [Migre um banco de dados Oracle da Amazon EC2 para o Amazon RDS for MariaDB usando o AWS DMS e o AWS SCT](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-mariadb-using-aws-dms-and-aws-sct.md) + [Migre um banco de dados Oracle da Amazon EC2 para o Amazon RDS for Oracle usando o AWS DMS](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-oracle-using-aws-dms.md) + [Migre um banco de dados Oracle para o Amazon RDS for Oracle usando adaptadores de arquivo simples GoldenGate Oracle](migrate-an-oracle-database-to-amazon-rds-for-oracle-by-using-oracle-goldengate-flat-file-adapters.md) + [Migre um banco de dados Oracle para o Amazon Redshift usando o AWS DMS e o AWS SCT](migrate-an-oracle-database-to-amazon-redshift-using-aws-dms-and-aws-sct.md) + [Migrar um banco de dados Oracle para o Aurora PostgreSQL usando AWS DMS e AWS SCT](migrate-an-oracle-database-to-aurora-postgresql-using-aws-dms-and-aws-sct.md) + [Migre um banco de dados Oracle JD Edwards EnterpriseOne para a AWS usando o Oracle Data Pump e o AWS DMS](migrate-an-oracle-jd-edwards-enterpriseone-database-to-aws-by-using-oracle-data-pump-and-aws-dms.md) + [Migre uma tabela particionada do Oracle para o PostgreSQL usando o AWS DMS](migrate-an-oracle-partitioned-table-to-postgresql-by-using-aws-dms.md) + [Migre um PeopleSoft banco de dados Oracle para a AWS usando o AWS DMS](migrate-an-oracle-peoplesoft-database-to-aws-by-using-aws-dms.md) + [Migrar um banco de dados do Couchbase Server para a Amazon EC2](migrate-couchbase-server-ec2.md) + [Migrar dados de um banco de dados Oracle on-premises para o Aurora PostgreSQL](migrate-data-from-an-on-premises-oracle-database-to-aurora-postgresql.md) + [Migre dados para o Nuvem AWS usando o Starburst](migrate-data-to-the-aws-cloud-by-using-starburst.md) + [Migre o Db2 for LUW para a Amazon EC2 usando o envio de registros para reduzir o tempo de interrupção](migrate-db2-for-luw-to-amazon-ec2-by-using-log-shipping-to-reduce-outage-time.md) + [Migre o Db2 for LUW para o Amazon EC2 com recuperação de desastres de alta disponibilidade](migrate-db2-for-luw-to-amazon-ec2-with-high-availability-disaster-recovery.md) + [Migre do Amazon RDS para Oracle para o Amazon RDS para MySQL](migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-mysql.md) + [Migre do Couchbase Server para o Couchbase Capella na AWS](migrate-from-couchbase-server-to-couchbase-capella-on-aws.md) + [Migre do IBM Db2 na Amazon para o EC2 Aurora compatível com PostgreSQL usando o AWS DMS e o AWS SCT](migrate-from-ibm-db2-on-amazon-ec2-to-aurora-postgresql-compatible-using-aws-dms-and-aws-sct.md) + [Migre do Oracle 8i ou 9i para o Amazon RDS para PostgreSQL usando visões materializadas e o AWS DMS](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-materialized-views-and-aws-dms.md) + [Migre do Oracle 8i ou 9i para o Amazon RDS for PostgreSQL usando o AWS DMS SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-shareplex-and-aws-dms.md) + [Migre do banco de dados Oracle para o Amazon RDS for PostgreSQL usando o Oracle GoldenGate](migrate-from-oracle-database-to-amazon-rds-for-postgresql-by-using-oracle-goldengate.md) + [Migre da Oracle no Amazon EC2 para o Amazon RDS para MySQL usando o AWS DMS e o AWS SCT](migrate-from-oracle-on-amazon-ec2-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migre do PostgreSQL na Amazon para o EC2 Amazon RDS for PostgreSQL usando pglogical](migrate-from-postgresql-on-amazon-ec2-to-amazon-rds-for-postgresql-using-pglogical.md) + [Migre do SAP ASE para o Amazon RDS para SQL Server usando o AWS DMS](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md) + [Migre índices baseados em funções do Oracle para o PostgreSQL](migrate-function-based-indexes-from-oracle-to-postgresql.md) + [Migre aplicativos legados do Oracle Pro\$1C para o ECPG](migrate-legacy-applications-from-oracle-pro-c-to-ecpg.md) + [Migre um banco de dados local do Microsoft SQL Server para a Amazon EC2 usando o Application Migration Service](migrate-microsoft-sql-server-to-amazon-ec2-using-aws-mgn.md) + [Migre workloads on-premises da Cloudera para a Cloudera Data Platform na AWS](migrate-on-premises-cloudera-workloads-to-cloudera-data-platform-on-aws.md) + [Migre bancos de dados MySQL locais para o Aurora MySQL usando XtraBackup Percona, Amazon EFS e Amazon S3](migrate-on-premises-mysql-databases-to-aurora-mysql-using-percona-xtrabackup-amazon-efs-and-amazon-s3.md) + [Migrar o Oracle Business Intelligence 12c para a Nuvem AWS a partir de servidores on-premises](migrate-oracle-business-intelligence-12c-to-the-aws-cloud-from-on-premises-servers.md) + [Migrar valores do Oracle CLOB para linhas individuais no PostgreSQL na AWS](migrate-oracle-clob-values-to-individual-rows-in-postgresql-on-aws.md) + [Migre códigos de erro do banco de dados Oracle para um banco de dados compatível com Amazon Aurora PostgreSQL](migrate-oracle-database-error-codes-to-an-amazon-aurora-postgresql-compatible-database.md) + [Migre tabelas externas da Oracle para a compatibilidade com o Amazon Aurora PostgreSQL](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md) + [Migre funções nativas do Oracle para o PostgreSQL usando extensões](migrate-oracle-native-functions-to-postgresql-using-extensions.md) + [Migre o Oracle PeopleSoft para o Amazon RDS Custom](migrate-oracle-peoplesoft-to-amazon-rds-custom.md) + [Migre a funcionalidade Oracle ROWID para o PostgreSQL na AWS](migrate-oracle-rowid-functionality-to-postgresql-on-aws.md) + [Migrar os pacotes de pragma Oracle SERIALLY\$1REUSABLE para o PostgreSQL](migrate-oracle-serially-reusable-pragma-packages-into-postgresql.md) + [Migre o SAP ASE na Amazon EC2 para o Amazon Aurora compatível com PostgreSQL usando o AWS SCT e o AWS DMS](migrate-sap-ase-on-amazon-ec2-to-amazon-aurora-postgresql-compatible-using-aws-sct-and-aws-dms.md) + [Migre colunas geradas virtualmente do Oracle para o PostgreSQL](migrate-virtual-generated-columns-from-oracle-to-postgresql.md) + [Configuração de um espaço de dados mínimo viável para compartilhar dados entre organizações](minimum-viable-data-space-share-data-organizations.md) + [Monitore ElastiCache clusters da Amazon para criptografia em repouso](monitor-amazon-elasticache-clusters-for-at-rest-encryption.md) + [Consulte tabelas do Amazon DynamoDB com SQL usando o Amazon Athena](query-amazon-dynamodb-tables-sql-amazon-athena.md) + [Proteja e simplifique o acesso de usuários em um banco de dados de federação Db2 na AWS usando contextos confiáveis](secure-and-streamline-user-access-in-a-db2-federation-database-on-aws-by-using-trusted-contexts.md) + [Configure uma PeopleSoft arquitetura altamente disponível na AWS](set-up-a-highly-available-peoplesoft-architecture-on-aws.md) + [Configure a funcionalidade Oracle UTL\$1FILE no Aurora compatível com PostgreSQL](set-up-oracle-utl_file-functionality-on-aurora-postgresql-compatible.md) + [Implantações simplificadas do PostgreSQL no Amazon EKS usando o PGO](streamline-postgresql-deployments-amazon-eks-pgo.md) + [Transfira z/OS dados do Db2 em grande escala para o Amazon S3 em arquivos CSV](transfer-large-scale-db2-z-os-data-to-amazon-s3-in-csv-files.md) + [Transporte bancos de dados PostgreSQL entre duas instâncias de banco de dados Amazon RDS usando pg\$1transport](transport-postgresql-databases-between-two-amazon-rds-db-instances-using-pg-transport.md) + [Valide objetos de banco de dados após migrar do Oracle para o Amazon Aurora PostgreSQL](validate-database-objects-after-migrating-from-oracle-to-amazon-aurora-postgresql.md)
conn_string = "dbname='%s' port='%s' user='%s' password='%s' host='%s'" \
% (redshift_db,
secret_dict["port"],
secret_dict["username"],
secret_dict["password"],
secret_dict["host"])
con = psycopg2.connect(conn_string)
unload_command = "UNLOAD ('{}') TO '{}' IAM_ROLE '{}' DELIMITER '|' REGION '{}';" \
.format(sql_query,
s3_bucket_path + str(datetime.datetime.now()) + ".csv",
chained_s3_write_role,
s3_bucket_region)
# Opening a cursor and run query
cur = con.cursor()
cur.execute(unload_command)
print(cur.fetchone())
cur.close()
con.close()