$ 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| Administrador de base de datos | | Cambie la configuración de transporte de registros conectándose a DGMGRL desde el nodo principal. | Cambie el modo de transporte de registros a `FastSync`, correspondiente a la configuración redo transport `SYNC+NOAFFIRM`. Para asegurarse de que tiene una configuración válida después del cambio de rol, cámbiela tanto para la base de datos principal como para la base de datos en espera.**No 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;| Administrador de base de datos | | Cambie el modo de protección a MaxAvailability. | Cambie el modo de protección a `MaxAvailability` mediante una conexión a `DGMGRL` desde el nodo principal.**No 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| Administrador de base de datos | ### Cambie el estado de la réplica de montada a de solo lectura y habilite redo apply. | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Detenga redo apply para la base de datos en espera. | La réplica de lectura se crea en modo `MOUNT` de forma predeterminada. Para abrirla en modo de solo lectura, primero debe desactivar redo apply conectándose a `DGMGRL` desde el nodo principal o en espera.**No 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| Administrador de base de datos | | Abra la instancia de réplica de lectura en modo de solo lectura. | Conéctese a la base de datos en espera mediante la entrada TNS y ábrala en modo de solo lectura conectándose a ella desde el nodo principal o en espera.**No 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| Administrador de base de datos | | Active redo apply en la instancia de réplica de lectura. | Active redo apply en la instancia de réplica de lectura mediante `DGMGR` L desde el nodo principal o en espera.**No 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| Administrador de base de datos | ## Recursos relacionados + [Configuración de Amazon RDS como una PeopleSoft base de datos de Oracle](https://d1.awsstatic.com/whitepapers/configuring-amazon-rds-as-peoplesoft-database.pdf) (documento técnico de AWS) + [Guía de agente de Oracle Data Guard](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/index.html) (documentación de referencia de Oracle) + [Oracle Data Guard Concepts and Administration](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/index.html)(documentación de referencia de Oracle) ## Información adicional **Seleccionar el modo de protección de su base de datos** Oracle Data Guard ofrece tres modos de protección para configurar su entorno de Data Guard en función de sus requisitos de disponibilidad, protección y rendimiento. Estos tres modos se resumen en la tabla siguiente: | | | Modo de protección | Configuración redo transport | Description (Descripción) | | --- |--- |--- | | ***MÁXIMO RENDIMIENTO*** | `ASYNC` | En el caso de las transacciones que se realizan en la base de datos principal, los datos de redo se transmiten de forma asíncrona y se escriben en el redo log de la base de datos en espera. Por lo tanto, el impacto en el rendimiento es mínimo.`MaxPerformance` no puede proporcionar RPO=0 debido al envío asincrónico de registros. | | ***MÁXIMA PROTECCIÓN*** | `SYNC+AFFIRM` | En el caso de las transacciones de la base de datos principal, los datos de redo se transmiten de forma sincrónica y se escriben en el disco de la base de datos en espera redo log antes de que se confirme la transacción. Si la base de datos en espera deja de estar disponible, la base de datos principal se cierra automáticamente para garantizar la protección de las transacciones. | | ***MÁXIMA DISPONIBILIDAD*** | `SYNC+AFFIRM` | Es similar al modo `MaxProtection`, excepto cuando no se recibe ningún acuse de recibo de la base de datos en espera. En ese caso, funciona como si estuviera en modo `MaxPerformance` para preservar la disponibilidad de la base de datos principal hasta que pueda volver a escribir su redo stream en una base de datos en espera sincronizada. | | `SYNC+NOAFFIRM` | En el caso de las transacciones de la base de datos principal, el redo se transmite de forma sincrónica a la base de datos en espera, y la principal solo espera una confirmación de acuse de recibo del redo en la base de datos en espera, no a que se haya escrito en el disco en espera. Este modo, también conocido como `FastSync`, puede proporcionar una ventaja en el rendimiento a costa de la posible exposición a la pérdida de datos en un caso especial de varios fallos simultáneos. | Las réplicas de lectura en RDS Custom para Oracle se crean con el modo de protección del máximo rendimiento, que también es el modo de protección predeterminado de Oracle Data Guard. El modo de rendimiento máximo proporciona el menor impacto en el rendimiento de la base de datos principal, lo que puede ayudarle a cumplir el requisito del objetivo de punto de recuperación (RPO) medido en segundos. Para lograr el objetivo de cero pérdidas de datos (RPO=0), puede personalizar el modo de protección de Oracle Data Guard a `MaxAvailability` con la configuración `SYNC+NOAFFIRM` redo transport para mejorar el rendimiento. Como las confirmaciones en la base de datos principal solo se reconocen después de que los vectores redo correspondientes se hayan transmitido correctamente a la base de datos en espera, la latencia de la red entre la instancia principal y la réplica puede ser crucial para las cargas de trabajo sensibles a las confirmaciones. Recomendamos realizar pruebas de carga de la carga de trabajo para evaluar el impacto en el rendimiento cuando la réplica de lectura esté personalizada para ejecutarse en modo `MaxAvailability`. La implementación de la réplica de lectura en la misma zona de disponibilidad que la base de datos principal proporciona una latencia de red más baja en comparación con la implementación de la réplica de lectura en una zona de disponibilidad diferente. Sin embargo, es posible que implementar las réplicas principal y de lectura en la misma zona de disponibilidad no cumpla con los requisitos de alta disponibilidad porque, en el improbable caso de que la zona de disponibilidad no esté disponible, tanto la instancia principal como la instancia de réplica de lectura se ven afectadas. # Análisis de las dependencias de los objetos para realizar migraciones parciales de bases de datos de Oracle a PostgreSQL *anuradha chintha, Amazon Web Services* ## Resumen Este patrón describe la importancia de identificar y administrar de forma sistemática las dependencias del sistema al migrar una base de datos de Oracle a Amazon Relational Database Service (Amazon RDS) o Amazon Aurora PostgreSQL. En una migración parcial, solo se migra un subconjunto de objetos de base de datos y datos de la base de datos original, mientras que la base de datos de origen sigue funcionando y sirviendo a aplicaciones que dependen de componentes no migrados Debe identificar y analizar el alcance de la migración cuando gestione bases de datos a gran escala que tengan aplicaciones con acoplamiento ajustado con dependencias en las fases anteriores y posteriores. Para iniciar una migración parcial, identifique los objetos que están en el alcance, incluidas las tablas, los desencadenadores, las vistas, los procedimientos almacenados, las funciones y los paquetes. El proceso de identificación del alcance sigue un enfoque integral: + Los objetos que están en el alcance de primer nivel se identifican mediante referencias directas en el código de la aplicación y en los trabajos críticos específicos de los módulos. + Los objetos de segundo nivel se obtienen mediante un análisis de dependencia exhaustivo. Cuando comprenda cómo interactúan las diferentes partes del sistema, podrá planificar mejor el orden correcto para mover los componentes de la base de datos y reducir el riesgo de que se produzcan errores en la migración. En la siguiente tabla se enumeran los distintos tipos de análisis de las dependencias. | | | Tipo de análisis | Áreas de interés | Finalidad | | --- |--- |--- | | Dependencias de objetos | TablasVistasProcedimientos almacenadosFuncionesDesencadenadores | Identifica las relaciones entre los objetos de la base de datos y sus estructuras jerárquicas | | Dependencias de segmentos | Relaciones de claves externasRelaciones de claves principalesReferencias entre esquemas | Mapea las relaciones de los datos y mantiene la integridad de las referencias | | Dependencias de seguridad | Permisos de usuarioJerarquías de rolesPrivilegios de objeto | Garantiza el control de acceso, la migración y el mantenimiento de la seguridad adecuados | | Patrones de acceso | Operaciones de lecturaOperaciones de escritura | Determina los patrones de interacción de las bases de datos | Para mantener la coherencia entre los sistemas de origen y destino, establezca mecanismos de sincronización de datos durante el periodo de transición. También debe modificar el código y las funciones de la aplicación para gestionar la distribución de datos en las bases de datos de Oracle de origen y las bases de datos de PostgreSQL de destino. ## Requisitos previos y limitaciones **Requisitos previos ** + Un activo Cuenta de AWS + Una base de datos de Oracle (origen) + Una base de datos de Amazon RDS o Amazon Aurora PostgreSQL (destino) **Versiones de producto** + Oracle 19c o posterior + PostgreSQL 16 o posterior ## Arquitectura **Pila de tecnología de origen** + Oracle 19c o posterior **Pila de tecnología de destino** + Amazon RDS o Amazon Aurora PostgreSQL **Arquitectura de destino** En el siguiente diagrama se muestra el proceso de migración de una base de datos de Oracle en las instalaciones a Amazon RDS para Oracle, que incluye lo siguiente: + Identificación de las dependencias de la base de datos + Migración del código y los objetos de la base de datos mediante AWS Schema Conversion Tool ()AWS SCT + Migración de datos mediante AWS Database Migration Service ()AWS DMS + Replicar los cambios en curso mediante la captura de datos sobre cambios (CDC) mediante AWS DMS Para obtener más información, consulte [Integración AWS Database Migration Service con AWS Schema Conversion Tool](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_DMSIntegration.html) en la AWS documentación. ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/90160825-3199-4382-95a8-ad63139c5c89/images/b09c36a4-27fa-412e-877e-57a31bcce0dc.png) ## Tools (Herramientas) **Servicios de AWS** + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) para Oracle lo ayuda a configurar, utilizar y escalar una base de datos relacional de Oracle en la Nube de AWS. + Amazon Aurora es un motor de base de datos relacional completamente administrado diseñado para la nube y compatible con MySQL y PostgreSQL. + AWS Schema Conversion Tool (AWS SCT) admite migraciones de bases de datos heterogéneas al convertir automáticamente el esquema de la base de datos de origen y la mayoría del código personalizado a un formato compatible con la base de datos de destino. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) le ayuda a migrar los almacenes de datos a una combinación de configuraciones locales y en la nube Nube de AWS o entre ellas. **Otros servicios** + [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) es un entorno de desarrollo integrado que simplifica el desarrollo y la administración de bases de datos de Oracle, tanto en implementaciones tradicionales como en implementaciones basadas en la nube. Para este patrón, puede usar [SQL\$1Plus](https://docs.oracle.com/cd/B19306_01/server.102/b14357/qstart.htm). ## Prácticas recomendadas Para ver prácticas recomendadas sobre el aprovisionamiento y migración de bases de datos de 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). ## Epics ### Identificación de las dependencias de objetos | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una tabla de objetos. | Identifique los objetos que son esenciales para la funcionalidad de la aplicación y cree una tabla con el nombre `DEPENDENT_ANALYSIS_BASELINE`. Agregue registros para cada objeto a la tabla. Para obtener ejemplos, consulte la sección *Información adicional*. | Ingeniero de datos, Administrador de base de datos | | Cree un procedimiento de la base de datos | Cree un procedimiento almacenado llamado `sp_object_dependency_analysis` para analizar las dependencias de los objetos en ambas direcciones (hacia adelante y hacia atrás) mediante los datos de la tabla `DBA_DEPENDENCIES`. Para obtener ejemplos, consulte la sección *Información adicional*. | Ingeniero de datos, Administrador de base de datos | | Ejecute el procedimiento. | Ejecute los scripts en cada nivel sucesivo hasta que no se encuentren nuevas dependencias entre objetos. Todas las dependencias y niveles se almacenan en la tabla `DEPENDENT_ANALYSIS_BASELINE`. | Administrador de base de datos, ingeniero de datos | ### Creación de un procedimiento para las dependencias a nivel de segmento | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una tabla de dependencias. | Cree una tabla de dependencias a nivel de segmento denominada `REFERENTIAL_ANALYSIS_BASELINE`. Cuando se detecten todas las dependencias a nivel de objeto, compruebe las tablas principales de `DEPENDENT_ANALYSIS_BASELINE` consultando la tabla `DBA_CONSTRAINT`.Excluya las dependencias en las que otras tablas hacen referencia a las tablas de referencia. La reposición gestiona estas relaciones. A continuación se muestra un ejemplo de script:
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| Ingeniero de datos, Administrador de base de datos | | Cree un procedimiento de la base de datos | Cree un procedimiento denominado `SP_OBJECT_REFERENTIAL_ANALYSIS` y genere un análisis referencial para todos los objetos identificados. Para obtener ejemplos, consulte la sección *Información adicional*. | Ingeniero de datos, Administrador de base de datos | | Ejecute el procedimiento. | Ejecute el procedimiento para obtener las dependencias referenciales. Genere detalles del objeto de análisis referencial en `REFERENTIAL_ANALYSIS_BASELINE`. | Ingeniero de datos, Administrador de base de datos | ### Identificación de objetos que leen y escriben | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree tablas para los objetos de lectura y escritura. | Utilice el siguiente script para crear una tabla de objetos de lectura denominada `TABLE_READ_OBJECT_DETAILS` y una tabla de objetos de escritura denominada `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| Ingeniero de datos, Administrador de base de datos | | Cree un procedimiento para el análisis. | Cree los procedimientos `SP_READER_OBJECTS_ANALYSIS` y `SP_WRITER_OBJECTS_ANALYSIS` para analizar los objetos de lectura y escritura, respectivamente. Estos procedimientos utilizan la coincidencia de patrones para buscar objetos relacionados. Para ver un ejemplo, consulte la sección *Información adicional*. | Ingeniero de datos, Administrador de base de datos | | Ejecute los procedimientos. | Ejecute estos procedimientos para identificar los objetos dependientes. | Administrador de base de datos, ingeniero de datos | ### Revisión de privilegios de base de datos | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una tabla para revisar los privilegios. | Cree una tabla para analizar los privilegios denominada `OBJECT_PRIVS_ANALYSIS`. Para capturar de forma recursiva los privilegios de los objetos de la tabla `DEPENDENT_ANALYSIS_BASELINE`, utilice el siguiente 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| Ingeniero de datos, Administrador de base de datos | | Cree un procedimiento para revisar los privilegios. | Cree un procedimiento denominado `SP_OBJECT_PRIVS_ANALYSIS`. Genere un análisis de privilegios para los objetos identificados. Para obtener ejemplos, consulte la sección *Información adicional*. | Administrador de base de datos, ingeniero de datos | | Ejecute el procedimiento. | Ejecute el procedimiento para capturarlos en la tabla `OBJECT_PRIVS_ANALYSIS`. | Administrador de base de datos, ingeniero de datos | ## Resolución de problemas | Problema | Solución | | --- | --- | | No se puede acceder a las tablas del diccionario | Asegúrese de que el usuario que creó los objetos de análisis pueda acceder a las tablas de DBA. | ## Recursos relacionados **Documentación de AWS** + [Documentación de Amazon RDS y 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) + [¿Qué es? 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/) **Otra documentación** + [Oracle database objects](https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Database-Objects.html) ## Información adicional **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)); ``` **Procedimientos 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; ``` **Procedimientos 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; ``` # Evaluar el rendimiento de las consultas para migrar bases de datos de SQL Server a MongoDB Atlas en AWS *Battulga Purevragchaa, Amazon Web Services* *Krishnakumar Sathyanarayana PeerIslands , US Inc* *Babu Srinivasan, MongoDB* ## Resumen Este patrón proporciona una guía para cargar MongoDB con datos casi reales y evaluar el rendimiento de las consultas de MongoDB que sea lo más parecido posible al escenario de producción. La evaluación proporciona información para ayudar a planificar la migración a MongoDB desde una base de datos relacional. El patrón utiliza el [generador de datos de prueba y el analizador PeerIslands de rendimiento para probar](https://tools.peerislands.io/) el rendimiento de las consultas. Este patrón es particularmente útil para la migración de Microsoft SQL Server a MongoDB, ya que realizar transformaciones de esquemas y cargar datos de las instancias actuales de SQL Server a MongoDB puede resultar muy complejo. En lugar de esto, puede cargar datos prácticamente reales en MongoDB, conocer el rendimiento de MongoDB y ajustar el diseño del esquema antes de iniciar la migración propiamente dicha. ## Requisitos previos y limitaciones **Requisitos previos ** + Una cuenta de AWS activa + Familiaridad con [MongoDB Atlas](https://www.mongodb.com/docs/atlas/getting-started/) + Esquema de MongoDB de destino + Patrones típicos de consulta **Limitaciones** + Los tiempos de carga de datos y el rendimiento estarán limitados por el tamaño de la instancia del clúster de MongoDB. Se recomienda seleccionar instancias que estén recomendadas para uso en producción a fin de comprender el rendimiento en el mundo real. + PeerIslands Actualmente, Test Data Generator y Performance Analyzer solo admiten consultas y cargas de datos en línea. Aún no se admite el procesamiento por lotes sin conexión (por ejemplo, cargar datos en MongoDB mediante conectores Spark). + PeerIslands El generador de datos de prueba y el analizador de rendimiento admiten las relaciones de campo dentro de una colección. No admite relaciones entre colecciones. **Ediciones de producto** + Este patrón es compatible con [MongoDB Atlas](https://www.mongodb.com/atlas) y [MongoDB Enterprise Advanced](https://www.mongodb.com/products/mongodb-enterprise-advanced). ## Arquitectura **Pila de tecnología de destino** + MongoDB Atlas o MongoDB Enterprise Advanced **Arquitectura** ![\[Arquitectura para evaluar el rendimiento de las consultas para migrar bases de datos de SQL Server a MongoDB Atlas en AWS\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/25f0ab73-d587-4bd0-9fc0-ac675d5aa349/images/717caae4-d52e-4c78-bb7d-2ecb5acccd42.png) PeerIslands El generador de datos de prueba y el analizador de rendimiento se crean con Java y Angular, y almacenan los datos generados en Amazon Elastic Block Store (Amazon EBS). La herramienta consta de dos flujos de trabajo: la generación de datos de prueba y las pruebas de rendimiento. + En la generación de datos de prueba, se crea una plantilla, que es la representación en JSON del modelo de datos que se debe generar. Después de crear la plantilla, se pueden generar los datos en una colección de destino, tal y como se define en la configuración de generación de carga. + En las pruebas de rendimiento, se crea un perfil. Un perfil es un escenario de prueba en varias etapas en el que se pueden configurar las operaciones de creación, lectura, actualización y eliminación (CRUD), los procesos de agregación, la ponderación de cada operación y la duración de cada etapa. Tras crear el perfil, puede realizar pruebas de rendimiento en la base de datos de destino, en función de la configuración. PeerIslands El generador de datos de prueba y el analizador de rendimiento almacenan sus datos en Amazon EBS, por lo que puede conectar Amazon EBS a MongoDB mediante cualquier mecanismo de conexión compatible con MongoDB, incluidos el emparejamiento, las listas de permisos y los puntos de enlace privados. De forma predeterminada, la herramienta no incluye componentes operativos; sin embargo, se puede configurar con Amazon Managed Service for Prometheus, Amazon Managed Grafana CloudWatch, Amazon y AWS Secrets Manager si es necesario. ## Tools (Herramientas) + PeerIslands El [generador de datos de prueba y el analizador de rendimiento incluyen dos componentes](https://tools.peerislands.io/). El componente generador de datos de prueba ayuda a generar datos del mundo real altamente específicos del cliente, basados en el esquema de MongoDB. La herramienta está totalmente basada en la interfaz de usuario, con una rica biblioteca de datos, y se puede utilizar para generar rápidamente miles de millones de registros en MongoDB. La herramienta también proporciona capacidades para implementar relaciones entre campos en el esquema de MongoDB. El componente analizador del rendimiento ayuda a generar consultas y agregaciones altamente específicas para el cliente y a realizar pruebas de rendimiento realistas en MongoDB. Se puede usar el analizador de rendimiento para probar el rendimiento de MongoDB con perfiles de carga enriquecidos y consultas parametrizadas para un caso de uso específico. ## Prácticas recomendadas Consulte los siguientes recursos: + [MongoDB Schema Design Best Practices](https://www.mongodb.com/developer/products/mongodb/mongodb-schema-design-best-practices/) (Prácticas recomendadas de diseño de esquemas de MongoDB) (sitio web para desarrolladores de MongoDB) + [Best Practices of Deploying MongoDB Atlas on AWS](https://www.mongodb.com/presentation/best-practices-of-deploying-mongodb-atlas-on-aws) (Prácticas recomendadas para implementar MongoDB Atlas en AWS) (sitio web de MongoDB) + [Conexión segura de aplicaciones a un plano de datos de MongoDB Atlas con AWS PrivateLink](https://aws.amazon.com/blogs/apn/connecting-applications-securely-to-a-mongodb-atlas-data-plane-with-aws-privatelink/) (entrada del blog de AWS) + [Best Practices Guide for MongoDB Performance](https://www.mongodb.com/basics/best-practices) (Guía de prácticas recomendadas para el rendimiento de MongoDB) (sitio web de MongoDB) ## Epics ### Comprender los datos de origen | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Conozca el tamaño de la base de datos de origen actual de SQL Server. | Conozca su huella actual de SQL Server. Para este fin, se pueden ejecutar consultas en el esquema `INFORMATION` de la base de datos. Determine el número de tablas y el tamaño de cada tabla. Analice el índice asociado a cada tabla. Para obtener más información sobre el análisis de SQL, consulte la entrada del blog [SQL2Mongo: Data Migration Journey](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) en el sitio web. PeerIslands | Administrador de base de datos | | Comprenda el esquema de origen. | Determine el esquema de la tabla y la representación empresarial de los datos (por ejemplo, códigos postales, nombres y moneda). Utilice el diagrama de relaciones entre entidades (ER) existente o genere el diagrama ER a partir de la base de datos existente. Para obtener más información, consulte la entrada del blog [SQL2Mongo: Data Migration Journey](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) en el PeerIslands sitio web. | Administrador de base de datos | | Comprenda los patrones de consulta. | Documente las 10 consultas SQL principales que utiliza. Puede utilizar las tablas **performance\$1schema.events\$1statements\$1summary\$1by\$1digest**, disponibles en la base de datos, para comprender las consultas principales. Para obtener más información, consulte la entrada del blog [SQL2Mongo: Data Migration Journey](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) en el PeerIslands sitio web. | Administrador de base de datos | | Comprenda los compromisos de SLA. | Documente los acuerdos de nivel de servicio (SLAs) previstos para las operaciones de bases de datos. Las medidas habituales incluyen la latencia de las consultas y las consultas por segundo. Las medidas y sus objetivos suelen estar disponibles en los documentos de requisitos no funcionales (NFR). | Administrador de base de datos | ### Definir el esquema de MongoDB | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Defina el esquema de origen. | Defina varias opciones para el esquema de MongoDB de destino. Para obtener más información, consulte [Schemas](https://www.mongodb.com/docs/atlas/app-services/schemas/) (Esquemas) en la documentación de MongoDB Atlas. Tenga en cuenta las prácticas recomendables y los patrones de diseño basados en las relaciones de las tablas. | Ingeniero de MongoDB | | Defina los patrones de consulta de destino. | Defina las consultas de MongoDB y las canalizaciones de agregación. Estas consultas equivalen a las consultas principales que capturó para su carga de trabajo de SQL Server. Para saber cómo construir canalizaciones de agregación de MongoDB, consulte la [documentación de MongoDB](https://www.mongodb.com/docs/manual/core/aggregation-pipeline/). | Ingeniero de MongoDB | | Defina el tipo de instancia de MongoDB. | Determine el tamaño de la instancia que planea utilizar para las pruebas. Para obtener orientación, consulte la [documentación de MongoDB](https://www.mongodb.com/docs/atlas/sizing-tier-selection/). | Ingeniero de MongoDB | ### Prepare la base de datos de destino | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Configure el clúster de MongoDB Atlas. | Para configurar un clúster de MongoDB en AWS, siga las instrucciones de la [documentación de MongoDB.](https://www.mongodb.com/docs/atlas/tutorial/create-new-cluster/) | Ingeniero de MongoDB | | Cree usuarios en la base de datos de destino. | Configure el clúster de MongoDB Atlas para el acceso y la seguridad de la red siguiendo las instrucciones de la [documentación de MongoDB.](https://www.mongodb.com/docs/atlas/connect-to-database-deployment/) | Ingeniero de MongoDB | | Cree los roles adecuados en AWS y configure el control de acceso basado en roles para Atlas. | Si es necesario, configure usuarios adicionales siguiendo las instrucciones de la [documentación de MongoDB](https://www.mongodb.com/docs/atlas/security/set-up-unified-aws-access/). Configure [la autenticación y la autorización](https://www.mongodb.com/docs/atlas/security/config-db-auth/) mediante los roles de AWS. | Ingeniero de MongoDB | | Configure Compass para el acceso a MongoDB Atlas. | Configure el programa de utilidad [GUI MongoDB Compass](https://www.mongodb.com/products/compass) para facilitar la navegación y el acceso. | Ingeniero de MongoDB | ### Configurar la carga base mediante el generador de datos de prueba | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Instale el generador de datos de prueba. | Instale [PeerIsland Test Data Generator](https://github.com/PeerIslands/loadgen_binary) en su entorno. | Ingeniero de MongoDB | | Configure el generador de datos de prueba para generar los datos adecuados. | Cree una plantilla mediante la biblioteca de datos para generar datos específicos para cada campo del esquema de MongoDB. Para obtener más información, consulte [MongoDB Data Generator & Perf. Video del analizador](https://vimeo.com/570068857). | Ingeniero de MongoDB | | Generador de datos de prueba con escala horizontal para generar la carga requerida. | Utilice la plantilla que creó para iniciar la generación de cargas con respecto a la colección de destino; para ello, configure el paralelismo requerido. Determine los plazos y la escala para generar los datos necesarios. | Ingeniero de MongoDB | | Valide la carga en MongoDB Atlas. | Compruebe los datos cargados en MongoDB Atlas. | Ingeniero de MongoDB | | Genere los índices necesarios en MongoDB. | Defina los índices según sea necesario, en función de los patrones de consulta. Para conocer las prácticas recomendadas, consulte la [documentación de MongoDB](https://www.mongodb.com/docs/manual/applications/indexes/). | Ingeniero de MongoDB | ### Llevar a cabo pruebas de rendimiento | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Configure los perfiles de carga en Performance Analyzer. | Cree un perfil de pruebas de rendimiento en Performance Analyzer; para ello, configure consultas específicas y sus correspondientes ponderación, duración de la prueba y etapas. Para obtener más información, consulte [MongoDB Data Generator & Perf. Video del analizador](https://vimeo.com/570068857). | Ingeniero de MongoDB | | Ejecute las pruebas de rendimiento. | Utilice el perfil de prueba de rendimiento que creó para iniciar la prueba con respecto a la colección de destino; para ello, configure el paralelismo requerido. Escale horizontalmente la herramienta de prueba de rendimiento para ejecutar consultas en MongoDB Atlas. | Ingeniero de MongoDB | | Registre los resultados de la prueba. | Registre la latencia P95 y P99 para las consultas. | Ingeniero de MongoDB | | Ajuste su esquema y sus patrones de consulta. | Modifique los índices y los patrones de consulta para solucionar cualquier problema de rendimiento. | Ingeniero de MongoDB | ### Cerrar el proyecto | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cerrar los recursos temporales de AWS. | Elimine todos los recursos temporales que utilizó para el generador de datos de prueba y el analizador de rendimiento. | Administrador de AWS | | Actualice los resultados de las pruebas de rendimiento. | Comprenda el rendimiento de las consultas de MongoDB y compárelo con el suyo. SLAs Si es necesario, ajuste el esquema de MongoDB y vuelva a ejecutar el proceso. | Ingeniero de MongoDB | | Finalice el proyecto. | Cerrar el proyecto y enviar comentarios. | Ingeniero de MongoDB | ## Recursos relacionados + GitHub [repositorio: S3toAtlas](https://github.com/mongodb-partners/S3toAtlas) + Esquema: [MongoDB Schema design](https://www.mongodb.com/developer/products/mongodb/mongodb-schema-design-best-practices/) (Diseño de esquema de MongoDB) + Canalizaciones de agregación: [MongoDB aggregation pipelines](https://www.mongodb.com/docs/manual/core/aggregation-pipeline/) (Canalizaciones de agregación de MongoDB) + Dimensionamiento de MongoDB Atlas: [Sizing tier selection](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) (Selección de capa de dimensionamiento) + Video: [MongoDB Data Generator](https://vimeo.com/570068857) & Perf. Analizador + Referencias: [documentación de MongoDB](https://www.mongodb.com/docs/) + Tutorialws:** **[MongoDB developer guide, ](https://www.mongodb.com/docs/develop-applications/)[MongoDB Jumpstart](https://www.youtube.com/playlist?list=PL4RCxklHWZ9v2lcat4oEVGQhZg6r4IQGV) + AWS Marketplace:** **[MongoDB Atlas en AWS Marketplace](https://aws.amazon.com/marketplace/seller-profile?id=c9032c7b-70dd-459f-834f-c1e23cf3d092) + Soluciones de socios de AWS: ** **[MongoDB Atlas on AWS Reference Deployment](https://aws.amazon.com/quickstart/architecture/mongodb-atlas/) (Implementación de referencia de MongoDB Atlas en AWS) Recursos adicionales: + [Análisis de SQL](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) + [MongoDB Developer Community forums](https://www.mongodb.com/community/forums/) (Foros de la comunidad de desarrolladores de MongoDB) + [MongoDB Performance Tuning Questions](https://www.mongodb.com/developer/products/mongodb/performance-tuning-tips/) (Preguntas sobre el ajuste del rendimiento de MongoDB) + [Operational Analytics with Atlas and Redshift](https://github.com/mongodb-partners/Atlas_to_Redshift) (Análisis operativo con Atlas y Redshift) + [Application modernization with MongoDB Atlas and AWS Elastic Beanstalk](https://github.com/mongodb-partners/MEANStack_with_Atlas_on_AWS_EB) (Modernización de aplicaciones con MongoDB Atlas y AWS Elastic Beanstalk) # Automatice blue/green las implementaciones de las bases de datos globales de Amazon Aurora mediante los principios de la IaC *Ishwar Chauthaiwale, ANKIT JAIN y Ramu Jagini, Amazon Web Services* ## Resumen La administración de las actualizaciones de bases de datos, las migraciones o los esfuerzos de escalado puede resultar difícil para las organizaciones que ejecutan cargas de trabajo críticas en [bases de datos globales de Amazon Aurora](https://aws.amazon.com/rds/aurora/global-database/). Garantizar que estas operaciones se lleven a cabo de forma fluida y sin tiempo de inactividad es esencial para mantener la disponibilidad del servicio y evitar interrupciones para los usuarios. Una estrategia de blue/green implementación ofrece una solución a este desafío, ya que le permite ejecutar dos entornos idénticos de forma simultánea: azul (el entorno actual) y verde (el nuevo entorno). Una blue/green estrategia le permite implementar cambios, realizar pruebas y cambiar el tráfico entre entornos con un riesgo y un tiempo de inactividad mínimos. Este patrón le ayuda a automatizar el proceso de blue/green implementación de las bases de datos globales de Aurora mediante el uso de los principios de la infraestructura como código (IaC). Utiliza [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)Amazon Route 53 y [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) para simplificar blue/green las implementaciones. [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) Para mejorar la confiabilidad, utiliza identificadores de transacciones globales (GTIDs) para la replicación. La replicación basada en GTID proporciona una mejor coherencia de datos y funcionalidades de conmutación por error entre entornos en comparación con la replicación de registros binarios (binlog). **nota** Este patrón presupone que usa un clúster de base de datos global de la edición de Aurora compatible con MySQL. Si en su lugar utiliza una edición de Aurora compatible con PostgreSQL, utilice los equivalentes en PostgreSQL de los comandos de MySQL. Si sigue los pasos que se describen en este patrón, puede hacer lo siguiente: + Aprovisionar una base de datos global de Aurora verde: mediante CloudFormation plantillas, se crea un entorno verde que refleja el entorno azul existente. + Configurar la replicación basada en GTID: configure la replicación de GTID para mantener sincronizados los entornos azul y verde. + Cambie el tráfico sin problemas: utilice Route 53 y Lambda para cambiar automáticamente el tráfico del entorno azul al verde tras completar la sincronización. + Finalice la implementación: valide que el entorno ecológico esté en pleno funcionamiento como base de datos principal y, a continuación, detenga la replicación y elimine los recursos temporales. El enfoque de este patrón proporciona las siguientes ventajas: + Reduce el tiempo de inactividad durante las actualizaciones o migraciones críticas de las bases de datos: la automatización garantiza una transición fluida entre entornos con una interrupción mínima del servicio. + Permite reversiones rápidas: si surge un problema después de cambiar el tráfico al entorno verde, puede volver rápidamente al entorno azul y mantener la continuidad del servicio. + Mejora las pruebas y la verificación: el entorno verde se puede probar por completo sin afectar al entorno azul activo, lo que reduce la probabilidad de que surjan errores en producción. + Garantiza la coherencia de datos: la replicación basada en GTID mantiene sincronizados los entornos azul y verde, lo que evita la pérdida de datos o las incoherencias durante la migración. + Mantiene la continuidad empresarial: la automatización de blue/green las implementaciones ayuda a evitar interrupciones prolongadas y pérdidas financieras al mantener sus servicios disponibles durante las actualizaciones o las migraciones. ## Requisitos previos y limitaciones **Requisitos previos ** + Un activo. Cuenta de AWS + Un clúster de base de datos global de Aurora compatible con MySQL de origen (entorno azul). Las bases de datos globales proporcionan una configuración multirregional para tener alta disponibilidad y recuperación ante desastres. Para obtener instrucciones sobre cómo configurar un clúster de base de datos global, consulte la [documentación de Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html). + [Replicación basada en GTID](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) habilitada en el clúster de origen. **Limitaciones** + Algunos Servicios de AWS no están disponibles en todos Regiones de AWS. Para conocer la disponibilidad de las regiones, consulte [Servicios de AWS by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para ver los puntos de conexión específicos, consulte la página [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) y elija el enlace del servicio. **Versiones de producto** + Versión 8.0 o posterior de Aurora compatible con MySQL ## Arquitectura ![\[Uso de la replicación basada en GTID para sincronizar los entornos azules y verdes en diferentes regiones.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/19922266-c2e5-460b-9a0f-22e6d6736094/images/7a8c3095-7904-4080-906f-0c403c289a4f.png) En el siguiente diagrama se ilustra lo siguiente: + Configuración de la base de datos global: un clúster de base de datos global Aurora se implementa estratégicamente en dos Regiones de AWS. Esta configuración permite la distribución geográfica y la redundancia regional para mejorar las capacidades de recuperación ante desastres. + Replicación de la región principal a la región secundaria: el mecanismo de replicación lógica garantiza una sincronización perfecta de los datos de la región principal a la secundaria. Esta replicación conserva la coherencia de datos con una latencia mínima en todas las distancias geográficas. + Replicación entre clústeres basada en GTID: la replicación basada en GTID mantiene la coherencia de las transacciones y el orden del flujo de datos entre el clúster principal azul y el clúster principal verde, y garantiza una sincronización de datos fiable. + Replicación del clúster azul principal al secundario: la replicación lógica establece una canalización de datos sólida entre el clúster principal azul y el clúster secundario. Esta replicación permite una sincronización continua de los datos y una alta disponibilidad. + Configuración de DNS de Route 53: los registros de zonas alojadas de Route 53 administran la resolución de DNS de todos los puntos de conexión de las bases de datos de clústeres azules y verdes. Esta configuración proporciona una asignación perfecta de los puntos de conexión y permite un enrutamiento eficiente del tráfico durante los escenarios de conmutación por error. ## Tools (Herramientas) **Servicios de AWS** + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) es un motor de base de datos relacional completamente administrado diseñado para la nube y compatible con MySQL y PostgreSQL. + [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)le ayuda a modelar y configurar sus AWS recursos para que pueda dedicar menos tiempo a administrarlos y más tiempo a centrarse en las aplicaciones en las que se ejecutan AWS. Crea una plantilla que describe todos los AWS recursos que desea y CloudFormation se encarga de aprovisionar y configurar esos recursos por usted. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) es un servicio de computación que permite ejecutar código sin aprovisionar ni administrar servidores. Lambda ejecuta su código solo cuando es necesario y escala de manera automática, desde unas pocas solicitudes por día hasta miles por segundo. + [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) es un servicio web de sistema de nombres de dominio (DNS) escalable y de alta disponibilidad. ## Prácticas recomendadas Le recomendamos que revise detenidamente la AWS documentación para comprender mejor la [estrategia de implementación económica y ecológica, la replicación basada](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-overview.html) [en GTID](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) y las políticas de enrutamiento [ponderado](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) de Route 53. Este conocimiento es crucial para implementar y administrar eficazmente las migraciones de bases de datos, garantizar la coherencia de datos y optimizar el enrutamiento del tráfico. Al obtener una comprensión completa de estas AWS funciones y prácticas recomendadas, estará mejor preparado para gestionar futuras actualizaciones, minimizar el tiempo de inactividad y mantener un entorno de base de datos seguro y resistente. Para ver las pautas de Servicios de AWS uso de este patrón, consulte la siguiente AWS documentación: + [Prácticas recomendadas con Amazon Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.BestPractices.html) + prácticas recomendadas de [CloudFormation ](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/best-practices.html) + [Prácticas recomendadas para trabajar con AWS Lambda funciones](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) + [Prácticas recomendadas para Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/best-practices.html) ## Epics ### Creación de un entorno verde | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una copia de seguridad de la instantánea a partir del clúster azul. | En una blue/green implementación, el entorno verde representa una versión nueva e idéntica del entorno de base de datos actual (azul). Utilice el entorno verde para probar las actualizaciones de forma segura, validar los cambios y garantizar la estabilidad antes de cambiar el tráfico de producción. Actúa como espacio de pruebas para implementar cambios en las bases de datos con una interrupción mínima del entorno activo.Para crear un entorno verde, primero debe crear una instantánea del clúster principal (azul) en la base de datos global de Aurora compatible con MySQL. Esta instantánea sirve de base para crear el entorno verde.Para crear una instantánea:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Como alternativa, puede usar AWS Command Line Interface (AWS CLI) para crear la instantánea:
(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-1Asegúrese de que la instantánea se complete correctamente antes de pasar al siguiente paso. | Administrador de base de datos | | Genere la CloudFormation plantilla para su base de datos global y sus recursos. | El generador CloudFormation IaC le ayuda a generar CloudFormation plantillas a partir de AWS los recursos existentes. Utilice esta función para crear una CloudFormation plantilla para su base de datos global compatible con Aurora MySQL existente y sus recursos asociados. Esta plantilla configura grupos de subred, grupos de seguridad, grupos de parámetros y otros ajustes.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html) | Administrador de base de datos | | Modifique la CloudFormation plantilla para el entorno ecológico. | Personalice la CloudFormation plantilla para que refleje la configuración del entorno verde. Esto implica actualizar los nombres e identificadores de los recursos para garantizar que el entorno verde funcione de forma independiente del clúster azul.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Si utiliza la propiedad `SnapshotIdentifier` para restaurar un clúster de base de datos, evite especificar propiedades como `GlobalClusterIdentifier`, `MasterUsername` o `MasterUserPassword`. | Administrador de base de datos | | Implemente la CloudFormation pila para crear recursos para un entorno ecológico. | En este paso, implementará la CloudFormation plantilla personalizada para crear los recursos para el entorno ecológico.Para implementar la CloudFormation pila:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)CloudFormation inicia el proceso de creación de los recursos del entorno ecológico. Este proceso puede tardar varios minutos en completarse. | Administrador de base de datos | | Valide la CloudFormation pila y los recursos. | Cuando se complete el despliegue de la CloudFormation pila, tendrás que comprobar que el entorno ecológico se ha creado correctamente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Tras la verificación, el entorno verde estará listo para seguirlo configurando, así como para replicarlo desde el entorno azul. | Administrador de base de datos | ### Configuración de la replicación basada en GTID | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Compruebe la configuración de GTID en el clúster azul. | GTIDs proporcionan un método altamente confiable para replicar datos entre sus entornos azul y verde. La [replicación basada en GTID](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) ofrece un enfoque flexible y simplificado al asignar un identificador único a cada transacción en el entorno azul. Este método garantiza que la sincronización de datos entre los entornos sea fluida, coherente y más fácil de administrar que la replicación binlog tradicional.Antes de configurar la replicación, debe asegurarse de que la replicación basada en GTID esté habilitada correctamente en el clúster azul. Este paso garantiza que cada transacción del entorno azul tenga un seguimiento exclusivo y se pueda replicar en el entorno verde.Para confirmar que los GTID están habilitados, siga estos pasos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Esta configuración permite hacer un seguimiento de los GTID para todas las transacciones futuras en el entorno azul. Después de confirmar esta configuración, puede comenzar a configurar la replicación. | Administrador de base de datos | | Cree un usuario de replicación | Para replicar datos del entorno azul al entorno verde, tiene que crear un usuario de replicación específico en el clúster azul. Este usuario será responsable de administrar el proceso de replicación.Para configurar el usuario de replicación, siga estos pasos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Este usuario ahora tiene los permisos necesarios para replicar datos entre los dos entornos. | Administrador de base de datos | | Configure la replicación basada en GTID en el clúster verde. | El siguiente paso es configurar el clúster verde para la replicación basada en GTID. Esta configuración garantiza que en el entorno verde se reflejen continuamente todas las transacciones que se realicen en el entorno azul.Para configurar el clúster verde, siga estos pasos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html) | Administrador de base de datos | | Inicie la replicación en el clúster verde. | Ya puede empezar el proceso de replicación: En el clúster verde, ejecute este comando:
START SLAVE;Este comando permite que el entorno verde comience a sincronizar los datos y a recibir y aplicar transacciones del entorno azul. | Administrador de base de datos | | Verifique el proceso de replicación. | Para comprobar que el entorno verde está replicando con precisión los datos del clúster azul, siga estos pasos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Si todos los indicadores son correctos, la replicación basada en GTID funciona sin problemas y el entorno verde está completamente sincronizado con el entorno azul. | Administrador de base de datos | ### Cambio del tráfico del clúster azul al verde | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Configure las políticas de enrutamiento ponderado de Route 53. | Después de verificar la coherencia de datos entre los entornos azul y verde, puede cambiar el tráfico del clúster azul al clúster verde. Esta transición debe ser fluida y minimizar el tiempo de inactividad y garantizar la integridad de la base de datos de la aplicación. Para cumplir con estos requisitos, puede usar Route 53 para el enrutamiento de DNS y Lambda para automatizar el cambio de tráfico. Además, un plan de reversión bien definido garantiza que pueda volver al clúster azul en caso de que surja algún problema.El primer paso es configurar el enrutamiento ponderado en Route 53. El enrutamiento ponderado le permite controlar la distribución del tráfico entre los clústeres azul y verde y desplazar gradualmente el tráfico de un entorno a otro.Para configurar el enrutamiento ponderado, siga estos pasos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Para obtener más información sobre las políticas de enrutamiento ponderado, consulte la [documentación de Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html). | AWS DevOps | | Implemente una función de Lambda para supervisar el retraso de la replicación. | Para garantizar que el entorno verde se sincronice completamente con el entorno azul, implemente una función de Lambda que supervise el retraso de la replicación entre los clústeres. Esta función puede comprobar el estado de la replicación (específicamente, la métrica **Seconds\$1Behind\$1Master**) para determinar si el clúster verde está preparado para gestionar todo el tráfico.A continuación, se muestra un ejemplo de función de Lambda que puede utilizar:
import boto3Esta función comprueba el retraso de la replicación y devuelve el valor. Si el retraso es cero, el clúster verde está totalmente sincronizado con el clúster azul. | AWS DevOps | | Automatice el ajuste de ponderaciones de DNS mediante Lambda. | Cuando el retraso de la replicación llegue a cero, ya podrá cambiar todo el tráfico al clúster verde. Puede automatizar esta transición mediante otra función de Lambda que ajuste las ponderaciones de DNS en Route 53 para dirigir el 100 % del tráfico al clúster verde.A continuación, se muestra un ejemplo de una función de Lambda que automatiza el cambio de tráfico:
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 boto3Esta función comprueba el retraso de la replicación y actualiza las ponderaciones de DNS de Route 53 cuando el retraso es cero para transferir completamente el tráfico al clúster verde.** **Durante el proceso de transición, si el clúster azul experimenta un tráfico de escritura intenso, considere la posibilidad de pausar temporalmente las operaciones de escritura durante la transición. Esto garantiza que la replicación se recupere del retraso y evita incoherencias en los datos entre los clústeres azul y verde. | AWS DevOps | | Verifique el cambio de tráfico. | Una vez que la función de Lambda ajuste las ponedraciones de DNS, debe comprobar que todo el tráfico se dirige al clúster verde y que el cambio se ha realizado correctamente.Para verificarlo, siga estos pasos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Si todo funciona según lo esperado, el cambio de tráfico se ha completado. | AWS DevOps | | Si encuentra algún problema, revierta los cambios. | Tener un plan de reversión es esencial en caso de que surja algún problema después del cambio de tráfico. A continuación, le explicamos cómo revertir rápidamente al clúster azul si es necesario:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Al implementar este plan de reversión, puede garantizar una interrupción mínima para sus usuarios en caso de que surjan problemas inesperados. | AWS DevOps | ### Validación y detención de la replicación basada en GTID | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Detenga la replicación basada en GTID en el clúster verde. | Después de cambiar el tráfico del entorno azul al entorno verde, debe validar que la transición se haya completado correctamente y asegurarse de que el clúster verde funcione según lo esperado. Además, debe detener la replicación basada en GTID entre los clústeres azul y verde, ya que el entorno verde ahora sirve como base de datos principal. Realizar estas tareas garantiza que su entorno sea seguro, ágil y optimizado para las operaciones continuas.Para detener la replicación, siga estos pasos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Cuando detiene la replicación, el clúster verde pasa a ser completamente independiente y funciona como el entorno de base de datos principal para las cargas de trabajo. | Administrador de base de datos | | Eliminación de recursos. | Al limpiar los recursos temporales o no usados que se crearon durante la migración del clúster azul al verde, se asegura de que el entorno siga siendo optimizado, seguro y rentable. Durante la limpieza, de ajustar la configuración de seguridad, realizar las copias de seguridad finales y retirar los recursos innecesarios.Para limpiar los recursos, siga estos pasos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)La limpieza de los recursos ayuda a mantener un entorno seguro y optimizado, reduce los costos y garantiza que solo quede la infraestructura necesaria. | AWS DevOps | ## Recursos relacionados CloudFormation: + [CloudFormation Guía del usuario](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) + prácticas recomendadas de [CloudFormation ](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/best-practices.html) + [Generar plantillas de los recursos existentes con el generador IaC](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/generate-IaC.html) + [Importe aplicaciones enteras a CloudFormation](https://aws.amazon.com/blogs/devops/import-entire-applications-into-aws-cloudformation/) (AWS entrada de blog) Amazon Aurora: + [Guía del usuario de Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Welcome.html) + [Administración de un clúster de base de datos Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_Aurora.html) Estrategia de implementación azul/verde: + [Descripción general de las Blue/Green implementaciones de Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-overview.html) Replicación basada en GTID: + [Uso de la replicación basada en GTID](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) (documentación de Amazon RDS) AWS Lambda: + [AWS Lambda Guía para desarrolladores](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) + [Prácticas recomendadas para trabajar con funciones AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) Amazon Route 53: + [Guía para desarrolladores de Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) + [Enrutamiento ponderado](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) Herramientas del cliente MySQL: + [PyMySQL](https://github.com/PyMySQL/PyMySQL) # Automatice la replicación de las instancias de Amazon RDS en Cuentas de AWS *Parag Nagwekar y Arun Chandapillai, Amazon Web Services* ## Resumen Este patrón le muestra cómo automatizar el proceso de replicación, seguimiento y reversión de sus instancias de base de datos de Amazon Relational Database Service (Amazon RDS) en Cuentas de AWS diferentes instancias mediante el uso de y. AWS Step Functions AWS Lambda Puede utilizar esta automatización para realizar una replicación a gran escala de instancias de base de datos de RDS sin que ello afecte al rendimiento ni a los gastos operativos adicionales, independientemente del tamaño de su organización. También puede utilizar este patrón para ayudar a su organización a cumplir con las estrategias de gobierno de datos obligatorias o los requisitos de conformidad que exigen que sus datos se repliquen y sean redundantes en diferentes y diferentes. Cuentas de AWS Regiones de AWS La replicación entre cuentas de los datos de Amazon RDS a escala es un proceso manual ineficiente y propenso a errores que puede resultar costoso y llevar mucho tiempo, pero la automatización de este patrón puede ayudarle a conseguir la replicación entre cuentas de forma segura, eficaz y eficiente. ## Requisitos previos y limitaciones **Requisitos previos ** + Dos Cuentas de AWS + Una instancia de base de datos de RDS, activa y en ejecución en la fuente Cuenta de AWS + Un grupo de subredes para la instancia de base de datos de RDS en el destino Cuenta de AWS + Una clave AWS Key Management Service (AWS KMS) creada en el origen Cuenta de AWS y compartida con la cuenta de destino (para obtener más información sobre los detalles de la política, consulte la sección de [información adicional](#automate-the-replication-of-amazon-rds-instances-across-aws-accounts-additional) de este patrón). + Una AWS KMS key en el destino Cuenta de AWS para cifrar la base de datos de la cuenta de destino **Limitaciones** + Algunas Servicios de AWS no están disponibles en todas Regiones de AWS. Para conocer la disponibilidad de las regiones, consulte [Servicios de AWS by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para ver los puntos de conexión específicos, consulte la página [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) y elija el enlace del servicio. **Versiones de producto** + Python 3.9 (usando AWS Lambda) + PostgreSQL 11.3, 13.x y 14.x ## Arquitectura **Pila de tecnología** + 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 **Arquitectura de destino** El siguiente diagrama muestra una arquitectura para usar Step Functions para orquestar la replicación programada y bajo demanda de instancias de base de datos de RDS desde una cuenta de origen (cuenta A) a una cuenta de destino (cuenta B). ![\[Replicación de instancias de bases de datos de Amazon RDS en cuentas de origen y destino mediante Step Functions.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/6310ad9b-1b1a-4a67-b684-ef605fef3e87/images/001550bb-cf6b-493d-9de9-0229a43753a1.png) En la cuenta de origen (cuenta A en el diagrama), la máquina de estados Step Functions realiza lo siguiente: 1. Crea una instantánea de la instancia de base de datos de RDS en la cuenta A. 1. Copia y cifra la instantánea con una AWS KMS key de la cuenta A. Para garantizar el cifrado en tránsito, la instantánea se cifra independientemente de que la instancia de base de datos esté cifrada o no. 1. Comparte la instantánea de base de datos con la cuenta B al permitir que la cuenta B acceda a la instantánea. 1. Envía una notificación al tema de SNS y, a continuación, el tema de SNS invoca la función de Lambda en la cuenta B. En la cuenta de destino (cuenta B en el diagrama), la función de Lambda ejecuta la máquina de estados Step Functions para orquestar lo siguiente: 1. Copia la instantánea compartida de la cuenta A a la cuenta B y utiliza la AWS KMS key de la cuenta A para descifrar primero los datos y, a continuación, los cifra mediante la AWS KMS key cuenta B. 1. Leer el secreto de Secrets Manager para capturar el nombre de la instancia de base de datos actual. 1. Restaura la instancia de base de datos de la instantánea con un nombre nuevo y predeterminado AWS KMS key para Amazon RDS. 1. Leer el punto de conexión de la nueva base de datos y actualizar el secreto de Secrets Manager con el nuevo punto de conexión de la base de datos y, a continuación, etiquetar la instancia de base de datos anterior para poder eliminarla más adelante. 1. Conservar las N instancias más recientes de las bases de datos y eliminar todas las demás instancias. ## Tools (Herramientas) **Servicios de AWS** + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) lo ayuda a configurar, utilizar y escalar una base de datos relacional en la Nube de AWS. + [Amazon Simple Notification Service (Amazon SNS)](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) le permite coordinar y administrar el intercambio de mensajes entre publicadores y clientes, incluidos los servidores web y las direcciones de correo electrónico. + [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)le ayuda a configurar AWS los recursos, aprovisionarlos de forma rápida y coherente y gestionarlos a lo largo de su ciclo de vida en todo el territorio Cuentas de AWS y Regiones de AWS. + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) le ayuda a crear y controlar claves criptográficas para proteger sus datos. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) es un servicio de computación que ayuda a ejecutar código sin necesidad de aprovisionar ni administrar servidores. Ejecuta el código solo cuando es necesario y amplía la capacidad de manera automática, por lo que solo pagará por el tiempo de procesamiento que utilice. + [AWS SDK para Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html)es un kit de desarrollo de software que le ayuda a integrar su aplicación, biblioteca o script de Python con Servicios de AWS. + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) lo ayuda a reemplazar las credenciales codificadas en su código, incluidas contraseñas, con una llamada a la API de Secrets Manager para recuperar el secreto mediante programación. + [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html)es un servicio de organización sin servidor que le ayuda a combinar funciones de Lambda y otras Servicios de AWS para crear aplicaciones críticas para la empresa. **Repositorio de código** [El código de este patrón está disponible en el repositorio RDS Replication de Crossaccount. GitHub ](https://github.com/aws-samples/aws-rds-crossaccount-replication) ## Epics ### Automatice la replicación de todas las instancias de base de datos de RDS Cuentas de AWS con un solo clic | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Implemente la CloudFormation pila en la cuenta de origen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Administrador de la nube, arquitecto de la nube | | Implemente la CloudFormation pila en la cuenta de destino. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Arquitecto de nube, DevOps ingeniero y administrador de nube | | Compruebe la creación de la instancia de base de datos de RDS en la cuenta de destino. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Administrador de nube, arquitecto de nube, ingeniero DevOps | | Suscriba la función de Lambda al tema de SNS. | Debe ejecutar los siguientes comandos AWS Command Line Interface (AWS CLI) para suscribir la función Lambda de la cuenta de destino (cuenta B) al tema de SNS de la cuenta de origen (cuenta A).En la cuenta A, ejecute el siguiente comando:
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 \En la cuenta B, ejecute el siguiente comando:
--label lambda-access --aws-account-id\
--topic-arn\
--action-name Subscribe ListSubscriptionsByTopic
aws lambda add-permission \En la cuenta B, ejecute el siguiente comando:
--function-name\
--source-arn\
--statement-id function-with-sns \
--action lambda:InvokeFunction \
--principal sns.amazonaws.com
aws sns subscribe \| Administrador de la nube, arquitecto de la nube y administrador de bases de datos | | Sincronice la instancia de base de datos de RDS de la cuenta de origen con la cuenta de destino. | Inicie la replicación de la base de datos bajo demanda iniciando la máquina de estados Step Functions en la cuenta de origen.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html)Hay un programador para ayudarlo a ejecutar la replicación automáticamente según lo programado, pero el programador está desactivado de forma predeterminada. Puedes encontrar el nombre de la CloudWatch regla de Amazon para el programador en la pestaña **Recursos** de la CloudFormation pila de la cuenta de destino. Para obtener instrucciones sobre cómo modificar la regla de CloudWatch eventos, consulte [Eliminar o deshabilitar una regla de CloudWatch eventos](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Delete-or-Disable-Rule.html) en la CloudWatch documentación. | Arquitecto de nube, DevOps ingeniero y administrador de nube | | Restaure su base de datos a cualquiera de las copias anteriores cuando sea necesario. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Administrador de la nube, administrador de bases de datos, ingeniero DevOps | ## Recursos relacionados + [Réplicas de lectura de para diferentes regiones](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.CrossRegionReadReplicas.html) (documentación de Amazon RDS) + [Implementaciones azul/verdes](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.BlueGreenDeployments.html) (documentación de Amazon RDS) ## Información adicional Puedes usar el siguiente ejemplo de política para compartir tu información AWS KMS key . Cuentas de 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/es_es/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html)
| AWS DevOps, administrador de bases de datos | | Cree tareas en el Programador de tareas. | Para crear una tarea en el Programador de tareas, siga estos pasos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html)Para ejecutar la tarea manualmente, haga clic con el botón derecho en la tarea recién creada y, a continuación, seleccione **Ejecutar**. | Administrador de base de datos | | Consulte el estado de la tarea. | Para ver el estado de una tarea en el Programador de tareas, siga estos pasos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html) | ADMINISTRADOR DE BASES DE DATOS (DBA), AWS DevOps | ### Automatice las tareas con AWS Lambda | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Implemente la solución. | Para implementar la solución de este patrón, siga los pasos que se describen a continuación:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html) | AWS DevOps, DevOps ingeniero | ## Resolución de problemas | Problema | Solución | | --- | --- | | Problemas con Lambda | Para obtener ayuda con los errores y problemas que pueda encontrar al usar Lambda AWS Lambda, consulte [Solución de problemas en Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-troubleshooting.html) en la AWS documentación. | ## Recursos relacionados + [Tipos de EC2 instancias de Amazon](https://aws.amazon.com/ec2/instance-types/) + [AWS Lambda documentación](https://docs.aws.amazon.com/lambda/latest/dg/with-eventbridge-scheduler.html) + [AWS Lambda precios](https://aws.amazon.com/lambda/pricing/) + [Programador de tareas para desarrolladores](https://learn.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-start-page) (sitio web de Microsoft) # Automatización de la conmutación por error y la conmutación por recuperación entre regiones mediante DR Orchestrator Framework *Jitendra Kumar, Pavithra Balasubramanian y Oliver Francis, Amazon Web Services* ## Resumen Este patrón describe cómo utilizar [DR Orchestrator Framework](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/dr-orchestrator-framework-overview.html) para orquestar y automatizar los pasos manuales que san propensos a errores, para realizar la recuperación ante desastres en todas las regiones de Amazon Web Services (AWS). El patrón cubre las siguientes bases de datos: + Amazon Relational Database Service (Amazon RDS) para MySQL, Amazon RDS para PostgreSQL o Amazon RDS para MariaDB + Edición compatible de Amazon Aurora MySQL o de Amazon Aurora PostgreSQL (mediante un archivo centralizado) + Amazon ElastiCache (Redis OSS) Para demostrar la funcionalidad de DR Orchestrator Framework, debe crear dos instancias o clústeres de bases de datos. El principal está en y Región de AWS `us-east-1` el secundario está dentro. `us-west-2` Para crear estos recursos, utilice las AWS CloudFormation plantillas de la `App-Stack` carpeta del GitHub repositorio [aws-cross-region-dr-databases](https://github.com/aws-samples/aws-cross-region-dr-databases). ## Requisitos previos y limitaciones **Requisitos previos generales** + El marco DR Orchestrator se implementó tanto en el sistema primario como en el secundario Regiones de AWS + Dos buckets de [Amazon Simple Storage Service](https://aws.amazon.com/s3/) + Una [nube privada virtual (VPC)](https://aws.amazon.com/vpc/) con dos subredes y un grupo de seguridad AWS **Requisitos previos específicos del motor** + **Amazon Aurora**: debe haber al menos una base de datos global de Aurora disponible en dos Regiones de AWS. Puede utilizar `us-east-1` como región principal y `us-west-2` como región secundaria. + **Amazon ElastiCache (Redis OSS)**: un almacén de datos ElastiCache global debe estar disponible en dos. Regiones de AWS Puede usar `use us-east-1` como región principal y `us-west-2` como región secundaria. **Limitaciones de Amazon RDS** + DR Orchestrator Framework no comprueba el retraso de la replicación antes de realizar una conmutación por error o una conmutación por recuperación. El retraso de la replicación debe comprobarse manualmente. + Esta solución se probó con una instancia de base de datos principal con una réplica de lectura. Si desea utilizar más de una réplica de lectura, pruebe la solución minuciosamente antes de implementarla en un entorno de producción. **Limitaciones de Aurora** + La disponibilidad de las características varía según las versiones específicas de cada motor de base de datos y entre Regiones de AWS. Para más información sobre la disponibilidad en características y regiones de la replicación entre regiones, consulte [Réplicas de lectura entre regiones](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.CrossRegionReadReplicas.html). + Las bases de datos globales de Aurora tienen requisitos de configuración específicos para las clases de instancias de base de datos Aurora compatibles y el número máximo de Regiones de AWS. Para más información, consulte [Requisitos de configuración de una base de datos global de Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html#aurora-global-database.configuration.requirements). + Esta solución se probó con una instancia de base de datos principal con una réplica de lectura. Si desea utilizar más de una réplica de lectura, pruebe la solución minuciosamente antes de implementarla en un entorno de producción. **ElastiCache Limitaciones** + Para obtener información sobre la disponibilidad regional del almacén de datos global y los requisitos de ElastiCache configuración, consulte los requisitos [previos y las limitaciones](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastores-Getting-Started.html) en la documentación. ElastiCache **Versiones de p****roductos de Amazon RDS** Amazon RDS es compatible con las siguientes versiones de motor: + **MySQL**: Amazon RDS admite instancias de base de datos que ejecutan las siguientes versiones de [MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_MySQL.html): MySQL 8.0 y MySQL 5.7. + **PostgreSQL**: para obtener información sobre las versiones compatibles de Amazon RDS para PostgreSQL, consulte [Versiones de bases de datos disponibles de PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html#PostgreSQL.Concepts.General.DBVersions). + **MariaDB**: Amazon RDS admite instancias de base de datos que ejecutan las siguientes versiones de [MariaDB](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_MariaDB.html): + MariaDB 10.11 + MariaDB 10.6 + MariaDB 10.5 **Versiones de productos de Aurora** + La transición de base de datos global de Amazon Aurora requiere una instancia de Aurora MySQL que sea compatible con MySQL 5.7 o la versión 2.09.1 y superior. Para más información, consulte [Limitaciones de bases de datos globales de Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html#aurora-global-database.limitations). **ElastiCache Versiones de productos (Redis OSS)** Amazon ElastiCache (Redis OSS) es compatible con las siguientes versiones de Redis: + Redis 7.1 (mejorada) + Redis 7.0 (mejorada) + Redis 6.2 (mejorada) + Redis 6.0 (mejorada) + Redis 5.0.6 (mejorada) Para obtener más información, consulte Versiones [compatibles ElastiCache (Redis OSS](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastores-Getting-Started.html)). ## Arquitectura **Arquitectura**** de Amazon RDS** La arquitectura de Amazon RDS incluye los siguientes recursos: + La instancia de base de datos de Amazon RDS principal creada en la región principal (`us-east-1`) con read/write acceso para los clientes + Una réplica de lectura de Amazon RDS creada en la región secundaria (`us-west-2`) con acceso de solo lectura para los clientes + DR Orchestrator Framework se implementó tanto en la región principal como en la secundaria ![\[Diagrama de la arquitectura RDS de dos regiones en una sola cuenta de AWS.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/ad217033-600c-40da-929c-b9f9aecb4c2c.png) En el diagrama se muestra lo siguiente: 1. Replicación asíncrona entre la instancia principal y la instancia secundaria 1. Acceso de lectura y escritura para los clientes de la región principal 1. Acceso de solo lectura para los clientes de la región secundaria **Arquitectura de Aurora** La arquitectura de Amazon Aurora incluye los siguientes recursos: + El clúster de base de datos principal de Aurora creado en la región principal (`us-east-1`) con un punto de conexión de escritura activo + Un clúster de base de datos de Aurora creado en la región secundaria (`us-west-2`) con un punto de conexión de escritura inactivo + DR Orchestrator Framework se implementó tanto en la región principal como en la secundaria ![\[Diagrama de la implementación de Aurora en dos regiones en una sola cuenta de AWS.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/524ec002-5aa7-47b2-8c8d-6d1a3b535e9e.png) En el diagrama se muestra lo siguiente: 1. Replicación asíncrona entre el clúster principal y el clúster secundario 1. El clúster de base de datos principal con un punto de conexión de escritura activo 1. El clúster de base de datos secundario con un punto de conexión de escritura inactivo **ElastiCache Arquitectura (Redis OSS)** La arquitectura Amazon ElastiCache (Redis OSS) incluye los siguientes recursos: + Un almacén de datos global ElastiCache (Redis OSS) creado con dos clústeres: 1. El clúster principal de la región principal (`us-east-1`) 1. El clúster secundario de la región secundaria (`us-west-2`) + Un enlace entre regiones de Amazon con encriptado TLS 1.2 entre los dos clústeres + DR Orchestrator Framework se implementó tanto en la región principal como en la secundaria ![\[Diagrama de una ElastiCache implementación en dos regiones con un enlace entre regiones de Amazon.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/cf6620a0-dd42-4042-8dc2-012bf514ffc0.png) **Automatización y escala** DR Orchestrator Framework es escalable y admite la conmutación por error o la conmutación por recuperación de más de una base de datos AWS en paralelo. Puede utilizar el siguiente código de carga útil para realizar la conmutación por error de varias AWS bases de datos de su cuenta. En este ejemplo, tres AWS bases de datos (dos bases de datos globales, como Aurora MySQL o Aurora PostgreSQL, y una instancia de Amazon RDS for MySQL) se conmutan por error a la región DR: ``` { "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" } } ] } ] } ``` ## Tools (Herramientas) **AWS servicios** + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) es un motor de base de datos relacional completamente administrado diseñado para la nube y compatible con MySQL y PostgreSQL. + [Amazon](https://docs.aws.amazon.com/elasticache/) le ElastiCache ayuda a configurar, gestionar y escalar los entornos de caché en memoria distribuidos en. Nube de AWS Este patrón usa Amazon ElastiCache (Redis OSS). + [AWS Lambda](https://aws.amazon.com/lambda/) es un servicio de computación que ayuda a ejecutar código sin necesidad de aprovisionar ni administrar servidores. Ejecuta el código solo cuando es necesario y amplía la capacidad de manera automática, por lo que solo pagará por el tiempo de procesamiento que utilice. En este patrón, las funciones Lambda se utilizan AWS Step Functions para realizar los pasos. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) lo ayuda a configurar, utilizar y escalar una base de datos relacional en la Nube de AWS. Este patrón admite Amazon RDS para MySQL, Amazon RDS para PostgreSQL y Amazon RDS para MariaDB. + [AWS SDK para Python (Boto3)](https://aws.amazon.com/sdk-for-python/)le ayuda a integrar su aplicación, biblioteca o script de Python con Servicios de AWS. En este patrón, los Boto3 APIs se utilizan para comunicarse con las instancias de la base de datos o las bases de datos globales. + [AWS Step Functions](https://aws.amazon.com/step-functions/)es un servicio de organización sin servidor que le ayuda a combinar AWS Lambda funciones y otras Servicios de AWS para crear aplicaciones críticas para la empresa. En este patrón, las máquinas de estado Step Functions se utilizan para organizar y ejecutar la conmutación por error y la conmutación por recuperación entre regiones de las instancias de bases de datos o las bases de datos globales. **Repositorio de código** [El código de este patrón está disponible en el repositorio -databases deaws-cross-region-dr.](https://github.com/aws-samples/aws-cross-region-dr-databases/tree/main/App-Stack) GitHub ## Epics ### Instalación de DR Orchestrator Framework | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Clona el GitHub repositorio. | Para clonar el repositorio, ejecute el siguiente 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 de AWS | | Comprima el código de las funciones de Lambda en un archivo .zip. | Cree los archivos de almacenamiento de las funciones de Lambda para incluir las dependencias de DR Orchestrator Framework:
cd| Administrador de AWS | | Cree los buckets de S3. | Los buckets de S3 son necesarios para almacenar DR Orchestrator Framework junto con la configuración más reciente. Cree dos buckets de S3, uno en la región principal (`us-east-1`) y otro en la región secundaria (`us-west-2`):[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html)Sustituya `xxxxxx` por un valor aleatorio para que los nombres de los buckets sean únicos. | Administrador de AWS | | Cree subredes y grupos de seguridad. | Tanto en la región principal (`us-east-1`) como en la región secundaria (`us-west-2`), cree dos subredes y un grupo de seguridad para la implementación de la función de Lambda en la VPC:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | Administrador de AWS | | Actualice los archivos de parámetros de DR Orchestrator. | En la carpeta `/DR-Orchestration-artifacts
bash scripts/deploy-orchestrator-sh.sh
[| Administrador de AWS | | Cargue el código de DR Orchestrator Framework en el bucket de S3. | El código estará más seguro en un bucket de S3 que en el directorio local. Cargue el directorio `DR-Orchestration-artifacts`, incluidos todos los archivos y subcarpetas, en los buckets de S3.Para cargar el código, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | Administrador de AWS | | Implemente DR Orchestrator Framework en la región principal. | Para implementar DR Orchestrator Framework en la región principal (`us-east-1`), ejecute los siguientes 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 de AWS | | Implemente DR Orchestrator Framework en la región secundaria. | En la región secundaria (`us-west-2`), ejecute los siguientes 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 de AWS | | Comprobar la implementación. | Si el CloudFormation comando se ejecuta correctamente, devuelve el siguiente resultado:/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, puede ir a la CloudFormation consola y verificar el estado de la `dr-orchestrator` pila. | Administrador de AWS | ### Creación de instancias o clústeres de bases de datos | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree las subredes y los grupos de seguridad de base de datos. | En su VPC, cree dos subredes y un grupo de seguridad para la instancia de base de datos o la base de datos global en las regiones principal (`us-east-1`) y secundaria (`us-west-2`):[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | Administrador de AWS | | Actualice el archivo de parámetros de la instancia o el clúster de la base de datos principal. | En la carpeta `
{
"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** En el archivo `Aurora-MySQL-parameter-us-east-1.json`, actualice `SubnetIds` y `DBSecurityGroup` con los nombres de los recursos que creó:{
"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)**En el archivo `ElastiCache-parameter-us-east-1.json`, actualice `SubnetIds` y `DBSecurityGroup` con los nombres de los recursos que creó.{
"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 de AWS |
| Implemente su instancia o clúster de base de datos en la región principal. | Para implementar la instancia o el clúster en la región principal (`us-east-1`), ejecute los siguientes comandos en función del motor de base de datos.**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
cdCompruebe que los CloudFormation recursos se han desplegado correctamente. | Administrador de AWS | | Actualice el archivo de parámetros de la instancia o el clúster de la base de datos secundaria. | En la carpeta `/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**En el archivo `Aurora-MySQL-parameter-us-west-2.json`, actualice `SubnetIDs` y `DBSecurityGroup` con los nombres de los recursos que creó. Actualice el valor `PrimaryRegionKMSKeyArn` con el valor `AuroraKmsKeyId` tomado de la sección de **salidas** de la CloudFormation pila de la instancia de base de datos principal:{
"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)**En el archivo `ElastiCache-parameter-us-west-2.json`, actualice `SubnetIDs` y `DBSecurityGroup` con los nombres de los recursos que creó. Actualice el valor `PrimaryRegionKMSKeyArn` con el valor `ElastiCacheKmsKeyId` obtenido de la sección de **resultados** de la CloudFormation pila de la instancia de base de datos principal:{
"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 de AWS |
| Implemente su instancia o clúster de base de datos en la región secundaria. | Ejecute los siguientes comandos, en función del motor de base de datos.**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
cdCompruebe que los CloudFormation recursos se han desplegado correctamente. | Administrador de AWS | ## Recursos relacionados + [Estrategia de recuperación ante desastres para bases de datos en AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/strategy-database-disaster-recovery/welcome.html) vigor (estrategia de orientación AWS prescriptiva) + [Automatice su solución de recuperación ante desastres para bases de datos relacionales en AWS(guía](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/dr-orchestrator-framework-overview.html) de orientación AWS prescriptiva) + [Uso de bases de datos globales de Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html) + [Replicación Regiones de AWS mediante el uso de almacenes de datos globales](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastore.html) + [Automatice su solución de recuperación ante desastres para bases de datos relacionales en AWS(guía de](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/introduction.html) orientación AWS prescriptiva) # Realice copias de seguridad automáticas de las bases de datos de SAP HANA mediante Systems Manager y EventBridge *Ambarish Satarkar y Gaurav Rath, Amazon Web Services* ## Resumen Este patrón describe cómo automatizar las copias de seguridad de bases de datos de SAP HANA mediante AWS Systems Manager EventBridge, Amazon, Amazon Simple Storage Service (Amazon S3) y AWS Backint Agent para SAP HANA. Este patrón proporciona un enfoque basado en script de intérprete de comandos utilizando el comando `BACKUP DATA` y elimina la necesidad de mantener scripts y configuraciones de trabajo para cada instancia de sistema operativo (OS) a través de numerosos sistemas. | | | Nota: En abril de 2023, AWS Backup anunció la compatibilidad con las bases de datos de SAP HANA en Amazon Elastic Compute Cloud (Amazon EC2). Para obtener más información, consulte la [copia de seguridad de bases de datos de SAP HANA en EC2 instancias de Amazon](https://docs.aws.amazon.com/aws-backup/latest/devguide/backup-saphana.html).Según las necesidades de su organización, puede utilizar el servicio AWS Backup para hacer copias de seguridad automáticas de sus bases de datos de SAP HANA o puede utilizar este patrón. | | --- | ## Requisitos previos y limitaciones **Requisitos previos ** + Una instancia de SAP HANA existente con una versión compatible en estado de ejecución en una instancia gestionada de Amazon Elastic Compute Cloud (Amazon EC2) configurada para Systems Manager + Debe contar con la versión 2.3.274.0 de Systems Manager Agent (Agente de SSM) instalada o una posterior + Un bucket de S3 que no tiene habilitado el acceso público + Una clave `hdbuserstore` llamada `SYSTEM` + Un rol de IAM de AWS Identity and Access Management para que el manual de procedimientos se ejecute según lo programado + Las políticas `AmazonSSMManagedInstanceCore` y `ssm:StartAutomationExecution` están asociadas al rol de servicio de automatización de Systems Manager. **Limitaciones** + AWS Backint Agent para SAP HANA no admite la deduplicación. + AWS Backint Agent para SAP HANA no admite la compresión de datos. **Versiones de producto** AWS Backint Agent es compatible con los siguientes sistemas operativos: + SUSE Linux Enterprise Server + SUSE Linux Enterprise Server para SAP + Red Hat Enterprise Linux para SAP AWS Backint Agent es compatible con las siguientes bases de datos: + SAP HANA 1.0 SP12 (nodo único y varios nodos) + SAP HANA 2.0 y versiones posteriores (nodo único y varios nodos) ## Arquitectura **Pila de tecnología de destino** + AWS Backint Agent + Amazon S3 + AWS Systems Manager + Amazon EventBridge + SAP HANA **Arquitectura de destino** En el siguiente diagrama se muestran los scripts de instalación que instalan AWS Backint Agent, el bucket S3 y Systems Manager EventBridge, y que utilizan un documento de comandos para programar copias de seguridad periódicas. ![\[Flujo de trabajo para programar copias de seguridad periódicas.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/0aa22a27-d100-483d-95f9-c3101f40402c/images/201d2b9a-b88e-4432-82cd-240b81da981e.png) **Automatización y escala** + Se pueden instalar varios AWS Backint Agents mediante un manual de procedimientos de Systems Manager Automation. + Cada ejecución del manual de procedimientos de Systems Manager puede escalarse hasta un número *n* de instancias de SAP HANA, en función de la selección de objetivos. + EventBridge puede automatizar las copias de seguridad de SAP HANA. ## Tools (Herramientas) + [AWS Backint Agent para SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-sap-hana.html) es una aplicación independiente que se integra con sus flujos de trabajo existentes para hacer copias de seguridad de la base de datos de SAP HANA en un bucket de S3 que especifique en el archivo de configuración. AWS Backint Agent admite copias de seguridad completas, incrementales y diferenciales de bases de datos de SAP HANA. Se ejecuta en un servidor de bases de datos SAP HANA, donde las copias de seguridad y los catálogos se transfieren de la base de datos de SAP HANA a AWS Backint Agent. + [Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html) es un servicio de bus de eventos sin servidor que puede utilizar para conectar sus aplicaciones con datos de diversas fuentes. EventBridge ofrece un flujo de datos en tiempo real desde sus aplicaciones, aplicaciones de software como servicio (SaaS) y servicios de AWS a objetivos como las funciones de AWS Lambda, los puntos de enlace de invocación HTTP que utilizan destinos de API o los buses de eventos de otras cuentas. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) es un servicio de almacenamiento de objetos. Puede utilizar Amazon S3 para almacenar y recuperar cualquier cantidad de datos en cualquier momento y desde cualquier parte de la web. + [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) le ayuda a ver y controlar la infraestructura en AWS. Mediante la consola de Systems Manager, puede ver los datos operativos de varios servicios de AWS y automatizar las tareas operativas en sus recursos de AWS. **Código** El código de este patrón está disponible en el repositorio. [aws-backint-automated-backup](https://github.com/aws-samples/aws-backint-automated-backup) GitHub ## Epics ### Cree un SISTEMA de claves hdbuserstore | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una clave hdbuserstore. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html) | Administrador de AWS, administrador de SAP HANA | ### Instalación de AWS Backint Agent | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Instalación de AWS Backint Agent. | Siga las instrucciones de [Instalación y configuración de AWS Backint Agent para SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-installing-configuring.html) en la documentación de AWS Backint Agent. | Administrador de AWS, administrador de SAP HANA | ### Cree un documento de comandos de Systems Manager | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree un documento de comandos de Systems Manager. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html) | Administrador de AWS, administrador de SAP HANA | ### Programe las copias de seguridad con una frecuencia periódica | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Programa copias de seguridad periódicas con Amazon EventBridge. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html)Puede verificar el éxito de la copia de seguridad desde la ruta del bucket de 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:/También puede verificar las copias de seguridad desde el catálogo de copias de seguridad de SAP HANA. | Administrador de AWS, administrador de 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) + [Instalación y configuración de AWS Backint Agent para SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-installing-configuring.html) # Generación automática de un modelo de PynamoDB y funciones CRUD para Amazon DynamoDB mediante una aplicación de Python *Vijit Vashishtha, Dheeraj Alimchandani y Dhananjay Karanjkar, Amazon Web Services* ## Resumen Es habitual que se requieran entidades y funciones de operaciones de creación, lectura, actualización y eliminación (CRUD) para realizar operaciones de base de datos de Amazon DynamoDB. PynamoDB es una interfaz basada en Python que admite Python 3. También ofrece características como la compatibilidad con las transacciones de Amazon DynamoDB, la serialización y deserialización automáticas de los valores de los atributos y la compatibilidad con los marcos de trabajo más comunes de Python, como Flask y Django. Este patrón permite a los desarrolladores trabajar con Python y DynamoDB, ya que proporciona una biblioteca que facilita la creación automática de modelos de PynamoDB y funciones de operación CRUD. Si bien genera funciones CRUD esenciales para las tablas de bases de datos, también puede aplicar ingeniería inversa a los modelos de PynamoDB y a las funciones CRUD de las tablas de Amazon DynamoDB. Este patrón está diseñado para simplificar las operaciones de la base de datos mediante una aplicación basada en Python. Estas son algunas de las características principales de la solución: + **Esquema JSON a modelo PynamoDB**: genere automáticamente modelos de PynamoDB en Python mediante la importación de un archivo de esquema JSON. + **Generación de funciones CRUD**: genere automáticamente funciones para realizar operaciones CRUD en tablas de DynamoDB. + **Ingeniería inversa desde DynamoDB**: utilice la asignación relacional de objetos (ORM) de PynamoDB para aplicar ingeniería inversa a los modelos de PynamoDB y a las funciones CRUD de las tablas de Amazon DynamoDB existentes. ## Requisitos previos y limitaciones **Requisitos previos ** + Un activo Cuenta de AWS + La versión 3.8 o posterior de Python [descargada](https://www.python.org/downloads/) e instalada + La versión 3.1.2 o posterior de Jinja2 [descargada](https://pypi.org/project/Jinja2/#files) e instalada + Tablas de Amazon DynamoDB para las que desea generar ORM + AWS Command Line Interface (AWS CLI), [instalado](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) y [configurado](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) + La versión 5.4.1 o posterior de PynamoDB [instalada](https://pynamodb.readthedocs.io/en/stable/tutorial.html#installation) ## Arquitectura **Pila de tecnología de destino** + script de JSON + aplicación de Python + modelo de PynamoDB + instancia de base de datos de Amazon DynamoDB **Arquitectura de destino** ![\[Use una aplicación de Python para generar funciones CRUD y el modelo de PynamoDB a partir de tablas de DynamoDB.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/74cc4c73-5c8b-448d-98fb-b681cfa5f860/images/c2c367d6-d88a-4f49-8571-89160539eb08.png) 1. Debe crear un archivo de esquema JSON de entrada. Este archivo de esquema JSON representa los atributos de las tablas de DynamoDB respectivas a partir de las que desea crear modelos de PyNamoDB y para las que desea crear funciones CRUD. Contiene estas tres claves importantes: + `name`: el nombre de la tabla de destino de DynamoDB. + `region`— El Región de AWS lugar donde está alojada la tabla + `attributes`: atributos que forman parte de la tabla de destino, como la [clave de partición](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey) (también conocida como *atributo hash*), la [clave de clasificación](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey), los [índices secundarios locales](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSI.html), los [índices secundarios globales](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html) y cualquier [atributo que no sea clave](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.TablesItemsAttributes). Esta herramienta espera que el esquema de entrada solo proporcione atributos que no sean clave, ya que la aplicación los obtiene directamente de la tabla de destino. Para ver un ejemplo de cómo especificar atributos en el archivo de esquema JSON, consulte la sección [Información adicional](#automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application-additional) de este patrón. 1. Ejecute la aplicación Python y proporcione el archivo de esquema JSON como entrada. 1. La aplicación Python lee el archivo de esquema JSON. 1. La aplicación Python se conecta a las tablas de DynamoDB para derivar el esquema y los tipos de datos. La aplicación ejecuta la operación [describe\$1table](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/describe_table.html) y obtiene los atributos clave y de índice de la tabla. 1. La aplicación Python combina los atributos del archivo de esquema JSON y la tabla de DynamoDB. Utiliza el motor de plantillas de Jinja para generar un modelo de PynamoDB y las funciones CRUD correspondientes. 1. Puede acceder al modelo de PynamoDB para realizar operaciones CRUD en la tabla de DynamoDB. ## Tools (Herramientas) **Servicios de AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) es un servicio de base de datos de NoSQL completamente administrado que ofrece un rendimiento rápido, predecible y escalable. **Otras herramientas** + [Jinja](https://jinja.palletsprojects.com/en/) es un motor de plantillas extensible que compila plantillas en código Python optimizado. Este patrón usa Jinja para generar contenido dinámico al incrustar marcadores de posición y lógica en las plantillas. + [PynamoDB](https://pynamodb.readthedocs.io/en/stable/) es una interfaz basada en Python para Amazon DynamoDB. + [Python](https://www.python.org/) es un lenguaje de programación informático de uso general. **Repositorio de código** El código de este patrón está disponible en el repositorio de funciones CRUD y modelos de [PynamoDB de GitHub generación automática](https://github.com/aws-samples/amazon-reverse-engineer-dynamodb). El repositorio está dividido en dos partes principales: el paquete de controladores y las plantillas. *Paquete de controladores* El paquete Python de controladores contiene la lógica de aplicación principal que ayuda a generar el modelo de PynamoDB y las funciones CRUD. Contiene lo siguiente: + `input_json_validator.py`: este script de Python valida el archivo de esquema JSON de entrada y crea los objetos Python que contienen la lista de tablas de DynamoDB de destino y los atributos necesarios para cada uno. + `dynamo_connection.py`: este script establece una conexión con la tabla de DynamoDB y utiliza la operación `describe_table` para extraer los atributos necesarios para crear el modelo de PynamoDB. + `generate_model.py`: este script contiene una clase de Python `GenerateModel` que crea el modelo de PynamoDB en función del archivo de esquema JSON de entrada y de la operación `describe_table`. + `generate_crud.py`: para las tablas de DynamoDB que se definen en el archivo de esquema JSON, este script utiliza la operación `GenerateCrud` para crear las clases de Python. *Plantillas* Este directorio de Python contiene las siguientes plantillas de Jinja: + `model.jinja`: esta plantilla de Jinja contiene la expresión de plantilla para generar el script de modelo de PynamoDB. + `crud.jinja`: esta plantilla de Jinja contiene la expresión de plantilla para generar el script de funciones CRUD. ## Epics ### Configuración del entorno | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Clonar el repositorio. | Introduzca el comando siguiente para clonar el repositorio [Generación automática de modelos de PynamoDB y funciones CRUD](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| Desarrollador de aplicaciones | | Configure el entorno de Python. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Desarrollador de aplicaciones | ### Generación del modelo de PynamoDB y las funciones CRUD | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Modifique el archivo de esquema JSON. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Desarrollador de aplicaciones | | Ejecute la aplicación Python. | Introduzca el siguiente comando para generar los modelos de PynamoDB y las funciones CRUD, donde `
python main.py --file| Desarrollador de aplicaciones | ### Verificación del modelo de PynamoDB y las funciones CRUD | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Compruebe el modelo de PynamoDB generado. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Desarrollador de aplicaciones | | Verifique las funciones CRUD generadas. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Desarrollador de aplicaciones | ## Recursos relacionados + [Componentes básicos de Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html) (documentación de DynamoDB) + [Mejora del acceso con índices secundarios](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) (documentación de DynamoDB) ## Información adicional **Ejemplos de atributos para el archivo de esquema JSON** ``` [ { "name": "test_table", "region": "ap-south-1", "attributes": [ { "name": "id", "type": "UnicodeAttribute" }, { "name": "name", "type": "UnicodeAttribute" }, { "name": "age", "type": "NumberAttribute" } ] } ] ``` # Bloquee el acceso público a Amazon RDS mediante Cloud Custodian *abhay kumar y Dwarika Patra, Amazon Web Services* ## Resumen Muchas organizaciones ejecutan sus cargas de trabajo y servicios en múltiples proveedores de nube. En estos entornos de nube híbrida, la infraestructura de nube necesita un gobierno estricto, además de la seguridad proporcionada por los proveedores de nube individuales. Una base de datos en la nube, como Amazon Relational Database Service (Amazon RDS), es un servicio importante que debe supervisarse para detectar cualquier vulnerabilidad de acceso y permisos. Si bien puede restringir el acceso a la base de datos de Amazon RDS configurando un grupo de seguridad, también puede añadir un segundo nivel de protección para prohibir acciones como el acceso público. Bloquear el acceso público lo ayudará a cumplir con el Reglamento General de Protección de Datos (RGPD), la Ley de Portabilidad y Responsabilidad de Seguros de Salud (HIPAA), el Instituto Nacional de Estándares y Tecnología (NIST) y el Estándar de Seguridad de Datos de la Industria de Tarjetas de Pago (PCI DSS). Cloud Custodian es un motor de reglas de código abierto que puede usar para imponer restricciones de acceso a los recursos de Amazon Web Services (AWS), como Amazon RDS. Cloud Custodian le permite establecer reglas que validen el entorno según los estándares de seguridad y conformidad definidos. Puede usar Cloud Custodian para administrar sus entornos de nube y así garantizar el cumplimiento de las políticas de seguridad, las políticas de etiquetado, la recopilación de elementos no utilizados y la administración de costos. Con Cloud Custodian puede usar una única interfaz para implementar la gobernanza en su entorno de nube híbrida. Por ejemplo, puede usar la interfaz Cloud Custodian para interactuar con Microsoft Azure AWS y reducir el esfuerzo de trabajar con mecanismos como AWS Config los grupos de AWS seguridad y las políticas de Azure. Este patrón proporciona instrucciones para usar Cloud Custodian AWS para imponer la restricción de la accesibilidad pública en las instancias de Amazon RDS. ## Requisitos previos y limitaciones **Requisitos previos ** + Un activo Cuenta de AWS + [Un par de claves](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-creds-create) + AWS Lambda instalado ## Arquitectura En el siguiente diagrama AWS Lambda, se muestra a Cloud Custodian implementando la política AWS CloudTrail e iniciando el `CreateDBInstance` evento y configurando la función Lambda en `PubliclyAccessible` false en Amazon RDS. ![\[Use Cloud Custodian en AWS para restringir el acceso público a las instancias de Amazon RDS.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/90f9537e-9365-4da2-8a28-da0ff374743c/images/6d04ca3b-6aa4-4c62-ade9-8b7474928c5e.png) ## Tools (Herramientas) **Servicios de AWS** + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html)le ayuda a auditar la gobernanza, el cumplimiento y el riesgo operativo de su empresa. Cuenta de AWS + [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) es una herramienta de código abierto que le ayuda a interactuar Servicios de AWS mediante comandos en su consola de línea de comandos. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) le ayuda a administrar de forma segura el acceso a sus AWS recursos al controlar quién está autenticado y autorizado a usarlos. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) es un servicio de computación que ayuda a ejecutar código sin necesidad de aprovisionar ni administrar servidores. Ejecuta el código solo cuando es necesario y amplía la capacidad de manera automática, por lo que solo pagará por el tiempo de procesamiento que utilice. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) lo ayuda a configurar, utilizar y escalar una base de datos relacional en la Nube de AWS. **Otras herramientas** + [Cloud Custodian](https://cloudcustodian.io/) unifica las herramientas y scripts que emplean muchas organizaciones para administrar sus cuentas de nube pública en una sola herramienta de código abierto. Emplea un motor de reglas sin estado para la definición y aplicación de las políticas con métricas, resultados estructurados e informes detallados de la infraestructura de la nube. Se integra perfectamente con tiempos de ejecución sin servidor para proporcionar soluciones y respuestas en tiempo real con una baja sobrecarga operativa. ## Epics ### Configure el AWS CLI | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Instale el AWS CLI. | Para instalar el AWS CLI, siga las instrucciones de la [AWS documentación](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html). | Administrador de AWS | | Configure AWS las credenciales. | Configure los ajustes AWS CLI con los que interactuarán AWS, incluidos el Región de AWS formato de salida que desee utilizar.
$>aws configurePara obtener más información, consulte la [Documentación de AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html). | Administrador de AWS | | Crear un rol de IAM. | Para crear un rol de IAM con el rol de ejecución de Lambda, ejecute el siguiente comando.
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 |
### Configure Cloud Custodian
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Instale Cloud Custodian. | Para instalar Cloud Custodian en su sistema operativo y entorno, siga las instrucciones de la [documentación de Cloud Custodian](https://cloudcustodian.io/docs/quickstart/index.html#install-cc). | DevOps ingeniero |
| Consulte el esquema de Cloud Custodian. | Para ver una lista completa de los recursos de Amazon RDS con los que puede ejecutar políticas, introduzca el siguiente comando.custodian schema aws.rds| DevOps ingeniero | | Cree la política de Cloud Custodian. | Guarda el código que se encuentra en el *archivo de políticas de Cloud Custodian* en la sección de [Información adicional](#block-public-access-to-amazon-rds-by-using-cloud-custodian-additional) con una extensión YAML. | DevOps ingeniero | | Defina las acciones de Cloud Custodian para cambiar el indicador de acceso público. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/block-public-access-to-amazon-rds-by-using-cloud-custodian.html) | DevOps ingeniero | | Ejecute una prueba. | (Opcional) Para comprobar qué recursos identifica la política sin ejecutar ninguna acción en ellos, emplee el siguiente comando.
custodian run -dryrun| DevOps ingeniero | ### Implemente la política | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Implemente la política mediante Lambda. | Para crear la función de Lambda que ejecutará la política, introduzca el siguiente comando..yaml -s
custodian run -s policy.yamlLuego, el AWS CloudTrail `CreateDBInstance` evento iniciará esta política.Como resultado, AWS Lambda configurará el indicador de acceso público `false` para las instancias que cumplan con los criterios. | DevOps ingeniero | ## Recursos relacionados + [AWS Lambda sitio web](https://aws.amazon.com/lambda/) + [Sitio web de Amazon RDS](https://aws.amazon.com/rds/) + [Documentación de Cloud Custodian](https://cloudcustodian.io/docs/quickstart/index.html) ## Información adicional **Archivo YAML de política de 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 ``` **Archivo rds.py de recursos de 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 ``` **Integración de Security Hub CSPM** Cloud Custodian se puede integrar con [AWS Security Hub CSPM](https://aws.amazon.com/security-hub/) para enviar resultados de seguridad y tratar de adoptar medidas correctivas. Para obtener más información, consulte [Anuncio de la integración de Cloud Custodian con](https://aws.amazon.com/blogs/opensource/announcing-cloud-custodian-integration-aws-security-hub/). AWS Security Hub CSPM # Configure la autenticación de Windows para Amazon RDS for Microsoft SQL Server mediante AWS Managed Microsoft AD *Ramesh Babu Donti, Amazon Web Services* ## Resumen Este patrón muestra cómo configurar la autenticación de Windows para un Amazon Relational Database Service (Amazon RDS) para instancias de SQL Server AWS Directory Service for Microsoft Active Directory mediante AWS Managed Microsoft AD(). La autenticación de Windows permite a los usuarios conectarse a la instancia de RDS mediante sus credenciales de dominio en lugar de tener que usar nombres de usuario y contraseñas específicos de la base de datos. Puede habilitar la autenticación de Windows al crear una nueva base de datos de SQL Server de RDS o al agregarla a una instancia de base de datos existente. La instancia de base de datos se integra AWS Managed Microsoft AD para proporcionar autenticación y autorización centralizadas a los usuarios del dominio que acceden a la base de datos de SQL Server. Esta configuración mejora la seguridad, ya que aprovecha la infraestructura de Active Directory existente y elimina la necesidad de administrar credenciales de bases de datos independientes para los usuarios del dominio. ## Requisitos previos y limitaciones **Requisitos previos ** + Un activo Cuenta de AWS con los permisos adecuados + Cree una nube privada virtual (VPC) con lo siguiente: + Tablas de enrutamiento y puertas de enlace de Internet configuradas + Puertas de enlace NAT en subredes públicas (si las instancias requieren acceso a Internet) + AWS Identity and Access Management Funciones (IAM): + Un rol de dominio con las siguientes políticas AWS administradas: + `AmazonSSMManagedInstanceCore`para habilitar AWS Systems Manager + `AmazonSSMDirectoryServiceAccess` para proporcionar permisos para unir instancias a directorios + Un rol de supervisión mejorado de RDS (si la supervisión mejorada está habilitada) + Grupos de seguridad: + grupo de seguridad del servicio de directorio para permitir los puertos de comunicación de Active Directory + Un grupo de seguridad de Amazon Elastic Compute Cloud (Amazon EC2) para permitir las comunicaciones RDP `3389` y de dominio + Un grupo de seguridad de RDS para permitir la portabilidad `1433` de SQL Server desde orígenes autorizados + Conectividad de red: + Resolución de DNS y conectividad de red adecuadas entre subredes **Limitaciones** + Para obtener información sobre Regiones de AWS ese soporte AWS Managed Microsoft AD con RDS para SQL Server, consulte Disponibilidad [regional y de versiones](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerWinAuth.html#USER_SQLServerWinAuth.RegionVersionAvailability). + Algunas Servicios de AWS no están disponibles en todos Regiones de AWS. Para conocer la disponibilidad de las regiones, consulte [Servicios de AWS by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para los puntos de conexión específicos, consulte la página [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) y elija el enlace del servicio. ## Arquitectura **Pila de tecnología de origen** + Un Active Directory local o AWS Managed Microsoft AD **Pila de tecnología de destino** + Amazon EC2 + Amazon RDS for Microsoft SQL Server + AWS Managed Microsoft AD **Arquitectura de destino** ![\[alt text not found\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/e02f6059-6631-46f6-819c-5961af7ba4ae/images/1aa50e3b-b4f6-4d44-9f9e-6cbb248a159c.png) La arquitectura incluye lo siguiente: + Un rol de IAM que une la EC2 instancia de Amazon al AWS Managed Microsoft AD dominio. + Una instancia de Amazon EC2 Windows para la administración y las pruebas de bases de datos. + Una instancia de Amazon VPC con una subred privada para alojar la instancia de Amazon RDS y los recursos internos en todas las zonas de disponibilidad. + Grupos de seguridad para el control del acceso a la red: + Un grupo de seguridad de Amazon RDS para controlar el acceso entrante al puerto `1433` de SQL Server desde orígenes autorizados. + Un grupo EC2 de seguridad de Amazon para gestionar el acceso RDP a través de los puertos de comunicación de puertos `3389` y dominios. + Un grupo de seguridad del servicio de directorio para las comunicaciones de Active Directory a través de los puertos `53`, `88`, `389` y `445`. + AWS Managed Microsoft AD para proporcionar servicios centralizados de autenticación y autorización para los recursos de Windows. + Una instancia de base de datos de Amazon RDS para SQL Server en la subred privada con la autenticación de Windows habilitada. ## Tools (Herramientas) **Servicios de AWS** + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) proporciona una capacidad informática escalable en el Nube de AWS. Puede lanzar tantos servidores virtuales como necesite y escalarlos o reducirlos con rapidez. + Amazon Relational Database Service (Amazon RDS) lo ayuda a configurar, utilizar y escalar una base de datos relacional en la Nube de AWS. + [AWS Directory Service](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/what_is.html)proporciona varias formas de utilizar Microsoft Active Directory (AD) con otras, Servicios de AWS como Amazon Elastic Compute Cloud (Amazon EC2), Amazon Relational Database Service (Amazon RDS) para SQL Server y 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 sus cargas de trabajo y AWS recursos compatibles con directorios utilicen Microsoft Active Directory en. Nube de AWS + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) le ayuda a administrar de forma segura el acceso a sus AWS recursos al controlar quién está autenticado y autorizado a usarlos. **Otros servicios** + [Microsoft SQL Server Management Studio (SSMS)](https://learn.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms) es una herramienta para administrar SQL Server, que incluye el acceso, la configuración y la administración de los componentes de SQL Server. ## Prácticas recomendadas + Para obtener información sobre las prácticas recomendadas generales, consulte [Prácticas recomendadas para Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_BestPractices.html). ## Epics ### Configuración AWS Managed Microsoft AD | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Configure el tipo de directorio. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Configure la información del directorio. | En la sección de **información del directorio**, introduzca la información necesaria y conserve los valores opcionales:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Configure la VPC y las subredes. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Revise y cree el directorio. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | ### Crear y configurar una EC2 instancia de Amazon | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Configure una AMI para Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Configure los valores de red. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Configure el almacenamiento | Configure los volúmenes de Amazon EBS según sea necesario. | DBA, ingeniero DevOps | | Configure los detalles avanzados y lance la instancia. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | ### Creación y configuración de RDS para SQL Server con la autenticación de Windows | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una base de datos y configure las opciones del motor. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Elija una plantilla. | Elija una plantilla de muestra que se adapte a sus necesidades. | DBA, ingeniero DevOps | | Configure los ajustes de base de datos. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Configurar la instancia | En la sección **Configuración de instancias**, en **Clase de instancia de base de datos**, seleccione un tamaño de instancia que cumpla sus requisitos. | DBA, ingeniero DevOps | | Configure el almacenamiento | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Configure la conectividad. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Configure la autenticación de Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Configure la supervisión | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html)Nota: Las métricas son útiles cuando desea ver cómo diferentes procesos o subprocesos usan la CPU. También puedes exportar los registros de errores a Amazon CloudWatch si **el registro de errores** está activado. | DBA, ingeniero DevOps | | Configure los ajustes adicionales. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Revise los costos y cree una base de datos. | Revise la sección de **costos mensuales estimados** y, a continuación, elija **Crear base de datos**. | DBA, ingeniero DevOps | ### Configuración del acceso a la base de datos y prueba de las conexiones | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Conéctese a la máquina de Windows. | Conéctese a su máquina de Windows e inicie SQL Server Management Studio.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Configure la conexión SSMS. | Configure la conexión a la base de datos mediante la autenticación de Windows.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Configurar configuración de seguridad. | Establezca los parámetros de seguridad necesarios para la versión 20 o posterior de SSMS.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | | Cree un inicio de sesión de Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html)
CREATE LOGIN [| DBA, ingeniero DevOps | | Pruebe la autenticación de Windows | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingeniero DevOps | ## Recursos relacionados + [Creando tu AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html) + [Unir una instancia de Amazon EC2 Windows a su AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/launching_instance.html) + [Regiones y motores de base de datos compatibles para la autenticación Kerberos en Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.KerberosAuthentication.html) + [Qué es SQL Server Management Studio (SSMS)?](https://learn.microsoft.com/en-us/ssms/sql-server-management-studio-ssms) # Configurar el acceso entre cuentas a Amazon DynamoDB *Shashi Dalmia, Imhoertha Ojior y Esteban Serna Parra, Amazon Web Services* ## Resumen Este patrón explica los pasos para configurar el acceso entre cuentas a Amazon DynamoDB mediante políticas basadas en recursos. En el caso de las cargas de trabajo que utilizan DynamoDB, cada vez es más común utilizar [estrategias de aislamiento de cargas de trabajo](https://aws.amazon.com/solutions/guidance/workload-isolation-on-aws/?did=sl_card&trk=sl_card) para minimizar las amenazas a la seguridad y cumplir con los requisitos de conformidad. La implementación de estrategias de aislamiento de la carga de trabajo a menudo requiere el acceso entre cuentas y regiones a los recursos de DynamoDB mediante AWS Identity and Access Management políticas basadas en la identidad (IAM). Esto implica establecer los permisos de IAM y establecer una relación de confianza entre. Cuentas de AWS [Las políticas basadas en recursos para DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/access-control-resource-based.html) simplifican en gran medida la postura de seguridad de las cargas de trabajo entre cuentas. Este patrón proporciona pasos y código de ejemplo para demostrar cómo se pueden configurar AWS Lambda las funciones en una sola cuenta Cuenta de AWS para escribir datos en una tabla de base de datos de DynamoDB en una cuenta diferente. ## Requisitos previos y limitaciones **Requisitos previos ** + Dos activas. Cuentas de AWS Este patrón hace referencia a estas cuentas como *Cuenta A* y *Cuenta B*. + AWS Command Line Interface (AWS CLI) [instalado](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) y [configurado](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) para acceder a la cuenta A y crear la tabla de DynamoDB. Los demás pasos de este patrón proporcionan instrucciones para usar las consolas IAM, DynamoDB y Lambda. Si piensa utilizarla AWS CLI en su lugar, configúrela para acceder a ambas cuentas. **Limitaciones** + Algunas Servicios de AWS no están disponibles en todas Regiones de AWS. Para conocer la disponibilidad de las regiones, consulte [Servicios de AWS by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para los puntos de conexión específicos, consulte la página [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) y elija el enlace del servicio. ## Arquitectura El siguiente diagrama muestra una arquitectura de cuenta única. AWS Lambda, Amazon Elastic Compute Cloud (Amazon EC2) y DynamoDB están todos en la misma cuenta. En este escenario, las funciones de Lambda y las EC2 instancias de Amazon pueden acceder a DynamoDB. Para conceder acceso a la tabla de DynamoDB, puede crear una política basada en identidades en IAM o una política basada en recursos en DynamoDB. ![\[Use los permisos de IAM para obtener acceso a una tabla de DynamoDB de la misma cuenta.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/bfc32fe8-5db0-4cac-a30f-b870a1a82875/images/cbb009eb-422d-4833-a1bc-0c571d83c21f.png) En el siguiente diagrama se muestra una arquitectura de varias cuentas. Si los recursos de una de ellas Cuenta de AWS requieren acceso a una tabla de DynamoDB de una cuenta diferente, debe configurar una política basada en recursos en DynamoDB para conceder el acceso necesario. Por ejemplo, en el siguiente diagrama, el acceso a la tabla de DynamoDB de la cuenta A se concede a una función de Lambda de la cuenta B mediante una política basada en recursos. ![\[Uso de una política basada en recursos para obtener acceso a una tabla de DynamoDB de otra cuenta.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/bfc32fe8-5db0-4cac-a30f-b870a1a82875/images/9f9165a8-b767-4427-a2ae-31b5b8c83326.png) En este patrón se describe el acceso entre cuentas entre Lambda y DynamoDB. Puede seguir estos pasos con otros pasos Servicios de AWS si se configuran los permisos adecuados en ambas cuentas. Por ejemplo, si desea proporcionar a una función de Lambda acceso a un bucket de Amazon Simple Storage Service (Amazon S3) en la cuenta A, puede crear una [política basada en recursos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-policies.html) en Amazon S3 y añadir los permisos al [rol de ejecución de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) en la cuenta B. ## Tools (Herramientas) **Servicios de AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) es un servicio de base de datos de NoSQL completamente administrado que ofrece un rendimiento rápido, predecible y escalable. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) le ayuda a administrar de forma segura el acceso a sus recursos de AWS al controlar quién está autenticado y autorizado a usarlos. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) es un servicio de computación que ayuda a ejecutar código sin necesidad de aprovisionar ni administrar servidores. Ejecuta el código solo cuando es necesario y amplía la capacidad de manera automática, por lo que solo pagará por el tiempo de procesamiento que utilice. **Código** Este patrón incluye código de muestra en la sección de [Información adicional](#configure-cross-account-access-to-amazon-dynamodb-additional) para ilustrar cómo se puede configurar una función de Lambda en la cuenta B para escribir en la tabla de DynamoDB de la cuenta A. El código se proporciona únicamente con fines ilustrativos y de prueba. Si va a implementar este patrón en un entorno de producción, utilice el código como referencia y personalícelo para su propio entorno. ## Prácticas recomendadas + Siga las [prácticas recomendadas para las políticas basadas en recursos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/rbac-best-practices.html) de la documentación de DynamoDB. + Cumpla con el principio de privilegio mínimo y conceda los permisos mínimos necesarios para llevar a cabo una tarea. Para obtener más información, consulte [Otorgar privilegio mínimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#grant-least-priv) y [Prácticas recomendadas de seguridad](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) en la documentación de IAM. ## Epics ### Creación de una política y rol de IAM para la función de Lambda en la cuenta B | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una política en la cuenta B. | Esta política de IAM permite la [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html)acción para una tabla de DynamoDB en la cuenta A.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | AWS general | | Cree un rol en la cuenta B. | La función de Lambda de la cuenta B utiliza este rol de IAM para acceder a la tabla de DynamoDB de la cuenta A.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)Para obtener más información sobre los usuarios de IAM, consulte la [documentación de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html). | AWS general | | Apunte el ARN del rol . | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | AWS general | ### Crear una tabla en DynamoDB en la cuenta A | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Crear una tabla de DynamoDB. | Utilice el siguiente AWS CLI comando para crear una tabla de DynamoDB.\ ] FROM WINDOWS;
GO
aws dynamodb create-table \Sustituya lo siguiente en el código de muestra:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)Para especificar la configuración de la política basada en los recursos en la declaración `create-table`, utilice el indicador `--resource-policy`. Esta política hace referencia al ARN de la tabla de DynamoDB de la cuenta A.Para obtener más información acerca de la creación de tablas, consulte la [documentación de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html). | AWS general | ### Creación de una función de Lambda en la cuenta B | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una función de Lambda para escribir datos en DynamoDB. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)Para obtener más información sobre la creación de funciones de Lambda, consulte la [documentación de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html). | AWS general | ### Limpieza | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Delete resources (Eliminar recursos). | Para evitar generar costos asociados a los recursos creados con este patrón, haga lo siguiente para eliminar los recursos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | AWS general | ## Resolución de problemas | Problema | Solución | | --- | --- | | Al crear la función de Lambda, recibe un error `ResourceNotFoundException`. | Confirme que ha introducido correctamente el ID Región de AWS y el ID de la cuenta A. Forman parte del ARN de la tabla de DynamoDB. | ## Recursos relacionados + [Introducción a DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) (documentación de DynamoDB) + [Introducción a Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) (documentación de Lambda) + [Uso de políticas basadas en recursos de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/access-control-resource-based.html) (documentación de DynamoDB) + [Creación de políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) (documentación de IAM) + [Lógica de evaluación de políticas entre cuentas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html) (documentación de IAM) + [Referencia de los elementos de las políticas de JSON de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) (documentación de IAM) ## Información adicional *Código de muestra* ``` 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') .El resultado devolverá el nombre de la réplica secundaria actual (`WSFCNODE1`). | Administrador de base de datos |
## Resolución de problemas
| Problema | Solución |
| --- | --- |
| No se puede crear el oyente y aparece el mensaje “El clúster WSFC no ha podido poner en línea el recurso Nombre de red”. | Para mayor información, consulte el blog de Microsoft [La creación del oyente dio el mensaje de error: “el clúster WSFC no ha podido poner en línea el recurso Nombre de red”](https://techcommunity.microsoft.com/t5/sql-server-support-blog/create-listener-fails-with-message-the-wsfc-cluster-could-not/ba-p/318235). |
| Posibles problemas, incluidos otros problemas con los oyentes o problemas de acceso a la red. | Consulte [Solución de problemas de configuración de grupos de disponibilidad 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) en la documentación de Microsoft. |
## Recursos relacionados
+ [Configure el enrutamiento de solo lectura en un grupo de disponibilidad Always On](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)
+ [Consulte Solución de problemas de configuración de grupos de disponibilidad 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)
## Información adicional
**Paso 1. Actualice las réplicas a solo lectura**
```
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
```
**Paso 2. Cree la URL de enrutamiento**
```
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
```
**Paso 3. Cree la URL de enrutamiento**
```
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
```
**Paso 4. Cree la lista de enrutamiento**
```
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
```
**Paso 5. Utilidad de comandos SQL**
```
sqlcmd -S SQLAG1,1433 -E -d test -K ReadOnly
```
# Conectar mediante un túnel SSH en pgAdmin
*Jeevan Shetty y Bhanu Ganesh Gudivada, Amazon Web Services*
## Resumen
Por motivos de seguridad, siempre es bueno colocar las bases de datos en una subred privada. Las consultas a la base de datos se pueden ejecutar conectándose a través de un host bastión de Amazon Elastic Compute Cloud (Amazon EC2) en una subred pública de la nube de Amazon Web Services (AWS). Esto requiere la instalación de software, como pgAdmin DBeaver o, que suelen utilizar los desarrolladores o administradores de bases de datos, en el host de Amazon. EC2
Ejecutar pgAdmin en un servidor Linux y acceder a él a través de un navegador web requiere la instalación de dependencias adicionales y la configuración de permisos.
Como solución alternativa, los desarrolladores o administradores de bases de datos pueden conectarse a una base de datos PostgreSQL mediante pgAdmin para habilitar un túnel SSH desde su sistema local. En este enfoque, pgAdmin utiliza el host de EC2 Amazon en la subred pública como host intermediario antes de conectarse a la base de datos. El diagrama de la sección de *arquitectura* muestra la configuración.
**nota**
Asegúrese de que el grupo de seguridad adjunto a la base de datos de PostgreSQL permita la conexión en el puerto 5432 desde el host de Amazon. EC2
## Requisitos previos y limitaciones
**Requisitos previos **
+ Una cuenta de AWS existente
+ Una nube privada virtual (VPC) con una subred pública y una subred privada
+ Una EC2 instancia con un grupo de seguridad adjunto
+ Base de datos de la edición compatible con Amazon Aurora PostgreSQL con un grupo de seguridad adjunto
+ Un par de claves Secure Shell (SSH) para configurar el túnel
**Versiones de producto**
+ pgAdmin versión 6.2\$1
+ Amazon Aurora, edición compatible con PostgreSQL, versión 12.7\$1
## Arquitectura
**Pila de tecnología de destino**
+ Amazon EC2
+ Amazon Aurora compatible con PostgreSQL
**Arquitectura de destino**
El siguiente diagrama muestra el uso de pgAdmin con un túnel SSH para conectarse a través de una puerta de enlace de Internet a EC2 la instancia, que se conecta a la base de datos.
![\[pgAdmin con túnel SSH se conecta a través de la puerta de enlace de Internet a la instancia que se conecta EC2 a la base de datos.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/7d25d570-5685-4f1a-bef0-212e257cb589/images/4556d930-f9b3-4b65-be5d-d40dd9437d5a.png)
## Tools (Herramientas)
**Servicios de AWS**
+ La [edición de Amazon Aurora compatible con PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) es un motor de base de datos relacional compatible con ACID, completamente administrado que le permite configurar, utilizar y escalar implementaciones de PostgreSQL.
+ [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/ec2/) proporciona capacidad informática escalable en la nube de AWS. Puede lanzar tantos servidores virtuales como necesite y escalarlos o reducirlos con rapidez.
**Otros servicios**
+ [pgAdmin](https://www.pgadmin.org/) es una herramienta de gestión de código abierto para PostgreSQL. Proporciona una interfaz gráfica que permite crear, mantener y utilizar objetos de bases de datos.
## Epics
### Creación de la conexión
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Cree un servidor. | En pgAdmin, seleccione **Crear** y, a continuación, **Servidor.** Para obtener ayuda adicional sobre la configuración de pgAdmin para registrar un servidor, configurar una conexión y conectarse a través de un túnel SSH mediante el cuadro de diálogo del servidor, consulte los enlaces de la sección *Recursos relacionados.* | Administrador de base de datos |
| Proporcione un nombre para el servidor. | En la pestaña **General**, introduzca un nombre. | Administrador de base de datos |
| Ingrese los detalles de base de datos. | En la pestaña **Conexión**, introduzca los valores siguientes:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/connect-by-using-an-ssh-tunnel-in-pgadmin.html) | Administrador de base de datos |
| Introduce los detalles EC2 del servidor de Amazon. | En la pestaña **Túnel SSH**, proporciona los detalles de la EC2 instancia de Amazon que se encuentra en la subred pública.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/connect-by-using-an-ssh-tunnel-in-pgadmin.html) | Administrador de base de datos |
| Guardar y conectar. | Seleccione **Guardar** para completar la configuración y conectarse a la base de datos Aurora compatible con PostgreSQL mediante el túnel SSH. | Administrador de base de datos |
## Recursos relacionados
+ [Diálogo del servidor](https://www.pgadmin.org/docs/pgadmin4/latest/server_dialog.html)
+ [Conectar al servidor](https://www.pgadmin.org/docs/pgadmin4/latest/connect_to_server.html)
# Convertir consultas JSON de Oracle en SQL de bases de datos PostgreSQL
*Pinesh Singal y Lokesh Gurram, Amazon Web Services*
## Resumen
Este proceso de migración para pasar del entorno local a la nube de Amazon Web Services (AWS) utiliza la herramienta de conversión de esquemas de AWS (AWS SCT) para convertir el código de una base de datos Orqacle en una base de datos PostgreSQL. AWS SCT convierte automáticamente la mayor parte del código. Sin embargo, las consultas de Oracle relacionadas con JSON no se convierten automáticamente.
A partir de la versión 12.2 de Oracle, Oracle Database admite varias funciones de JSON que ayudan a convertir los datos basados en JSON en datos basados en filas. Sin embargo, AWS SCT no convierte automáticamente los datos basados en JSON a un lenguaje compatible con PostgreSQL.
Este patrón de migración se centra principalmente en convertir manualmente las consultas de Oracle relacionadas con JSON con funciones como `JSON_OBJECT`, `JSON_ARRAYAGG`, y `JSON_TABLE` de una base de datos de Oracle a una base de datos PostgreSQL.
## Requisitos previos y limitaciones
**Requisitos previos **
+ Una cuenta de AWS activa
+ Una instancia de base de datos de Oracle local (en funcionamiento)
+ Una instancia de base de datos de Amazon Relational Database Service (Amazon RDS) para la Edición compatible con PostgreSQL o Amazon Aurora
**Limitaciones**
+ Las consultas relacionadas con JSON requieren un formato AND fijo `KEY` y `VALUE`. Si no se utiliza ese formato, se obtiene un resultado incorrecto.
+ Si algún cambio en la estructura de JSON añade pares nuevos `KEY` y `VALUE`en la sección de resultados, se debe cambiar el procedimiento o la función correspondiente en la consulta SQL.
+ Algunas funciones relacionadas con JSON se admiten en versiones anteriores de Oracle y PostgreSQL, pero con menos capacidades.
**Versiones de producto**
+ Oracle Database, versión 12.2 y posterior
+ Amazon RDS para PostgreSQL o Aurora, compatible con PostgreSQL, versión 9.5 y versiones posteriores
+ Última versión de AWS SCT (probadas con la versión 1.0.664)
## Arquitectura
**Pila de tecnología de origen**
+ Una instancia de base de datos de Oracle con la versión 19c
**Pila de tecnología de destino**
+ Una instancia de base de datos compatible con Amazon RDS para PostgreSQL o Aurora PostgreSQL con la versión 13
**Arquitectura de destino**
![\[La descripción sigue el diagrama.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/5e2c3b07-9ef5-417f-b049-bcea58f2c3ec/images/2ff8b00b-8849-4ef1-9be1-579f7b51be10.png)
1. Utilice AWS SCT con el código de función JSON para convertir el código fuente de Oracle a PostgreSQL.
1. La conversión produce archivos.sql migrados compatibles con PostgreSQL.
1. Convierta manualmente los códigos de función JSON de Oracle no convertidos en códigos de función JSON de PostgreSQL.
1. Ejecute los archivos.sql en la instancia de base de datos compatible con PostgreSQL de Aurora de destino.
## Tools (Herramientas)
**Servicios de AWS**
+ [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) es un motor de base de datos relacional completamente administrado diseñado para la nube y compatible con MySQL y PostgreSQL.
+ [Amazon Relational Database Service (Amazon RDS) para PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) le ayuda a configurar, utilizar y escalar una base de datos relacional de PostgreSQL en la nube de AWS.
+ La [Herramienta de conversión de esquemas de AWS (AWS SCT)](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html) simplifica las migraciones de bases de datos heterogéneas al convertir automáticamente el esquema de la base de datos de origen y la mayor parte del código personalizado, lo que incluye las vistas, los procedimientos almacenados y las funciones, a un formato compatible con la base de datos de destino.
**Otros servicios**
+ [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) es un entorno de desarrollo integrado que simplifica el desarrollo y la administración de bases de datos de Oracle, tanto en implementaciones tradicionales como en implementaciones basadas en la nube.
+ pgAdmin o. DBeaver [pgAdmin](https://www.pgadmin.org/) es una herramienta de gestión de código abierto para PostgreSQL. Proporciona una interfaz gráfica que le ayuda a crear, mantener y utilizar objetos de bases de datos. [DBeaver](https://dbeaver.io/)es una herramienta de base de datos universal.
## Prácticas recomendadas
La consulta de Oracle tiene el tipo `CAST` como valor predeterminado cuando se utiliza la función `JSON_TABLE`. Una buena práctica es utilizarla también `CAST` en PostgreSQL, utilizando caracteres dobles mayores que (`>>`).
Para obtener más información, consulte *Postgres\$1SQL\$1read\$1JSON* en la sección *Información adicional.*
## Epics
### Genere los datos JSON en las bases de datos de Oracle y PostgreSQL
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Guarde los datos JSON en la base de datos de Oracle. | Cree una tabla en la base de datos de Oracle y almacene los datos JSON en la columna `CLOB`. Utilice el *Oracle\$1Table\$1Creation\$1Insert\$1Script* que se encuentra en la sección *Información adicional*. | Ingeniero de migraciones |
| Guarde los datos JSON en la base de datos PostgreSQL. | Cree una tabla en la base de datos PostgreSQL y almacene los datos JSON en la columna `TEXT`. Utilice el archivo *Postgres\$1Table\$1Creation\$1Insert\$1Script* que se encuentra en la sección *Información adicional*. | Ingeniero de migraciones |
### Convierte el JSON al formato ROW
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Convertir los datos JSON en la base de datos de Oracle. | Escriba una consulta SQL de Oracle para leer los datos JSON en formato ROW. Para obtener más detalles y ejemplos de sintaxis, consulte *Oracle\$1SQL\$1read\$1JSON* en la sección *Información adicional*. | Ingeniero de migraciones |
| Convierta los datos JSON en la base de datos PostgreSQL. | Escriba una consulta de PostgreSQL para leer los datos JSON en formato ROW. Para obtener más detalles y ejemplos de sintaxis, consulte *Oracle\$1SQL\$1read\$1JSON* en la sección *Información adicional*. | Ingeniero de migraciones |
### Convertir manualmente los datos JSON mediante la consulta SQL e informe el resultado en formato JSON
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Realizar agregaciones y validaciones en la consulta SQL de Oracle. | Para convertir manualmente los datos de JSON, realice una unión, agregación y validación en la consulta SQL de Oracle e informe el resultado en formato JSON. Utilice el código que aparece en *Oracle\$1SQL\$1JSON\$1Aggregation\$1JOIN* en la sección *Información adicional*.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/convert-json-oracle-queries-into-postgresql-database-sql.html) | Ingeniero de migraciones |
| Realice agregaciones y validaciones en la consulta SQL de Postgres. | Para convertir manualmente los datos de JSON, realice una unión, agregación y validación en la consulta de PostgreSQL e informe el resultado en formato JSON. Use el código que aparece en *Postgres\$1SQL\$1JSON\$1AGGREGATION\$1JOIN* en la sección *Información adicional*.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/convert-json-oracle-queries-into-postgresql-database-sql.html) | Ingeniero de migraciones |
### Convertir el procedimiento de Oracle en una función de PostgreSQL que contenga consultas JSON
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Convierta las consultas JSON del procedimiento de Oracle en filas. | Para el procedimiento de Oracle de ejemplo, utilice la consulta de Oracle anterior y el código de *Oracle\$1Procedure\$1with\$1JSON\$1Query* en la sección *Información adicional*. | Ingeniero de migraciones |
| Convierta las funciones de PostgreSQL que tienen consultas JSON en datos basados en filas. | Para las funciones de PostgreSQL de ejemplo, utilice la consulta de PostgreSQL anterior y el código que se encuentra en *Postgres\$1function\$1with\$1JSON\$1Query* en la sección *Información adicional*. | Ingeniero de migraciones |
## Recursos relacionados
+ [Funciones JSON de Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/adjsn/generation.html)
+ [Funciones JSON de PostgreSQL](https://www.postgresql.org/docs/13/functions-json.html)
+ [Ejemplos de funciones JSON de Oracle](https://oracle-base.com/articles/12c/sql-json-functions-12cr2)
+ [Ejemplos de funciones JSON de PostgreSQL](https://dba.stackexchange.com/questions/69655/select-columns-inside-json-agg)
+ [Herramienta de conversión de esquemas de AWS](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html)
## Información adicional
Para convertir el código JSON de la base de datos de Oracle a la base de datos PostgreSQL, utilice los siguientes scripts en orden.
**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**
Los siguientes bloques de código muestran cómo convertir los datos JSON de Oracle a formato de fila.
*Ejemplo de consulta y sintaxis*
```
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 );
```
El documento JSON almacena los datos como colecciones. Cada colección puede tener pares `KEY` y `VALUE`. Cada `VALUE` puede tener anidados pares `KEY` y `VALUE`. En la siguiente tabla se proporciona información sobre la lectura del `VALUE` específico del documento JSON.
|
|
| KEY | HIERARCHY or PATH to be used to get the VALUE | VALUE |
| --- |--- |--- |
| `profileType` | `metadata` -> `profileType` | «P» |
| `positionId` | `data` -> `positionId` | «0100» |
| `accountNumber` | `data` -> account -> `accountNumber` | 42000 |
En la tabla anterior, `KEY` `profileType` es una `VALUE` de las `metadata` `KEY`. El `KEY` `positionId` es un `VALUE` de los `data` `KEY`. El `KEY` `accountNumber` es un `VALUE` de los `account``KEY`, y el `account` `KEY` es un `VALUE` de los `data``KEY`.
*Ejemplo 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 que se utiliza para obtener los campos seleccionados del 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
```
En la consulta anterior, `JSON_TABLE` es una función integrada en Oracle que convierte los datos JSON en formato de fila. La función JSON\$1TABLE espera parámetros en formato JSON.
Cada elemento `COLUMNS` tiene un valor predefinido `PATH`, y cuando hay un `VALUE` adecuado para un determinado elemento `KEY`, se devuelve en formato de fila.
*Resultado de la consulta anterior*
|
|
| PARENT\$1ACCOUNT\$1NUMBER | ACCOUNT\$1NUMBER | BUSINESS\$1UNIT\$1ID | POSITION\$1ID |
| --- |--- |--- |--- |
| 32000 | 42000 | 7 | 0100 |
| 32001 | 42001 | 6 | 0090 |
**4. Postgres\$1SQL\$1READ\$1JSON**
** ***Ejemplo de consulta y sintaxis*
```
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 ;
```
En Oracle, `PATH` se utiliza para identificar el `KEY` y `VALUE` especifico. Sin embargo, PostgreSQL utiliza un modelo `HIERARCHY` para leer `KEY` y `VALUE` desde JSON. Los mismos datos de JSON que se mencionan en `Oracle_SQL_Read_JSON` se utilizan en los siguientes ejemplos.
*No se admiten consultas SQL de tipo CAST*
(Si fuerza el tipo de texto `CAST`, la consulta fallará y se producirá un error de sintaxis).
```
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 ;
```
Si se utiliza un operador una vez mayor (`>`), se devolverá el `VALUE` definido para ese `KEY`. Por ejemplo, `KEY`: `positionId`, y `VALUE`: `"0100"`.
No se permite escribir el tipo `CAST` cuando se utiliza el operador una vez mayor (`>`).
*Se admiten consultas SQL de tipo CAST*
```
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 el tipo `CAST`, debe usar un operador mayor del doble. Si utiliza el operador una vez mayor, la consulta devuelve el `VALUE` definido (por ejemplo `KEY`: `positionId`, y `VALUE`: `"0100"`). Si se utiliza el operador mayor del doble (`>>`), se devolverá el valor real definido para ese valor `KEY` (por ejemplo, `KEY`: `positionId`, y `VALUE`: `0100` sin comillas dobles).
En el caso anterior, `parentAccountNumber` es el tipo `CAST` a `INT`, `accountNumber` es el tipo `CAST` a `INT`, `businessUnitId` es el tipo `CAST` a `INT`, y `positionId` es el tipo `CAST` a `VARCHAR`.
En las tablas siguientes se muestran los resultados de las consultas que explican el papel del operador único mayor que (`>`) y del operador doble mayor que (`>>`).
En la primera tabla, la consulta utiliza el único operador mayor que (`>`). Cada columna es de tipo JSON y no se puede convertir en otro tipo de datos.
|
|
| parentAccountNumber | Número de cuenta | businessUnitId | ID de puesto |
| --- |--- |--- |--- |
| 2003565430 | 2003564830 | 7 | «0100» |
| 2005284042 | 2005284042 | 6 | “0090” |
| 2000272719 | 2000272719 | 1 | «0100» |
En la segunda tabla, la consulta utiliza el operador doble mayor que (`>>`). Cada columna admite el tipo `CAST` en función del valor de la columna. Por ejemplo, en este caso `INTEGER`.
|
|
| parentAccountNumber | Número de cuenta | businessUnitId | ID de puesto |
| --- |--- |--- |--- |
| 2003565430 | 2003564830 | 7 | 0100 |
| 2005284042 | 2005284042 | 6 | 0090 |
| 2000272719 | 2000272719 | 1 | 0100 |
**5. Oracle\$1SQL\$1JSON\$1AGGREGATION\$1JOIN**
*Consulta de ejemplo*
```
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 convertir los datos de nivel de fila al formato JSON, Oracle tiene funciones integradas como `JSON_OBJECT`, `JSON_ARRAY`, `JSON_OBJECTAGG` y `JSON_ARRAYAGG`.
+ `JSON_OBJECT` acepta dos parámetros: `KEY` y `VALUE`. El parámetro `KEY` debe estar codificado de forma rígida o ser de naturaleza estática. El parámetro `VALUE` se deriva de la salida de la tabla.
+ `JSON_ARRAYAGG` acepta `JSON_OBJECT` como parámetro. Esto ayuda a agrupar el conjunto de `JSON_OBJECT` elementos en forma de lista. Por ejemplo, si tiene un elemento `JSON_OBJECT` que tiene varios registros (múltiples pares `KEY` y `VALUE`en el conjunto de datos), `JSON_ARRAYAGG` agrega el conjunto de datos y crea una lista. Según el lenguaje de estructura de datos, `LIST` es un grupo de elementos. En este contexto, `LIST` es un grupo de elementos `JSON_OBJECT`.
En el siguiente ejemplo, se muestra un elemento `JSON_OBJECT`.
```
{
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
```
En el siguiente ejemplo, se muestran dos elementos `JSON_OBJECT`, con `LIST` indicado mediante llaves cuadradas (`[ ]`).
```
[
{
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
,
{
"taxProfessionalCount": 2,
"attorneyCount": 1,
"nonAttorneyCount": 3,
"clerkCount":4
}
]
```
*Ejemplo 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
);
```
*Ejemplo de resultado de la 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**
Las funciones integradas de PostgresQL `JSON_BUILD_OBJECT` y `JSON_AGG` convierten los datos de nivel de fila a formato JSON. PostgreSQL `JSON_OBJECT` y `JSON_AGG`son equivalentes a Oracle `JSON_BUILD_OBJECT` y `JSON_ARRAYAGG`.
*Consulta de ejemplo*
```
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;
```
*Ejemplo de salida de la consulta anterior*
Las salidas de Oracle y PostgreSQL son exactamente las mismas.
```
{
"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**
Este código convierte el procedimiento de Oracle en una función de PostgreSQL que tiene consultas JSON SQL. Muestra cómo la consulta transpone JSON a filas y viceversa.
```
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;
/
```
*Ejecutando el procedimiento*
El siguiente bloque de código explica cómo puede ejecutar el procedimiento de Oracle creado anteriormente con una entrada JSON de ejemplo en el procedimiento. También proporciona el resultado o la salida de este procedimiento.
```
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;
/
```
*Resultado del procedimiento*
```
{
"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**
*Función de ejemplo*
```
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;
$$;
```
*Ejecución de la función*
```
select f_pg_json_test('{
"accounts": [{
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}, {
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}]
}') ;
```
*Salida de función*
La siguiente salida de es similar a la salida del procedimiento de Oracle. La diferencia es que esta salida está en 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 tablas de Amazon DynamoDB entre cuentas mediante AWS Backup
*Ramkumar Ramanujam, Amazon Web Services*
## Resumen
Cuando se trabaja con Amazon DynamoDB AWS, un caso de uso común es copiar o sincronizar tablas de DynamoDB en entornos de desarrollo, pruebas o ensayo con los datos de la tabla que se encuentran en el entorno de producción. Como práctica estándar, cada entorno utiliza una Cuenta de AWS diferente.
AWS Backup admite la copia de seguridad y la restauración de datos entre regiones y cuentas para DynamoDB, Amazon Simple Storage Service (Amazon S3) y otros. Servicios de AWS Este patrón proporciona los pasos para utilizar la copia de seguridad y la restauración AWS Backup entre cuentas para copiar tablas de DynamoDB entre ellas. Cuentas de AWS
## Requisitos previos y limitaciones
**Requisitos previos **
+ Dos activos Cuentas de AWS que pertenecen a la misma organización en AWS Organizations
+ Permisos para crear tablas de DynamoDB en ambas cuentas
+ AWS Identity and Access Management Permisos (IAM) para crear y usar bóvedas AWS Backup
**Limitaciones**
+ El origen y el destino Cuentas de AWS deben formar parte de la misma organización en. AWS Organizations
## Arquitectura
**Pila de tecnología de destino**
+ AWS Backup
+ Amazon DynamoDB
**Arquitectura de destino**
![\[La descripción para copiar la tablas entre almacenes de copia de seguridad sigue el diagrama.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/ef6e7393-edb6-4744-be26-43f1cbff9de9/images/fa9f3f2f-7a01-4093-9bd5-fc355e57ba67.png)
1. Cree la copia de seguridad de la tabla de DynamoDB en AWS Backup el almacén de copias de seguridad de la cuenta de origen.
1. Copie la copia de seguridad en el almacén de copias de seguridad de la cuenta de destino.
1. Restaure la tabla de DynamoDB en la cuenta de destino mediante la copia de seguridad del almacén de copias de seguridad de la cuenta de destino.
**Automatización y escala**
Puede utilizarla AWS Backup para programar las copias de seguridad para que se ejecuten a intervalos específicos.
## Tools (Herramientas)
+ [AWS Backup](https://docs.aws.amazon.com/aws-backup/latest/devguide/whatisbackup.html)es un servicio totalmente gestionado para centralizar y automatizar la protección de datos tanto en la nube como en las instalaciones. Servicios de AWS Con este servicio, puede configurar las políticas de respaldo y monitorear la actividad de sus AWS recursos en un solo lugar. Le permite automatizar y consolidar las tareas de copia de seguridad que antes se realizaban servicio por servicio y elimina la necesidad de crear scripts personalizados y procesos manuales.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) es un servicio de base de datos NoSQL totalmente administrado que ofrece un rendimiento rápido y predecible, así como una perfecta escalabilidad.
## Epics
### Activa AWS Backup las funciones en las cuentas de origen y destino
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Active las características avanzadas de copia de seguridad de DynamoDB y entre cuentas. | Tanto en la fuente como en la de destino Cuentas de AWS, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, ingeniero de migración |
### Crear almacenes de copia de seguridad en las cuentas de origen y destino
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Cree almacenes de copias de seguridad. | Tanto en el origen como en el destino Cuentas de AWS, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html)Al copiar la copia ARNs de seguridad de la tabla de DynamoDB entre las cuentas de origen y destino, se necesitarán las bóvedas de copia de seguridad de origen y destino. | AWS DevOps, ingeniero de migración |
### Realizar copias de seguridad y restaurar mediante almacenes de copias de seguridad
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| En la cuenta de origen, cree una copia de seguridad de la tabla de DynamoDB. | Para crear una copia de seguridad de la tabla de DynamoDB en la cuenta de origen, realice lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html)Se creará un nuevo trabajo de copia de seguridad. Para supervisar el estado del trabajo de copia de seguridad, en la página AWS Backup **Trabajos**, seleccione la pestaña **Trabajos de copia** de seguridad. En esta pestaña se muestran todos los trabajos de copia de seguridad activos, en curso y finalizados. | AWS DevOps, DBA, ingeniero de migración |
| Copie la copia de seguridad de la cuenta de origen a la cuenta de destino. | Una vez finalizado el trabajo de copia de seguridad, copie la copia de seguridad de la tabla de DynamoDB del almacén de copias de seguridad de la cuenta de origen al almacén de copias de seguridad de la cuenta de destino.Para copiar el almacén de copias de seguridad, realice lo siguiente en la cuenta de origen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, ingeniero de migración, administrador de bases de datos |
| Restaurar la copia de seguridad en la cuenta de destino. | En el objetivo Cuenta de AWS, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, DBA, ingeniero de migración |
## Recursos relacionados
+ [Uso AWS Backup con DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/backuprestore_HowItWorksAWS.html)
+ [Crear copias de seguridad en Cuentas de AWS](https://docs.aws.amazon.com/aws-backup/latest/devguide/create-cross-account-backup.html)
+ [AWS Backup precios](https://aws.amazon.com/backup/pricing/)
# Copiar tablas de Amazon DynamoDB entre cuentas mediante una implementación personalizada
*Ramkumar Ramanujam, Amazon Web Services*
## Resumen
Cuando se trabaja con Amazon DynamoDB en Amazon Web Services (AWS), un caso de uso habitual consiste en copiar o sincronizar tablas de DynamoDB en entornos de desarrollo, de prueba o de ensayo con datos de la tabla que se encuentra en el entorno de producción. Como práctica estándar, cada entorno utiliza una cuenta AWS diferente.
DynamoDB ahora admite copias de seguridad entre cuentas mediante AWS Backup. Para obtener información sobre los costos de almacenamiento asociados al uso de AWS Backup, consulte los [precios de AWS Backup](https://aws.amazon.com/backup/pricing/). Cuando se utiliza AWS Backup para copiar entre cuentas, las cuentas de origen y de destino deben formar parte de una organización de AWS Organizations. Existen otras soluciones para realizar copias de seguridad y restauraciones entre cuentas mediante servicios de AWS, como AWS Glue. Sin embargo, el uso de esas soluciones aumenta el tamaño de las aplicaciones, ya que es necesario implementar y mantener más servicios de AWS.
También puede utilizar Amazon DynamoDB Streams para capturar los cambios en la tabla de la cuenta de origen. A continuación, puede iniciar una función de AWS Lambda y realizar los cambios correspondientes en la tabla de destino de la cuenta de destino. Sin embargo, esa solución se aplica a los casos de uso en los que las tablas de origen y de destino deben mantenerse siempre sincronizadas. Es posible que no se aplique a los entornos de desarrollo, pruebas y uso transitorio en los que los datos se actualizan con frecuencia.
Este patrón proporciona los pasos para implementar una solución personalizada para copiar una tabla de Amazon DynamoDB de una cuenta a otra. Este patrón se puede implementar mediante lenguajes de programación comunes, como C\$1, Java y Python. Recomendamos utilizar un lenguaje que sea compatible con un [AWS SDK](https://aws.amazon.com/tools/).
## Requisitos previos y limitaciones
**Requisitos previos **
+ Dos cuentas de AWS activas
+ Tablas de DynamoDB en ambas cuentas
+ Configuración de políticas y roles de AWS Identity and Access Management (IAM)
+ Conocimiento de cómo acceder a las tablas de Amazon DynamoDB mediante cualquier lenguaje de programación común, como C\$1, Java o Python
**Limitaciones**
Este patrón se aplica a las tablas de DynamoDB de alrededor de 2 GB o menos. Con una lógica adicional para gestionar las interrupciones de conexión o sesión, las limitaciones y los errores y reintentos, también se puede utilizar para tablas más grandes.
La operación de escaneo de DynamoDB, que lee los elementos de la tabla de origen, solo puede recuperar hasta 1 MB de datos en una sola llamada. En el caso de tablas más grandes, de más de 2 GB, esta limitación puede aumentar el tiempo total necesario para realizar una copia completa de la tabla.
## Arquitectura
El siguiente diagrama muestra la implementación personalizada entre las cuentas de AWS de origen y destino. Las políticas de IAM y los tokens de seguridad se utilizan con la implementación personalizada. Los datos se leen desde Amazon DynamoDB en la cuenta de origen y se escriben en DynamoDB en la cuenta de destino.
![\[Arquitectura de cuentas de origen y destino para copiar mediante la implementación personalizada.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/ba8175be-9809-4c2e-b2d1-6b9180ed056c/images/d9d4c2c8-ff04-443f-9137-e37b8e23ccb5.png)
**Automatización y escala**
Este patrón se aplica a las tablas de DynamoDB de tamaño más pequeño, de unos 2 GB.
Para aplicar este patrón a tablas más grandes, aborde los problemas siguientes:
+ Durante la operación de copia de la tabla, se mantienen dos sesiones activas, utilizando diferentes tokens de seguridad. Si la operación de copia de la tabla tarda más que los tiempos de caducidad del token, debe implementar una lógica para actualizar los tokens de seguridad.
+ Si no se aprovisionan suficientes unidades de capacidad de lectura (RCUs) y unidades de capacidad de escritura (WCUs), es posible que se limiten las lecturas o escrituras en la tabla de origen o destino. Asegúrese de atrapar y gestionar estas excepciones.
+ Controle cualquier otro error o excepción y establezca un mecanismo de reintento para volver a intentarlo o continuar desde el punto en el que se produjo el error en la operación de copia.
## Tools (Herramientas)
**Herramientas**
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html): Amazon DynamoDB es un servicio de base de datos NoSQL totalmente administrado que ofrece un rendimiento rápido y predecible, así como una perfecta escalabilidad.
+ Las herramientas adicionales necesarias variarán según el lenguaje de programación que se elija para la implementación. Por ejemplo, si usa C\$1, necesitará Microsoft Visual Studio y los siguientes NuGet paquetes:
+ `AWSSDK`
+ `AWSSDK.DynamoDBv2`
**Código**
El siguiente fragmento de código de Python elimina y vuelve a crear una tabla de DynamoDB mediante la biblioteca Boto3.
No utilice el `AWS_ACCESS_KEY_ID` ni el `AWS_SECRET_ACCESS_KEY` de un nombre de usuario de IAM porque se trata de credenciales a largo plazo, que deben evitarse para el acceso programático a los servicios de AWS. Para obtener más información sobre cómo usar credenciales de seguridad temporales, consulte la sección *Prácticas recomendables*.
Las credenciales `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` y `TEMPORARY_SESSION_TOKEN` utilizadas en el siguiente fragmento de código son credenciales temporales obtenidas de 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ácticas recomendadas
**Credenciales temporales**
Como práctica recomendada de seguridad, al acceder a los servicios de AWS mediante programación, se debe evitar utilizar `AWS_ACCESS_KEY_ID` y `AWS_SECRET_ACCESS_KEY` de un usuario de IAM, ya que se trata de credenciales a largo plazo. Intente utilizar siempre credenciales temporales para acceder a los servicios de AWS mediante programación.
Así, por ejemplo, un desarrollador codifica de forma rígida la dirección `AWS_ACCESS_KEY_ID` y `AWS_SECRET_ACCESS_KEY` de un usuario de IAM en la aplicación durante el desarrollo, pero no elimina los valores codificados antes de incorporar los cambios en el repositorio de código. Estas credenciales expuestas pueden ser utilizadas por usuarios de forma involuntaria o malintencionada, lo que puede tener graves consecuencias (especialmente si las credenciales expuestas tienen privilegios de administrador). Estas credenciales expuestas se deben desactivar o eliminar inmediatamente mediante la consola de IAM o interfaz de la línea de comandos de AWS (AWS CLI).
Para obtener credenciales temporales para el acceso mediante programación a los servicios de AWS, utilice AWS STS. Las credenciales temporales son válidas solo durante el tiempo especificado (de 15 minutos a 36 horas). La duración máxima permitida de las credenciales temporales varía en función de factores como la configuración de los roles y el encadenamiento de funciones. Para obtener más información acerca de AWS STS, consulte la [ documentación](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html).
## Epics
### Configurar tablas de DynamoDB
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Cree tablas de DynamoDB. | Cree tablas de DynamoDB, con índices, en las cuentas de AWS de origen y de destino.Configure el aprovisionamiento de capacidad como modo bajo demanda, lo que permite a DynamoDB read/write escalar las capacidades de forma dinámica en función de la carga de trabajo. Como alternativa, puede utilizar la capacidad aprovisionada con 4000 y 4000. RCUs WCUs | Desarrollador de aplicaciones, administrador de bases de datos e ingeniero de migraciones |
| Rellene la tabla de origen. | Rellene la tabla de DynamoDB de la cuenta de origen con datos de prueba. Tener al menos 50 MB o más de datos de prueba le ayuda a ver el consumo máximo y medio RCUs consumido durante la copia de la tabla. A continuación, puede cambiar el aprovisionamiento de capacidad según sea necesario. | Desarrollador de aplicaciones, administrador de bases de datos e ingeniero de migraciones |
### Configurar las credenciales para acceder a las tablas de DynamoDB
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Cree roles de IAM para acceder a las tablas de DynamoDB de origen y destino. | Cree un rol de IAM en la cuenta de origen con permisos de acceso (lectura) a la tabla de DynamoDB de la cuenta de origen.Agregue la cuenta de origen como entidad de confianza para este rol.Cree un rol de IAM en la cuenta de destino con permisos de acceso (creación, lectura, actualización, eliminación) a la tabla de DynamoDB de la cuenta de destino. Agregue la cuenta de destino como entidad de confianza para este rol. | Desarrollador de aplicaciones, AWS DevOps |
### Copiar datos de tablas de una cuenta a otra
| Tarea | Descripción | Habilidades requeridas |
| --- | --- | --- |
| Obtenga credenciales temporales para los roles de IAM. | Obtenga credenciales temporales para el rol de IAM creado en la cuenta de origen.Obtenga credenciales temporales para el rol de IAM creado en la cuenta de destino.Una forma de obtener las credenciales temporales para el rol de IAM es usar AWS STS desde la AWS CLI.aws sts assume-role --role-arn arn:aws:iam::Utilice el perfil de AWS adecuado (correspondiente a la cuenta de origen o de destino).Para obtener más información sobre cómo obtener credenciales temporales consulte lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html) | Desarrollador de aplicación, ingeniero de migraciones | | Inicialice los clientes de DynamoDB para el acceso a DynamoDB de origen y destino. | Inicialice los clientes de DynamoDB, que proporciona AWS SDK, para las tablas de DynamoDB de origen y destino.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html)Para obtener más información sobre cómo realizar solicitudes mediante credenciales temporales de IAM, consulte la [Documentación de AWS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/AuthUsingTempSessionToken.html). | Desarrollador de aplicaciones | | Eliminar y recrear la tabla de destino. | Elimine y vuelva a crear la tabla de DynamoDB de destino (junto con los índices) en la cuenta de destino mediante el cliente DynamoDB de la cuenta de destino.Eliminar todos los registros de una tabla de DynamoDB es una operación costosa porque consume aprovisionamiento. WCUs Al eliminar y volver a crear la tabla, se evitan esos costos adicionales.Puede añadir índices a una tabla después de crearla, pero esto requiere de 2 a 5 minutos más. Resulta más eficiente crear índices durante la creación de la tabla, pasando la colección de índices a la llamada `createTable`. | Desarrollador de aplicaciones | | Realice la copia de la tabla. | Repita los pasos siguientes hasta que se copien todos los datos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html)Para obtener más información, consulte la implementación de referencia en C\$1 (para eliminar, crear y rellenar tablas) en la sección de *adjuntos.* También se adjunta un ejemplo de archivo de notación de JavaScript objetos (JSON) de configuración de tablas. | Desarrollador de aplicaciones | ## Recursos relacionados + [Documentación de Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) + [Creación de un usuario de IAM en su cuenta de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html) + [AWS SDKs](https://aws.amazon.com/tools/) + [Using temporary credentials with AWS resources](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) (Usar credenciales temporales con recursos de AWS) ## Información adicional Este patrón se implementó con C\$1 para copiar una tabla de DynamoDB con 200 000 elementos (el tamaño medio de los elementos es de 5 KB y el tamaño de la tabla de 250 MB). La tabla de DynamoDB de destino se configuró con una capacidad aprovisionada de 4000 y 4000. RCUs WCUs La operación completa de copia de la tabla (de la cuenta de origen a la cuenta de destino), incluida la eliminación y la recreación de la tabla, duró 5 minutos. Capacidad total de unidades consumidas: 30 000 RCUs y aproximadamente 400 000. WCUs Para obtener más información sobre los modos de capacidad de DynamoDB, consulte [Read/Write capacity mode](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html) (Modo de capacidad de lectura/escritura) en la documentación de AWS. ## Conexiones Para acceder al contenido adicional asociado a este documento, descomprima el archivo: [attachment.zip](samples/p-attach/ba8175be-9809-4c2e-b2d1-6b9180ed056c/attachments/attachment.zip) # Crear informes detallados de costos y uso para Amazon RDS y Amazon Aurora *Lakshmanan Lakshmanan y Sudarshan Narasimhan, Amazon Web Services* ## Resumen Este patrón muestra cómo realizar un seguimiento de los costos de uso de los clústeres de Amazon Relational Database Service (Amazon RDS) o Amazon Aurora mediante la configuración de [etiquetas de asignación de costos definidas por el usuario](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/custom-tags.html). Puede usar estas etiquetas para crear informes detallados de costos y uso en el explorador de costos de AWS para clústeres en varias dimensiones. Por ejemplo, puede realizar un seguimiento de los costos de uso a nivel de equipo, proyecto o centro de costos y, a continuación, analizar los datos en Amazon Athena. ## Requisitos previos y limitaciones **Requisitos previos ** + Una cuenta de AWS activa + Una o más instancias de [Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateDBInstance.html) o [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.CreateInstance.html) **Limitaciones** Para conocer las restricciones de etiquetado, consulte la [Guía del usuario de facturación de AWS](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/allocation-tag-restrictions.html). ## Arquitectura **Pila de tecnología de destino** + Amazon RDS o Amazon Aurora + AWSInforme de uso y costos + Explorador de costos de AWS + Amazon Athena **Flujo de trabajo y arquitectura** El flujo de trabajo de etiquetado y análisis consta de los siguientes pasos: 1. Un ingeniero de datos, un administrador de bases de datos o un administrador de AWS crea etiquetas de asignación de costos definidas por el usuario para los clústeres de Amazon RDS o Aurora. 1. Un administrador de AWS activa las etiquetas. 1. Las etiquetas envían los metadatos al explorador de costos de AWS. 1. Un ingeniero de datos, un administrador de bases de datos o un administrador de AWS crea un [informe mensual de asignación de costos](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/configurecostallocreport.html#allocation-viewing). 1. Un ingeniero de datos, un administrador de bases de datos o un administrador de AWS analiza el informe mensual de asignación de costos mediante Amazon Athena. En el siguiente diagrama, se muestra cómo aplicar etiquetas para realizar un seguimiento de los costos de uso de las instancias de Amazon RDS o Aurora. ![\[Aplicar etiquetas para realizar un seguimiento de los costos de uso de las instancias y los clústeres de bases de datos\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/eab5001d-5115-4aa6-bdd2-23063b08b262/images/63292b18-01d6-4523-b8ac-2c3b12b11b84.png) El siguiente diagrama de arquitectura muestra cómo el informe de asignación de costos se integra con Amazon Athena para su análisis. ![\[Consultar informes de asignación de costos en Athena\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/eab5001d-5115-4aa6-bdd2-23063b08b262/images/9c028405-1e93-4f6a-a0e5-36154e2b8eab.png) El informe de asignación de costos mensual se almacena en un bucket de Amazon S3 que especifique. Al configurar Athena con la CloudFormation plantilla de AWS, tal y como se describe en la sección *Epics*, la plantilla incluye varios recursos adicionales, como un rastreador de AWS Glue, una base de datos de AWS Glue, un evento del Amazon Simple Notification System (Amazon SNS), funciones de AWS Lambda y roles de AWS Identity and Access Management (IAM) para las funciones de Lambda. A medida que llegan nuevos archivos de datos de costos al bucket de S3, las notificaciones de eventos se utilizan para reenviar estos archivos a una función de Lambda para su procesamiento. La función de Lambda inicia un trabajo de rastreador de AWS Glue para crear o actualizar la tabla en el catálogo de datos de AWS Glue. Esta tabla se usa a continuación para consultar datos en Athena. ## Tools (Herramientas) + [Amazon Athena](https://aws.amazon.com/athena/) es un servicio de consultas interactivo que facilita el análisis de datos en Amazon S3 con SQL estándar. + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) es un motor de base de datos relacional completamente administrado diseñado para la nube y compatible con MySQL y PostgreSQL. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) le ayuda a configurar, utilizar y escalar una base de datos relacional en la nube de AWS. + [AWS CloudFormation](https://aws.amazon.com/cloudformation/) es un servicio de infraestructura como código (IaC) que le permite modelar, aprovisionar y administrar fácilmente recursos de AWS y de terceros. + El [Explorador de costos de AWS](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/ce-what-is.html) permite ver y analizar los costos y el uso. ## Epics ### Crear y activar etiquetas para su clúster de Amazon RDS o Aurora | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree etiquetas de asignación de costos definidas por el usuario para su clúster de Amazon RDS o Aurora. | Para añadir etiquetas a un clúster de Amazon RDS o Aurora nuevo o existente, siga las instrucciones de [Cómo añadir, publicar y eliminar etiquetas](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html#Tagging.HowTo) de la *Guía del usuario de Amazon Aurora*.Para obtener información sobre cómo configurar un clúster de Amazon Aurora, consulte las instrucciones para [MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.Aurora.html) y [PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.AuroraPostgreSQL.html) en la *Guía del usuario de Amazon Aurora*. | Administrador de AWS, ingeniero de datos, administrador de bases de datos | | Active las etiquetas de asignación de costos definidas por el usuario. | Siga las instrucciones de [Activación de etiquetas de asignación de costos definidas por el usuario](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/activating-tags.html) en la *Guía del usuario de facturación de AWS*. | Administrador de AWS | ### Crear informes de uso y costo | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree y configure informes de costos y uso para sus clústeres. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/create-detailed-cost-and-usage-reports-for-amazon-rds-and-amazon-aurora.html)Los datos estarán disponibles en 24 horas. | Propietario de la aplicación, administrador de AWS, administrador de bases de datos, AWS general, ingeniero de datos | ### Analizar los datos de los informes de costos y uso | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Analice los datos del informe de costos y uso. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/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 obtener más información, consulte [Ejecutar consultas de Amazon Athena](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-run.html) en la *Guía del usuario de los informes de costos y uso de AWS*.Cuando ejecute su consulta de SQL, asegúrese de que la base de datos correcta esté seleccionada en la lista desplegable. | Propietario de la aplicación, administrador de AWS, administrador de bases de datos, AWS general, ingeniero de datos | ## Recursos relacionados **Referencias** + [Configuración de Athena con CloudFormation plantillas de AWS (recomendado](https://docs.aws.amazon.com/cur/latest/userguide/use-athena-cf.html)) + [Configuración manual de Athena](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-manual.html) + [Ejecutar consultas de Amazon Athena](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-run.html) + [Cargar datos de informes en otros recursos](https://docs.aws.amazon.com/cur/latest/userguide/cur-query-other.html) **Tutoriales y videos** + [Analice los informes de costos y uso con Amazon Athena (vídeo](https://youtu.be/KEeJEZTYE8E)) YouTube # Implemente instancias de clústeres de conmutación por error de SQL Server en Amazon EC2 y Amazon FSx mediante Terraform *Mark Hudson y Matt Burgess, Amazon Web Services* ## Resumen Este patrón utiliza Terraform para implementar instancias de clústeres de conmutación por error de SQL Server (FCIs) en los nodos del clúster de conmutación por error de Windows Server (WSFC) de Amazon Elastic Compute Cloud (Amazon). EC2 Además, el patrón utiliza el almacenamiento FSx compartido de Amazon para los datos y los archivos de registro. Cuando se migran las bases de datos de SQL Server a AWS, la primera opción es Amazon RDS for SQL Server. Sin embargo, a veces Amazon RDS for SQL Server no es adecuado y SQL Server debe implementarse en EC2 Amazon en una arquitectura de alta disponibilidad. En esta solución, los servidores SQL Server FCIs se instalan en todos los nodos de WSFC. El módulo Terraform incluido en este patrón aprovisiona hasta dos instancias de Amazon EC2 SQL Server. Un sistema de archivos de Amazon FSx para Windows File Server actúa como testigo del quórum y almacena los datos compartidos y los archivos de registro. Independientemente del número de instancias configuradas, los nodos de instancia de SQL Server siempre crearán un clúster de FCI y se unirán a él para garantizar la paridad del entorno. (Normalmente, una instancia se configura para entornos de desarrollo y dos instancias para entornos de producción). Para las configuraciones que utilizan dos nodos para una alta disponibilidad, se aprovisiona un equilibrador de carga de red interno. El equilibrador de carga de red utiliza una sonda de estado configurada en el clúster de la FCI para identificar qué nodo es el principal. ## Requisitos previos y limitaciones **Requisitos previos ** + Un activo Cuenta de AWS. + Amazon Virtual Private Cloud (Amazon VPC) con dos subredes en zonas de disponibilidad independientes. + [Conjunto de opciones de DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/DHCPOptionSet.html) de Amazon VPC. Configure el nombre de dominio para que se resuelva en su nombre de dominio de Active Directory y los servidores de nombres de dominio y NetBIOS para que apunten a sus controladores de dominio de Active Directory. Para obtener más información, consulte *Configuración de VPC* en [Información adicional](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). + AWS Directory Service for Microsoft Active Directory (AWS Managed Microsoft AD). + Imagen de máquina de Amazon (AMI) personalizada. Para obtener más información, consulte *Configuración de AMI* en [Información adicional](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). + Bucket de Amazon Simple Storage Service (Amazon S3) que incluye la imagen ISO de SQL Server. Este requisito previo solo es necesario si se utiliza [EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html) con el `component.yaml` archivo proporcionado para crear la AMI personalizada. + AWS Key Management Service (AWS KMS) clave de cifrado. + De forma predeterminada, SQL Server se instala con una clave de producto de la edición para desarrolladores. Se espera que los sistemas de producción utilicen una clave de producto válida que la variable correspondiente transmita al módulo. **Limitaciones** + Esta solución requiere AWS Managed Microsoft AD. Sin embargo, si lo prefiere, puede utilizar una implementación de Active Directory autoadministrada en su lugar. Para ello, modifique el módulo Amazon FSx Terraform incluido para eliminar el `active_directory_id` atributo. A continuación, añada los cuatro atributos necesarios para la autoadministración de Active Directory, tal y como se muestra en la [documentación de Terraform](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/fsx_windows_file_system). + SQL Server está configurado para usar la autenticación de modo mixto. Si lo prefiere, puede utilizar la autenticación solo de Windows. Para ello, en el script de datos de usuario proporcionado, elimine los parámetros `/SECURITYMODE` y `/SAPWD` que se proporcionan al comando `setup.exe`. Puede eliminar el archivo `sql_accounts.tf` y modificar el archivo `instances.tf` para eliminar la entrada `sql_sa_password`. + Al eliminar un clúster implementado, debe eliminar los objetos de computadora virtual correspondientes y los objetos de equipo individuales de Active Directory. Para eliminar los objetos, utilice las herramientas administrativas de Active Directory. + Algunos Servicios de AWS no están disponibles en todos Regiones de AWS. Para obtener información sobre la disponibilidad en regiones, consulte [AWS Services by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para ver los puntos de conexión específicos, consulte [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) y elija el enlace del servicio. **Versiones de producto** Esta solución se probó con las siguientes versiones: + Windows Server 2019 + SQL Server 2019 + [Terraform v0.13.0](https://developer.hashicorp.com/terraform/language/v1.1.x/upgrade-guides/0-13) ## Arquitectura **Pila de tecnología de origen** + SQL Server **Pila de tecnología de destino** + FCI de SQL Server en nodos WSFC mediante Amazon EC2 + Servidor FSx de archivos Amazon para Windows + Bucket de Amazon S3 + AWS Secrets Manager + AWS Managed Microsoft AD + AWS KMS + AWS Identity and Access Management (IAM) **Arquitectura de destino** En el siguiente diagrama se muestra la arquitectura para esta solución. ![\[Arquitectura para implementar instancias de clústeres de conmutación por error de SQL Server en los nodos del clúster de conmutación por error de Windows Server en Amazon. EC2\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/45f3ab19-d240-4353-ab6e-f6e565f537a4/images/0bff16f2-94e7-4e86-91ea-7ab5f3725620.png) En el diagrama se muestra lo siguiente: + Una función de IAM que proporciona a las EC2 instancias acceso a AWS KMS Secrets Manager + Dos nodos de SQL Server implementados en EC2 instancias de Amazon en subredes privadas en dos zonas de disponibilidad + Un equilibrador de carga de red para facilitar las conexiones a la instancia activa de SQL Server (no se implementa al configurar un clúster de un solo nodo) + Sistema de archivos Amazon FSx para Windows File Server implementado en ambas subredes privadas para el almacenamiento compartido por los nodos de SQL Server + Secrets Manager para almacenar las credenciales y la configuración de Active Directory y SQL Server + Bucket de Amazon S3 para almacenar la imagen de instalación de SQL Server + AWS Managed Microsoft AD para la autenticación de Windows + AWS KMS para crear la clave de cifrado **Automatización y escala** Puede automatizar el despliegue de la arquitectura de destino mediante los módulos de Terraform que se encuentran en el [GitHub repositorio](https://github.com/aws-samples/cluster-amazon-elastic-compute-cloud-amazon-fsx-microsoft-sql-server). Debe modificar el archivo `terraform.tfvars` para incluir valores variables específicos de su entorno. El depósito de Amazon S3, AWS Managed Microsoft AD los componentes, la clave de AWS KMS cifrado y algunos secretos son requisitos previos para esta implementación y no se incluyen en el código de Terraform. ## Tools (Herramientas) **Servicios de AWS** + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)permite que sus cargas de trabajo y AWS recursos compatibles con directorios utilicen Microsoft Active Directory en. Nube de AWS En este patrón, AWS Managed Microsoft AD se utiliza para la autenticación de Windows Server y SQL Server y para el DNS. + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) proporciona una capacidad informática escalable en el Nube de AWS. Puede lanzar tantos servidores virtuales como necesite y escalarlos o reducirlos con rapidez. En este patrón, las instancias del clúster de conmutación por error de SQL Server se instalan en las EC2 instancias de Amazon. + [EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html) le ayuda a automatizar la creación, la administración y el despliegue de imágenes de servidor personalizadas. + [Amazon FSx for Windows File Server](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) proporciona almacenamiento compartido totalmente gestionado en Windows Server. Siguiendo este patrón, en el FSx caso de Windows, File Server proporciona almacenamiento compartido para los datos y los archivos de registro de SQL Server y para el testigo de quórum. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) le ayuda a administrar de forma segura el acceso a sus AWS recursos al controlar quién está autenticado y autorizado a usarlos. + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) le ayuda a crear y controlar claves criptográficas para proteger sus datos. En este patrón, se utiliza para cifrar los secretos de Secrets Manager, el almacenamiento de SQL Server en los volúmenes de Amazon Elastic Block Store (Amazon EBS) y el FSx sistema de archivos de Windows File Server. + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) lo ayuda a reemplazar las credenciales codificadas en su código, incluidas contraseñas, con una llamada a la API de Secrets Manager para recuperar el secreto mediante programación. En este patrón, las credenciales de Active Directory para instalar y ejecutar SQL Server, las credenciales de usuario `sa` y la información de conexión a la base de datos se almacenan en Secrets Manager. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) es un servicio de almacenamiento de objetos basado en la nube que lo ayuda a almacenar, proteger y recuperar cualquier cantidad de datos. Este patrón utiliza un bucket de Amazon S3 para almacenar la imagen de instalación de SQL Server. + [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) le ayuda a lanzar AWS recursos en una red virtual que haya definido. Esa red virtual es similar a la red tradicional que utiliza en su propio centro de datos, con los beneficios de usar la infraestructura escalable de AWS. ** ****Otras herramientas** + [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) se instala en los nodos del clúster de Windows Server. Además, se pueden instalar en varias subredes. En este patrón, las instancias FCI de SQL Server se instalan en los nodos de WSFC. + [Terraform](https://www.terraform.io/) es una herramienta de infraestructura como código (IaC) que facilita usar el código para aprovisionar y administrar los recursos y la infraestructura en la nube. En este patrón, Terraform se usa para crear los recursos y configurar las instancias FCI de SQL Server. + Los [clústeres de conmutación por error de 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) proporcionan características de infraestructura que respaldan la alta disponibilidad de las aplicaciones de servidor alojadas, como SQL Server. En este patrón, los nodos de la FCI utilizan la funcionalidad WSFC para proporcionar una alta disponibilidad local mediante la redundancia a nivel de instancia. **Repositorio de código** El código de este patrón está disponible en el repositorio 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). Los siguientes recursos están disponibles en el repositorio: + Un archivo `README.md` que proporciona una descripción general de la solución e información adicional sobre la instalación y el uso + Un conjunto básico de archivos de configuración de Terraform y un módulo FSx específico de Amazon para aprovisionar los componentes de este patrón + Un script de configuración de instancias que se ejecuta como un script de datos EC2 de usuario de Amazon + Un archivo `component.yam`l que Image Builder puede usar para crear una AMI personalizada ## Prácticas recomendadas **Seguridad y creación de parches** + Las instalaciones y configuraciones de requisitos previos de la AMI son los requisitos mínimos para implementar clústeres FCI de SQL Server. Es posible que se necesiten configuraciones y software adicionales para cumplir con los estándares y requisitos de seguridad de su organización. + Después de la implementación, aplique los parches de Windows de forma continua. Parchee directamente las instancias en ejecución o cree una nueva AMI con los últimos parches de Windows y sustituya las instancias (una por una) por la nueva AMI. AWS publica AMIs mensualmente un nuevo Windows que contiene los últimos parches, controladores y agentes de lanzamiento del sistema operativo. Le recomendamos que compruebe las AMI más recientes al lanzar nuevas instancias o al crear sus propias imágenes personalizadas. + Las EC2 instancias de Amazon están configuradas para permitir todo el tráfico saliente. Cuando se implementan en un entorno de producción, se deben establecer reglas de salida en el grupo de seguridad para restringir este tráfico a los destinos requeridos. + El sistema de archivos del servidor de archivos FSx para Windows puede registrar automáticamente los registros de auditoría para compartir archivos y acceder a archivos y carpetas y enviarlos al destino deseado si así lo requiere su entorno. + Rote automáticamente los secretos de Secrets Manager de forma regular. Para el par de claves de EC2 instancia de Amazon, considere una solución de rotación automática, tal como se describe en [Cómo usar AWS Secrets Manager para almacenar y rotar pares de claves SSH de forma segura](https://aws.amazon.com/blogs/security/how-to-use-aws-secrets-manager-securely-store-rotate-ssh-key-pairs/). Para las credenciales de Active Directory y los secretos de credenciales de `sa` de SQL Server, configure la rotación automática de acuerdo con sus políticas de administración de contraseñas. **Administración de Active Directory** + Como parte del clúster de FCI, Windows genera un objeto de nombre de equipo (CNO) en Active Directory. El CNO responde a las solicitudes de DNS y reenvía el tráfico al nodo SQL activo. *No* recomendamos usar este DNS proporcionado por Active Directory. El TTL es demasiado alto para proporcionar un tiempo de conmutación por error razonable y, a menudo, tarda más de 5 minutos en reflejar la nueva dirección IP principal. Por el contrario, para las instalaciones de alta disponibilidad, el equilibrador de carga de red interno está configurado para realizar la conmutación por error en 30 segundos. + Se necesita un administrador de dominio de Active Directory para crear el clúster. Este requisito se debe a los elevados permisos necesarios para crear los objetos del clúster y modificar los permisos en Active Directory. Sin embargo, no es necesario que los servicios de SQL Server se ejecuten como administrador de dominio. Por lo tanto, se recomienda crear un segundo usuario de Active Directory para este fin. Sin embargo, puede eliminar este usuario si los servicios se ejecutan como usuario administrador del dominio. En ese caso, el usuario administrador del dominio debe agregarse al grupo de administradores de Active Directory que se crea como parte de este patrón. ## Epics ### Configuración de las credenciales del clúster | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree grupos de Active Directory. | En AWS Managed Microsoft AD, cree los siguientes grupos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Para obtener más información, consulte [Crear un AWS Managed Microsoft AD grupo](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_create_group.html) en la AWS documentación. | Administrador de AD | | Cree usuarios de Active Directory. | En AWS Managed Microsoft AD, cree los siguientes usuarios[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Para obtener más información, consulte [Crear un AWS Managed Microsoft AD usuario](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_manage_users_groups_create_user.html) en la AWS documentación. | Administrador de AD | | Añada credenciales de Active Directory a los secretos. | Use Secrets Manager para crear cuatro secretos para almacenar la siguiente información:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Para obtener más información, consulte [Crear un AWS Secrets Manager secreto](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) en la AWS documentación. | Administrador de AWS | ### Prepare el entorno | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree la AMI de Windows. | Cree una AMI de Windows personalizada que incluya las configuraciones y el software necesarios. Para obtener más información, consulte [Detalles adicionales](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). | Administrador de AWS, AWS DevOps | | Instale Terraform. | Para instalar Terraform, siga las instrucciones del sitio web de [Terraform](https://learn.hashicorp.com/tutorials/terraform/install-cli). | AWS DevOps | | Clonar el repositorio. | Clone el [repositorio](https://github.com/aws-samples/cluster-amazon-elastic-compute-cloud-amazon-fsx-microsoft-sql-server) de este patrón. Para obtener más información, consulte [Clonación de un repositorio](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) en el GitHub sitio web. | AWS DevOps | ### Instalación del clúster | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Modifique las variables de Terraform. | Actualice el archivo `terraform.tfvars` suministrado para establecer todas las variables en los valores adecuados para su entorno.Por ejemplo, actualice las variables `domain_group_administrators` y `domain_group_rdp_users` para usar su nombre de dominio de Active Directory y el nombre de los grupos de Active Directory creados anteriormente. | AWS DevOps | | Inicialice Terraform. | Para ver la implementación propuesta, navegue hasta la raíz del repositorio. Use la interfaz de la línea de comandos (CLI) de Terraform para ejecutar `terraform init` y luego ejecutar `terraform plan`. | AWS DevOps | | Implemente los recursos. | Para implementar el clúster de SQL y los recursos asociados, utilice la CLI de Terraform para ejecutar `terraform apply`. | AWS DevOps, administrador de AWS | | Valide la implementación. | Para validar la implementación, siga estos pasos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html) | Administrador de base de datos, administrador de sistemas | ## Resolución de problemas | Problema | Solución | | --- | --- | | Se completó el aprovisionamiento de Terraform, pero el administrador de clústeres de conmutación por error de Windows no muestra que se haya creado un clúster o que el clúster se encuentre en un estado no operativo. | La instalación completa de los recursos y la configuración de los clústeres pueden tardar entre 45 y 60 minutos. Una vez que Terraform se haya completado, el script de datos de usuario debe ejecutarse hasta su finalización, lo que requiere varios reinicios. Para supervisar el progreso, puede utilizar el directorio `Checkpoints` de la unidad `C:\` e iniciar sesión en la instalación de SQL Server en `C:\Program Data\Microsoft SQL Server\150\Log`. Cuando haya terminado, aparecerá el mensaje de **instalación completa** en el archivo `C:\ProgramData\Amazon\EC2-Windows\Launch\Log\UserdataExecution.log`. | | Tras aprovisionar un clúster en funcionamiento, no se puede utilizar Terraform para eliminar y volver a crear el clúster. Terraform finaliza, pero el clúster no está configurado correctamente. | Parte del proceso de aprovisionamiento implica registrar máquinas y objetos virtuales en el DNS de Active Directory y Active Directory. Cuando existen nombres de equipo para los nodos del EC2 clúster de Amazon y el nodo del clúster, la FCI no se puede inicializar correctamente y se produce un error en el aprovisionamiento.Para solucionar este problema, siga estos pasos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html) | ## Recursos relacionados **AWS documentación** + [Cree imágenes personalizadas con Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-images.html) + [Cree una clave KMS](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) + [Crear un depósito de uso general](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) + [Crear una política clave](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) + [Creando tu AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html) ## Información adicional **Información del módulo Terraform** Este módulo utiliza una combinación de configuración de AMI y configuración de datos de usuario para obtener una buena combinación de tiempo de aprovisionamiento y estabilidad. Durante el aprovisionamiento, Windows requiere varios reinicios y esperas. Se ha implementado un método de puntos de control para evitar que se produzcan bucles infinitos durante los reinicios de los datos de usuario persistentes. Los datos de usuario están configurados para ser persistentes. Por lo tanto, los scripts de configuración de los datos de usuario deben seguir desarrollándose para que sean idempotentes. La idempotencia agiliza el proceso de actualización, ya que permite intercambiar instancias durante un ciclo de actualización sin necesidad de realizar una configuración manual para volver a unir los clústeres de la FCI o volver a crearlos. **Cadenas de conexión de SQL Server y clústeres de conmutación por error** El módulo publicará un secreto con la dirección del punto conexión que debe usarse en las cadenas de conexión de esta base de datos. El nombre del secreto sigue este formato: `{environment_name}/sqlserver/{cluster_name}/endpoint`. Para las instalaciones en las que solo se utiliza un nodo, puede esperar que sea la dirección IP de la interfaz de SQL Server de la EC2 instancia de Amazon. Para instalaciones de alta disponibilidad (dos instancias), puede esperar que sea el nombre DNS del equilibrador de carga de red interno. Este módulo IPs no admite los clústeres virtuales de conmutación por error. Una IP virtual debe permanecer en la misma subred para que funcione. En AWS, una sola subred no puede abarcar varias zonas de disponibilidad. Por lo tanto, el uso de la IPs tecnología virtual eliminaría la posibilidad de que este módulo se considere de alta disponibilidad. A cada EC2 instancia de Amazon se le asignan tres direcciones IP privadas. El uso es como se indica a continuación: + **IP principal para el tráfico de red**: la IP de origen para el tráfico de salida. + **Comunicaciones FCI**: se utilizan para mantener el estado y la sincronización del clúster de conmutación por error. + **SQL Server (puerto TCP 1433)**: oyente y también escucha el tráfico intermitente para determinar qué instancia es la principal. **Configuración de la VPC** Los [requisitos previos](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-prereqs)incluyen un conjunto de opciones de DHCP configurado para usar Active Directory para la resolución de DNS. Sin embargo, este requisito previo no es obligatorio. El requisito más importante es que las EC2 instancias puedan resolver tu nombre de dominio de Active Directory. El cumplimiento de este requisito se puede lograr de otras maneras, como mediante el uso de Amazon Route 53 Resolver puntos finales. Para obtener más información, consulte [Integración de la resolución de DNS de su servicio de directorio con Amazon Route 53 Resolvers](https://aws.amazon.com/blogs/networking-and-content-delivery/integrating-your-directory-services-dns-resolution-with-amazon-route-53-resolvers/) (entrada AWS del blog). **Configuración de AMI** La AMI utilizada en este patrón debe contener los siguientes requisitos previos de software y configuraciones: 1. Descargue y amplíe los archivos de instalación de SQL Server 2019 a `C:\SQL_Install_media`. 1. Instale las siguientes características de 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. Deshabilite el firewall de Windows como se indica a continuación: + `Get-NetFirewallProfile | Set-NetFirewallProfile -Enabled False` 1. Habilite el método de autenticación CredSSP (sustituya `
DECLARE| Administrador de base de datos | | Ejecute el PL/SQL bloque. | Ejecute el PL/SQL bloque fuente en Oracle. Si hay brechas entre los valores de índice de una matriz asociativa, no se almacena ningún dato en esas brechas. Esto permite que el bucle de Oracle itere únicamente a través de las posiciones del índice. | Administrador de base de datos | | Revise la salida. | Se insertaron cinco elementos en la matriz (`cc`) a intervalos no consecutivos. El recuento de matrices se muestra en el resultado siguiente:
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| Administrador de base de datos | ### Comportamiento de la matriz asociativa de PostgreSQL (destino) | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree un PL/pgSQL bloque de destino en PostgreSQL. | Cree un PL/pgSQL bloque de destino en PostgreSQL que utilice la siguiente matriz asociativa:
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 $$| Administrador de base de datos | | Ejecute el bloque. PL/pgSQL | Ejecute el PL/pgSQL bloque de destino en PostgreSQL. Si hay brechas entre los valores de índice de una matriz asociativa, no se almacena ningún dato en esas brechas. Esto permite que el bucle de Oracle itere únicamente a través de las posiciones del índice. | Administrador de base de datos | | Revise la salida. | La longitud de la matriz es superior a 5 porque `NULL` se almacena en las brechas entre las posiciones del índice. Como se muestra en el siguiente resultado, el bucle completa 10 iteraciones para recuperar 5 valores de la 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| Administrador de base de datos | ### Emulación del comportamiento de una matriz asociativa de Oracle | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree un PL/pgSQL bloque de destino con una matriz y un tipo definido por el usuario. | Para optimizar el rendimiento y adaptarlo a la funcionalidad de Oracle, podemos crear un tipo definido por el usuario que almacene tanto las posiciones del índice como sus datos correspondientes. Este enfoque reduce las iteraciones innecesarias al mantener las asociaciones directas entre los índices y los 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 $$| Administrador de base de datos | | Ejecuta el PL/pgSQL bloque. | Ejecuta el PL/pgSQL bloque objetivo. Si hay brechas entre los valores de índice de una matriz asociativa, no se almacena ningún dato en esas brechas. Esto permite que el bucle de Oracle itere únicamente a través de las posiciones del índice. | Administrador de base de datos | | Revise la salida. | Como se muestra en el siguiente resultado, el tipo definido por el usuario almacena solo los elementos de datos rellenados, lo que significa que la longitud de la matriz coincide con el número de valores. Como resultado, las iteraciones de `LOOP` se optimizan para procesar solo los datos existentes, lo que elimina la necesidad de rastrear las posiciones vacías.
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| Administrador de base de datos | ## Recursos relacionados **AWS documentación** + [AWS blog de base de datos](https://aws.amazon.com/blogs/database/) + [Manual de estrategias de migración de Oracle a Aurora PostgreSQL](https://docs.aws.amazon.com/dms/latest/oracle-to-aurora-postgresql-migration-playbook/chap-oracle-aurora-pg.html) **Otra documentación** + [Matrices asociativas de Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/23/lnpls/associative-arrays.html#GUID-8060F01F-B53B-48D4-9239-7EA8461C2170) + [Funciones y operadores de matriz de PostgreSQL](https://www.postgresql.org/docs/current/functions-array.html) + [Tipos de PostgreSQL definidos por el usuario](https://www.postgresql.org/docs/current/sql-createtype.html) # Habilite conexiones cifradas para instancias de base de datos de PostgreSQL en Amazon RDS *Rohit Kapoor, Amazon Web Services* ## Resumen Amazon Relational Database Service (Amazon RDS) admite el cifrado SSL en instancias de base de datos PostgreSQL. Con SSL, puede cifrar una conexión de PostgreSQL entre sus aplicaciones y sus instancias de base de datos de Amazon RDS para PostgreSQL. De forma predeterminada, Amazon RDS for SSL/TLS PostgreSQL utiliza y espera que todos los clientes se conecten mediante cifrado. SSL/TLS Amazon RDS para PostgreSQL admite las versiones 1.1 y 1.2 de TLS. En este patrón se describe cómo puede habilitar conexiones cifradas para una instancia de base de datos de Amazon RDS para PostgreSQL. Puede usar el mismo proceso para habilitar conexiones cifradas en Amazon Aurora compatible con PostgreSQL. ## Requisitos previos y limitaciones + Una cuenta de AWS activa + Una [instancia de base de datos de Amazon RDS para PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_RDS_Configuring.html) + Un [paquete SSL](https://www.postgresql.org/docs/current/ssl-tcp.html) ## Arquitectura ![\[Habilitar conexiones cifradas para instancias de base de datos PostgreSQL en Amazon RDS\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/4f87c6a3-b4ff-4248-96d3-a4a498659735/images/ccc5c880-1191-4c12-a255-6908b96b96a5.png) ## Tools (Herramientas) + [pgAdmin](https://www.pgadmin.org/) es una plataforma de administración y desarrollo de código abierto para PostgreSQL. Puede usar pgAdmin en Linux, Unix, macOS y Windows para administrar los objetos de su base de datos en PostgreSQL 10 y versiones posteriores. + Los [editores de PostgreSQL](https://wiki.postgresql.org/wiki/PostgreSQL_Clients) proporcionan una interfaz más fácil de usar que le ayuda a crear, desarrollar y ejecutar consultas, así como a editar el código según sus necesidades. ## Prácticas recomendadas + Supervise las conexiones de bases de datos no seguras. + Audite los derechos de acceso a la base de datos. + Asegúrese de que las copias de seguridad y las instantáneas estén cifradas en reposo. + Supervise el acceso a bases de datos. + Evite los grupos de acceso sin restricciones. + Mejora tus notificaciones con [Amazon GuardDuty](https://docs.aws.amazon.com/guardduty/latest/ug/what-is-guardduty.html). + Supervise el cumplimiento de las políticas con regularidad. ## Epics ### Descargue un certificado de confianza e impórtelo a su almacén de confianza | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cargue un certificado de confianza en su computadora. | Para agregar certificados al almacén de entidades emisoras de certificados raíz de confianza de su equipo, siga estos pasos. (Estas instrucciones usan Windows Server como ejemplo).[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html) | DevOps ingeniero, ingeniero de migración, DBA | ### Fuerza las conexiones SSL. | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree un grupo de parámetros y establezca el parámetro rds.force\$1ssl. | Si la instancia de base de datos PostgreSQL tiene un grupo de parámetros personalizado, edite dicho grupo y cambie `rds.force_ssl` a 1.Si la instancia de base de datos usa el grupo de parámetros predeterminado sin `rds.force_ssl` habilitado, cree un nuevo grupo de parámetros. Puede modificar el nuevo grupo de parámetros usando la API de Amazon RDS o bien manualmente siguiendo estos pasos.Para crear un nuevo grupo de parámetros:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Para asociar el grupo de parámetros a su instancia de base de datos PostgreSQL:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Para obtener más información, consulte la [documentación de Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithDBInstanceParamGroups.html). | DevOps ingeniero, ingeniero de migración, DBA | | Fuerza las conexiones SSL. | Conéctese a la instancia de base de datos de Amazon RDS para PostgreSQL. Los intentos de conexión que no usan SSL se rechazan con un mensaje de error. Para obtener más información, consulte la [documentación de Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html#PostgreSQL.Concepts.General.SSL.Requiring). | DevOps ingeniero, ingeniero de migración, DBA | ### Instale la extensión SSL | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Instale la extensión SSL. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Para obtener más información, consulte la [documentación de Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html). | DevOps ingeniero, ingeniero de migración, DBA | ### Configure su cliente PostgreSQL para SSL | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Configure un cliente para SSL. | Al usar SSL, puede iniciar el servidor PostgreSQL con soporte para conexiones cifradas que empleen protocolos TLS. El servidor escucha tanto las conexiones estándar como las SSL en el mismo puerto TCP, y negocia con cualquier cliente que se conecte si debe utilizar SSL. Por defecto, esto es una una opción de cliente.Si usa el cliente psql:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Para otros clientes de PostgreSQL:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Consulte las siguientes páginas para estos clientes:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html) | DevOps ingeniero, ingeniero de migración, DBA | ## Resolución de problemas | Problema | Solución | | --- | --- | | No se puede descargar el certificado SSL. | Compruebe la conexión al sitio web y vuelva a intentar descargar el certificado en su computadora local. | ## Recursos relacionados + [Documentación de Amazon RDS para PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) + [Uso de SSL con una instancia de base de datos PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html) (documentación de Amazon RDS) + [ TCP/IP Conexiones seguras con SSL](https://www.postgresql.org/docs/9.1/ssl-tcp.html) (documentación de PostgreSQL) + [Uso de SSL](https://jdbc.postgresql.org/documentation/ssl/) (documentación de JDBC) # Cifrar una instancia de base de datos de Amazon RDS para PostgreSQL existente *Piyush Goyal, Shobana Raghu y Yaser Raja, Amazon Web Services* ## Resumen Este patrón explica cómo cifrar una instancia de base de datos de Amazon Relational Database Service (Amazon RDS) para PostgreSQL en la nube de AWS con un tiempo de inactividad mínimo. Este proceso también funciona para instancias de base de datos de Amazon RDS para MySQL. Puede habilitar el cifrado para una instancia de base de datos de Amazon RDS cuando la cree, pero no después de haberla creado. Sin embargo, puede añadir cifrado a una instancia de base de datos sin cifrar creando una instantánea de la instancia de base de datos y, a continuación, creando una copia cifrada de esa instantánea. A continuación, puede restaurar una instancia de base de datos a partir de la instantánea encriptada para obtener una copia encriptada de su instancia de base de datos original. Si su proyecto permite un tiempo de inactividad (al menos en el caso de las transacciones de escritura) para esta actividad, esto es todo lo que tiene que hacer. Cuando esté disponible la nueva copia cifrada de la instancia de base de datos, podrá dirigir sus aplicaciones a la nueva base de datos. Sin embargo, si su proyecto no permite un tiempo de inactividad significativo para esta actividad, necesitará un enfoque alternativo que le ayude a minimizar dicho tiempo de inactividad. Este patrón emplea AWS Database Migration Service (AWS DMS) para migrar y replicar continuamente los datos, de modo que la transición a la nueva base de datos cifrada se podrá realizar con un tiempo de inactividad mínimo. En las instancias de base de datos cifradas de Amazon RDS se utiliza el algoritmo de cifrado AES-256 estándar del sector para cifrar los datos en el servidor que aloja la instancia de base de datos de Amazon RDS. Una vez cifrados los datos, Amazon RDS se encarga de la autenticación de acceso y del descifrado de los datos de forma transparente, con un impacto mínimo en el desempeño. No es necesario modificar las aplicaciones cliente de base de datos para utilizar el cifrado. ## Requisitos previos y limitaciones **Requisitos previos ** + Una cuenta de AWS activa + Una instancia de base de datos de Amazon RDS para PostgreSQL sin encriptar + Experiencia trabajando con tareas de AWS DMS (creación, modificación o detención) (consulte [Trabajar con tareas de AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.html) en la documentación de AWS DMS) + Familiaridad con AWS Key Management Service (AWS KMS) para el cifrado de bases de datos (consulte la [documentación de AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)) **Limitaciones** + Únicamente se puede activar el cifrado para una instancia de base de datos de Amazon RDS al crearla, no después de que se ha creado. + Los datos de las [tablas no registradas](https://www.postgresql.org/docs/current/sql-createtable.html) no se podrán restaurar mediante instantáneas. Para obtener más información, consulte [Prácticas recomendadas para trabajar con PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_BestPractices.html#CHAP_BestPractices.PostgreSQL). + No se puede tener una réplica de lectura cifrada de una instancia de base de datos sin cifrar ni una réplica de lectura sin cifrar de una instancia de base de datos cifrada. + No se puede restaurar una copia de seguridad ni una instantánea sin cifrar en una instancia de base de datos cifrada. + AWS DMS no transfiere automáticamente las secuencias, por lo que necesitará pasos adicionales para gestionarlas. Para obtener más información, consulte [Limitaciones de las instancias de base de datos cifradas de Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html#Overview.Encryption.Limitations) en la documentación de Amazon RDS. ## Arquitectura **Arquitectura de origen** + Instancia de base de datos de RDS sin cifrar **Arquitectura de destino** + Instancia de base de datos de RDS cifrada + La instancia de base de datos de RDS de destino se crea restaurando la copia de instantánea de base de datos de la instancia de base de datos de RDS de origen. + Al restaurar la instantánea, se emplea una clave de AWS KMS para el cifrado. + Para migrar los datos, se emplea una tarea de replicación de AWS DMS. ![\[El proceso utiliza AWS DMS para cifrar una instancia de base de datos de Amazon RDS para PostgreSQL existente en una nueva base de datos.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/820d17c0-0eed-4ed9-9f43-cbada081d924/images/44dd8420-d89d-466e-b7fb-1bdafab8f7f9.png) ## Tools (Herramientas) **Herramientas usadas para habilitar el cifrado:** + Clave de AWS KMS prara encriptar: Cuando crea una instancia de base de datos cifrada, puede elegir una clave administrada por el cliente o la clave de AWS KMS para Amazon RDS para cifrar la instancia de base de datos. Si no especifica el identificador de clave para una clave administrada por el cliente, Amazon RDS utiliza la clave administrada de AWS para la nueva instancia de base de datos. Amazon RDS crea una clave administrada de AWS para Amazon RDS para su cuenta de AWS. Su cuenta de AWS tiene una clave administrada de AWS diferente para Amazon RDS para cada región de AWS. Para obtener más información sobre el uso de claves de KMS para el cifrado de Amazon RDS, consulte [Cifrar recursos de Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html). **Herramientas utilizadas para la replicación continua**: + AWS DMS: puede usar AWS Database Migration Service (AWS DMS) para replicar los cambios desde la base de datos de origen a la base de datos de destino. Es importante mantener sincronizadas las bases de datos de origen y destino para poder reducir al mínimo el tiempo de inactividad. Para obtener información sobre la configuración de AWS DMS y la creación de tareas, consulte la [documentación de AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html). ## Epics ### Cree una instantánea de la instancia de base de datos de origen y cífrela | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Compruebe los detalles de la instancia de base de datos PostgreSQL de origen. | En la consola de Amazon RDS, seleccione la instancia de base de datos PostgreSQL de origen. En la pestaña **Configuración**, asegúrese de que el cifrado no esté habilitado en esta instancia. Para ver una ilustración de la pantalla, consulte la sección de [Información adicional](#encrypt-an-existing-amazon-rds-for-postgresql-db-instance-additional). | Administrador de base de datos | | Crear la instantánea de base de datos. | Cree una instantánea de la base de datos de la instancia que desea encriptar. La cantidad de tiempo que tarda en crearse una instantánea depende del tamaño de su base de datos. Para obtener instrucciones, consulte [Crear una instantánea de base de datos](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html) en la documentación de Amazon RDS. | Administrador de base de datos | | Cifre la instantánea. | En el panel de navegación de la consola de Amazon RDS, elija **Instantáneas** y, a continuación, seleccione la instantánea de base de datos que ha creado. En **Actions (Acciones)**, elija **Copy Snapshot (Copiar instantánea)**. Indique la región de AWS de destino y el nombre de la copia de la instantánea de base de datos en los campos correspondientes. Seleccione la casilla de verificación **Habilitar el cifrado**. En **Master Key**, especifique el identificador de la clave de KMS que se debe usar para cifrar la copia de la instantánea de base de datos. Elija **Copy Snapshot**. Para más información, consulte [Copiar una instantánea](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CopySnapshot.html) en la documentación de Amazon RDS. | Administrador de base de datos | ### Prepare la instancia de base de datos de destino | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Restaurare la instantánea de la base de datos. | En la consola de Amazon RDS, seleccione **Instantáneas**. Elija la instantánea cifrada que ha creado. En **Actions (Acciones)**, seleccione **Restore Snapshot (Restaurar instantánea)**. Para **Identificador de Instancia de la base de datos**, proporcione un nombre único para la nueva instancia de la base de datos. Revise los detalles de la instancia y, a continuación, seleccione **Restaurar instancia de base de datos**. Se creará una nueva instancia de base de datos cifrada a partir de la instantánea. Para más información, consulte [Restauración a partir de una instantánea de la base de datos](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_RestoreFromSnapshot.html) en la documentación de Amazon RDS. | Administrador de base de datos | | Migre los datos mediante AWS DMS. | En la consola de AWS DMS, cree una tarea de AWS DMS. En **Tipo de migración**, elija **Migración de los datos existentes y réplica de los cambios en curso**. En **Configuración de tareas**, en el **Modo de preparación de la tabla de destino**, seleccione **Truncar**. Para más información, consulte [Crear una tarea](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) en la documentación de AWS DMS. | Administrador de base de datos | | Habilitar la validación de datos. | En **Configuración de tareas**, seleccione **Habilitar validación**. Esto le permite comparar los datos de origen con los de destino para verificar que los datos se han migrado correctamente. | Administrador de base de datos | | Deshabilite las restricciones en la instancia de base de datos de destino. | [Desactive todos los desencadenantes y restricciones de clave externa](https://www.postgresql.org/docs/current/sql-altertable.html) en la instancia de base de datos de destino y, a continuación, inicie la tarea de AWS DMS. Para obtener más información sobre cómo deshabilitar los desencadenantes y restricciones de clave externa, consulte la [documentación de AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.PostgreSQL.html). | Administrador de base de datos | | Compruebe los datos. | Una vez completada la carga, compruebe los datos de la instancia de base de datos de destino para asegurarse de que coinciden con los datos de origen. Para obtener más información consulte la [AWS DMS data validation](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Validating.html) (Validación de datos de AWS DMS) en la documentación de AWS DMS. | Administrador de base de datos | ### Transición a la instancia de base de datos de destino | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Detenga las operaciones de escritura en la instancia de base de datos de origen. | Detenga las operaciones de escritura en la instancia de base de datos de origen para que pueda comenzar el tiempo de inactividad de la aplicación. Compruebe que AWS DMS haya completado la replicación de los datos en el proceso. Habilite los desencadenantes y claves externas en la instancia de base de datos de destino. | Administrador de base de datos | | Actualice las secuencias de la base de datos | Si la base de datos de origen contiene números de secuencia, compruebe y actualice las secuencias en la base de datos de destino. | Administrador de base de datos | | Configure el punto de conexión de la aplicación. | Configure las conexiones de la aplicación para usar los nuevos puntos de conexión de la instancia de base de datos de Amazon RDS. La instancia de base de datos ya está cifrada. | Administrador de base de datos, propietario de la aplicación | ## Recursos relacionados + [Creación de una tarea de AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) + [Supervisión de las tareas de replicación mediante Amazon CloudWatch](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Monitoring.html#CHAP_Monitoring.CloudWatch) + [Monitorización de tareas de AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Monitoring.html) + [Actualización de la clave de cifrado de Amazon RDS](https://aws.amazon.com/premiumsupport/knowledge-center/update-encryption-key-rds/) ## Información adicional Comprobar el cifrado de la instancia de base de datos PostgreSQL de origen: ![\[La página de resumen de la instancia de base de datos de PostgreSQL de origen muestra que el cifrado no está habilitado para el almacenamiento.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/820d17c0-0eed-4ed9-9f43-cbada081d924/images/d53d1dab-b5c2-452d-b823-ba3d6508ad15.png) Notas adicionales para este patrón: + Habilite la replicación en PostgreSQL estableciendo el parámetro `rds.logical_replication` en 1. **Nota importante:** Las ranuras de replicación retienen los archivos de registro de escritura anticipada (WAL) hasta que los archivos se consumen externamente, por ejemplo, mediante `pg_recvlogical`, mediante trabajos de extracción, transformación y carga (ETL) o mediante AWS DMS. Al establecer el valor del parámetro `rds.logical_replication` en 1, AWS DMS establece los parámetros `wal_level`, `max_wal_senders`, `max_replication_slots` y `max_connections`. Si hay ranuras de replicación lógica pero no se consumen los archivos WAL retenidos por la ranura de replicación, es posible que aumente el uso del disco del registro de transacciones y disminuya el espacio de almacenamiento libre. Para obtener más información y los pasos para resolver este problema, consulte el artículo [¿Cómo puedo identificar la causa del error «No queda espacio en el dispositivo» o «» DiskFull en Amazon RDS for PostgreSQL?](https://aws.amazon.com/premiumsupport/knowledge-center/diskfull-error-rds-postgresql/) en el centro de conocimiento de AWS Support. + Los cambios de esquema que realice en la instancia de base de datos de origen tras crear la instantánea de base de datos no quedarán reflejados en la instancia de base de datos de destino. + Después de crear una instancia de base de datos encriptada, no puede cambiar la clave KMS utilizada por esa instancia de base de datos. Asegúrese de determinar los requisitos de su clave de KMS antes de crear la instancia de base de datos cifrada. + Debe deshabilitar los desencadenantes y claves externas en la instancia de base de datos de destino antes de ejecutar la tarea de AWS DMS. Podrá volver a habilitarlos cuando se complete la tarea. # Imponga el etiquetado automático de las bases de datos de Amazon RDS en el lanzamiento *Susanne Kangnoh y Archit Mathur, Amazon Web Services* ## Resumen Amazon Relational Database Service (Amazon RDS) es un servicio web que facilita la configuración, el funcionamiento y la escala de una base de datos relacional en la nube de Amazon Web Services (AWS). Proporciona una capacidad rentable y de tamaño ajustable para una base de datos relacional estándar y se ocupa de las tareas de administración de bases de datos comunes. Las etiquetas le permiten clasificar los recursos de AWS de diversas maneras. El etiquetado de bases de datos relacionales es útil cuando tiene muchos recursos en la cuenta y desea identificar rápidamente un recurso específico en función de las etiquetas. Puede utilizar etiquetas de Amazon RDS para añadir metadatos personalizados a las instancias de base de datos de RDS. Una etiqueta es una marca que consta de una clave y un valor definidos por el usuario. Le recomendamos que cree un conjunto de etiquetas coherente para satisfacer los requisitos de su organización. Este patrón proporciona una CloudFormation plantilla de AWS que le ayuda a supervisar y etiquetar las instancias de base de datos de RDS. La plantilla crea un evento de Amazon CloudWatch Events que vigila el DBInstance evento AWS CloudTrail **Create**. (CloudTrail captura las llamadas a la API de Amazon RDS como eventos). Cuando detecta este evento, llama a una función de AWS Lambda que aplica automáticamente las claves de etiquetas y los valores que usted defina. La plantilla también envía una notificación de que la instancia ha sido etiquetada mediante Amazon Simple Notification Service (Amazon SNS). ## Requisitos previos y limitaciones **Requisitos previos** + Una cuenta de AWS activa. + Un bucket de Amazon Simple Storage Service (Amazon S3) para cargar el código de Lambda. + Una dirección de correo electrónico activa en la que recibir las notificaciones de etiquetado. **Limitaciones** + La solución es compatible con CloudTrail **Create DBInstance events**. No crea notificaciones para ningún otro evento. ## Arquitectura **Arquitectura de flujo de trabajo** ![\[Workflow diagram showing Servicios de AWS interaction for RDS instance creation and notification.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/5541bc1e-e00f-4b5a-94b7-bb1808b5591a/images/ec0bcf92-f986-4af3-bfe7-d2c5e04051c5.png) **Automatización y escala** + Puede utilizar la CloudFormation plantilla de AWS varias veces para distintas regiones y cuentas de AWS. Debe ejecutar la plantilla solo una vez en cada región o cuenta. ## Tools (Herramientas) **Servicios de AWS** + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html): AWS CloudTrail es un servicio de AWS que le ayuda con la gobernanza, el cumplimiento y la auditoría operativa y de riesgos de su cuenta de AWS. Las acciones realizadas por un usuario, un rol o un servicio de AWS se registran como eventos en CloudTrail. + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html): Amazon CloudWatch Events ofrece una transmisión casi en tiempo real de los eventos del sistema que describen los cambios en los recursos de AWS. CloudWatch Events se da cuenta de los cambios operativos a medida que se producen y toma las medidas correctivas necesarias, mediante el envío de mensajes en respuesta al entorno, la activación de funciones, la introducción de cambios y la recopilación de información sobre el estado. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html): AWS Lambda es un servicio de computación que permite ejecutar código sin aprovisionar ni administrar servidores. Lambda ejecuta su código solo cuando es necesario y escala de manera automática, desde unas pocas solicitudes por día hasta miles por segundo. Solo pagará por el tiempo de computación que consuma, no se aplican cargos cuando el código no se está ejecutando. + [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html): Amazon Simple Storage Service (Amazon S3) es un servicio de almacenamiento de objetos altamente escalable que se puede utilizar para una amplia gama de soluciones de almacenamiento, incluidos sitios web, aplicaciones móviles, copias de seguridad y lagos de datos. + [Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html): Amazon Simple Notification Service (Amazon SNS) es un servicio web que permite a las aplicaciones, los usuarios finales y los dispositivos enviar y recibir al instante notificaciones desde la nube. **Codigo** Este patrón incluye un adjunto con dos archivos: + `index.zip` es un archivo comprimido que incluye el código de Lambda de este patrón. + `rds.yaml`es una CloudFormation plantilla que despliega el código Lambda. Consulte la sección *Epics* para obtener información sobre cómo usar estos archivos. ## Epics ### Implementar el código de Lambda | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cargue el código en un bucket de S3. | Cree un bucket de S3 nuevo o utilice un bucket de S3 ya existente para cargar el archivo adjunto `index.zip` (código de Lambda). Este bucket debe estar en la misma región de AWS que los recursos (instancias de base de datos de RDS) que desea supervisar. | Arquitecto de la nube | | Implemente la plantilla CloudFormation . | Abra la consola de Cloudformation en la misma región de AWS que el bucket de S3 e implemente el archivo `rds.yaml` que se incluye en el archivo adjunto. En la siguiente Epic, proporcione los valores de los parámetros. | Arquitecto de la nube | ### Complete los parámetros de la CloudFormation plantilla | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Proporcione el nombre del bucket de S3. | Escriba el nombre del bucket de S3 que ha creado o seleccionado en la primera Epic. Este bucket de S3 contiene el archivo.zip del código Lambda y debe estar en la misma región de AWS que CloudFormation la plantilla y las instancias de base de datos de RDS que desea supervisar. | Arquitecto de la nube | | Proporcione la clave de S3. | Proporcione la ubicación del archivo .zip del código de Lambda en su bucket de S3, sin barras diagonales iniciales (por ejemplo, `index.zip` o `controls/index.zip`). | Arquitecto de la nube | | Proporcione una dirección de correo electrónico. | Proporcione una dirección de correo electrónico activa en la que desee recibir notificaciones de infracciones. | Arquitecto de la nube | | Especifique un nivel de registro. | Especifique el nivel de registro y el detalle. `Info` designa mensajes informativos detallados sobre el progreso de la aplicación y solo debe usarse para la depuración. `Error` designa los eventos de error que aún podrían permitir que la aplicación siguiera ejecutándose. `Warning` designa situaciones potencialmente dañinas. | Arquitecto de la nube | | Introduzca las claves y los valores de las etiquetas de sus instancias de base de datos de RDS. | Escriba las claves de etiqueta y los valores que desea aplicar automáticamente a la instancia de RDS. Para más información, consulte [Etiquetar recursos de base de datos de Amazon](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html) en la documentación de AWS. | Arquitecto de la nube | ### Confirmar la suscripción | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Confirme la suscripción de correo electrónico. | Cuando la CloudFormation plantilla se implementa correctamente, envía un mensaje de correo electrónico de suscripción a la dirección de correo electrónico que proporcionó. Debe confirmar esta suscripción de correo electrónico para recibir notificaciones de cuando se han etiquetado sus instancias. | Arquitecto de la nube | ## Recursos relacionados + [Creación de un bucket](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html) (documentación de Amazon S3) + [Etiquetado de los recursos de Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html) (documentación de Amazon Aurora) + [Carga de objetos](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html) (documentación de Amazon S3) + [Creación de una regla de CloudWatch eventos que se active en una llamada a la API de AWS mediante AWS CloudTrail](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-CloudTrail-Rule.html) ( CloudWatch documentación de Amazon) ## Conexiones Para acceder al contenido adicional asociado a este documento, descomprima el archivo: [attachment.zip](samples/p-attach/5541bc1e-e00f-4b5a-94b7-bb1808b5591a/attachments/attachment.zip) # Estime el costo de una tabla de DynamoDB para la capacidad bajo demanda *Moinul Al-Mamun, Amazon Web Services* ## Resumen [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) es una base de datos transaccional NoSQL que proporciona una latencia de milisegundos de un solo dígito incluso a escala de petabytes. Esta oferta sin servidor de Amazon Web Services (AWS) se está haciendo popular debido a su rendimiento y escalabilidad consistentes. No es necesario aprovisionar la infraestructura subyacente. Su única tabla puede crecer hasta petabytes. Con el modo de capacidad bajo demanda, usted paga por solicitud por las lecturas y escrituras de datos que la aplicación realiza en las tablas. Los cargos de AWS se basan en las unidades de solicitud de lectura (RRUs) y las unidades de solicitud de escritura (WRUs) acumuladas en un mes. DynamoDB supervisa el tamaño de la tabla de forma continua durante todo el mes para determinar los cargos de almacenamiento. Admite copias de seguridad continuas con point-in-time-recovery (PITR). DynamoDB supervisa el tamaño de la tabla habilitada para PITR de forma continua durante todo el mes para determinar los cargos de la copia. Para estimar el costo de DynamoDB para un proyecto, es importante calcular cuánto RRU, WRU y almacenamiento se consumirán en las diferentes etapas del ciclo de vida del producto. Para obtener una estimación aproximada de los costes, puede utilizar la [calculadora de precios de AWS](https://calculator.aws/#/createCalculator/DynamoDB), pero debe proporcionar un número aproximado de RRUs y los requisitos de almacenamiento de la tabla. WRUs Puede resultar difícil estimarlos al principio del proyecto. La calculadora de precios de AWS no tiene en cuenta la tasa de crecimiento de los datos ni el tamaño de los elementos, ni el número de lecturas y escrituras de la tabla base y de los índices secundarios globales (GSIs) por separado. Para utilizar la calculadora de precios de AWS, debe estimar todos esos aspectos a fin de suponer cifras aproximadas de la WRU, la RRU y el tamaño del almacenamiento a fin de obtener una estimación de los costos. Este patrón proporciona un mecanismo y una plantilla de Microsoft Excel reutilizable para estimar los factores de costo básicos de DynamoDB, como los costos de escritura, lectura, almacenamiento, copia de seguridad y recuperación, para el modo de capacidad bajo demanda. Es más detallada que la calculadora de precios de AWS y considera la tabla base y GSIs los requisitos de forma independiente. También tiene en cuenta la tasa de crecimiento mensual de los datos por artículo y prevé los costos para tres años. ## Requisitos previos y limitaciones **Requisitos previos ** + Conocimientos básicos de DynamoDB y diseño de modelos de datos de DynamoDB + Conocimientos básicos sobre los precios de DynamoDB, WRU, RRU, almacenamiento y copia de seguridad y recuperación (para obtener más información, consulte [Precios de la capacidad bajo demanda](https://aws.amazon.com/dynamodb/pricing/on-demand/)) + Conocimiento de los datos, el modelo de datos y el tamaño de los elementos en DynamoDB + Conocimientos de DynamoDB GSIs **Limitaciones** + La plantilla proporciona un cálculo aproximado, pero no es adecuada para todas las configuraciones. Para obtener una estimación más precisa, debe medir el tamaño individual de cada elemento de la tabla base y. GSIs + Para obtener una estimación más precisa, debe tener en cuenta el número esperado de escrituras (insertar, actualizar y eliminar) y lecturas de cada elemento en un mes promedio. + Este patrón permite estimar únicamente los costos de escritura, lectura, almacenamiento y copia de seguridad y recuperación para los próximos años, sobre la base de hipótesis de crecimiento fijo de los datos. ## Tools (Herramientas) **Servicios de AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) es un servicio de base de datos de NoSQL completamente administrado que ofrece un rendimiento rápido, predecible y escalable. **Otras herramientas** + La [Calculadora de precios de AWS](https://calculator.aws/#/createCalculator/DynamoDB) es una herramienta de planificación basada en la web destinada a crear presupuestos para los casos de uso de AWS. ## Prácticas recomendadas Para ayudar a mantener los costos bajos, tenga en cuenta las siguientes prácticas recomendadas de diseño de DynamoDB. + [Diseño de claves de partición](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-partition-key-uniform-load.html): utilice una clave de partición de alta cardinalidad para distribuir la carga de manera uniforme. + [Patrón de diseño de lista de adyacencia](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-adjacency-graphs.html): utilice este patrón de diseño para la gestión one-to-many y many-to-many las relaciones. + Índice [disperso: utilice un índice](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-indexes-general-sparse-indexes.html) disperso para su. GSIs Cuando crea un GSI, especifica una clave de partición y, de forma opcional, una clave de clasificación. Solo los elementos de la tabla base que contienen la clave de partición de GSI correspondiente aparecen en el índice disperso. Esto ayuda a mantener GSIs el tamaño más pequeño. + [Sobrecarga de índices](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-gsi-overloading.html): utilice el mismo GSI para indexar varios tipos de elementos. + [Partición de escritura de GSI](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-indexes-gsi-sharding.html): particione de manera inteligente para distribuir los datos entre las particiones y realice consultas más rápidas y eficientes. + [Elementos grandes](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-use-s3-too.html): solo almacene los metadatos dentro de la tabla, guarde el blob en Amazon S3 y guarde la referencia en DynamoDB. Divida los elementos grandes en varios elementos e indexe de manera eficiente mediante claves de clasificación. A fin de conocer más prácticas recomendadas de diseño, consulte la [Guía para desarrolladores](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html) de Amazon DynamoDB. ## Epics ### Extraiga la información de los artículos de su modelo de datos de DynamoDB | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Obtener el tamaño del artículo. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Ingeniero de datos | | Calcule el costo de escritura. | Para estimar el coste de escritura en el modo de capacidad bajo demanda, primero hay que medir la cantidad que se WRUs consumirá en un mes. Para ello, debe tener en cuenta los siguientes factores:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html)Para obtener más información, consulte la sección *Additional information* (Información adicional). | Ingeniero de datos | | Calcule el costo de lectura. | Para estimar el coste de lectura en el modo bajo demanda, primero hay que medir cuántas se RRUs consumirán en un mes. Para ello, debe tener en cuenta los siguientes factores: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Desarrollador de aplicaciones, ingeniero de datos | | Calcule el tamaño y el costo del almacenamiento. | En primer lugar, calcule el requisito de almacenamiento mensual promedio en función del tamaño del artículo de la tabla. A continuación, calcule el costo de almacenamiento multiplicando el tamaño de almacenamiento por el precio por GB de almacenamiento de su región de AWS. Si ya ha introducido datos para estimar el costo de escritura, no es necesario que los vuelva a introducir para calcular el tamaño de almacenamiento. De lo contrario, para estimar el tamaño de almacenamiento, debe tener en cuenta los siguientes factores: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Ingeniero de datos | ### Introduzca la información del artículo y el objeto en la plantilla de Excel | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Descargue la plantilla de Excel de la sección de adjuntos y ajústela para que se adapte a su tabla de casos de uso. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Ingeniero de datos | | Introduzca la información en la plantilla de Excel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html)En la plantilla, hay tres elementos o entidades: información, metadatos y relación. Hay dos GSIs. Para su caso de uso, si necesita más elementos, cree filas nuevas. Si necesitas más GSIs, copia un bloque de GSI existente y pégalo para crear tantos bloques de GSI como necesites. A continuación, ajuste los cálculos de las columnas SUM y TOTAL. | Ingeniero de datos | ## Recursos relacionados **Referencias** + [Precios de Amazon DynamoDB para capacidad bajo demanda](https://aws.amazon.com/dynamodb/pricing/on-demand/) + [Calculadora de precios de AWS para DynamoDB](https://calculator.aws/#/createCalculator/DynamoDB) + [Prácticas recomendadas para el diseño y la arquitectura con DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html) + [Introducción a DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) **Guías y patrones** + [Modelado de datos con Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-data-modeling/) + [Costos de almacenamiento estimados para una tabla de Amazon DynamoDB](https://apg-library.amazonaws.com/content/9b74399d-9655-47ee-b9b3-de46b65bc4e3) ## Información adicional **Ejemplo de cálculo de costos de escritura** El diseño del modelo de datos de DynamoDB muestra tres elementos por producto y un tamaño medio de artículo de 4 KB. Al añadir un producto nuevo a la tabla base de DynamoDB, consume el número de elementos \$1 (tamaño del elemento/unidad de escritura de 1 KB) = 3 \$1 (4/1) = 12 WRU. En este ejemplo, si se escribe 1 KB, el producto consume 1 WRU. **Lea el ejemplo de cálculo de costos** Para obtener la estimación de la RRU, considere el promedio de cuántas veces se leerá cada elemento en un mes. Por ejemplo, el elemento de información se leerá, en promedio, 10 veces en un mes, el elemento de metadatos se leerá dos veces y el elemento de relación se leerá cinco veces. En la plantilla de ejemplo, la RRU total de todos los componentes = número de componentes nuevos creados al mes \$1 RRU por componente al mes = 10 millones \$1 17 RRU = 170 millones de RRU cada mes. Cada mes, se añadirán elementos nuevos (componentes o productos) y el número total de productos aumentará con el tiempo. Por lo tanto, los requisitos de RRU también aumentarán con el tiempo. + Durante el primer mes, el consumo de RRU será de 170 millones. + Durante el segundo mes, el consumo de RRU será 2 \$1 170 millones, es decir, 340 millones. + Durante el primer mes, el consumo de RRU será de 3 \$1 170 millones, es decir, 510 millones. El siguiente gráfico muestra una previsión mensual del consumo y los costos de la RRU. ![\[El consumo de RRU aumenta de forma más pronunciada que el coste.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/1797b48f-a183-4f25-811f-44921c3a48ee/images/3505bfc8-694d-4acc-8585-cd71258fa315.png) Tenga en cuenta que los precios en el gráfico son solo ilustrativos. Para crear previsiones precisas para su caso de uso, consulte la página de precios de AWS y utilice esos precios en la hoja de Excel. **Ejemplos de cálculos de costos de almacenamiento, copia de seguridad y recuperación** El almacenamiento, la copia de seguridad y la restauración de DynamoDB están conectados entre sí. La copia de seguridad está conectada directamente con el almacenamiento y la recuperación está directamente relacionada con el tamaño de la copia de seguridad. A medida que aumente el tamaño de la tabla, los costos correspondientes de almacenamiento, copia de seguridad y restauración aumentarán proporcionalmente. *Tamaño y costo del almacenamiento* El costo del almacenamiento aumentará con el tiempo en función de la tasa de crecimiento de los datos. Por ejemplo, supongamos que el tamaño medio de un componente o producto en la tabla base GSIs es de 11 KB y que cada mes se añadirán 10 millones de productos nuevos a la tabla de base de datos. En ese caso, el tamaño de la tabla de DynamoDB aumentará (11 KB \$1 10 millones) /1024/1024 = 105 GB al mes. El primer mes, el tamaño de almacenamiento de la tabla será de 105 GB, el segundo será de 105 \$1 105 = 210 GBs, y así sucesivamente. + Durante el primer mes, el costo del almacenamiento será de 105 GB \$1 el precio de almacenamiento por GB para su región de AWS. + Durante el segundo mes, el costo del almacenamiento será de 210 GB \$1 el precio de almacenamiento por GB para su región. + Durante el tercer mes, el costo del almacenamiento será de 315 GB \$1 el precio de almacenamiento por GB para su región. Para conocer el tamaño y el costo del almacenamiento para los próximos tres años, consulte la sección *Tamaño del almacenamiento y previsión*. *de la copia de seguridad* El costo de las copias de seguridad aumentará con el tiempo en función de la tasa de crecimiento de los datos. Al activar la copia de seguridad continua con point-in-time-recovery (PITR), los cargos por copia de seguridad continua se basan en una media de GB de almacenamiento al mes. En un mes natural, el tamaño medio de las copias de seguridad sería el mismo que el tamaño de almacenamiento de la tabla, aunque el tamaño real podría ser un poco diferente. Como se añadirán productos nuevos cada mes, el tamaño total de almacenamiento y el tamaño de las copias de seguridad aumentarán con el tiempo. Por ejemplo, durante el primer mes, el tamaño medio de las copias de seguridad de 105 GB podría aumentar a 210 GB durante el segundo mes. + Durante el primer mes, el costo de la copia de seguridad será de 105 GB al mes \$1 el precio de la copia de seguridad continua por GB para su región de AWS. + Durante el segundo mes, el costo de la copia de seguridad será de 210 GB al mes \$1 el precio de la copia de seguridad continua por GB para su región. + Durante el tercer mes, el costo de la copia de seguridad será de 315 GB al mes \$1 el precio de la copia de seguridad continua por GB para su región. + … y así sucesivamente. El costo de la copia de seguridad se incluye en el gráfico de la sección *Previsión del tamaño y el costo del almacenamiento*. *Costo de recuperación* Cuando realiza copias de seguridad continuas con la PITR habilitada, los cargos por la operación de recuperación se basan en el tamaño de la restauración. Cada vez que restaure, pagará en función de los gigabytes de datos restaurados. Si el tamaño de la tabla es grande y realiza la restauración varias veces en un mes, será costosa. Para estimar el costo de la restauración, en este ejemplo se supone que se realiza una recuperación del PITR una vez al mes al final del mes. En el ejemplo, se utiliza el tamaño medio mensual de la copia de seguridad como tamaño de los datos de restauración de ese mes. Durante el primer mes, el tamaño medio de la copia de seguridad es de 105 GB, y para la recuperación al final del mes, el tamaño de los datos de restauración sería de 105 GB. Para el segundo mes, serían 210 GBs, y así sucesivamente. El costo de recuperación aumentará con el tiempo en función de la tasa de crecimiento de los datos. + Durante el primer mes, el costo de recuperación será de 105 GB \$1 el precio de recuperación por GB para su región de AWS. + Durante el segundo mes, el costo de recuperación será de 210 GB \$1 el precio de restauración por GB para su región. + Durante el tercer mes, el costo de recuperación será de 315 GB \$1 el precio de restauración por GB para su región. Para obtener más información, consulte la pestaña Almacenamiento, copia de seguridad y recuperación de la plantilla de Excel y el gráfico de la siguiente sección. *Previsión del tamaño y los costos del almacenamiento* En la plantilla, el tamaño de almacenamiento facturable real se calcula restando 25 GB al mes de la capa gratuita de la clase de tabla estándar. En la hoja, obtendrá un gráfico de pronóstico dividido en valores mensuales. El siguiente gráfico de ejemplo prevé el tamaño de almacenamiento mensual en GB, el costo de almacenamiento facturable, el costo de las copias de seguridad bajo demanda y el costo de recuperación para los próximos 36 meses naturales. Todos los costos están en USD. A partir del gráfico, queda claro que los costos de almacenamiento, copia de seguridad y recuperación aumentan proporcionalmente al aumento del tamaño del almacenamiento. ![\[El tamaño del almacenamiento supera los tres mil, mientras que los costes son inferiores a mil.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/1797b48f-a183-4f25-811f-44921c3a48ee/images/fd9f06d0-bc9c-4b4e-8cbd-3e527fe09e88.png) Tenga en cuenta que los precios en el gráfico son solo ilustrativos. Para crear previsiones precisas para su caso de uso, consulte la página de precios de AWS y utilice esos precios en la hoja de Excel. ## Conexiones Para acceder al contenido adicional asociado a este documento, descomprima el archivo: [attachment.zip](samples/p-attach/1797b48f-a183-4f25-811f-44921c3a48ee/attachments/attachment.zip) # Costos de almacenamiento estimados para una tabla de Amazon DynamoDB *Moinul Al-Mamun, Amazon Web Services* ## Resumen Amazon DynamoDB es una base de datos transaccional NoSQL que proporciona una latencia de milisegundos de un solo dígito incluso a escala de petabytes. Esta popular oferta sin servidor de ofrece un rendimiento y una escalabilidad AWS consistentes. No es necesario aprovisionar almacenamiento y su única tabla puede crecer hasta petabytes. DynamoDB supervisa el tamaño de la tabla de forma continua durante todo el mes para determinar los cargos de almacenamiento. AWS a continuación, le cobrará por el tamaño medio del almacenamiento en gigabytes. Cuanto más crezca su tabla con el tiempo, más crecerán sus costos de almacenamiento. Para calcular el coste de almacenamiento, puede utilizar la [calculadora de AWS precios](https://calculator.aws/#/createCalculator/DynamoDB), pero debe proporcionar el tamaño aproximado de la tabla, incluidos los índices secundarios globales (GSIs), lo que resulta muy difícil de estimar al principio del proyecto. Además, la calculadora AWS de precios no tiene en cuenta la tasa de crecimiento de los datos. Este patrón proporciona un mecanismo y una plantilla de Microsoft Excel reutilizable para calcular el tamaño y el costo del almacenamiento de DynamoDB. Considera los requisitos de almacenamiento para la tabla base y los de GSIs forma independiente. Calcula el tamaño del almacenamiento teniendo en cuenta el tamaño de los elementos individuales y la tasa de crecimiento de los datos a lo largo del tiempo. Para obtener una estimación, inserte dos datos en la plantilla: + El tamaño del elemento individual en kilobytes de la tabla base y GSIs + Cuántos objetos o productos nuevos se podrían añadir a la tabla, en promedio, en un mes (por ejemplo, 10 millones) La plantilla genera un gráfico de previsión de costos y almacenamiento para los próximos tres años, como se muestra en el siguiente ejemplo. ![\[La línea inferior para el costo sube lentamente y la línea superior para el almacenamiento sube más rápidamente.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/9b74399d-9655-47ee-b9b3-de46b65bc4e3/images/c0436252-cc42-4ea3-ac50-c0455aece39d.png) ## Requisitos previos y limitaciones **Requisitos previos ** + Conocimientos básicos de DynamoDB, incluido el almacenamiento y los precios de DynamoDB + Conocimiento de los datos, el modelo de datos y el tamaño de los elementos en DynamoDB + Conocimiento de los índices secundarios globales de DynamoDB () GSIs **Limitaciones** + La plantilla proporciona un cálculo aproximado, pero no es adecuada para todas las configuraciones. Para obtener una estimación más precisa, debe medir el tamaño individual de cada elemento de la tabla base y. GSIs + Este patrón permite estimar únicamente el tamaño y los costos de almacenamiento para los próximos años, sobre la base de hipótesis de crecimiento fijo de los datos. ## Tools (Herramientas) **Servicios de AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) es un servicio de base de datos de NoSQL completamente administrado que ofrece un rendimiento rápido, predecible y escalable. **Otras herramientas** + AWS La [calculadora de precios](https://docs.aws.amazon.com/pricing-calculator/latest/userguide/what-is-pricing-calculator.html) es una herramienta de planificación basada en la web que puede utilizar para crear estimaciones para sus casos de AWS uso. ## Epics ### Extraiga la información de los artículos de su modelo de datos de DynamoDB | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Obtener el tamaño del artículo. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Ingeniero de datos | | Obtenga el número de objetos que se han agregado en un mes. | Calcule cuántos componentes u objetos se añadirán a la tabla de DynamoDB, de media, en un mes. | Ingeniero de datos | ### Introduzca la información del artículo y el objeto en la plantilla de Excel | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Descargue y ajuste la hoja de cálculo de Excel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Ingeniero de datos | | Introduzca la información en la plantilla de Excel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Ingeniero de datos | ## Recursos relacionados + [Precios de la capacidad bajo demanda](https://aws.amazon.com/dynamodb/pricing/on-demand/) para Amazon DynamoDB + [AWS Calculadora de precios para DynamoDB](https://calculator.aws/#/createCalculator/DynamoDB) ## Información adicional Tenga en cuenta que la plantilla adjunta solo prevé el tamaño y el costo del almacenamiento para la clase de tabla de almacenamiento estándar. En función de la previsión de los costos de almacenamiento y teniendo en cuenta el tamaño individual del artículo y la tasa de crecimiento del producto o del objeto, puede estimar lo siguiente: + Costo de exportación de datos + Precio de copias de seguridad y recuperación + Requisitos de almacenamiento de datos. **Costo del almacenamiento de datos de Amazon DynamoDB** DynamoDB supervisa el tamaño de la tabla de forma continua durante todo el mes para determinar los cargos de almacenamiento. DynamoDB mide el tamaño de los datos facturables al agregar el tamaño de byte sin procesar de los datos y una capacidad de almacenamiento por elemento que depende de las características que haya habilitado. Para obtener más información, consulte la [Guía para desarrolladores de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/CapacityUnitCalculations.html). El precio del almacenamiento de datos depende de la clase de tabla. Los primeros 25 GB almacenados cada mes son gratuitos si utiliza la clase de tabla estándar de DynamoDB. [Para obtener más información sobre los costes de almacenamiento de las clases de tablas Estándar y Estándar de Acceso Infrecuente, en distintas categorías Regiones de AWS, consulte Precios de la capacidad bajo demanda.](https://aws.amazon.com/dynamodb/pricing/on-demand/) ## Conexiones Para acceder al contenido adicional asociado a este documento, descomprima el archivo: [attachment.zip](samples/p-attach/9b74399d-9655-47ee-b9b3-de46b65bc4e3/attachments/attachment.zip) # Calcule el tamaño del motor de Amazon RDS para una base de datos de Oracle mediante informes de AWR *Abhishek Verma y Eduardo Valentim, Amazon Web Services* ## Resumen Al migrar una base de datos Oracle a Amazon Relational Database Service (Amazon RDS) o Amazon Aurora, el cálculo de la CPU, la memoria y el I/O disco de la base de datos de destino es un requisito clave. Puede estimar la capacidad requerida de la base de datos de destino analizando los informes del repositorio automático de cargas de trabajo (AWR) de Oracle. Este patrón explica cómo utilizar los informes de AWR para estimar estos valores. La base de datos Oracle de origen puede estar en las instalaciones o alojada en una instancia de Amazon Elastic Compute Cloud (Amazon EC2), o puede ser una instancia de base de datos de Amazon RDS for Oracle. La base de datos de destino puede ser cualquier base de datos de Amazon RDS o Aurora. **nota** Las estimaciones de capacidad serán más precisas si el motor de base de datos de destino es Oracle. En el caso de otras bases de datos de Amazon RDS, el tamaño del motor puede variar debido a las diferencias en la arquitectura de la base de datos. Le recomendamos que realice la prueba de rendimiento antes de migrar la base de datos de Oracle. ## Requisitos previos y limitaciones **Requisitos previos ** + Una licencia de Oracle Database Enterprise Edition y una licencia de Oracle Diagnostics Pack para descargar los informes de AWR. **Versiones de producto** + Todas las ediciones de bases de datos de Oracle para las versiones 11g (versiones 11.2.0.3.v1 y posteriores) y hasta 12.2, 18c y 19c. + Este patrón no cubre Oracle Engineered Systems ni Oracle Cloud Infrastructure (OCI). ## Arquitectura **Pila de tecnología de origen** Uno de los siguientes: + Una base de datos de Oracle en las instalaciones + Una base de datos de Oracle en una instancia EC2 + Una instancia de base de datos de Amazon RDS para Oracle **Pila de tecnología de destino** + Cualquier base de datos de Amazon RDS a Amazon Aurora. **Arquitectura de destino** Para obtener información sobre el proceso de migración completo, consulte el patrón [Migración de una base de datos de Oracle a Aurora PostgreSQL mediante AWS DMS y 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) **Automatizar y escalar** Si tiene que migrar varias bases de datos de Oracle y desea utilizar métricas de rendimiento adicionales, puede automatizar el proceso siguiendo los pasos descritos en la entrada del blog [Dimensionar correctamente las instancias de Amazon RDS a escala en función de las métricas de rendimiento de Oracle](https://aws.amazon.com/blogs/database/right-sizing-amazon-rds-instances-at-scale-based-on-oracle-performance-metrics/). ## Tools (Herramientas) + El [Repositorio automático de cargas de trabajo (AWR) de Oracle](https://docs.oracle.com/en-us/iaas/performance-hub/doc/awr-report-ui.html) es un repositorio integrado en las bases de datos de Oracle. Recopila y almacena periódicamente los datos de actividad y carga de trabajo del sistema, que luego son analizados por el Monitor de diagnóstico automático de bases de datos (ADDM). AWR toma instantáneas de los datos de rendimiento del sistema periódicamente (de forma predeterminada, cada 60 minutos) y almacena la información (de forma predeterminada, hasta 8 días). Puede utilizar las vistas y los informes de AWR para analizar estos datos. ## Prácticas recomendadas + Para calcular las necesidades de recursos de la base de datos de destino, puede utilizar un único informe de AWR, varios informes de AWR o vistas de AWR dinámicas. Le recomendamos que utilice varios informes de AWR durante el período de máxima carga para estimar los recursos necesarios para gestionar esos picos de carga. Además, las vistas dinámicas proporcionan más puntos de datos que lo ayudan a calcular las necesidades de recursos con mayor precisión. + Debe estimar las IOPS solo para la base de datos que planea migrar, no para otras bases de datos y procesos que utilizan el disco. + Para calcular cuánto I/O utiliza la base de datos, no utilices la información de la sección Perfil de carga del informe AWR. En su lugar, usa la sección I/O Perfil, si está disponible, o ve a la sección Estadísticas de actividad de la instancia y consulta los valores totales de las operaciones físicas de lectura y escritura. + Cuando estime el uso de la CPU, le recomendamos que utilice el método de métricas de la base de datos en lugar de las estadísticas del sistema operativo (SO), ya que se basa en la CPU que utilizan únicamente las bases de datos. (Las estadísticas del sistema operativo también incluyen el uso de la CPU por parte de otros procesos). También debería consultar las recomendaciones relacionadas con la CPU en el informe de ADDM para mejorar el rendimiento tras la migración. + Tenga en cuenta los límites de I/O rendimiento (rendimiento de Amazon Elastic Block Store (Amazon EBS) y rendimiento de red, para el tamaño de instancia específico a la hora de determinar el tipo de instancia correcto. + Realice la prueba de rendimiento antes de la migración para validar el tamaño del motor. ## Epics ### Crear un informe de AWR | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Habilite el informe AWR. | Para activar el informe, siga las instrucciones de la [documentación de Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/18/tgdba/gathering-database-statistics.html#GUID-26D359FA-F809-4444-907C-B5AFECD9AE29). | Administrador de base de datos | | Compruebe el periodo de retención. | Para comprobar el periodo de retención del informe AWR, utilice la siguiente consulta.
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;| Administrador de base de datos | | Genere la instantánea. | Si el intervalo de instantáneas de AWR no es lo suficientemente detallado como para captar el pico de carga de trabajo, puede generar el informe de AWR manualmente. Para generar la instantánea de AWR manual, utilice la siguiente consulta.
SQL> EXEC dbms_workload_repository.create_snapshot;| Administrador de base de datos | | Compruebe las instantáneas recientes. | Para comprobar las instantáneas de AWR recientes, utilice la siguiente consulta.
SQL> SELECT snap_id, to_char(begin_interval_time,'dd/MON/yy hh24:mi') Begin_Interval,| Administrador de base de datos | ### I/O Calcule los requisitos de disco | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Elija un método. | Las IOPS son la medida estándar de las operaciones de entrada y salida por segundo en un dispositivo de almacenamiento e incluyen las operaciones de lectura y escritura. Si va a migrar una base de datos local a AWS, debe determinar el pico de disco que I/O utiliza la base de datos. Puede utilizar los siguientes métodos para estimar el disco de la base de I/O datos de destino:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Estos cuatro métodos se describen en los siguientes pasos. | Administrador de base de datos | | Opción 1: utilice el perfil de carga. | La siguiente tabla muestra un ejemplo de la sección Perfil de carga del informe AWR.Para obtener información más precisa, le recomendamos que utilice la opción 2 (perfiles de E/S) o la opción 3 (estadísticas de actividad de la instancia) en lugar del perfil de carga.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)En función de esta información, puede calcular IOPs y procesar de la siguiente manera:*IOPS = solicitudes de lectura: \$1 I/O Solicitudes de escritura = I/O 3.586,8 \$1 574,7 = 4134,5** Rendimiento = lectura física (bloques) \$1 escritura física (bloques) = 13 575,1 \$1 3467,3 = 17 042,4*Como el tamaño del bloque en Oracle es de 8 KB, puede calcular el rendimiento total de la siguiente manera:* El rendimiento total en MB es 17 042,4 \$1 8 \$1 1024 / 1024 / 1024 = 133,2 MB*No utilice el perfil de carga para estimar el tamaño de la instancia. No es tan preciso como las estadísticas o los perfiles de actividad de las instancias. I/O | Administrador de base de datos | | Opción 2: utilizar estadísticas de actividad de instancia. | Si utiliza una versión de la base de datos de Oracle anterior a la 12c, puede utilizar la sección de estadísticas de actividad de las instancias del informe AWR para estimar las IOPS y el rendimiento. En la tabla siguiente se muestra un ejemplo de esta sección.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)En función de esta información, puede calcular el total de IOPS y el rendimiento de la siguiente manera:* TIOPS totales = 3610,28 \$1 757,11 = 4367** Mbps totales = 114 482 426,26 \$1 36 165 631,84 = 150 648 058,1 / 1024 / 1024 = 143 Mbps* | Administrador de base de datos | | Opción 3: utilizar perfiles. I/O | En Oracle Database 12c, el informe AWR incluye una sección de I/O perfiles que presenta toda la información en una sola tabla y proporciona datos más precisos sobre el rendimiento de la base de datos. En la tabla siguiente se muestra un ejemplo de esta sección.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)En esta tabla se proporcionan los siguientes valores de rendimiento e IOPS totales:* Rendimiento = 143 MBPS (desde la quinta fila, denominada Total, segunda columna)** IOPS = 4367,4 (desde la primera fila, denominada Solicitudes totales, segunda columna)* | Administrador de base de datos | | Opción 4: utilizar vistas AWR. | Puede ver la misma información de IOPS y rendimiento mediante las vistas de AWR. Para obtener esta información, utilice la siguiente consulta:
to_char(end_interval_time,'dd/MON/yy hh24:mi') End_Interval
FROM dba_hist_snapshot
ORDER BY 1;
break on report| Administrador de base de datos | | | Por segundo | Transacción | Por ejecutivo | Por llamada | | --- |--- |--- |--- |--- | | **Tiempo/s de base de datos:** | 26.6 | 0.2 | 0,00 | 0,02 | | **CPU de base de datos:** | 18,0 | 0.1 | 0,00 | 0.01 | | **CPU de fondo:** | 0.2 | 0.0 | 0,00 | 0,00 | | **Tamaño de Redo (bytes):** | 2.458.539,9 | 17.097,5 | | | | **Lectura lógica (bloques):** | 3.371.931,5 | 23.449,6 | | | | **Cambios en bloques:** | 21.643,5 | 150,5 | | | | **Lectura física bloques):** | 13.575,1 | 94,4 | | | | **Escritura física (bloques):** | 3.467,3 | 24,1 | | | | **Leer las solicitudes de E/S:** | 3.586,8 | 24,9 | | | | **Solicitudes de escritura IO**: | 574,7 | 4.0 | | | | **Leer E/S (MB):** | 106.1 | 0.7 | | | | **Escribir E/S (MB):** | 27,1 | 0.2 | | | | **Filas de escaneo de mensajería instantánea:** | 0.0 | 0.0 | | | | **Mensajería instantánea de lectura lógica de sesión:** | | | | | | **User calls**: | 1.245,7 | 8.7 | | | | **Análisis (SQL):** | 4.626,2 | 32,2 | | | | **Análisis duros (SQL):** | 8.9 | 0.1 | | | | **Área de trabajo de SQL (MB):** | 824,9 | 5.7 | | | | **Inicios de sesión:** | 1.7 | 0.0 | | | | **Ejecutar (SQL):** | 136.656,5 | 950,4 | | | | **Reversión**: | 22.9 | 0.2 | | | | **Transacciones**: | 143.8 | | | | | Estadística | Total | Por segundo | por Trans | | --- |--- |--- |--- | | **lectura física total de solicitudes de E/S** | 2.547.333.217 | 3.610,28 | 25,11 | | **bytes totales de lectura física** | 80.776.296.124 928 | 114,482,426,26 | 796.149,98 | | **escritura física, total de solicitudes de E/S** | 534.198.208 | 757,11 | 5.27 | | **bytes totales de escritura física** | 25.517.678.849.024 | 36.165.631,84 | 251.508,18 | | | Lectura \$1 escritura por segundo | Lecturas por segundo | Escrituras por segundo | | --- |--- |--- |--- | | **Solicitudes por segundo** | 4.367,4 | 3.610,3 | 757,1 | | **Solicitudes de bases de datos:** | 4.161,5 | 3.586,8 | 574,7 | | **Solicitudes optimizadas:** | 0.0 | 0.0 | 0.0 | | **Rehacer solicitudes:** | 179,3 | 2.8 | 176,6 | | **Total (MB):** | 143.7 | 109,2 | 34,5 | | **Base de datos (MB):** | 133,1 | 106.1 | 27,1 | | **Total optimizado (MB):** | 0.0 | 0.0 | 0.0 | | **Rehacer (MB):** | 7.6 | 2.7 | 4.9 | | **Base de datos (bloques):** | 17.042,4 | 13.575,1 | 3.467,3 | | **A través de Buffer Cache (bloques):** | 5.898,5 | 5.360,9 | 537,6 | | **Directo (bloques):** | 11.143,9 | 8.214,2 | 2.929,7 | ### Calcule los requisitos de CPU | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Elija un método. | Puede estimar la CPU necesaria para la base de datos de destino de tres maneras:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Si está analizando los núcleos utilizados, le recomendamos que utilice el método de métricas de la base de datos en lugar de las estadísticas del sistema operativo, ya que se basa en la CPU que utilizan únicamente las bases de datos que planea migrar. (Las estadísticas del sistema operativo también incluyen el uso de la CPU por parte de otros procesos). También debería consultar las recomendaciones relacionadas con la CPU en el informe de ADDM para mejorar el rendimiento tras la migración.También puede estimar los requisitos en función de la generación de CPU. Si utiliza distintas generaciones de CPU, puede estimar la CPU necesaria para la base de datos de destino siguiendo las instrucciones del documento técnico [Desmitificando el número de v para lograr un rendimiento óptimo de la carga](https://d1.awsstatic.com/whitepapers/Demystifying_vCPUs.df200b766578b75009ad8d15c72e493d6408c68a.pdf) de trabajo. CPUs | Administrador de base de datos | | Opción 1: calcule los requisitos en función de los núcleos disponibles. | En informes AWR:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Puede estimar los núcleos disponibles de dos maneras:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)**Para estimar los núcleos disponibles mediante comandos del sistema operativo**Utilice el siguiente comando para contar los núcleos del procesador.
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"|uniqUtilice el siguiente comando para contar los sockets del procesador.
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 -uNo recomendamos utilizar comandos del sistema operativo, como **nmon** y **sar**, para extraer el uso de la CPU. Esto se debe a que esos cálculos incluyen el uso de la CPU por parte de otros procesos y es posible que no reflejen la CPU real que utiliza la base de datos.**Para estimar los núcleos disponibles mediante el informe AWR**También puede deducir el uso de la CPU de la primera sección del informe de AWR. A continuación se muestra un extracto del informe.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)En este ejemplo, el CPUs recuento es 80, lo que indica que son lógicos (virtuales). CPUs También puede ver que esta configuración tiene dos sockets, un procesador físico en cada socket (para un total de dos procesadores físicos) y 40 núcleos para cada socket o procesador físico. | Administrador de base de datos | | Opción 2: Calcule el uso de la CPU mediante las estadísticas del sistema operativo. | Puede comprobar las estadísticas de uso de la CPU del sistema operativo directamente en el sistema operativo (mediante **sar** u otra utilidad del sistema operativo host) o revisando los valores de IDLE/(IDLE\$1BUSY) de la sección de estadísticas del sistema operativo del informe AWR. Puede ver los segundos de CPU consumidos directamente desde **v\$1osstat**. Los informes AWR y Statspack también muestran estos datos en la sección de estadísticas del sistema operativo.Si hay varias bases de datos en el mismo cuadro, todas tienen los mismos valores de **v\$1osstat** para BUSY\$1TIME.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Si no hay otros consumidores importantes de CPU en el sistema, utilice la siguiente fórmula para calcular el porcentaje de uso de la CPU:* Utilización = tiempo de actividad / tiempo total** Tiempo de actividad = requisitos = v\$1osstat.BUSY\$1TIME** C = Tiempo total (actividad \$1 inactivo)** C = capacidad = v\$1ostat.BUSY\$1TIME \$1 v\$1ostat.IDLE\$1TIME** Utilización = BUSY\$1TIME / (BUSY\$1TIME \$1 IDLE\$1TIME)** = -1 305 569 937 / (1 305 569 937 \$1 4 312 718 839)** = 23 % utilizado* | Administrador de base de datos | | Opción 3: calcule el uso de la CPU mediante métricas de bases de datos. | Si hay varias bases de datos en ejecución en el sistema, puede utilizar las métricas de la base de datos que aparecen al principio del informe.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Para obtener las métricas de uso de la CPU, utilice esta fórmula:* Uso de la CPU de la base de datos (% de la potencia de la CPU disponible) = tiempo de CPU / NUM\$1CPUS / tiempo transcurrido*donde el uso de la CPU se describe mediante el *tiempo de CPU* y representa el tiempo dedicado a la CPU, no el tiempo de espera a la CPU. Este cálculo da como resultado:* = 312 625,40 / 11 759,64/80 = Se está utilizando el 33 % de la CPU** Número de núcleos (33 %) \$1 80 = 26,4 núcleos** Núcleos totales = 26,4 \$1 (120 %) = 31,68 núcleos*Puede usar el mayor de estos dos valores para calcular la utilización de la CPU de la instancia de base de datos Amazon RDS o Aurora.En IBM AIX, la utilización calculada no coincide con los valores del sistema operativo o de la base de datos. Estos valores coinciden en otros sistemas operativos. | Administrador de base de datos | | Nombre de base de datos | DB Id | Instancia | Inst num | Hora de inicio | Release | RAC | | --- |--- |--- |--- |--- |--- |--- | | XXXX |
physical id : 0
physical id : 1
call mysql.rds_set_configuration('binlog retention hours', XX)Confirme la configuración ejecutando el siguiente comando.call mysql.rds_show_configuration;Las bases de datos compatibles con MySQL administradas por AWS purgan los registros binarios lo antes posible. Por lo tanto, el período de retención debe ser lo suficientemente prolongado como para garantizar que los registros no se purguen antes de ejecutar la tarea de AWS DMS. Un valor de 24 horas suele ser suficiente, pero deberá basarse en el tiempo necesario para configurar la tarea de AWS DMS en la región de DR. | Administrador de base de datos | ### Actualice la tarea de AWS DMS existente en la región principal | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Registre el ARN de la tarea de AWS DMS. | Use el nombre de recurso de Amazon (ARN) para obtener el nombre de tarea de AWS DMS. Lo usará posteriormente. Para recuperar el ARN de la tarea de AWS DMS, visualice la tarea en la consola o ejecute el siguiente comando.
aws dms describe-replication-tasksUn registro de ARN tiene el siguiente aspecto.
arn:aws:dms:us-east-1:Los caracteres que aparecen tras los últimos dos puntos corresponden al nombre de la tarea que se usará en un paso posterior. | Administrador de AWS | | Modifique la tarea de AWS DMS existente para registrar el punto de control. | El punto de comprobación que AWS DMS crea contiene información para que el motor de replicación sepa el punto de recuperación del flujo de cambios. Para registrar la información del punto de control, siga estos pasos en la consola:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html) | Administrador de AWS | | Valide la información del punto de control. | Con un cliente MySQL conectado al punto de conexión de escritura del clúster, consulte la nueva tabla de metadatos en el clúster secundario de base de datos para comprobar que existe y contiene la información del estado de la replicación. Ejecute el comando siguiente.:task:AN6HFFMPM246XOZVEUHCNSOVF7MQCLTOZUIRAMY
select * from awsdms_control.awsdms_txn_state;El nombre de la tarea de ARN se encuentra en la columna `Task_Name` de esta tabla. | Administrador de base de datos | ### Amplíe ambos clústeres de Amazon Aurora a una región de DR | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una infraestructura base en la región de DR. | Cree los componentes básicos necesarios para la creación y acceso a los clústeres de Amazon Aurora:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html)Asegúrese de que la configuración de ambos grupos de parámetros coincida con la configuración de la región principal. | Administrador de AWS | | Agregue la región de DR a ambos clústeres de Amazon Aurora. | Agregue una región secundaria (la región de DR) a los clústeres principales y secundarios de Amazon Aurora. Para mayor información, consulte [Cómo agregar una región AWS a una base de datos global de Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html#aurora-global-database-attaching). | Administrador de AWS | ### Realice una conmutación por error | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Detenga las tareas de AWS DMS. | La tarea de AWS DMS en la región principal no funcionará correctamente tras la conmutación por error, y deberá detenerla para evitar errores. | Administrador de AWS | | Realice una conmutación por error gestionada. | Realice una conmutación por error gestionada del clúster de base de datos principal a la región de DR. Para instrucciones, consulte [Ejecución de la conmutación por error planificada administrada para bases de datos globales de Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-disaster-recovery.html#aurora-global-database-disaster-recovery.managed-failover). Una vez finalizada la conmutación por error en el clúster de base de datos principal, realice la misma operación en el clúster de base de datos secundaria. | Administrador de AWS, administrador de base de datos | | Cargue los datos en la base de datos principal. | Inserte los datos de prueba en el nodo de escritura de la base de datos principal del clúster de base de datos de DR. Estos datos se usarán para validar el correcto funcionamiento de la replicación. | Administrador de base de datos | | Cree una instancia de replicación de AWS DMS. | Para crear la instancia de replicación de AWS DMS en la región de DR, consulte [Crear una instancia de replicación](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.Creating.html). | Administrador de AWS, administrador de base de datos | | Cree los puntos de conexión de AWS DMS de origen y de destino. | Para crear los puntos de conexión de origen y destino de AWS DMS en la región de DR, consulte [Crear puntos de conexión de origen y destino](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Endpoints.Creating.html). El origen debe apuntar a la instancia de escritura del clúster de la base de datos principal. El origen debe apuntar a la instancia de escritura del clúster de la base de datos principal. | Administrador de AWS, administrador de base de datos | | Obtenga el punto de control de replicación. | Para obtener el punto de control de replicación, consulte la tabla de metadatos con un cliente MySQL ejecutando la siguiente operación en el nodo de escritura del clúster de base de datos secundaria de la región de DR.
select * from awsdms_control.awsdms_txn_state;En la tabla, busque el valor task\$1name que corresponde al ARN de la tarea de AWS DMS en la región principal que obtuvo en la segunda épica. | Administrador de base de datos | | Cree una tarea de AWS DMS. | Desde la consola, cree una tarea de AWS DMS en la región de DR. En la tarea, especifique un método de migración para **replicar únicamente los cambios de datos**. Para obtener más información, consulte [Crear una tarea](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/es_es/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html)Establezca la configuración **Iniciar tarea de migración** de la tarea de AWS DMS en **Automáticamente al crear**. | Administrador de AWS, administrador de base de datos | | Registre el ARN de la tarea de AWS DMS. | Utilice el ARN para obtener el nombre de la tarea tarea de AWS DMS para uso posterior. Para recuperar el ARN de la tarea de AWS DMS, ejecute el siguiente comando.
aws dms describe-replication-tasks| Administrador de AWS, administrador de base de datos | | Valide los datos replicados. | Consulte el clúster de base de datos secundaria en la región de DR para confirmar que los datos de prueba que cargó en el clúster de base de datos principal se han replicado. | Administrador de base de datos | ### Realice una conmutación por recuperación | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Detenga las tareas de AWS DMS. | La tarea de AWS DMS en la región DR no funcionará correctamente tras la conmutación por error, y deberá detenerla para evitar errores. | Administrador de AWS | | Realice una conmutación por error gestionada. | Realice una conmutación por error el clúster de base de datos principal de la región principal. Para instrucciones, consulte [Ejecución de la conmutación por error planificada administrada para bases de datos globales de Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-disaster-recovery.html#aurora-global-database-disaster-recovery.managed-failover). Una vez finalizada la conmutación por error en el clúster de la base de datos principal, realice la misma operación en el clúster de base de datos. | Administrador de AWS, administrador de base de datos | | Obtenga el punto de control de replicación. | Para obtener el punto de control de replicación, consulte la tabla de metadatos con un cliente MySQL ejecutando la siguiente operación en el nodo de escritura del clúster de base de datos secundaria de la región de DR.
select * from awsdms_control.awsdms_txn_state;En la tabla, busque el valor `task_name` que corresponde al ARN de la tarea de AWS DMS en la región DR que obtuvo en la cuarta épica. | Administrador de base de datos | | Actualice los puntos de conexión de origen y de destino de AWS DMS. | Una vez conmutados por error los clústeres de bases de datos, compruebe los clústeres de la región principal para determinar qué nodos son las instancias de escritura. A continuación, compruebe que los puntos de conexión de origen y destino de AWS DMS existentes en la región principal apunten a las instancias de escritura. Si no es así, actualice los puntos de conexión con los nombres del sistema de nombres de dominio (DNS) de la instancia de escritura. | Administrador de AWS | | Cree una tarea de AWS DMS. | Utilizando la consola, cree una tarea de AWS DMS en la región principal. En la tarea, especifique un método de migración para **replicar únicamente los cambios de datos**. Para obtener más información, consulte [Crear una tarea](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/es_es/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html) | Administrador de AWS, administrador de base de datos | | Registre el nombre de recurso de Amazon (ARN) de la tarea AWS DMS. | Utilice el ARN para obtener el nombre de la tarea tarea de AWS DMS para uso posterior. Para recuperar el ARN de tarea de AWS DMS, ejecute el siguiente comando:
aws dms describe-replication-tasksNecesitará el nombre de la tarea cuando realice otra conmutación por error gestionada o en un escenario de DR. | Administrador de AWS, administrador de base de datos | | Elimine las tareas de AWS DMS. | Elimine la tarea de AWS DMS original (actualmente detenida) en la región principal y la tarea de AWS DMS existente (actualmente detenida) en la región secundaria. | Administrador de AWS | ## Recursos relacionados + [Configuración de su clúster de base de datos de Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraSettingUp.html) + [Uso de bases de datos globales de Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html) + [Trabajar con Amazon Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraMySQL.html) + [Trabajar con una instancia de replicación de AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.html) + [Trabajar con puntos de conexión de AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Endpoints.html) + [Trabajar con tareas de AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.html) + [¿Qué es AWS CloudFormation?](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) ## Información adicional En este ejemplo de DR se usan bases de datos globales de Amazon Aurora, ya que proporcionan un objetivo de tiempo de recuperación (RTO) efectivo de 1 segundo y un objetivo de punto de recuperación (RPO) de menos de 1 minuto, ambos inferiores a los de las soluciones replicadas tradicionales e ideales para escenarios de DR. Las bases de datos globales de Amazon Aurora ofrecen muchas otras ventajas, entre las que se incluyen las siguientes: + Lecturas globales con latencia local: los consumidores globales pueden acceder a la información en una región local y con latencia local. + Clústeres de base de datos Amazon Aurora secundarios escalables: los clústeres secundarios se pueden escalar de forma independiente, y es posible añadir hasta 16 réplicas de solo lectura. + Replicación rápida de clústeres de base de datos Aurora primarios a secundarios – La replicación realizada tiene poco impacto en el clúster principal. Se produce en la capa de almacenamiento, con latencias típicas de replicación entre regiones de menos de 1 segundo. Este patrón también emplea AWS DMS para la replicación. Las bases de datos de Amazon Aurora ofrecen la posibilidad de crear réplicas de lectura, lo que puede simplificar el proceso de replicación y la configuración de DR. AWS DMS suele usarse para replicar cuando es necesario transformar los datos, o cuando la base de datos de destino requiere índices adicionales que la base de datos de origen no contiene. # Migración de funciones y procedimientos de Oracle con más de 100 argumentos a PostgreSQL *Srinivas Potlachervoo, Amazon Web Services* ## Resumen Este patrón muestra cómo migrar funciones y procedimientos de Oracle Database que tienen más de 100 argumentos a PostgreSQL. Por ejemplo, puede usar este patrón para migrar funciones y procedimientos de Oracle a uno de los siguientes servicios de bases de datos de AWS compatibles con PostgreSQL: + Amazon Relational Database Service (Amazon RDS) para PostgreSQL + Edición de Amazon Aurora compatible con PostgreSQL PostgreSQL no admite funciones o procedimientos que tengan más de 100 argumentos. Como solución alternativa, puede definir un nuevo tipo de datos cuyos campos de tipo coincidan con los argumentos de la función de origen. A continuación, puede crear y ejecutar una PL/pgSQL función que utilice el tipo de datos personalizado como argumento. ## Requisitos previos y limitaciones **Requisitos previos ** + Una cuenta de AWS activa + Una [instancia de base de datos (DB) Oracle de Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) + Una [instancia de base de datos Amazon RDS para PostgreSQL](https://aws.amazon.com/getting-started/hands-on/create-connect-postgresql-db/) o una [instancia de base de datos Aurora compatible con PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.AuroraPostgreSQL.html) **Versiones de producto** + Instancia de base de datos de Oracle de Amazon RDS, versión 10.2 y posteriores + Instancia de base de datos Amazon RDS PostgreSQL, versión 9.4 y posteriores, o instancia de base de datos Aurora compatible con PostgreSQL, versión 9.4 y posteriores + Oracle SQL Developer versión 18 y posteriores + pgAdmin versión 4 y posteriores ## Arquitectura **Pila de tecnología de origen** + Instancia de base de datos de Oracle de Amazon RDS, versión 10.2 y posteriores **Pila de tecnología de destino** + Instancia de base de datos Amazon RDS PostgreSQL, versión 9.4 y posteriores, o instancia de base de datos Aurora compatible con PostgreSQL, versión 9.4 y posteriores ## Tools (Herramientas) **Servicios de AWS** + [Amazon Relational Database Service (Amazon RDS) para PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) le ayuda a configurar, utilizar y escalar una base de datos relacional de PostgreSQL en la nube de AWS. + La [edición de Amazon Aurora compatible con PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) es un motor de base de datos relacional compatible con ACID, completamente administrado que le permite configurar, utilizar y escalar implementaciones de PostgreSQL. **Otros servicios** + [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) es un entorno de desarrollo integrado que simplifica el desarrollo y la administración de bases de datos de Oracle, tanto en implementaciones tradicionales como en implementaciones basadas en la nube. + [pgAdmin](https://www.pgadmin.org/) es una herramienta de gestión de código abierto para PostgreSQL. Proporciona una interfaz gráfica que permite crear, mantener y utilizar objetos de bases de datos. ## Prácticas recomendadas Asegúrese de que el tipo de datos creado coincida con los campos de tipos que se incluyen en la función o procedimiento de Oracle de origen. ## Epics ### Ejecute una función o procedimiento de Oracle con más de 100 argumentos | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree o identifique una Oracle/PLSQL función o procedimiento existente que tenga más de 100 argumentos. | Cree una Oracle/PLSQL función o un procedimiento que tenga más de 100 argumentos.-o bien-Identifique una Oracle/PLSQL función o un procedimiento existente que tenga más de 100 argumentos.Para obtener más información, consulte las secciones [14.7 Instrucción CREATE FUNCTION](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/lnpls/CREATE-FUNCTION-statement.html#GUID-B71BC5BD-B87C-4054-AAA5-213E856651F2) y [14.11 Instrucción CREATE PROCEDURE](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/lnpls/CREATE-PROCEDURE-statement.html#GUID-5F84DB47-B5BE-4292-848F-756BF365EC54) de la documentación de bases de datos de Oracle. | Conocimientos de Oracle/PL/SQL | | Compila la Oracle/PLSQL función o el procedimiento. | Compila la Oracle/PLSQL función o el procedimiento.Para más información, consulte [Compilación de una función](https://docs.oracle.com/cd/E37097_01/doc.42/e35128/GUID-6B7B6F82-616D-4915-82BE-D4AE7F59CF37.htm#AEUTL165) en la documentación de la base de datos de Oracle. | Conocimientos de Oracle/PL/SQL | | Ejecute la Oracle/PLSQL función. | Ejecute la Oracle/PLSQL función o el procedimiento. A continuación, guarde el resultado. | Conocimientos de Oracle/PL/SQL | ### Defina un nuevo tipo de datos que coincida con los argumentos de la función o procedimiento de origen | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Defina un nuevo tipo de datos en PostgreSQL. | Defina un nuevo tipo de datos en PostgreSQL que incluya todos los campos que aparecen en los argumentos de la función o procedimiento de Oracle de origen.Para obtener más información, consulte [CREATE TYPE](https://www.postgresql.org/docs/current/sql-createtype.html) en la documentación de PostgreSQL. | Conocimientos de PostgreSQL PL/pgSQL | ### Cree una función de PostgreSQL que incluya el nuevo argumento TYPE | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una función de PostgreSQL que incluya el nuevo tipo de datos. | Crear una función de PostgreSQL que incluya el nuevo argumento `TYPE`.Para ver un ejemplo de función, consulte la sección de **Información adicional** de este patrón. | Conocimientos de PostgreSQL PL/pgSQL | | Compile la función PostgreSQL. | Compile la función en PostgreSQL. Si los campos del nuevo tipo de datos coinciden con los argumentos de la función o procedimiento de origen, la función se compilará correctamente. | Conocimientos de PostgreSQL PL/pgSQL | | Ejecute la función de PostgreSQL. | Ejecute la función de PostgreSQL. | Conocimientos de PostgreSQL PL/pgSQL | ## Resolución de problemas | Problema | Solución | | --- | --- | | La función devuelve el siguiente error:**ERROR: syntax error near "
hdbnsutil -sr_enable --name=siteA| Administrador de SAP Basis | | Registre la base de datos de SAP HANA de destino como sistema secundario. | Para registrar la base de datos de SAP HANA de destino como sistema secundario de origen para SAP HSR, elija la replicación **asíncrona**.
(sid)adm $> HDB stopTambién puede seleccionar la opción de registro `–online`. En ese caso, no necesita detener e iniciar la base de datos de SAP HANA. | Administrador de SAP Basis | | Valide la sincronización. | En la base de datos de SAP HANA de origen, compruebe que todos los registros se apliquen al sistema de destino (ya que se trata de una replicación asíncrona).Para verificar la replicación, ejecute los siguientes comandos en el entorno de origen.
(sid)adm $> hdbnsutil -sr_register –name=siteB –remotehost=hdbhost /
--remoteInstance=00 –replicationMode=async –operationMode=logreplay
(sid)adm $> HDB start
(sid)adm $> cdpy| Administrador de SAP Basis | | Cierre la aplicación SAP de origen y la base de datos de SAP HANA. | Durante la transición a la migración, apague el sistema de origen (la aplicación SAP y la base de datos SAP HANA). | Administrador de SAP Basis | | Realice la adquisición del destino. | Para realizar la adquisición del destino en AWS, ejecute el comando `hdbnsutil -sr_takeover`. | Administrador de SAP Basis | | En la base de datos de SAP HANA de destino, desactive la replicación. | Para borrar los metadatos de la replicación, detenga la replicación en el sistema de destino ejecutando el comando `hdbnsutil -sr_disable`. Según la Nota de SAP 2693441: No se pudo cambiar el nombre de un sistema SAP HANA debido a un error. | Administrador de SAP Basis | | Realice una copia de seguridad de la base de datos SAP HANA de destino. | Una vez que la adquisición se haya realizado correctamente, recomendamos realizar una copia de seguridad completa de la base de datos de SAP HANA. | Administrador de SAP Basis | ### Revierta al nombre de host original en el sistema de destino | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Revierta al nombre de host original el nombre de host de SAP HANA DB. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-sap-hana-to-aws-using-sap-hsr-with-the-same-hostname.html)Puede validar otras opciones según sea necesario. Sin embargo, asegúrese de no confundir el cambio de nombre del host con un cambio de SID (Nota de SAP 2598814: hdblcm: error al cambiar el nombre del SID). | Administrador de SAP Basis | | Ajuste hdbuserstore. | Adapte los detalles de `hdbuserstore` apuntando a los detalles de la fuente `schema/user`. Para ver los pasos detallados, consulte la [documentación de SAP](https://help.sap.com/viewer/b3ee5778bc2e4a089d3299b82ec762a7/2.0.02/en-US/ddbdd66b632d4fe7b3c2e0e6e341e222.html?q=hdbuserstore). Para validar este paso, ejecute el comando `R3trans -d`. El resultado debe reflejar una conexión correcta a la base de datos de SAP HANA. | Administrador de SAP Basis | | Inicie las conexiones con los clientes. | En el entorno de destino, inicie los servidores de aplicaciones de SAP y otras conexiones de clientes. | Administrador de SAP Basis | ## Recursos relacionados **Referencias de SAP** SAP actualiza con frecuencia las referencias de documentación de SAP. Para mantenerse al día, consulte la Nota de SAP 2407186: Guías prácticas y documentos técnicos sobre la alta disponibilidad de SAP HANA. *Notas adicionales de SAP* + 2550327 – Cómo cambiar el nombre de un sistema SAP HANA + 1999880 – Preguntas frecuentes: replicación del sistema SAP HANA + 2078425 – Nota de solución de problemas para la herramienta de gestión del ciclo de vida de la plataforma SAP HANA hdblcm + 2592227 – Cambio del sufijo FQDN en sistemas HANA + 2048681 – Realización de tareas de administración de ciclo de vida de la plataforma SAP HANA en sistemas con varios hosts sin credenciales de SSH o root *Documentos de SAP* + [System Replication Network Connection](https://help.sap.com/docs/SAP_HANA_PLATFORM/4e9b18c116aa42fc84c7dbfd02111aba/47190b425eb1433697b026ecd46ff5f9.html) + [Resolución del nombre de host para la replicación del sistema](https://help.sap.com/viewer/eb3777d5495d46c5b2fa773206bbfb46/1.0.12/en-US/c0cba1cb2ba34ec89f45b48b2157ec7b.html) **AWS referencias** + [Migración de SAP HANA de otras plataformas a AWS](https://docs.aws.amazon.com/sap/latest/sap-hana/migrating-hana-hana-to-aws.html) ## Información adicional Los cambios realizados por `hdblcm` como parte de la actividad de cambio de nombre de host se consolidan en el siguiente registro detallado. ![\[Código que muestra que los procesos se detuvieron en el host temporal, se iniciaron en hdbhost y se cambió el nombre del sistema de bases de datos de SAP HANA.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/004781c1-96df-43dd-a52e-ed1db5bdf9ef/images/9e0c11ca-6555-484f-9639-107f60f725f5.png) # Migre el grupo de disponibilidad Always On de Microsoft SQL Server mediante AWS Application Migration Service *Sreenivas Nettem, Bharath Kumar Pammi Ramesh, Anantharaman Seshadri y Gireesh Sreekantan, Amazon Web Services* ## Resumen AWS Application Migration Service (AWS MGN) es la herramienta preferida para realojar los entornos existentes en el sistema Nube de AWS, lo que permite a los clientes alejarse de los centros de datos locales. Este patrón describe el proceso de uso de AWS MGN para migrar clústeres de Windows con grupos de disponibilidad Always On de Microsoft SQL Server. ## Requisitos previos y limitaciones **Requisitos previos ** + Un activo Cuenta de AWS. + Un papel AWS Identity and Access Management (IAM) en la orquestación de AWS MGN. + Acceso a servidores de bases de datos de origen (grupo de disponibilidad de SQL Server Always On). + Active Directory en una AWS landing zone para conservar los nombres DNS. + Una subred provisional con comunicación de red cerrada con Active Directory. + Subredes de destino que pueden comunicarse con Active Directory. + Dos direcciones IP reservadas para el clúster de Windows en una subred de destino (una en cada zona de disponibilidad). + Dos direcciones IP reservadas para el oyente de SQL Always On en una subred de destino (una en cada zona de disponibilidad). **Versiones de producto** + Windows Server 2012 o posterior + SQL Server 2012 o posterior ## Arquitectura **Pila de tecnología de origen** Grupo de disponibilidad de Microsoft SQL Server Always On del clúster de Microsoft Windows (máquina virtual o física en las instalaciones) **Pila de tecnología de destino** Instancia EC2 de Amazon Windows **Arquitectura de destino** ![\[Arquitectura de AWS para migrar la disponibilidad de SQL Server Always On con AWS MGN.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/aa94040b-5ecf-42f9-90e3-929d0fa5e715/images/0b85c613-51df-475b-9598-3da3f9cd47c6.png) ## Tools (Herramientas) *Servicios de AWS* + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) proporciona una capacidad informática escalable en el Nube de AWS. Puede lanzar tantos servidores virtuales como necesite y escalarlos o reducirlos con rapidez. + [AWS Application Migration Service](https://docs.aws.amazon.com/mgn/latest/ug/what-is-application-migration-service.html)le ayuda a realojar (levantar y trasladar) las aplicaciones Nube de AWS sin cambios y con un tiempo de inactividad mínimo. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) le ayuda a administrar de forma segura el acceso a sus AWS recursos al controlar quién está autenticado y autorizado a usarlos. *Otras herramientas* + [Microsoft SQL Server Management Studio (SSMS)](https://learn.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms) es una herramienta para administrar SQL Server, que incluye el acceso, la configuración y la administración de los componentes de SQL Server. ## Prácticas recomendadas Para AWS MGN, consulte las prácticas [recomendadas](https://docs.aws.amazon.com/mgn/latest/ug/best_practices_mgn.html) para. AWS Application Migration Service ## Epics ### Preparación de la cuenta de destino | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Inicialice MGN AWS . | Inicialice AWS MGN en el objetivo. Región de AWS De este modo, se crean las políticas y los roles de IAM necesarios. Para obtener más información, consulte [Initializing Application Migration Service with the console](https://docs.aws.amazon.com/mgn/latest/ug/mgn-initialize-console.html). | Administrador de la nube | | Cree plantillas de replicación y lanzamiento. | Configure las plantillas de replicación y lanzamiento para usarlas con AWS MGN. Para obtener más información, consulte [Configuración de las plantillas](https://docs.aws.amazon.com/mgn/latest/ug/mgn-initialization-templates.html) en la AWS documentación. | Administrador de la nube | | Permita los puertos de comunicación. | Para habilitar las comunicaciones de red para AWS MGN, permita el tráfico a través de los puertos TCP 443 y 1500. Para obtener más información, consulte [los requisitos de red para el Servicio de migración de aplicaciones](https://docs.aws.amazon.com/mgn/latest/ug/Network-Requirements.html) en la AWS documentación. | Administrador de red, administrador de la nube | ### Preparación del servidor de origen | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Compruebe los requisitos previos AWS de MGN. | Compruebe que los servidores de origen cumplen los requisitos previos para la instalación del agente AWS MGN. Para obtener más información, consulte [los requisitos de instalación](https://docs.aws.amazon.com/mgn/latest/ug/installation-requirements.html) en la AWS documentación. | Ingeniero de migraciones | | Instale el agente AWS MGN. | Instale el agente AWS MGN en los servidores de origen. Durante la instalación, elija el Región de AWS lugar al que se migrarán los servidores. Tras la instalación, el agente se comunica con el servicio e inicia la replicación. Para obtener más información, consulte [Instalación del agente de AWS replicación en servidores Windows](https://docs.aws.amazon.com/mgn/latest/ug/windows-agent.html). | Ingeniero de migraciones | | Compruebe el estado del servidor de origen. | En la consola AWS MGN, compruebe el estado de los servidores de origen. Cuando comience la replicación, los servidores muestran **Listo para la prueba**.Si encuentra algún error, consulte [Solución de errores de comunicación](https://docs.aws.amazon.com/mgn/latest/ug/Troubleshooting-Communication-Errors.html) en la documentación de AWS MGN. | Administrador de la nube, ingeniero de migraciones | | Optimice la configuración de replicación. | Los clústeres de SQL Always On utilizan una alta replicación I/O sincrónica del servidor principal al servidor secundario. Para optimizar la replicación y evitar retrasos, utilice un [servidor de replicación dedicado](https://docs.aws.amazon.com/mgn/latest/ug/replication-settings-template.html) para cada servidor de SQL Always On.Si la base de datos tiene un tamaño superior a 5 TB, considere la posibilidad de elegir un tamaño de instancia de servidor de replicación superior, como **m5.large**, en lugar de la opción **t3.small** predeterminada. | Administrador de la nube, ingeniero de migraciones | | Actualice la plantilla de lanzamiento. | Actualice la [configuración de lanzamiento](https://docs.aws.amazon.com/mgn/latest/ug/launch-settings.html) y elija subredes para los servidores de SQL Always On. Los servidores de clúster SQL Always On están repartidos en diferentes ubicaciones Zonas de disponibilidad de AWS para ofrecer una alta disponibilidad. | Ingeniero de migraciones, líder de migración | | Actualice la configuración de lanzamiento. | En función de sus requisitos de tamaño y rendimiento, actualice el tipo de instancia y input/output las operaciones por segundo (IOPS) en la configuración de lanzamiento.(Opcional) Elija una interfaz de red elástica existente en la configuración de lanzamiento. | Ingeniero de migraciones, líder de migración | ### Prueba de la transición | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Verifique los servidores de origen. | En la consola AWS MGN, verifica que el estado del servidor de origen sea **Listo para** la prueba. | Administrador de la nube, ingeniero de migraciones | | Lance las instancias de prueba. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | Administrador de la nube, ingeniero de migraciones | | Pruebe la conectividad y la integridad de la base de datos. | Pruebe la conectividad y la integridad de la base de datos de las instancias de prueba. A continuación, marque los servidores de origen como **Listos para la transición en la AWS consola** MGN. | Administrador de la nube, ingeniero de migraciones | ### Tareas previas a la migración | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Pruebe la integridad de la base de datos. | Esto ayuda a garantizar que no haya problemas de integridad de la base de datos en el origen antes de la migración. Ejecute `DBCC CHECKDB` y especifique `WITH_PHYSICAL_ONLY`. Si se ejecuta esta comprobación sin `WITH_PHYSICAL_ONLY`, se pueden producir problemas de rendimiento en el origen. Para mantener la integridad de la base de datos, ejecute una comprobación completa semanal de la base de datos.Estos comandos comprueban la integridad física y lógica de la base de datos mediante la detección de posibles problemas de corrupción. La comprobación verifica la estructura de la base de datos, como las páginas, las filas, los índices y las tablas del sistema. | Ingeniero de datos, Administrador de base de datos | | Pruebe las conexiones a los servidores vinculados. | Pruebe las conexiones entre todos los servidores existentes y documente su estado. Esto ayuda a garantizar que los servidores vinculados funcionen según lo previsto tras la migración. | Ingeniero de datos, Administrador de base de datos | | Verifique las copias de seguridad. | Confirme la integridad de las copias de seguridad de origen. | Ingeniero de datos, Administrador de base de datos | ### AWS Transición a MGN | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Detenga los servicios de clúster y de SQL Server. | Detenga los servicios de clúster de SQL Server y Microsoft en todos los nodos de clústeres de SQL. | Administrador de base de datos, ingeniero de migraciones | | Verifique los servidores. | **En la consola AWS MGN, compruebe que el estado de los servidores de origen sea **Preparado para la transición y que el estado de la replicación de datos** sea Correcto.** | Ingeniero de migraciones | | Lance la transición. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html)Para obtener más información, consulte Cómo [lanzar una instancia transitada en la documentación de MGN](https://docs.aws.amazon.com/mgn/latest/ug/launch-cutover-gs.html). AWS | Ingeniero de migraciones | | Pruebe los servidores lanzados. | Inicia sesión en las EC2 instancias de Amazon lanzadas y valida el estado del clúster. Compruebe que los servidores estén en las subredes correctas, que el tamaño de la instancia y la configuración de IOPS sean correctos y que se pueda acceder al servidor de testigo. | Administrador de base de datos, ingeniero de migraciones | ### Tareas posteriores a la transición de la base de datos | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Actualice la dirección IP del clúster. | Actualice la dirección IP del clúster para el clúster de Windows mediante las dos direcciones IP reservadas de las subredes de destino. Para obtener más información, consulte [Cambiar la dirección IP de una instancia de clúster de conmutación por error](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). | Administrador de base de datos, ingeniero de migraciones | | Actualice el listener IPs del grupo de disponibilidad de Always On. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | Administrador de base de datos, ingeniero de migraciones | | Verifique la conexión. | Conéctese al oyente del grupo de disponibilidad Always On mediante SSMS y confirme que la conexión se lleve a cabo correctamente. | Administrador de base de datos, ingeniero de migraciones | | Compruebe el estado del grupo de disponibilidad Always On. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | Administrador de base de datos, ingeniero de migraciones | | Comprobación del registro de errores. | Abra el registro de errores y verifique los errores notificados en la instancia de SQL Server. Asegúrese de que la recuperación se haya completado en todas las bases de datos. | Administrador de base de datos, ingeniero de migraciones | | Pruebe los servidores vinculados. | Pruebe la conectividad de todos los servidores vinculados. En caso de problemas de conectividad, asegúrese de que se pueda acceder al servidor y al puerto de destino. | Administrador de base de datos, ingeniero de migraciones | ### Finalización de la transición | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Finalice la transición. | Tras validar los clústeres de SQL Always On de destino, [finalice](https://docs.aws.amazon.com/mgn/latest/ug/launch-cutover-gs.html#revert-finalize-cutover-gs) la transición a través de la consola MGN. AWS Esto detiene la replicación de datos de los servidores de origen y descarta los datos del servidor de replicación. También elimina el servidor de replicación y sus recursos asociados. | Administrador de la nube, ingeniero de migraciones | ## Resolución de problemas | Problema | Solución | | --- | --- | | AWS Solución de problemas de MGN | Para ver los problemas y las soluciones más comunes, consulte las secciones [de solución de problemas](https://docs.aws.amazon.com/mgn/latest/ug/troubleshooting.html) y [preguntas frecuentes](https://docs.aws.amazon.com/mgn/latest/ug/FAQ.html) de la documentación de AWS MGN. | ## Recursos relacionados *AWS resources* + [Opción 1: Realojar (-) 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) + [¿Qué es? AWS Application Migration Service](https://docs.aws.amazon.com/mgn/latest/ug/what-is-application-migration-service.html) *Recursos de SQL Server* + [What is SQL Server Management Studio (SSMS)?](https://learn.microsoft.com/en-us/ssms/sql-server-management-studio-ssms) ## Información adicional Para conocer los requisitos de seguridad estándar para la migración de cargas de trabajo a Nube de AWS ella, consulte las [prácticas recomendadas en materia de seguridad, identidad y cumplimiento](https://aws.amazon.com/architecture/security-identity-compliance/) en el AWS sitio web. # Migración de SQL Server a AWS mediante grupos de disponibilidad distribuidos *Praveen Marthala, Amazon Web Services* ## Resumen Los grupos de disponibilidad Always On de Microsoft SQL Server proporcionan una solución de alta disponibilidad (HA) y recuperación de desastres (DR) para SQL Server. Un grupo de disponibilidad consta de una réplica principal que acepta read/write tráfico y hasta ocho réplicas secundarias que aceptan tráfico de lectura. Un grupo de disponibilidad se configura en un clúster de conmutación por error de Windows Server (WSFC) con dos o más nodos. Los grupos de disponibilidad distribuida Always On de Microsoft SQL Server proporcionan una solución para configurar dos grupos de disponibilidad independientes entre dos grupos de disponibilidad independientes WFSCs. Los grupos de disponibilidad que forman parte del grupo de disponibilidad distribuida no tienen que estar en el mismo centro de datos. Un grupo de disponibilidad puede estar en las instalaciones y el otro grupo de disponibilidad puede estar en la nube de Amazon Web Services (AWS) en instancias de Amazon Elastic Compute Cloud (Amazon EC2) en un dominio diferente. Este patrón describe los pasos para usar un grupo de disponibilidad distribuido para migrar bases de datos de SQL Server locales que forman parte de un grupo de disponibilidad existente a SQL Server con grupos de disponibilidad configurados en Amazon EC2. Si sigue este patrón, puede migrar las bases de datos a la nube de AWS con un tiempo de inactividad mínimo durante la transición. Las bases de datos están altamente disponibles en AWS inmediatamente después de la transición. También puede usar este patrón para cambiar el sistema operativo subyacente de local a AWS y, al mismo tiempo, mantener la misma versión de SQL Server. ## Requisitos previos y limitaciones **Requisitos previos ** + Una cuenta de AWS activa + AWS Direct Connect o Site-to-Site VPN de AWS + La misma versión de SQL Server instalada localmente y en los dos nodos de AWS **Versiones de producto** + SQL Server versión 2016 y posteriores + SQL Server Enterprise Edition ## Arquitectura **Pila de tecnología de origen** + Base de datos de Microsoft SQL Server con grupos de disponibilidad Always On en las instalaciones **Pila de tecnología de destino** + Base de datos de Microsoft SQL Server con grupos de disponibilidad Always On en Amazon EC2 en la nube de AWS **Arquitectura de migración** ![\[SQL Server con replicación sincrónica en grupos de disponibilidad en las instalaciones y en AWS.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/6e229e30-9b11-4ccb-bccd-cbe6601139c0/images/79ee7911-d68f-4db7-9b94-113dcf09c28b.png) *Terminología* + WSFC 1: WSFC en las instalaciones + WSFC 2: WSFC en la nube de AWS + AG 1: primer grupo de disponibilidad, que se encuentra en el WSFC 1 + AG 2: segundo grupo de disponibilidad, que se encuentra en el WSFC 2 + Réplica principal de SQL Server: nodo del AG 1 que se considera el principal global para todas las escrituras + Reenviador de SQL Server: nodo de AG 2 que recibe datos de forma asíncrona desde la réplica principal de SQL Server + Réplica secundaria de SQL Server: nodos en el AG 1 o el AG 2 que reciben datos de forma sincrónica desde la réplica principal o el reenviador ## Tools (Herramientas) + [AWS Direct Connect](https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html): AWS Direct Connect se utiliza para vincular su red interna con una ubicación de AWS Direct Connect de a través de cable de fibra óptica Ethernet de fibra óptica. Con esta conexión, puede crear *interfaces virtuales* directamente en servicios públicos de AWS, omitiendo a los proveedores de servicios de Internet en su ruta de acceso a la red. + [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/concepts.html): Amazon Elastic Compute Cloud (Amazon EC2) proporciona capacidad informática escalable en la nube de AWS. Puede usar Amazon EC2 para lanzar tantos o tan pocos servidores virtuales como necesite, y puede ampliarlos de manera horizontal o horizontal. + [ Site-to-SiteVPN de AWS](https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html): la Site-to-Site VPN de AWS permite crear una red privada site-to-site virtual (VPN). Puede configurar la VPN para que transmita el tráfico entre las instancias que lance en AWS y su propia red remota. + [Microsoft SQL Server Management Studio](https://docs.microsoft.com/en-us/sql/ssms/sql-server-management-studio-ssms?view=sql-server-ver15): Microsoft SQL Server Management Studio (SSMS) es un entorno integrado para administrar la infraestructura de SQL Server. Proporciona una interfaz de usuario y un grupo de herramientas con editores de scripts enriquecidos que interactúan con SQL Server. ## Epics ### Configurar un segundo grupo de disponibilidad en AWS | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Crear un WSFC en AWS. | Cree WSFC 2 en EC2 instancias de Amazon con dos nodos para HA. Utilizará este clúster de conmutación por error para crear el segundo grupo de disponibilidad (AG 2) en AWS. | Administrador de sistemas, administrador SysOps | | Cree el segundo grupo de disponibilidad en el WSFC 2. | Con SSMS, cree el AG 2 en dos nodos del WSFC 2. El primer nodo del WSFC 2 actuará como reenviador. El segundo nodo del WSFC 2 actuará como réplica secundaria del AG 2.En este momento, no hay bases de datos disponibles en AG 2. Este es el punto de partida para configurar el grupo de disponibilidad distribuida. | Administrador de base de datos, desarrollador | | Crear bases de datos sin opción de recuperación en AG 2. | Realice copias de seguridad de las bases de datos en el grupo de disponibilidad local (AG 1). Restaurar las bases de datos tanto en el reenviador como en la réplica secundaria del AG 2 sin opción de recuperación. Al restaurar las bases de datos, especifique una ubicación con suficiente espacio en disco para los archivos de datos de la base de datos y los archivos de registro.En este momento, las bases de datos se encuentran en estado de restauración. No forman parte del AG 2 ni del grupo de disponibilidad distribuida y no se sincronizan. | Administrador de base de datos, desarrollador | ### Configurar el grupo de disponibilidad distribuida | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree el grupo de disponibilidad distribuida en AG 1. | Para crear el grupo de disponibilidad distribuida en el AG 1, utilice el `CREATE AVAILABILITY GROUP` con la `DISTRIBUTED` opción.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html) | Administrador de base de datos, desarrollador | | Cree el grupo de disponibilidad distribuida en AG 2. | Para crear el grupo de disponibilidad distribuida en AG 2, utilice `ALTER AVAILABILITY GROUP` con la opción `DISTRIBUTED`.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html)El grupo de disponibilidad distribuida se crea entre el AG 1 y el AG 2.Las bases de datos del AG 2 aún no están configuradas para participar en el flujo de datos del AG 1 al AG 2. | Administrador de base de datos, desarrollador | | Añada bases de datos al reenviador y a la réplica secundaria en AG 2. | Agregue las bases de datos al grupo de disponibilidad distribuida utilizando `ALTER DATABASE` con la opción `SET HADR` `AVAILABILITY GROUP` tanto en el reenviador como en la réplica secundaria en el AG 2. Esto inicia un flujo de datos asíncrono entre las bases de datos de la AG 1 y la AG 2. La principal global realiza las escrituras, envía los datos de forma sincrónica a la réplica secundaria en la AG 1 y envía los datos de forma asíncrona al reenviador en la AG 2. El reenviador del AG 2 envía los datos de forma sincrónica a la réplica secundaria del AG 2. | Administrador de base de datos, desarrollador | ### Supervise el flujo de datos asíncrono entre AG 1 y AG 2 | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Registros DMVs de uso y de SQL Server. | Supervise el estado del flujo de datos entre dos grupos de disponibilidad mediante vistas de administración dinámicas (DMVs) y registros de SQL Server. DMVs Entre los que son de interés para la supervisión se incluyen `sys.dm_hadr_availability_replica_states` y`sys.dm_hadr_automatic_seeding`.Para conocer el estado de la sincronización del reenviador, supervise el *estado sincronizado* en el registro de SQL Server del reenviador. | Administrador de base de datos, desarrollador | ### Realice actividades de transición para la migración final | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Detener todo el tráfico hacia la réplica principal. | Detenga el tráfico entrante a la réplica principal en la AG 1 para que no se produzca ninguna actividad de escritura en las bases de datos y las bases de datos estén listas para la migración. | Propietario de la aplicación, desarrollador | | Cambie el modo de disponibilidad del grupo de disponibilidad distribuida en AG 1. | En la réplica principal, establezca el modo de disponibilidad del grupo de disponibilidad distribuido en sincrónico. Tras cambiar el modo de disponibilidad a sincrónico, los datos se envían de forma sincrónica desde la réplica principal de la AG 1 al reenviador de la AG 2. | Administrador de base de datos, desarrollador | | Compruebe LSNs los dos grupos de disponibilidad. | Compruebe los últimos números de secuencia logarítmica (LSNs) tanto en el AG 1 como en el AG 2. Como no se está realizando ninguna escritura en la réplica principal de AG 1, los datos se sincronizan y los últimos LSNs de ambos grupos de disponibilidad deben coincidir. | Administrador de base de datos, desarrollador | | Actualice AG 1 al rol secundario. | Al actualizar el AG 1 al rol secundario, el AG 1 pierde el rol de réplica principal y no acepta escrituras, y el flujo de datos entre dos grupos de disponibilidad se detiene. | Administrador de base de datos, desarrollador | ### Conmutación por error al segundo grupo de disponibilidad | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Conmutar por error manualmente a AG 2. | En el reenviador de AG 2, modifique el grupo de disponibilidad distribuida para permitir la pérdida de datos. Como ya ha comprobado y confirmado que los últimos datos del AG 1 y LSNs el AG 2 coinciden, la pérdida de datos no es motivo de preocupación.Al permitir la pérdida de datos en el reenviador de AG 2, las funciones de AG 1 y AG 2 cambian:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html) | Administrador de base de datos, desarrollador | | Cambie el modo de disponibilidad del grupo de disponibilidad distribuida en AG 2. | En la réplica principal de AG 2, cambie el modo de disponibilidad a asíncrono.Esto cambia el movimiento de datos del AG 2 al AG 1, de sincrónico a asíncrono. Este paso es necesario para evitar la latencia de la red entre el AG 2 y el AG 1, si existe, y no afectará al rendimiento de la base de datos. | Administrador de base de datos, desarrollador | | Comience a enviar tráfico a la nueva réplica principal. | Actualice la cadena de conexión para utilizar el punto de conexión de la URL del oyente en la AG 2 para enviar el tráfico a las bases de datos.El AG 2 ahora acepta escrituras y envía datos al reenviador en el AG 1, además de enviar los datos a su propia réplica secundaria en el AG 2. Los datos se mueven de forma asíncrona del AG 2 al AG 1. | Propietario de la aplicación, desarrollador | ### Realice actividades posteriores a la transición | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Elimine el grupo de disponibilidad distribuida en AG 2. | Supervise la migración durante el tiempo planificado. A continuación, coloque el grupo de disponibilidad distribuida en la AG 2 para eliminar la configuración del grupo de disponibilidad distribuida entre la AG 2 y la AG 1. Esto elimina la configuración del grupo de disponibilidad distribuida y se detiene el flujo de datos del AG 2 al AG 1. En este momento, AG 2 está altamente disponible en AWS, con una réplica principal que realiza escrituras y una réplica secundaria en el mismo grupo de disponibilidad. | Administrador de base de datos, desarrollador | | Quite del servicio de los servidores en las instalaciones. | Retire del servicio los servidores locales del WSFC 1 que forman parte del AG 1. | Administrador de sistemas, SysOps administrador | ## Recursos relacionados + [Grupos de disponibilidad distribuida](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-sql-server/distributed-groups.html) + [SQL Docs: grupos de disponibilidad distribuida](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/distributed-availability-groups?view=sql-server-ver15) + [SQL Docs: grupos de disponibilidad Always On: una solución de alta disponibilidad y recuperación de desastres](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/always-on-availability-groups-sql-server?view=sql-server-ver15) # Migrar una base de datos relacional a MongoDB Atlas en AWS *Battulga Purevragchaa e Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Resumen En este patrón se describen los pasos para migrar de una base de datos relacional como SQL Server, MySQL o PostgreSQL a MongoDB Atlas en la Nube de AWS. Utilice [MongoDB Relational Migrator](https://www.mongodb.com/products/relational-migrator) para ayudar a acelerar la migración de datos desde bases de datos relacionales a MongoDB Atlas. El patrón acompaña a la guía [Migración a MongoDB Atlas que se encuentra en AWS el sitio](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) web de orientación prescriptiva. AWS Proporciona los pasos de implementación para uno de los escenarios de migración que se analizan en esa guía. Para ver otros escenarios de migración, consulte los siguientes patrones en el sitio web de la Guía prescriptiva: AWS + [Migre un entorno MongoDB autohospedado a MongoDB Atlas en 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 datos desde IBM Db2, SAP, Sybase y otras bases de datos a MongoDB Atlas en AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/stream-data-from-ibm-db2-to-mongodb-atlas.html) El patrón está destinado a los [socios y AWS usuarios de AWS System Integrator (SI)](https://aws.amazon.com/managed-services/partners/). ## Requisitos previos y limitaciones **Requisitos previos ** + Una base de datos relacional de origen (Oracle Database, SQL Server, PostgreSQL, SAP/Sybase MySQL, ASE y otras) para migrar a MongoDB Atlas. + Familiaridad con las bases de datos relacionales, MongoDB Atlas y. Servicios de AWS Este patrón explica algunos de los pasos de migración de forma general. Se agregarán detalles adicionales en futuras versiones. **Versiones de producto** + MongoDB versión 5.0 o posterior ## Arquitectura En el siguiente diagrama se muestra la migración de una base de datos de un sistema de administración de bases de datos relacionales (RDBMS) a MongoDB Atlas en AWS. ![\[Arquitectura para migrar de RDBMS a MongoDB Atlas en AWS.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/4e3ea0f1-21e8-4641-a9ee-732355f20baf/images/8eacf3ec-f480-4912-9002-6a50800fe9bf.png) Para ver las arquitecturas de referencia de MongoDB Atlas que admiten diferentes escenarios de uso, consulte [Migración a MongoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) Atlas en el sitio web de orientación prescriptiva. AWS AWS ## Tools (Herramientas) + [MongoDB](https://www.mongodb.com/atlas) Atlas es una base de datos como servicio DBaa (S) totalmente gestionada para implementar y gestionar bases de datos MongoDB en la nube. + [MongoDB Relational Migrator](https://www.mongodb.com/products/relational-migrator) proporciona una transición fluida de datos desde bases de datos relacionales tradicionales a MongoDB. Ayuda a automatizar el proceso de conversión y transforma el modelo de datos estructurados de las bases de datos relacionales en el formato de documento flexible proporcionado por MongoDB. Relational Migrator preserva las relaciones y la integridad de los datos para simplificar la migración. Las organizaciones pueden aprovechar las ventajas de escalabilidad, rendimiento y versatilidad que ofrece MongoDB y, al mismo tiempo, retener la familiaridad de sus datos existentes. ## Prácticas recomendadas [Para conocer las mejores prácticas para usar MongoDB AWS en, consulte las publicaciones del blog de Partner Network AWS .](https://aws.amazon.com/blogs/apn/tag/mongodb-atlas/) ## Epics ### Descubrimiento y evaluación | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Determine los parámetros y el tamaño de la base de datos relacional. | Para calcular el tamaño del conjunto de trabajo, utilice las recomendaciones de Relational Migrator y la información de `db.stats()` para el espacio total del índice Presuponga que se accederá con frecuencia a un porcentaje de su espacio de datos. Esta tarea puede necesitar aproximadamente una semana. Para obtener más información y ejemplos de esta y otras historias de esta épica, consulte la sección [Recursos relacionados](#migrate-relational-database-to-mongodb-atlas-resources). | Administrador de base de datos, propietario de la aplicación | | Calcule los requisitos de ancho de banda de la red. | Para calcular los requisitos de ancho de banda de la red, multiplique el tamaño medio de los documentos por el número de documentos servidos por segundo. Tenga en cuenta el tráfico máximo que soportará cualquier nodo del clúster como base. Para calcular las velocidades de transferencia de datos descendentes del clúster a las aplicaciones cliente, utilice la suma del total de documentos devueltos durante un período de tiempo. Si sus aplicaciones leen desde nodos secundarios, divida este número total de documentos por el número de nodos que pueden realizar operaciones de lectura. Para encontrar el tamaño medio de los documentos de una base de datos, utilice el comando `db.stats().avgObjSize`. Esta tarea suele necesitar un día. | Administrador de base de datos | | Seleccione la capa de Atlas. | Siga las instrucciones de la [documentación de MongoDB](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) para seleccionar la capa del clúster de Atlas correcta. | Administrador de base de datos | | Planifique la transición. | Planifique la transición de la aplicación. | Administrador de base de datos, propietario de la aplicación | ### Configure un nuevo entorno de MongoDB Atlas en AWS | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree un nuevo clúster de MongoDB Atlas en. AWS | En MongoDB Atlas, elija **Build a Cluster**. En el cuadro de diálogo **Crear nuevo clúster**, seleccione AWS como proveedor de nube. | Administrador de base de datos | | Seleccione Regiones de AWS una configuración de clúster global. | Seleccione una opción de la lista de disponibles Regiones de AWS para su clúster de Atlas. Configure clústeres globales si es necesario. | Administrador de base de datos | | Seleccione la capa del clúster. | Seleccione la capa del clúster que prefiera. La selección de la capa determina factores como la memoria, el almacenamiento y las especificaciones de IOPS. | Administrador de base de datos | | Configure los ajustes adicionales del clúster. | Configure los ajustes adicionales del clúster, como la versión de MongoDB, la copia de seguridad y las opciones de cifrado. Para obtener más información sobre estas opciones, consulte la sección [Recursos relacionados](#migrate-relational-database-to-mongodb-atlas-resources). | Administrador de base de datos | ### Configure la seguridad y el cumplimiento | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Configure la lista de acceso. | Para conectarse al clúster de Atlas, debe agregar una entrada a la lista de acceso del proyecto. Atlas TLS/SSL lo utiliza para cifrar las conexiones a la nube privada virtual (VPC) de su base de datos. Para configurar la lista de acceso al proyecto y obtener más información sobre las historias de esta epopeya, consulte la sección [Recursos relacionados](#migrate-relational-database-to-mongodb-atlas-resources). | Administrador de base de datos | | Autentique y autorice a los usuarios. | Debe crear y autenticar a los usuarios de la base de datos que accederán a los clústeres de MongoDB Atlas. Para acceder a los clústeres de un proyecto, los usuarios deben pertenecer a ese proyecto y pueden pertenecer a varios proyectos. | Administrador de base de datos | | Cree roles personalizados. | (Opcional) Atlas admite la creación de roles personalizados en los casos en que los permisos de usuario integrados en la base de datos Atlas no cubran el conjunto de privilegios deseado. | Administrador de base de datos | | Configure las interconexiones con VPC. | (Opcional) Atlas admite la interconexión de [VPC con otras](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html). VPCs AWS | Administrador de AWS | | Configure un punto final AWS PrivateLink . | (Opcional) Puede configurar puntos de conexión privados AWS utilizando AWS PrivateLink. Para obtener más información, consulte la [documentación de Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html). | Administrador de AWS | | Habilitar la autenticación en dos pasos. | (Opcional) Atlas admite la autenticación en dos pasos (2FA) para ayudar a los usuarios a controlar el acceso a sus cuentas de Atlas. | Administrador de AWS | | Configure la autenticación y la autorización de los usuarios con LDAP. | (Opcional) Atlas admite realizar la autenticación y autorización de los usuarios con el Protocolo ligero de acceso a directorios (LDAP). | Administrador de base de datos | | Configure el AWS acceso unificado. | (Opcional) Algunas funciones de Atlas, como Atlas Data Lake y el cifrado en reposo mediante la gestión de claves del cliente, utilizan funciones AWS Identity and Access Management (IAM) para la autenticación. | Administrador de AWS | | Configure el cifrado en reposo utilizando AWS KMS. | (Opcional) Atlas admite el uso de AWS Key Management Service (AWS KMS) para cifrar los motores de almacenamiento y las copias de seguridad de los proveedores de servicios en la nube. | Administrador de AWS | | Configure el cifrado en el nivel de campo del cliente. | (Opcional) Atlas admite el cifrado en el nivel de campo del cliente, incluido el cifrado automático de los campos. | Administrador de AWS | ### Migración de datos | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Agregue MongoDB Relational Migrator a la lista de acceso. | Agregue Relational Migrator a la lista de acceso para la base de datos de origen. Esto ayuda a preparar el entorno de origen para conectarse al clúster de Atlas de destino. | Administrador de base de datos | | Evalúe los objetos de la base de datos relacional. | Inicie MongoDB Relational Migrator y conéctese a la base de datos relacional. Inicie la evaluación. | Administrador de base de datos | | Acepte los patrones de migración o elija si quiere modificarlos en función de las necesidades de la empresa. | Acepte los patrones de bases de datos recomendados por Relational Migrator en función de la evaluación inicial y los parámetros de rendimiento, u opte por modificarlos en función de los requisitos de la empresa. | Administrador de base de datos | | Lance el conjunto de réplicas de destino en MongoDB Atlas. | Lance el conjunto de réplicas de destino en MongoDB Atlas. En Relational Migrator, elija **I'm ready to migrate**. | Administrador de base de datos | ### Configurar la integración operativa | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Conéctese al clúster de MongoDB Atlas. | Asegúrese de que la conectividad del clúster de MongoDB Atlas funcione según lo esperado. | Propietario de la aplicación | | Interactúe con los datos del clúster. | Verifique los datos del clúster. | Administrador de base de datos | | Supervise los clústeres. | Compruebe que sus clústeres estén configurados correctamente. | Administrador de base de datos | | Realice copias de seguridad y restaure los datos del clúster. | Programe las copias de seguridad con una cadencia regular para los datos del clúster. | Administrador de base de datos | ## Recursos relacionados Todos los enlaces siguientes, a menos que se indique lo contrario, van a páginas web de la documentación de MongoDB. **Guía de migración** + [Migración a MongoDB Atlas AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) en (Guía prescriptiva)AWS **Detectar y evaluar** + [Memoria](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Ejemplo de dimensionamiento con conjuntos de datos de muestra de Atlas](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Ejemplo de dimensionamiento para aplicaciones móviles](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Tráfico de red](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Escalado automático de clústeres](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Plantilla de dimensionamiento de Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Configure la seguridad y el cumplimiento** + [Configurar entradas de la lista de acceso IP](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Configure Database Users](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Configure Access to the Atlas UI](https://docs.atlas.mongodb.com/organizations-projects/) + [Configure Custom Database Roles](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 un emparejamiento de red](https://docs.atlas.mongodb.com/security-vpc-peering/) + [Learn About Private Endpoints in Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Manage Your Multi-Factor Authentication Options](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Configurar la autenticación y la autorización de usuarios con LDAP](https://docs.atlas.mongodb.com/security-ldaps/) + [Lago de datos Atlas](https://docs.mongodb.com/datalake/) + [Cifrado en reposo mediante la administración de claves de cliente](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Métodos para asumir un rol ](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (documentación de IAM) + [Configurar el cifrado en el nivel de campo del cliente](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Automatic Encryption](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) + [Centro de confianza de MongoDB](https://www.mongodb.com/cloud/trust) + [Configure Security Features for Clusters](https://docs.atlas.mongodb.com/setup-cluster-security/) **Configuración de un nuevo entorno de MongoDB Atlas en ****AWS** + [Proveedores y regiones de la nube](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Manage Global Clusters](https://docs.atlas.mongodb.com/global-clusters/) + [Select Cluster Tier](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Configure Additional Settings](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Introducción a Atlas](https://docs.atlas.mongodb.com/getting-started/) + [Configure Access to the Atlas UI](https://docs.atlas.mongodb.com/organizations-projects/) **Migración de datos** + [Migrate or Import Data](https://www.mongodb.com/docs/atlas/import/) **Monitorear clústeres** + [Monitor Your Clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) **Integrar operaciones** + [Conectarse a un clúster](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interact with Your Data](https://docs.atlas.mongodb.com/data-explorer/) + [Monitor Your Clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Back Up, Restore, and Archive Data](https://docs.atlas.mongodb.com/backup-restore-cluster/) # Migre un entorno MongoDB autohospedado a MongoDB Atlas en AWS *Battulga Purevragchaa e Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Resumen Este patrón describe los pasos para migrar de un entorno de MongoDB autoadministrado (que incluye MongoDB Community Server, Enterprise Server, Enterprise Advanced, mLab o cualquier clúster de MongoDB administrado) a MongoDB Atlas en la Nube de AWS. Utiliza [Atlas Live Migration Service](https://www.mongodb.com/cloud/atlas/migrate) para ayudar a acelerar la migración de los datos de MongoDB a MongoDB Atlas. El patrón acompaña a la guía [Migración a MongoDB Atlas que se encuentra en AWS el sitio](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) web de orientación prescriptiva. AWS Proporciona los pasos de implementación para uno de los escenarios de migración que se analizan en esa guía. Para ver otros escenarios de migración, consulte los siguientes patrones en el sitio web de la Guía prescriptiva: AWS + [Migrar una base de datos relacional a MongoDB Atlas en AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-relational-database-to-mongodb-atlas.html) + [Transmita datos desde IBM Db2, SAP, Sybase y otras bases de datos a MongoDB Atlas en AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/stream-data-from-ibm-db2-to-mongodb-atlas.html) El patrón está destinado a socios y usuarios [AWS de Systems Integrator (SI)](https://aws.amazon.com/managed-services/partners/). AWS ## Requisitos previos y limitaciones **Requisitos previos ** + Un entorno de MongoDB Enterprise Advanced, Community Server u otro entorno de MongoDB autoadministrado de origen para migrar a MongoDB Atlas. + Familiaridad con MongoDB, MongoDB Atlas y. Servicios de AWS Este patrón explica algunos de los pasos de migración de forma general. Se agregarán detalles adicionales en futuras versiones. **Versiones de producto** + MongoDB versión 6.0.13 o posterior ## Arquitectura En el siguiente diagrama se muestra Atlas Live Migration Service, que se utiliza para migrar datos de una base de datos de MongoDB Enterprise Advanced y una base de datos de MongoDB Community a MongoDB Atlas en AWS. Utilice este servicio cuando tenga que migrar bases de datos grandes y complejas a MongoDB Atlas con un tiempo de inactividad mínimo y una sincronización de datos continua. Este patrón utiliza Atlas Live Migration Service. ![\[Migración de datos con MongoDB Atlas Live Migration Service.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/52cdb923-64ff-4ee2-b129-93b9a139e24b/images/372134c4-ba47-4e48-bd0d-8b43017773b8.png) El siguiente diagrama muestra el servicio de réplica de MongoDB `mongomirror` () que también puede utilizar para migrar datos de una base de datos de MongoDB Enterprise Advanced y una base de datos de MongoDB Community a MongoDB Atlas a través de una conexión segura. AWS [AWS PrivateLink](https://aws.amazon.com/privatelink/) Use `mongomirror` para la replicación de datos continua entre MongoDB en las instalaciones y MongoDB Atlas. Esta herramienta es ideal para la recuperación ante desastres o las migraciones por fases, pero queda fuera del alcance de este patrón. ![\[Migración de datos con la herramienta mongomirror.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/52cdb923-64ff-4ee2-b129-93b9a139e24b/images/53488a9b-2210-4b3d-b517-b618c1e0182c.png) Para obtener más arquitecturas de referencia de MongoDB Atlas que admiten diferentes escenarios de uso, consulte [Migración a MongoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) Atlas en el sitio web de orientación prescriptiva. AWS AWS ## Tools (Herramientas) + [MongoDB Atlas](https://www.mongodb.com/atlas) es una base de datos como servicio (DbaaS) completamente administrada para implementar y administrar bases de datos de MongoDB en la nube. + [Atlas Live Migration Service](https://www.mongodb.com/cloud/atlas/migrate) es un programa de utilidad gratuito de MongoDB que ayuda a migrar bases de datos a Atlas. Este servicio mantiene la base de datos de origen sincronizada con la base de datos de destino hasta la transición. Cuando esté todo a punto para realizar la transición, detenga las instancias de la aplicación, diríjalas al clúster Atlas de destino y reinícielas. Para acceder a este servicio, elija **Opciones de base de datos** en su clúster de MongoDB Atlas. + [mongomirror](https://www.mongodb.com/docs/atlas/import/mongomirror/) es una herramienta para migrar datos manualmente de un conjunto de réplicas de MongoDB existente a un conjunto de réplicas de MongoDB Atlas. `mongomirror` no requiere que cierre el conjunto de réplicas ni las aplicaciones existentes, no importa datos de usuarios ni roles ni copia la base de datos de configuración. Puede descargar `mongomirror` desde la [documentación de MongoDB](https://www.mongodb.com/docs/atlas/import/mongomirror/#download-mongomirror). ## Prácticas recomendadas [Para conocer las mejores prácticas para usar MongoDB AWS en, consulte las publicaciones del blog de Partner Network AWS .](https://aws.amazon.com/blogs/apn/tag/mongodb-atlas/) ## Epics ### Descubrimiento y evaluación | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Determine el tamaño del clúster. | Calcule el tamaño del conjunto de trabajo utilizando la información de `db.stats()` para el espacio total del índice. Presuponga que se accederá con frecuencia a un porcentaje de su espacio de datos. O bien, puede estimar las necesidades de memoria en función de sus propias presuposiciones. Esta tarea puede necesitar aproximadamente una semana. Para obtener más información y ejemplos de esta y otras historias de esta épica, consulte la sección [Recursos relacionados](#migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud-resources). | Administrador de base de datos, propietario de la aplicación | | Calcule los requisitos de ancho de banda de la red. | Para calcular los requisitos de ancho de banda de la red, multiplique el tamaño medio de los documentos por el número de documentos servidos por segundo. Tenga en cuenta el tráfico máximo que soportará cualquier nodo del clúster como base. Para calcular las velocidades de transferencia de datos descendentes del clúster a las aplicaciones cliente, utilice la suma del total de documentos devueltos durante un período de tiempo. Si sus aplicaciones leen desde nodos secundarios, divida este número total de documentos por el número de nodos que pueden realizar operaciones de lectura. Para encontrar el tamaño medio de los documentos de una base de datos, utilice el comando `db.stats().avgObjSize`. Esta tarea suele necesitar un día. | Administrador de base de datos | | Seleccione la capa de Atlas. | Siga las instrucciones de la [documentación de MongoDB](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) para seleccionar la capa del clúster de Atlas correcta. | Administrador de base de datos | | Planifique la transición. | Planifique la transición de la aplicación. | Administrador de base de datos, propietario de la aplicación | ### Configurar un nuevo entorno de MongoDB Atlas en AWS | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree un nuevo clúster de MongoDB Atlas en. AWS | Inicie sesión en Atlas y abra la página **Información general** de su proyecto. Seleccione el botón **Crear** para crear un clúster. Para obtener más información, consulte la [ documentación de MongoDB](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/). | Administrador de base de datos | | Seleccione una Regiones de AWS configuración de clúster global. | Seleccione una opción de la lista de disponibles Regiones de AWS para su clúster de Atlas. Configure clústeres globales si es necesario. Para obtener más información, consulte la [ documentación de MongoDB](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/#select-your-preferred-region.). | Administrador de base de datos | | Seleccione la capa del clúster. | Seleccione la capa del clúster que prefiera. La selección de la capa determina factores como la memoria, el almacenamiento y las especificaciones de IOPS. | Administrador de base de datos | | Configure los ajustes adicionales del clúster. | Configure los ajustes adicionales del clúster, como la versión de MongoDB, la copia de seguridad y las opciones de cifrado. Para obtener más información sobre estas opciones, consulte la sección [Recursos relacionados](#migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud-resources). | Administrador de base de datos | ### Configure la seguridad y el cumplimiento | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Autentique y autorice a los usuarios. | Debe crear y autenticar a los usuarios de la base de datos que accederán a los clústeres de MongoDB Atlas. Para acceder a los clústeres de un proyecto, los usuarios deben pertenecer a ese proyecto y pueden pertenecer a varios proyectos. Atlas también admite la autenticación basada en AWS Identity and Access Management (IAM). Para obtener más información, consulte la [ documentación de MongoDB](https://www.mongodb.com/docs/atlas/security/aws-iam-authentication/#set-up-authentication-with-aws-iam). | Administrador de base de datos | | Cree roles personalizados. | (Opcional) Atlas admite la creación de roles personalizados en los casos en que los permisos de usuario integrados en la base de datos Atlas no cubran el conjunto de privilegios deseado. | Administrador de base de datos | | Configure las interconexiones con VPC. | (Opcional) Atlas admite el [emparejamiento de nubes privadas virtuales (VPC) con otras](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html). VPCs AWS | Administrador de AWS | | Configure un punto final AWS PrivateLink . | (Opcional) Puede configurar puntos de conexión privados AWS utilizando AWS PrivateLink. Para obtener más información, consulte la [documentación de Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html). | Administrador de AWS | | Habilitar la autenticación en dos pasos. | (Opcional) Atlas admite la autenticación en dos pasos (2FA) para ayudar a los usuarios a controlar el acceso a sus cuentas de Atlas. | Administrador de AWS | | Configure la autenticación y la autorización de los usuarios con LDAP. | (Opcional) Atlas admite realizar la autenticación y autorización de los usuarios con el Protocolo ligero de acceso a directorios (LDAP). | Administrador de AWS | | Configure el AWS acceso unificado. | (Opcional) Algunas características de Atlas, como Atlas Data Lake y el cifrado en reposo mediante la administración de claves de cliente, utilizan los roles de IAM para la autenticación. | Administrador de AWS | | Configure el cifrado en reposo utilizando AWS KMS. | (Opcional) Atlas admite el uso de AWS Key Management Service (AWS KMS) para cifrar los motores de almacenamiento y las copias de seguridad de los proveedores de servicios en la nube. | Administrador de AWS | | Configure el cifrado en el nivel de campo del cliente. | (Opcional) Atlas admite el cifrado en el nivel de campo del cliente, incluido el cifrado automático de los campos. | Administrador de AWS | ### Migración de datos | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Seleccionar el conjunto de réplicas de destino en MongoDB Atlas. | Vaya al clúster de Atlas de destino y elija el botón de puntos suspensivos (…). En la lista de clústeres, este botón aparece debajo del nombre del clúster. En los detalles del clúster, el botón aparece a la derecha, junto a los botones **Conectarse** y **Configuración**. Para obtener más información, consulte la [ documentación de MongoDB](https://www.mongodb.com/docs/atlas/import/c2c-pull-live-migration/#procedure). | Administrador de base de datos | | Agregar Atlas Live Migration Service a la lista de acceso. | Añada el servicio Atlas Live Migration a la lista de acceso de su clúster AWS de origen. Esto ayuda a preparar el entorno de origen para conectarse al clúster de Atlas de destino. | Administrador de base de datos | | Llevar a cabo la migración con Atlas Live Migration Service. | Elija **Iniciar migración**. Cuando el botón **Preparación de la transición** se ponga en verde, lleve a cabo la transición. Revise las métricas de rendimiento de los clústeres de Atlas. Considere la posibilidad de actualizar la conexión de la base de datos en todas las capas de la aplicación para que apunte a la nueva base de datos. | Administrador de base de datos | ### Configurar la integración operativa | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Conéctese al clúster de MongoDB Atlas. | Asegúrese de que la conectividad del clúster de MongoDB Atlas funcione según lo esperado. | Propietario de la aplicación | | Interactúe con los datos del clúster. | Pruebe los datos del clúster. | Administrador de base de datos | | Supervise los clústeres. | Compruebe que sus clústeres estén configurados correctamente. | Administrador de base de datos | | Realice copias de seguridad y restaure los datos del clúster. | Programe las copias de seguridad con una cadencia regular para los datos del clúster. | Administrador de base de datos | ## Resolución de problemas | Problema | Solución | | --- | --- | | Error: No se pudo alcanzar el origen especificado | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud.html) | | Error: No se pudo resolver el nombre de host | No se encontró ninguna dirección IP para el nombre de host indicado. Confirme que el nombre de host indicado sea correcto y de acceso público. | | Cualquier otro error | Si encuentra algún otro error, consulte [Troubleshoot Live Migration (Pull)](https://www.mongodb.com/docs/atlas/import/live-import-troubleshooting/) en la documentación de MongoDB. | ## Recursos relacionados Todos los enlaces siguientes, a menos que se indique lo contrario, van a páginas web de la documentación de MongoDB. **Guía de migración** + [Migración a MongoDB Atlas AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) en (Guía prescriptiva)AWS **Migración de versiones antiguas** + [Migration of older versions of MongoDB](https://www.mongodb.com/docs/atlas/legacy-migration/) **Detectar y evaluar** + [Memoria](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Ejemplo de dimensionamiento con conjuntos de datos de muestra de Atlas](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Ejemplo de dimensionamiento para aplicaciones móviles](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Tráfico de red](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Escalado automático de clústeres](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Plantilla de dimensionamiento de Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Configure la seguridad y el cumplimiento** + [Configurar entradas de la lista de acceso IP](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Configure Database Users](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Configure Access to the Atlas UI](https://docs.atlas.mongodb.com/organizations-projects/) + [Configure Custom Database Roles](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 un emparejamiento de red](https://docs.atlas.mongodb.com/security-vpc-peering/) + [Learn About Private Endpoints in Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Manage Your Multi-Factor Authentication Options](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Configurar la autenticación y la autorización de usuarios con LDAP](https://docs.atlas.mongodb.com/security-ldaps/) + [Lago de datos Atlas](https://docs.mongodb.com/datalake/) + [Cifrado en reposo mediante la administración de claves de cliente](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Métodos para asumir un rol ](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (documentación de IAM) + [Configurar el cifrado en el nivel de campo del cliente](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Automatic Encryption](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) + [Centro de confianza de MongoDB](https://www.mongodb.com/cloud/trust) + [Configure Security Features for Clusters](https://docs.atlas.mongodb.com/setup-cluster-security/) **Configuración de un nuevo entorno de MongoDB Atlas en ****AWS** + [Proveedores y regiones de la nube](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Manage Global Clusters](https://docs.atlas.mongodb.com/global-clusters/) + [Select Cluster Tier](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Configure Additional Settings](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Introducción a Atlas](https://docs.atlas.mongodb.com/getting-started/) + [Configure Access to the Atlas UI](https://docs.atlas.mongodb.com/organizations-projects/) **Migración de datos** + [Migrate or Import Data](https://www.mongodb.com/docs/atlas/import/) **Monitorización de clústeres** + [Monitor Your Clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) **Integrar operaciones** + [Conectarse a un clúster](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interact with Your Data](https://docs.atlas.mongodb.com/data-explorer/) + [Monitor Your Clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Back Up, Restore, and Archive Data](https://docs.atlas.mongodb.com/backup-restore-cluster/) **Entrenamiento** + [Live Migration with MongoDB Atlas](https://learn.mongodb.com/courses/live-migration-with-mongodb-atlas) ## Información adicional Para obtener más información, consulte los siguientes temas en la documentación de MongoDB: + Para mover datos a una instancia sin servidor, [utilice Compass para exportar e importar datos](https://www.mongodb.com/docs/compass/current/import-export/), o migre los datos con herramientas autogestionadas. Para obtener más información, consulte [Serverless Instance Limitations](https://www.mongodb.com/docs/atlas/reference/serverless-instance-limitations/). + Para cargar datos en un nuevo clúster de Atlas, consulte [Load Data into Atlas](https://www.mongodb.com/docs/atlas/sample-data/#std-label-sample-data). + Para hacer una copia del clúster con fines de prueba, consulte [Backup Methods for a Self-Managed Deployment](https://www.mongodb.com/docs/manual/core/backups/). + Si la aplicación que desea migrar requiere un tiempo de actividad casi continuo, póngase en contacto con el equipo de [atención al cliente de MongoDB](https://www.mongodb.com/docs/atlas/support/#std-label-request-support) y comparta sus requisitos de tiempo de actividad y la configuración del clúster. + Para obtener información adicional, consulte [Migrate or Import Data](https://www.mongodb.com/docs/atlas/import/). # Migración de una base de datos de Oracle a Amazon DynamoDB mediante AWS DMS *Rambabu Karnena, Amazon Web Services* ## Resumen Este patrón le guía por los pasos para migrar una base de datos de Oracle a [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) mediante AWS Database Migration Service ([AWS DMS](https://aws.amazon.com/dms/)). Abarca tres tipos de bases de datos de origen: + Bases de datos de Oracle en las instalaciones + Bases de datos de Oracle en Amazon Elastic Compute Cloud ([Amazon EC2](https://aws.amazon.com/ec2/)) + Amazon Relational Database Service ([Amazon RDS](https://aws.amazon.com/rds/)) para instancias de bases de datos de Oracle En esta prueba de concepto, este patrón se centra en la migración desde una instancia de BD de Amazon RDS para Oracle. ## Requisitos previos y limitaciones **Requisitos previos ** + Una cuenta de AWS activa + Una aplicación que se conecta a una base de datos de Amazon RDS para Oracle + Una tabla creada en la base de datos de Amazon RDS para Oracle de origen con una clave principal y datos de muestra **Limitaciones** + Los objetos de la base de datos de Oracle, como los procedimientos, las funciones, los paquetes y los desencadenadores, no se consideran para la migración porque Amazon DynamoDB no admite estos objetos de base de datos. **Versiones de producto** + Este patrón se aplica a todas las ediciones y versiones de las bases de datos de Oracle compatibles con AWS DMS. Para obtener más información, consulte el uso de una [base de datos de Oracle como origen para AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html) y el uso de una [base de datos de Amazon DynamoDB como destino para AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.DynamoDB.html). Le recomendamos utilizar las versiones más recientes de AWS DMS para obtener el soporte más completo de versiones y características. ## Arquitectura **Pila de tecnología de origen** + Instancias de bases de datos Amazon RDS para Oracle, Oracle on EC2 Amazon o bases de datos Oracle locales **Pila de tecnología de destino** + Amazon DynamoDB **Arquitectura de migración de datos de AWS** ![\[Los datos se transfieren de Oracle DB a AWS DMS y a Amazon DynamoDB.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/463fc7d4-ec8d-473b-8c7f-1df31800ee03/images/180e7340-3887-455d-a591-b5850e22770a.png) ## Tools (Herramientas) + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) le permite migrar los almacenes de datos a la nube de AWS o entre combinaciones de configuraciones en la nube y en las instalaciones. + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) es un servicio de base de datos de NoSQL completamente administrado que ofrece un rendimiento rápido, predecible y escalable. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) le ayuda a configurar, utilizar y escalar una base de datos relacional en la nube de AWS. Este patrón utiliza Amazon RDS para Oracle. ## Epics ### Planificación de la migración | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una VPC. | En su cuenta de AWS, cree una nube privada virtual (VPC) y una subred privada. | Administrador de sistemas | | Cree grupos de seguridad y listas de control de acceso a la red. | Para obtener más información, consulte la [documentación de AWS](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html). | Administrador de sistemas | | Configure e inicie la instancia de BD de Amazon RDS para Oracle. | Para obtener más información, consulte la [documentación de AWS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html). | Administrador de base de datos, administrador de sistemas | ### Migración de datos | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Crear un rol de IAM para acceder a DynamoDB. | En la consola de AWS Identity and Access Management (IAM), cree el rol, adjunte la política `AmazonDynamoDBFullAccess to it` y seleccione AWS DMS como servicio. | Administrador de sistemas | | Crear una instancia de replicación de AWS DMS para la migración. | La instancia de replicación debe estar en la misma zona de disponibilidad y VPC que la base de datos de origen. | Administrador de sistemas | | Cree puntos de conexión de origen y destino en AWS DMS. | Para crear el punto de conexión de la base de datos de origen, tiene dos opciones:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.html)Para crear el punto de conexión de la base de datos de destino, elija el rol de Nombre de recurso de Amazon (ARN) de la tarea anterior para acceder a DynamoDB. | Administrador de sistemas | | Cree una tarea de AWS DMS para cargar las tablas de base de datos de Oracle de origen en DynamoDB. | Elija los nombres de los puntos de conexión de origen y destino y la instancia de replicación en los pasos anteriores. El tipo puede ser de carga completa. Elija el esquema de Oracle y especifique **%** para seleccionar todas las tablas. | Administrador de sistemas | | Valide las tablas en DynamoDB. | Para ver los resultados de la migración, seleccione **Tablas** en el panel de navegación izquierdo de la consola de DynamoDB. | Administrador de base de datos | ### Migración de la aplicación | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cómo modificar el código de la aplicación | Para conectarse y recuperar datos de DynamoDB, actualice el código de la aplicación. | Administrador de base de datos, propietario de la aplicación, administrador de sistemas | ### Realizar la transición | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cambie los clientes de la aplicación para que usen DynamoDB. | | Administrador de base de datos, propietario de la aplicación, administrador de sistemas | ### Cerrar el proyecto | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cierre los recursos de AWS. | Por ejemplo, cierre la instancia de Amazon RDS para Oracle, DynamoDB y la instancia de replicación de AWS DMS. | Administrador de base de datos, administrador de sistemas | | Recopile métricas. | Las métricas incluyen el tiempo de migración, los porcentajes de trabajo manual y realizado por la herramienta y el ahorro de costos. | Administrador de base de datos, propietario de la aplicación, administrador de sistemas | ## Recursos relacionados + [AWS Database Migration Service (AWS DMS) y Amazon DynamoDB: lo que necesita saber](https://aws.amazon.com/blogs/database/aws-database-migration-service-and-amazon-dynamodb-what-you-need-to-know/) (entrada del blog) + [Uso de una base de datos de Oracle como origen para AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html) + [Uso de una base de datos de Amazon DynamoDB como objetivo del servicio de migración de bases de datos de AWS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.DynamoDB.html) + [Prácticas recomendadas para migrar de RDBMS a Amazon DynamoDB](https://docs.aws.amazon.com/whitepapers/latest/best-practices-for-migrating-from-rdbms-to-dynamodb/welcome.html) (documento técnico) # Migre de Oracle 8i o 9i a Amazon RDS para Oracle con AWS DMS SharePlex *Ramu Jagini, Amazon Web Services* ## Resumen Este patrón describe cómo migrar una base de datos de Oracle 8i o 9i en las instalaciones a una base de datos de Amazon Relational Database Service (Amazon RDS) para Oracle. Puede utilizar este patrón para completar la migración con un tiempo de inactividad reducido si utiliza Quest para la replicación sincrónica. SharePlex Debe usar una instancia de base de datos de Oracle intermedia para la migración, ya que AWS Database Migration Service (AWS DMS) no admite Oracle 8i o 9i como entorno de origen. Puede utilizar la versión [SharePlex 7.6.3](https://www.quest.com/community/shareplex/f/forum/20700/where-can-download-7-6-3-or-support-9i-shareplex) para replicar desde versiones anteriores de bases de datos Oracle a versiones posteriores de bases de datos Oracle. La instancia de base de datos Oracle intermedia es compatible como destino para SharePlex 7.6.3 y se admite como fuente para AWS DMS o versiones más recientes de. SharePlex Esta compatibilidad permite la replicación posterior de los datos en el entorno de destino de Amazon RDS para Oracle. Tenga en cuenta que varios tipos de datos y funciones obsoletos pueden afectar a una migración de Oracle 8i o 9i a la versión más reciente de Oracle Database. Para mitigar este impacto, este patrón emplea Oracle 11.2.0.4 como versión de base de datos intermedia para ayudar a optimizar el código del esquema antes de migrar al entorno de destino de Amazon RDS para Oracle. ## Requisitos previos y limitaciones **Requisitos previos ** + Una cuenta de AWS activa + Una base de datos de Oracle 8i o 9i de origen en un entorno en las instalaciones + [Oracle Database 12c versión 2](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/index.html) (12CR2) para almacenamiento en Amazon Elastic Compute Cloud (Amazon) EC2 + Quest SharePlex 7.6.3 (versión comercial) **Limitaciones** + [Limitaciones de RDS para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Oracle.Concepts.limitations.html) **Versiones de producto** + Oracle 8i o 9i para la base de datos de origen + Oracle 12 CR2 para la base de datos provisional (debe coincidir con la versión Amazon RDS for Oracle) + Oracle 12 CR2 o posterior para la base de datos de destino (Amazon RDS for Oracle) ## Arquitectura **Pila de tecnología de origen** + Base de datos de Oracle 8i o 9i + SharePlex **Pila de tecnología de destino** + Amazon RDS para Oracle **Arquitectura de migración** El siguiente diagrama muestra cómo migrar una base de datos de Oracle 8i o 9i de un entorno en las instalaciones a una instancia de base de datos de Amazon RDS para Oracle en la nube de AWS. ![\[Flujo de trabajo para migrar una base de datos de Oracle en las instalaciones a Amazon RDS en AWS.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/6e07d586-fd74-4f3d-8e81-79dd55c445c3/images/36e1a5ff-908b-4cb7-96f7-997eb105f1d6.png) En el diagrama, se muestra el siguiente flujo de trabajo: 1. Habilite la base de datos de origen de Oracle con modo de registro de archivos, registro forzado y registro suplementario. 1. [Restaure la base de datos provisional de Oracle desde la base de datos de origen de Oracle mediante Recovery Manager (RMAN) point-in-time y FLASHBACK\$1SCN.](https://docs.oracle.com/database/121/SUTIL/GUID-D408B112-1A81-4F68-BEFF-7403A9588DDB.htm#SUTIL849) 1. Configure SharePlex para leer los redo logs de la base de datos fuente de Oracle mediante (se utiliza `FLASHBACK_SCN` en RMAN). 1. Inicie SharePlex la replicación para sincronizar los datos de la base de datos de origen de Oracle con la base de datos provisional de Oracle. 1. Restaure la base de datos de destino de Amazon RDS para Oracle mediante EXPDP e IMPDP con `FLASHBACK_SCN`. 1. Configure AWS DMS y sus tareas de origen como base de datos transitoria de Oracle, y Amazon RDS para Oracle como base de datos de destino mediante `FLASHBACK_SCN` (se usa en EXPDP). 1. Inicie las tareas de AWS DMS para sincronizar los datos de la base de datos transitoria de Oracle con la base de datos de destino de Oracle. ## Tools (Herramientas) + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) le ayuda a configurar, utilizar y escalar una base de datos relacional en la nube de AWS. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) le permite migrar los almacenes de datos a la nube de AWS o entre combinaciones de configuraciones en la nube y en las instalaciones. + [Quest SharePlex](https://support.quest.com/shareplex/11.0/technical-documents) es una herramienta Oracle-to-Oracle de replicación de datos para mover datos con un tiempo de inactividad mínimo y sin pérdida de datos. + [Recovery Manager (RMAN)](https://docs.oracle.com/cd/E11882_01/backup.112/e10642/rcmquick.htm) es un cliente de Oracle Database que realiza tareas de copia de seguridad y recuperación en sus bases de datos. Simplifica en gran medida las copias de seguridad, la restauración y la recuperación de los archivos de bases de datos. + [Data Pump Export](https://docs.oracle.com/cd/E11882_01/server.112/e22490/dp_export.htm#SUTIL823) le ayuda a cargar datos y metadatos en un conjunto de archivos del sistema operativo denominado conjunto de archivos de volcado. El conjunto de archivos de volcado solo se puede importar mediante la utilidad [Data Pump Import](https://docs.oracle.com/cd/E11882_01/server.112/e22490/dp_import.htm#SUTIL300) o el paquete [DBMS\$1DATAPUMP](https://docs.oracle.com/database/121/ARPLS/d_datpmp.htm#ARPLS356). ## Epics ### Configuración SharePlex y la base de datos provisional de Oracle en Amazon EC2 | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una EC2 instancia. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html) | Administración de Oracle | | Prepare la base de datos transitoria. | Prepare la base de datos provisional de Oracle para restaurarla como una actualización en Oracle 12 CR2 realizando la copia de seguridad en RMAN del entorno de origen de la base de datos Oracle 8i o 9i.Para obtener más información, consulte la [Guía del usuario de Oracle 9i Recovery Manager](https://docs.oracle.com/cd/B10500_01/server.920/a96566/toc.htm) y la [Guía del usuario de copia de seguridad y recuperación de bases de datos](https://docs.oracle.com/database/121/BRADV/rcmcomre.htm#BRADV8005) en la documentación de Oracle. | Administración de Oracle | | Configure. SharePlex | Configure el SharePlex origen como una base de datos Oracle 8i o 9i local y configure el destino como la base de datos provisional de Oracle 12 CR2 alojada en Amazon. EC2 | SharePlex, administración de Oracle | ### Configure Amazon RDS para Oracle como su entorno objetivo | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Crear una instancia de base de datos de Oracle. | Cree una base de datos Amazon RDS for Oracle y, a continuación, conecte Oracle CR2 12 a la base de datos.Para más información, consulte [Crear una instancia de base de datos de Oracle y conectarse a una base de datos en una instancia de base de datos en Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.Oracle.html) en la documentación de Amazon RDS. | Administrador de base de datos | | Restaure Amazon RDS para Oracle desde la base de datos transitoria. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html)Para obtener más información, consulte [54 DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/21/arpls/DBMS_DATAPUMP.html#GUID-AEA7ED80-DB4A-4A70-B199-592287206348) en la documentación de Oracle. | Administrador de base de datos | ### Configure AWS DMS | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree puntos de conexión para las bases de datos. | Cree un punto de conexión de origen para la base de datos transitoria de Oracle y un punto de conexión de destino para la base de datos Amazon RDS para Oracle.Para obtener más información, consulte [¿Cómo puedo crear puntos de conexión de origen o de destino con AWS DMS?](https://aws.amazon.com/premiumsupport/knowledge-center/create-source-target-endpoints-aws-dms/) en el Centro de conocimientos de AWS. | Administrador de base de datos | | Cree una instancia de replicación. | Use AWS DMS para lanzar una instancia de replicación de la base de datos transitoria de Oracle en la base de datos Amazon RDS para Oracle.Para obtener más información, consulte el tema [¿Cómo crear una instancia de replicación de AWS DMS?](https://aws.amazon.com/premiumsupport/knowledge-center/create-aws-dms-replication-instance/) en el Centro de conocimientos de AWS. | Administrador de base de datos | | Crear e iniciar tareas de replicación. | Cree tareas de replicación de AWS DMS para la captura de datos de cambios (CDC) usando `FLASHBACK_SCN` de EXPDP (dado que la carga completa ya se ha realizado a través de EXPDP).Para obtener más información, consulte [Crear una tarea](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) en la documentación de AWS DMS. | Administrador de base de datos | ### Cómo hacer la transición a Amazon RDS para Oracle | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Detenga la carga de trabajo de la aplicación. | Detenga los servidores de aplicaciones y sus aplicaciones durante el período de transición previsto. | Desarrollador de aplicaciones, administrador de base de datos | | Valide la sincronización de la base de datos provisional de Oracle local con la instancia. EC2 | Confirme que se hayan publicado todos los mensajes para las tareas de replicación desde la instancia de SharePlex replicación a la base de datos provisional de Oracle en Amazon EC2 realizando algunos cambios de registro en la base de datos de origen local.Para obtener más información, consulte [6.4.2 Cómo cambiar un archivo de registro](https://docs.oracle.com/database/121/ADMQS/GUID-E30B4C65-2AC7-4A44-A58C-D3C121EB152F.htm#ADMQS12075) en la documentación de Oracle. | Administrador de base de datos | | Valide la sincronización de la base de datos transitoria de Oracle con la base de datos Amazon RDS para Oracle. | Confirme que sus tareas de AWS DMS no presentan retrasos ni errores y, a continuación, compruebe el estado de validación de las tareas. | Administrador de base de datos | | Detenga la replicación SharePlex de Amazon RDS. | Si tanto la replicación SharePlex de AWS DMS como la de AWS no muestran ningún error, detenga ambas replicaciones. | Administrador de base de datos | | Reasigne la aplicación a Amazon RDS. | Comparta los detalles del punto de conexión de Amazon RDS para Oracle con el servidor de aplicaciones y sus aplicaciones y, a continuación, inicie la aplicación para reanudar las operaciones empresariales. | Desarrollador de aplicaciones, administrador de base de datos | ### Pruebe el entorno de destino de AWS | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Pruebe el entorno de base de datos transitoria de Oracle en AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html) | SharePlex, administración de Oracle | | Pruebe el entorno de Amazon RDS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html)Para obtener más información, consulte [Amazon RDS para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) en la documentación de Amazon RDS. | Administración de Oracle | ## Recursos relacionados + [Migración con confianza](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 (AWS DMS)](https://aws.amazon.com/dms/) + [Depuración de las migraciones a AWS DMS: qué hacer cuando las cosas van mal (parte 1)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-1/) + [Depuración de las migraciones a AWS DMS: qué hacer cuando las cosas van mal (parte 2)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-2/) + [Depuración de las migraciones a AWS DMS: ¿qué hacer cuando las cosas van mal? (Parte 3)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-3/) + [SharePlex para la replicación de bases de datos](https://aws.amazon.com/marketplace/pp/B07943W4MJ) + [SharePlex: replicación de bases de datos para cualquier entorno](https://www.youtube.com/watch?v=ygS_ouUaNus) # Migración de una base de datos MySQL en las instalaciones a Amazon EC2 *Lorenzo Mota, Amazon Web Services* ## Resumen Este patrón proporciona orientación para migrar una base de datos MySQL en las instalaciones a una base de datos MySQL en una instancia de Amazon Elastic Compute Cloud (Amazon EC2). El patrón analiza el uso de AWS Database Migration Service (AWS DMS) o herramientas nativas de MySQL, como **mysqldump**, para la migración. Se centra en la migración completa de la base de datos a una instancia de base de datos MySQL. El patrón es principalmente para DBAs arquitectos de soluciones y arquitectos de soluciones. Se puede usar en proyectos pequeños o grandes, en una fase de prueba o de migración final. Se recomienda ejecutar al menos un ciclo de pruebas antes de utilizar este patrón en un entorno de producción. ## Requisitos previos y limitaciones **Requisitos previos ** + Una cuenta de AWS activa + Una base de datos de MySQL de origen en un centro de datos en las instalaciones **Versiones de producto** + Versión 5.5 de MySQL o posterior + [Un sistema operativo de destino compatible con Amazon EC2; consulte Amazon EC2 FAQs](https://aws.amazon.com/ec2/faqs/) ## Arquitectura **Pila de tecnología de origen** + Una base de datos MySQL en las instalaciones **Pila de tecnología de destino** + Una instancia de base de datos de MySQL en Amazon EC2 **Métodos de migración de datos de AWS** + AWS DMS + [Herramientas nativas de MySQL, como [mysqldump](https://dev.mysql.com/doc/refman/en/mysqldump.html), o herramientas de terceros, como Percona XtraBackup](https://www.percona.com/mysql/software/percona-xtrabackup) **Arquitectura de destino** En el siguiente diagrama se muestra la implementación de Amazon EC2 de destino tras la transición. ![\[Una instancia de base de datos MySQL en Amazon EC2 con replicación en una instancia de base de datos MySQL en espera.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/34cab6f9-9107-4c3b-98ec-a6d7fa9f298a.png) **Arquitectura de migración de datos de AWS** *Uso de AWS DMS:* El siguiente diagrama ilustra el flujo de trabajo de migración de datos en el que se basa el AWS DMS envío de cambios completos e incrementales a la base de datos MySQL de destino hasta la transición. La conexión de red local a otra AWS depende de los requisitos del cliente SQL y queda fuera del ámbito de este patrón. ![\[Uso de AWS DMS para enviar datos a una base de datos MySQL de destino en Amazon EC2.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/c906c45d-fac5-4bb9-b8c8-55e2f9f05fd8.png) *Uso de otras herramientas de MySQL:* En el siguiente diagrama se ilustra el flujo de trabajo de migración de datos basado en el uso de herramientas de MySQL para generar archivos de volcado de exportación desde la base de datos en las instalaciones. Estos archivos se trasladan a Amazon Simple Storage Service (Amazon S3) y se importan a la base de datos MySQL de destino antes de la transición. La conexión de red local a otra AWS depende de los requisitos del cliente SQL y queda fuera del ámbito de este patrón. ![\[Uso de herramientas de MySQL nativas para enviar datos a una base de datos MySQL de destino en Amazon EC2.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/18e88877-7879-4a99-b985-25c56bf7c35f.png) Notas: + En función del tiempo de inactividad y del tamaño de la base de datos para la transición final, puede utilizar AWS DMS otra herramienta de captura de datos de cambios (CDC) para minimizar el tiempo de transición. Si utiliza una herramienta de los CDC, por ejemplo AWS DMS, puede migrar a la base de datos de destino en cuestión de minutos. + Una estrategia sin conexión con **mysqldump** puede ser suficiente si el tamaño de la base de datos y la latencia de la red permiten una transición breve a la migración. (Le recomendamos que lleve a cabo pruebas para obtener un tiempo aproximado). + Por lo general, una estrategia de los CDC AWS DMS requiere más supervisión y complejidad que una opción fuera de línea. ## Tools (Herramientas) **AWS servicios** + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) admite varias bases de datos de origen y destino. Para obtener información sobre las bases de datos de origen y destino de MySQL compatibles con AWS DMS, consulte [Uso de una base de datos compatible con MySQL como fuente AWS DMS y [Uso de una base de datos compatible con 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 Si su base de datos de origen no es compatible con AWS DMS, debe elegir otro método para migrar los datos. **Otras herramientas** + [mysqldump](https://dev.mysql.com/doc/refman/8.0/en/mysqldump.html) es una utilidad de MySQL que crea un archivo de volcado desde una base de datos MySQL con fines de copia de seguridad o migración. + [Percona XtraBackup](https://www.percona.com/mysql/software/percona-xtrabackup) es una utilidad de código abierto para realizar copias de seguridad sin bloqueo en bases de datos MySQL. ## Epics ### Planificación de la migración | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Valide las versiones de las bases de datos. | Valide las versiones de las bases de datos de origen y de destino. Para obtener información sobre las versiones de MySQL compatibles AWS DMS, consulte [Fuentes AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.Sources.html) y [destinos AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.Targets.html) en la AWS DMS documentación. | Administrador de base de datos | | Identifique el sistema operativo de destino. | Determine la versión del sistema operativo de destino. Para obtener una lista de los sistemas operativos de destino compatibles con Amazon EC2, consulte Amazon [EC2](https://aws.amazon.com/ec2/faqs/). FAQs | Administrador de base de datos, administrador de sistemas | | Identifique los requisitos de hardware. | Determine los requisitos de hardware para la [instancia del servidor de destino](https://aws.amazon.com/rds/instance-types/) en función de la lista de compatibilidad de MySQL y los requisitos de capacidad. | Administrador de base de datos, administrador de sistemas | | Identifique los requisitos de almacenamiento. | Determine el tipo de almacenamiento y la capacidad para la base de datos de destino. | Administrador de base de datos, administrador de sistemas | | Identifique requisitos de red. | Determine los requisitos de la red, como la latencia y el ancho de banda. | Administrador de base de datos, administrador de sistemas | | Elija el tipo de instancia de destino. | Elija el [tipo de instancia de destino](https://aws.amazon.com/rds/instance-types/) en función de la capacidad, las características de almacenamiento y las características de red. | Administrador de base de datos, administrador de sistemas | | Identifique los requisitos de seguridad. | Determine los requisitos de seguridad para acceder a la red o al host de las bases de datos de origen y destino. | Administrador de base de datos, administrador de sistemas | | Identifique los usuarios. | Determine la lista de los usuarios del sistema operativo para la instalación del software de MySQL. Para obtener más información, consulte la [documentación de MySQL](https://dev.mysql.com/doc/mysql-security-excerpt/en/access-control.html). | Administrador de base de datos, administrador de sistemas | | Determine una estrategia de copia de seguridad. | | Administrador de base de datos | | Determine los requisitos de disponibilidad. | | Administrador de base de datos | | Identifique la estrategia de migración o transición de aplicaciones. | | Administrador de base de datos, administrador de sistemas | ### Configuración de la infraestructura | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una nube privada virtual (VPC) y subredes. | Configure las tablas de enrutamiento, las puertas de enlace de Internet, las puertas de enlace NAT y las subredes. Para obtener más información, consulte [VPC configuration options](https://docs.aws.amazon.com/vpc/latest/userguide/create-vpc-options.html) en la documentación de Amazon VPC. | Administrador de sistemas | | Cree grupos de seguridad y listas de control de acceso a la red ()ACLs. | Configure los puertos (el valor predeterminado para MySQL es 3306) y rangos de CIDR o específicos IPs según sus requisitos. | Administrador de sistemas | | Configure e inicie una instancia EC2. | Para obtener instrucciones, consulte [Launch an EC2 instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/LaunchingAndUsingInstances.html) en la documentación de Amazon EC2. | Administrador de sistemas | ### Instalar el software MySQL | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree usuarios y grupos. | Cree los usuarios y grupos del sistema operativo que necesitan acceder al servidor y a la base de datos. Para obtener más información, consulte [Control de acceso y administración de cuentas](https://dev.mysql.com/doc/refman/en/access-control.html) en la documentación de MySQL. | Administrador de base de datos, administrador de sistemas | | Descargue MySQL. | Descargue el software de MySQL. Para obtener instrucciones y archivos binarios, consulte [Installing MySQL](https://dev.mysql.com/doc/refman/en/installing.html) en la documentación de MySQL. | Administrador de base de datos, administrador de sistemas | | Instale MySQL en la instancia de EC2 y configure el servidor. | Conéctese a la instancia de EC2 e instale el software de MySQL. Para obtener más información, consulte [Connect to your EC2 instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect.html) en la documentación de Amazon EC2. | Administrador de base de datos, administrador de sistemas | ### Migración de datos: opción 1 | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Migre los datos con herramientas de terceros o de MySQL nativas. | Esta opción utiliza herramientas de MySQL nativas o herramientas de terceros para migrar los objetos y datos de la base de datos. Para obtener instrucciones, consulte la documentación de [mysqldump](https://dev.mysql.com/doc/refman/en/mysqldump.html) o [ XtraBackupPercona](https://docs.percona.com/percona-xtrabackup/2.4/index.html) (para la migración física). Para obtener más información sobre el uso de estas herramientas, consulte la entrada del AWS blog [Opciones de migración de MySQL a Amazon RDS for MySQL o Amazon Aurora MySQL](https://aws.amazon.com/blogs/database/migration-options-for-mysql-to-amazon-rds-for-mysql-or-amazon-aurora-mysql/). | Administrador de base de datos | ### Migración de datos: opción 2 | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Migre datos con AWS DMS. | Para obtener más información, consulte la [vista de alto nivel de AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.HighLevelView.html) en la AWS DMS documentación. | Administrador de base de datos | ### Preparación para la transición | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Reúna recuentos de objetos. | Reúna los recuentos de objetos de la base de datos de origen y de las nuevas bases de datos de destino. Corrija cualquier discrepancia en la base de datos de destino. | Administrador de base de datos | | Compruebe las dependencias. | Confirme que las dependencias (los enlaces) con destino y origen en otras bases de datos sigan siendo válidas y funcionen correctamente. | Administrador de base de datos | | Pruébelo. | Si se trata de un ciclo de pruebas, lleve a cabo pruebas de consulta, recopile métricas y solucione cualquier problema. | Administrador de base de datos | ### Realizar la transición | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Traslade los clientes. | Cambie los clientes de la aplicación a la nueva infraestructura. | Administrador de base de datos, propietario de la aplicación, administrador de sistemas | | Proporcione soporte. | Proporcione soporte durante las pruebas de aplicaciones funcionales. | Administrador de base de datos | ### Cerrar el proyecto | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cierre los recursos. | Cierre la instancia de AWS DMS replicación y otros AWS recursos temporales. | Administrador de base de datos, administrador de sistemas | | Revise los documentos del proyecto. | Revise y valide los documentos del proyecto. | Administrador de base de datos, propietario de la aplicación, administrador de sistemas | | Recopile métricas. | Recopile métricas como el tiempo para la migración, el porcentaje de cambios manuales en comparación con los cambios asistidos por herramientas y el ahorro de costos. | Administrador de base de datos, propietario de la aplicación, administrador de sistemas | | Cierre el proyecto. | Cierre el proyecto de migración y envíe sus comentarios. | Administrador de base de datos, propietario de la aplicación, administrador de sistemas | | Reitre del servicio la base de datos de origen. | Retire del servicio la base de datos MySQL en las instalaciones. | Administrador de base de datos, administrador de sistemas | ## Recursos relacionados **Referencias** + [Documentación de Amazon EC2](https://docs.aws.amazon.com/ec2/) + [AWS DMS documentación](https://docs.aws.amazon.com/dms/) + [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/) + [AWS DMS Step-by-Step Tutoriales](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) **Tutoriales y videos** + [Empezando con 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) (video) # Supervisar Amazon Aurora en busca de instancias sin cifrado *Mansi Suratwala, Amazon Web Services* ## Resumen Este patrón proporciona una CloudFormation plantilla de Amazon Web Services (AWS) que puede implementar para configurar notificaciones automáticas cuando se crea una instancia de Amazon Aurora sin el cifrado activado. Aurora es un motor de base de datos relacional completamente administrado compatible con MySQL y PostgreSQL. Con algunas cargas de trabajo, Aurora puede proporcionar hasta cinco veces el rendimiento de MySQL y hasta tres veces el rendimiento de PostgreSQL sin requerir cambios en la mayoría de las aplicaciones existentes. La CloudFormation plantilla crea un evento de Amazon CloudWatch Events y una función de AWS Lambda. El evento usa AWS CloudTrail para monitorear la creación de cualquier instancia de Aurora o la restauración puntual de una instancia existente. El evento de los Eventos de Cloudwatch inicia la función de Lambda, que comprueba si el cifrado está habilitado. Si el cifrado no está activado, la función de Lambda envía una notificación de Amazon Simple Notification Service (Amazon SNS) informándolo de la infracción. ## Requisitos previos y limitaciones **Requisitos previos**** ** + Una cuenta de AWS activa **Limitaciones** + Este control de servicio solo funciona con las instancias de Amazon Aurora. No admite otras instancias de Amazon Relational Database Service (Amazon RDS). + La CloudFormation plantilla debe implementarse únicamente para `CreateDBInstance`**** y `RestoreDBClusterToPointInTim` **e**. **Versiones de producto** + Versiones de PostgreSQL compatibles con Amazon Aurora + Versiones de MySQL compatibles con Amazon Aurora ## Arquitectura **Pila de tecnología de destino** + Amazon Aurora + AWS CloudTrail + Amazon CloudWatch + AWS Lambda + Amazon Simple Storage Service (Amazon S3) + Amazon SNS **Arquitectura de destino** ![\[Aurora se lanza sin invocar CloudWatch eventos CloudTrail, Lambda ni un mensaje de SNS mediante cifrado.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/de1528b8-a5a4-4c66-8ab3-7d9863572cbc/images/7dcab41a-d805-4bb0-99d1-1dcef37c4e55.png) **Automatización y escala** Puede usar la CloudFormation plantilla varias veces para diferentes regiones y cuentas. Debe ejecutarla solo una vez en cada región o cuenta. ## Tools (Herramientas) **Herramientas** + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html): Amazon Aurora es un motor de base de datos relacional completamente administrado compatible con MySQL y PostgreSQL. + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html): AWS le CloudTrail ayuda a gestionar la gobernanza, el cumplimiento y la auditoría operativa y de riesgos de su cuenta de AWS. Las acciones realizadas por un usuario, un rol o un servicio de AWS se registran como eventos en CloudTrail. + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html): Amazon CloudWatch Events ofrece una near-real-time secuencia de eventos del sistema que describen los cambios en los recursos de AWS. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html): AWS Lambda es un servicio de computación que permite ejecutar código sin aprovisionar ni administrar servidores. Lambda ejecuta su código solo cuando es necesario y escala de manera automática, desde unas pocas solicitudes por día hasta miles por segundo. + [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/gsg/GetStartedWithS3.html): Amazon Simple Storage Service (Amazon S3) es un servicio de almacenamiento de objetos altamente escalable que se puede utilizar para una amplia gama de soluciones de almacenamiento, incluyendo sitios web, aplicaciones móviles, copias de seguridad y lagos de datos. + [Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) – Amazon Simple Notification Service (Amazon SNS) es un servicio gestionado que proporciona la entrega de mensajes mediante Lambda, HTTP, correo electrónico, notificaciones push móviles y mensajes de texto móviles (SMS). **Código** El archivo .zip del proyecto está disponible como adjunto. ## Epics ### Cree el bucket de S3 para el script de Lambda | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Defina el bucket de S3. | Abra la consola de Amazon S3 y elija o cree un bucket de S3. Este bucket de S3 alojará el archivo .zip de código de Lambda. Su bucket de S3 debe estar en la misma región que Aurora. El nombre del bucket de S3 no puede incluir barras diagonales iniciales. | Arquitecto de la nube | ### Cómo cargar el código de Lambda en el bucket de S3 | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cargue el código de Lambda. | Cargue el archivo .zip de código de Lambda que se proporciona en la sección *Adjuntos* en el bucket de S3 que haya definido. | Arquitecto de la nube | ### Implemente la CloudFormation plantilla | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Implemente la CloudFormation plantilla. | En la CloudFormation consola, implementa la `RDS_Aurora_Encryption_At_Rest.yml` CloudFormation plantilla que se proporciona como adjunto a este patrón. En la siguiente Epic, proporcione los valores de los parámetros. | Arquitecto de la nube | ### Complete los parámetros de la CloudFormation plantilla | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Proporcione el nombre del bucket de S3. | Escriba el nombre de bucket de S3 que ha creado o elegido en la primera Epic. | Arquitecto de la nube | | Proporcione la clave de S3. | Proporcione la ubicación del archivo .zip del código de Lambda en su bucket de S3 sin barras diagonales iniciales (por ejemplo, `
(sidadm $> python systemReplicationStatus.py
sudo yum install -y awslogs| AWS general | | Edite los archivos de configuración del agente. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | AWS general | | Inicie el CloudWatch agente. | Para iniciar el agente, utilice el comando siguiente.
$ sudo service awslogsd startTras iniciar el agente, podrá ver el grupo de registros en la CloudWatch consola. El flujo de registro incluirá el contenido del archivo. | AWS general | ### Paso 6. Crear filtros de métricas en el grupo de registros | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree filtros de métricas para las palabras clave ABEND y STOPPED. | Al crear filtros de métricas para el grupo de registros, cada vez que los filtros se identifican en el registro de errores, se activa una alarma y se envía una notificación por correo electrónico basada en la configuración de Amazon SNS.Para crear un filtro de métricas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | CloudWatch | ### Paso 7. Configurar Amazon SNS | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree un tema de SNS. | En este paso, configurará Amazon SNS para crear alarmas para los filtros de métricas.Para crear un tema de SNS:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | Amazon SNS | | Cree una suscripción. | Para crear una suscripción al tema:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html)En Amazon SNS, se abre su navegador web y se muestra una confirmación de suscripción con su ID de suscripción. | Amazon SNS | ### Paso 8. Crear una alarma para enviar notificaciones a los filtros de métricas | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una alarma para el tema de SNS. | Para crear una alarma basada en un filtro de métricas del grupo de registros:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html)Tras estos pasos, cada vez que se detecten estos patrones en el archivo de registro de GoldenGate errores (`ggserr.log`) que está supervisando, recibirá una notificación por correo electrónico. | CloudWatch | ## Resolución de problemas | Problema | Solución | | --- | --- | | El flujo de registro del registro de GoldenGate errores no fluye hacia él CloudWatch. | Compruebe el `/etc/awslogs/awslogs.conf` archivo para comprobar el nombre del archivo, el nombre del grupo de registros y el date/time formato. Debe especificar el formato de fecha date/time para que coincida con el formato de fecha`ggserror.log`. De lo contrario, el flujo de registro no fluirá hacia CloudWatch. | ## Recursos relacionados + [ CloudWatch Documentación de Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) + [Recopilación de métricas y registros con el CloudWatch agente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) + [Documentación de Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) # Redefina la plataforma de Oracle Database Enterprise Edition a Standard Edition 2 en Amazon RDS para Oracle *Lanre (Lan-Ray) showunmi y Tarun Chawla, Amazon Web Services* ## Resumen Oracle Database Enterprise Edition (EE) es una opción popular para ejecutar aplicaciones en muchas empresas. Sin embargo, en algunos casos, las aplicaciones utilizan pocas o ninguna de las características de Oracle Database EE, por lo que no está justificado incurrir en enormes costos de licencia. Puede ahorrar costes al degradar dichas bases de datos a Oracle Database Standard Edition 2 (SE2) al migrar a Amazon RDS. Este patrón describe cómo pasar de Oracle Database EE a Oracle Database SE2 al migrar de una base de datos local a [Amazon RDS for](https://aws.amazon.com/rds/oracle/) Oracle. Los pasos que se presentan en este patrón también se aplican si la base de datos EE Oracle ya se está ejecutando en Amazon RDS o en una instancia de [Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) (Amazon EC2). Para obtener más información, consulte la guía Recomendaciones de AWS sobre cómo [evaluar el cambio de versión de las bases de datos de Oracle a la edición estándar 2 en AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/welcome.html). ## Requisitos previos y limitaciones **Requisitos previos ** + Una cuenta de AWS activa + Oracle Database Enterprise Edition + Una herramienta de cliente, como [Oracle SQL Developer](https://www.oracle.com/database/sqldeveloper/) o SQL\$1Plus, para conectarse a oo ejecutar comandos SQL en la base de datos de Oracle + Usuario de base de datos para realizar la evaluación; por ejemplo, uno de los siguientes: + Usuario con [privilegios](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Source.Oracle.html#CHAP_Source.Oracle.Permissions) suficientes para ejecutar la evaluación de la [Herramienta de conversión de esquemas de AWS (AWS SCT)](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html) + Usuario con privilegios suficientes para ejecutar consultas SQL en las tablas del diccionario de bases de datos de Oracle + Usuario de base de datos para realizar la migración de base de datos; por ejemplo, uno de los siguientes: + Usuario con [privilegios](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html#CHAP_Source.Oracle.Self-Managed) suficientes para ejecutar [AWS Database Migration Service (AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)) + Usuario con [privilegios suficientes para realizar la exportación e importación de Oracle Data Pump](https://docs.oracle.com/database/121/SUTIL/GUID-8B6975D3-3BEC-4584-B416-280125EEC57E.htm#SUTIL807) + Usuario con [privilegios suficientes para ejecutar Oracle GoldenGate](https://docs.oracle.com/goldengate/1212/gg-winux/GIORA/user_assignment.htm#GIORA546) **Limitaciones** + Amazon RDS para Oracle tiene un tamaño máximo de la base de datos. Para obtener más información, consulte [Almacenamiento de instancias de base de datos de Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Storage.html). **Versiones de producto** La lógica general descrita en este documento se aplica a las versiones de Oracle de la versión 9i y posteriores. Para ver las versiones compatibles de las bases de datos autogestionadas y de Amazon RDS para Oracle, consulte la [documentación de AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html). Para identificar el uso de características en los casos en que no se admite AWS SCT, ejecute consultas SQL en la base de datos de origen. Para migrar desde versiones anteriores de Oracle en las que no se admiten AWS DMS y Oracle Data Pump, utilice las [utilidades de exportación e importación de Oracle](https://docs.oracle.com/cd/B19306_01/server.102/b14215/exp_imp.htm). Para obtener una lista actualizada de las versiones y ediciones compatibles, consulte [Oracle en Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) en la documentación de AWS. Para obtener más información sobre los precios y las clases de instancias compatibles, consulte [Precios de Amazon RDS para Oracle](https://aws.amazon.com/rds/oracle/pricing/). ## Arquitectura **Pila de tecnología de origen** + Oracle Database Enterprise Edition que se ejecuta en las instalaciones o en Amazon EC2 **Pila de tecnología de destino con herramientas nativas de Oracle** + Amazon RDS para Oracle con Oracle Database SE2 ![\[Proceso de tres pasos para migrar de una base de datos de Oracle en las instalaciones a Amazon RDS.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/a1b28050-9bab-4de6-b2a9-b97b3e5070bd/images/bf765c5b-4b12-4a8c-b27c-c5e0bd605dd1.png) 1. Exporte datos mediante Oracle Data Pump. 1. Copie los archivos de volcado a Amazon RDS a través de un enlace a una base de datos. 1. Importe los archivos de volcado a Amazon RDS mediante Oracle Data Pump. **Pila de tecnología de destino con AWS DMS** + Amazon RDS para Oracle con Oracle Database SE2 + AWS DMS ![\[Proceso de cuatro pasos para migrar de una base de datos de Oracle en las instalaciones a Amazon RDS mediante AWS DMS.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/a1b28050-9bab-4de6-b2a9-b97b3e5070bd/images/fef4eced-1acb-4303-baaa-5c1c29650935.png) 1. Exporte datos mediante Oracle Data Pump con FLASHBACK\$1SCN. 1. Copie los archivos de volcado a Amazon RDS a través de un enlace a una base de datos. 1. Importe los archivos de volcado a Amazon RDS mediante Oracle Data Pump. 1. Utilice la [captura de datos de cambio de AWS DMS (CDC)](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Task.CDC.html). ## Tools (Herramientas) **Servicios de AWS** + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) le permite migrar los almacenes de datos a la nube de AWS o entre combinaciones de configuraciones en la nube y en las instalaciones. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) le ayuda a configurar, utilizar y escalar una base de datos relacional en la nube de AWS. Este patrón utiliza Amazon RDS para Oracle. + [AWS SCT](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html)** **ofrece una interfaz de usuario basada en proyectos para evaluar, convertir y copiar automáticamente el esquema de base de datos de su base de datos de Oracle de origen a un formato compatible con Amazon RDS para Oracle. AWS SCT le permite analizar los posibles ahorros de costos que se pueden lograr al cambiar el tipo de licencia de Enterprise Edition a Standard Edition de Oracle. La sección **Evaluación de licencias y soporte en la nube** del informe SCT de AWS proporciona información detallada sobre las características de Oracle en uso para que pueda tomar una decisión informada al migrar a Amazon RDS para Oracle. **Otras herramientas** + Las utilidades de importación y exportación nativas de Oracle admiten mover datos de Oracle dentro y fuera de las bases de datos de Oracle. Oracle ofrece dos tipos de utilidades de importación y exportación de bases de datos: [Oracle Export and Import](https://docs.oracle.com/cd/B19306_01/server.102/b14215/exp_imp.htm) (para versiones anteriores) y [Oracle Data Pump Export and Import](https://docs.oracle.com/cd/B19306_01/server.102/b14215/part_dp.htm#CEGJCCHC) (disponible en Oracle Database 10g y versiones posteriores). + [Oracle GoldenGate](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.OracleGoldenGate.html) ofrece capacidades de replicación en tiempo real para que pueda sincronizar la base de datos de destino después de una carga inicial. Esta opción puede ayudar a reducir el tiempo de inactividad de las aplicaciones durante la puesta en marcha. ## Epics ### Realice una evaluación previa a la migración | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Valide los requisitos de la base de datos para sus aplicaciones. | Asegúrese de que sus aplicaciones estén certificadas para ejecutarse en Oracle SE2 Database. Consulte directamente con el proveedor del software, el desarrollador o la documentación de la aplicación. | Desarrollador de aplicaciones, administrador de bases de datos, propietario de la aplicación | | Investigue el uso de las características de EE directamente en la base de datos. | Para determinar el uso de la característica EE, lleve a cabo alguna de las siguientes operaciones:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.html) | Propietario de la aplicación, administrador de base de datos, desarrollador de la aplicación | | Identifique el uso de las características de EE para las actividades operativas. | Los administradores de bases de datos o aplicaciones a veces utilizan características exclusivas de EE para sus actividades operativas. Algunos ejemplos comunes incluyen las actividades de mantenimiento en línea (reconstrucción de índices, movimiento de tablas) y el uso del paralelismo en los trabajos por lotes.Estas dependencias se pueden mitigar modificando las operaciones siempre que sea posible. Identifique el uso de estas características y tome una decisión basada en el costo en comparación con los beneficios.Utilice la tabla de [comparación de Oracle Database EE y sus SE2 características](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/compare-features.html) como guía para identificar las funciones que están disponibles en Oracle Database SE2. | Desarrollador de aplicaciones, administrador de bases de datos, propietario de la aplicación | | Revise los patrones de carga de trabajo de la base de datos EE Oracle. | Oracle Database restringe SE2 automáticamente el uso a un máximo de 16 subprocesos de CPU en cualquier momento.Si su base de datos Oracle EE tiene licencia para utilizar el paquete de diagnóstico de Oracle, utilice la herramienta Automatic Workload Repository (AWR), o las vistas DBA\$1HIST\$1\$1, para analizar los patrones de carga de trabajo de la base de datos y determinar si el límite máximo de 16 subprocesos de la CPU afectará negativamente a los niveles de servicio cuando pase a una versión inferior a. SE2Asegúrese de que su evaluación cubra los períodos de máxima actividad, como el procesamiento al final del día, del mes o del año. | Propietario de la aplicación, administrador de base de datos, desarrollador de la aplicación | ### Prepare la infraestructura de destino en AWS | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Implemente y configure la infraestructura de redes. | Cree una [nube privada virtual (VPC) y subredes](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html), [grupos de seguridad](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) y [listas de control de acceso a la red](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html). | Administrador de AWS, arquitecto de nube, administrador de redes, DevOps ingeniero | | Aprovisione la base de datos Amazon RDS for SE2 Oracle. | Aprovisione la base de datos [Amazon RDS for](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.Oracle.html) SE2 Oracle de destino para cumplir con los requisitos de rendimiento, disponibilidad y seguridad de sus aplicaciones. Recomendamos zonas de disponibilidad múltiples para las cargas de trabajo de producción. Sin embargo, para mejorar el rendimiento de la migración, puede aplazar la [activación de zonas de disponibilidad múltiples](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/create-multi-az-db-cluster.html) hasta después de la migración de datos. | Administrador de nube, arquitecto de nube, DBA, DevOps ingeniero, administrador de AWS | | Personalice el entorno de Amazon RDS. | Configure [parámetros](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) y [opciones](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithOptionGroups.html) personalizados y habilite una [supervisión](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/MonitoringOverview.html) adicional. Para obtener más información, consulte [Prácticas recomendadas para migrar a Amazon RDS para Oracle](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html). | Administrador de AWS, administrador de sistemas de AWS, administrador de la nube, administrador de bases de datos, arquitecto de la nube | ### Realice la migración, el simulacro y las pruebas de la aplicación | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Migre los datos (simulacro). | Migre los datos de la base de datos Oracle EE de origen a la instancia de base de datos Amazon RDS for SE2 Oracle utilizando el enfoque que mejor se adapte a su entorno específico. Seleccione una estrategia de migración en función de factores como el tamaño, la complejidad y el período de inactividad disponible. Use una de las siguientes o una combinación de ellas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.html) | Administrador de base de datos | | Validar la base de datos objetivo. | Realice una validación posterior a la migración del almacenamiento de la base de datos y de los objetos de código. Revise los registros de migración y solucione los problemas detectados. Para obtener más información, consulte la guía [Migración de bases de datos de Oracle a la nube de AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html#post-import). | Administrador de base de datos | | Pruebe las aplicaciones. | Los administradores de aplicaciones y bases de datos deben realizar pruebas funcionales, de rendimiento y operativas según corresponda. Para obtener más información, consulte [Prácticas recomendadas para migrar a Amazon RDS para Oracle](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html#test-migration).Por último, obtenga la aprobación de las partes interesadas sobre los resultados de las pruebas. | Desarrollador de aplicaciones, propietario de aplicaciones, ingeniero de migraciones, líder de migración | ### Realizar la transición | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Actualice los datos de Oracle Database EE. | Seleccione un enfoque de actualización de datos en función del requisito de disponibilidad de la aplicación. Para obtener más información, consulte los métodos de migración en [Estrategias de migración de bases de datos de Oracle a AWS](https://docs.aws.amazon.com/whitepapers/latest/strategies-migrating-oracle-db-to-aws/data-migration-methods.html).Por ejemplo, puede lograr un tiempo de inactividad prácticamente nulo mediante el uso de herramientas como Oracle GoldenGate o AWS DMS con replicación continua. Si el período de inactividad lo permite, puede realizar la transición final de los datos mediante métodos fuera de línea, como Oracle Data Pump o las utilidades Original Export-Import. | Propietario de aplicaciones, jefe de transición, administrador de base de datos, ingeniero de migraciones, líder de migración | | Dirija las aplicaciones a la instancia de la base de datos de destino. | Actualice los parámetros de conexión en las aplicaciones y otros clientes para que apunten a la base de datos Amazon RDS for SE2 Oracle. | Desarrollador de aplicaciones, propietario de aplicaciones, ingeniero de migraciones, líder de migración, jefe de transición | | Realice actividades posteriores a la migración. | Realice tareas posteriores a la migración de datos, como habilitar las zonas de disponibilidad múltiples, la validación de datos y otras comprobaciones. | Administrador de base de datos, ingeniero de migraciones | | Realice una supervisión posterior a la transición. | Utilice herramientas como [Amazon CloudWatch y Amazon](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/monitoring-cloudwatch.html) [RDS Performance Insights](https://aws.amazon.com/rds/performance-insights/) para supervisar la base de datos Amazon RDS for SE2 Oracle. | Desarrollador de aplicaciones, propietario de aplicaciones, administrador de AWS, administrador de bases de datos, ingeniero de migraciones | ## Recursos relacionados **Recomendaciones de AWS** + [Migración de bases de datos de Oracle a la nube de AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/welcome.html) (guía) + [Evalúe cambiar la versión de las bases de datos de Oracle a Standard Edition 2 en AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/welcome.html) (guía) + [Migración de una base de datos de Oracle en las instalaciones a 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) (patrón) + [Migración de una base de datos de Oracle en las instalaciones a Amazon RDS para Oracle mediante 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) (patrón) **Publicaciones de blog** + [Migración de bases de datos de Oracle con un tiempo de inactividad prácticamente nulo mediante AWS DMS](https://aws.amazon.com/blogs/database/migrating-oracle-databases-with-near-zero-downtime-using-aws-dms/) + [Análisis del manejo del rendimiento en Oracle SE mediante Amazon RDS para Oracle](https://aws.amazon.com/blogs/database/analyzing-performance-management-in-oracle-se-using-amazon-rds-for-oracle/) + [Administración de su plan SQL en Oracle SE con Amazon RDS para Oracle](https://aws.amazon.com/blogs/database/managing-your-sql-plan-in-oracle-se-with-amazon-rds-for-oracle/) + [Implementación del particionamiento de tablas en Oracle Standard Edition: primera parte](https://aws.amazon.com/blogs/database/implementing-table-partitioning-in-oracle-standard-edition-part-1/) # Replicar bases de datos de unidades centrales en AWS mediante Precisely Connect *Lucio Pereira, Sayantan Giri y Balaji Mohan, Amazon Web Services* ## Resumen Este patrón describe los pasos para replicar datos de bases de datos de unidades centrales a los almacenes de datos de Amazon casi en tiempo real mediante Precisely Connect. El patrón implementa una arquitectura basada en eventos con Amazon Managed Streaming para Apache Kafka (Amazon MSK) y conectores de bases de datos personalizados en la nube para mejorar la escalabilidad, la resiliencia y el rendimiento. Precisely Connect es una herramienta de replicación que captura datos de sistemas de unidades centrales heredados y los integra en entornos en la nube. Los datos se replican desde las unidades centrales a AWS mediante la captura de datos de cambios (CDC) mediante flujos de mensajes prácticamente en tiempo real con canalizaciones de datos heterogéneas de baja latencia y alto rendimiento. Este patrón también abarca una estrategia de recuperación de desastres para canalizaciones de datos resilientes con replicación de datos multirregional y enrutamiento de conmutación por error. ## Requisitos previos y limitaciones **Requisitos previos ** + Una base de datos de mainframe existente, por ejemplo, IBM DB2, IBM Information Management System (IMS) o Virtual Storage Access Method (VSAM), que desee replicar en la nube de AWS + Una [cuenta de AWS](https://aws.amazon.com/account/) activa + [AWS Direct Connect](https://aws.amazon.com/directconnect/) o [red privada virtual de AWS (AWS VPN](https://aws.amazon.com/vpn/)) desde su entorno corporativo a AWS + Una [nube privada virtual](https://aws.amazon.com/vpc/) con una subred a la que pueda acceder su plataforma antigua ## Arquitectura **Pila de tecnología de origen** Un entorno de unidad central que incluya al menos una de las siguientes bases de datos: + Base de datos IBM IMS + DB2 Base de datos de IBM + Archivos VSAM **Pila de tecnología de destino** + Amazon MSK + Amazon Elastic Kubernetes Service (Amazon EKS) y Amazon EKS Anywhere + Docker + Una base de datos relacional o NoSQL de AWS como la siguiente: + Amazon DynamoDB + Amazon Relational Database Service (Amazon RDS) para Oracle, Amazon RDS para PostgreSQL o Amazon Aurora + Amazon ElastiCache para Redis + Amazon Keyspaces (para Apache Cassandra) **Arquitectura de destino** *Replicación de datos de unidad central en bases de datos de AWS* El siguiente diagrama ilustra la replicación de datos de mainframe en una base de datos de AWS, como DynamoDB, Amazon RDS, Amazon o Amazon Keyspaces ElastiCache. La replicación se produce prácticamente en tiempo real mediante el uso de Precisely Capture y Publisher en su entorno de unidad central en las instalaciones, Precisely Dispatcher en Amazon EKS Anywhere en su entorno distribuido en las instalaciones y Precisely Apply Engine y los conectores de base de datos en la nube de AWS. ![\[Replicación de datos de unidad central en bases de datos de AWS\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/777dd7da-48ed-4510-b8fa-9041be042671.png) En el diagrama, se muestra el siguiente flujo de trabajo: 1. Precisely Capture obtiene los datos de unidad central de los registros CDC y los mantiene en un almacenamiento transitorio interno. 1. Precily Publisher escucha los cambios en el almacenamiento interno de datos y envía los registros CDC a Precily Dispatcher a través de una conexión. TCP/IP 1. Precisely Dispatcher recibe los registros de los CDC de Publisher y los envía a Amazon MSK. Dispatcher crea claves de Kafka en función de la configuración del usuario y de varias tareas de trabajo para enviar los datos en paralelo. Dispatcher envía un acuse de recibo a Publisher cuando los registros se han almacenado en Amazon MSK. 1. Amazon MSK guarda los registros de los CDC en el entorno de nube. El tamaño de las particiones de los temas depende de los requisitos de rendimiento del sistema de procesamiento de transacciones (TPS). La clave de Kafka es obligatoria para seguir ordenando transformaciones y transacciones. 1. Precisely Apply Engine escucha los registros de CDC de Amazon MSK y transforma los datos (por ejemplo, filtrándolos o mapeándolos) en función de los requisitos de la base de datos de destino. Puede añadir una lógica personalizada a los scripts de Precisely SQD. (SQD es el lenguaje propiedad de Precisely). Precisely Apply Engine transforma cada registro de CDC al formato Apache Avro o JSON y lo distribuye a diferentes temas según sus necesidades. 1. Los temas de Kafka de destino contienen los registros CDC en varios temas según la base de datos de destino, y Kafka facilita la ordenación de las transacciones en función de la clave de Kafka definida. Las claves de partición se alinean con las particiones correspondientes para permitir un proceso secuencial. 1. Los conectores de bases de datos (aplicaciones Java personalizadas) escuchan los registros CDC de Amazon MSK y los almacenan en la base de datos de destino. 1. Puede seleccionar una base de datos de destino en función de sus requisitos. Este patrón es compatible con bases de datos NoSQL y relacionales. *Recuperación de desastres* La continuidad empresarial es clave para el éxito de su organización. La nube de AWS proporciona capacidades de alta disponibilidad (HA) y recuperación de desastres (DR), y respalda los planes de conmutación por error y alternativos de su organización. Este patrón sigue una estrategia de active/passive DR y proporciona una guía de alto nivel para implementar una estrategia de DR que cumpla con sus requisitos de RTO y RPO. En el siguiente diagrama, se ilustra el flujo de trabajo de DR. ![\[Flujo de trabajo de recuperación de desastres para replicar datos de unidad central en AWS\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/9cccba7a-7a25-411e-829f-7cd5a7a20ab4.png) En el diagrama se muestra lo siguiente: 1. Se requiere una conmutación por error semiautomática si se produce algún error en la Región de AWS 1. En caso de que se produzca un error en la Región 1, el sistema debe iniciar los cambios de enrutamiento para conectar a Precisely Dispatcher con la Región 2. 1. Amazon MSK replica los datos mediante la duplicación entre regiones. Por este motivo, durante la conmutación por error, hay que promover al clúster de Amazon MSK de la región 2 como líder principal. 1. Precisely Apply Engine y los conectores de bases de datos son aplicaciones sin estado que pueden funcionar en cualquier región. 1. La sincronización de la base de datos depende de la base de datos de destino. Por ejemplo, DynamoDB puede usar tablas globales ElastiCache y almacenes de datos globales. *Procesamiento de baja latencia y alto rendimiento mediante conectores de bases de datos* Los conectores de bases de datos son componentes fundamentales en este patrón. Los conectores siguen un enfoque basado en el oyente para recopilar datos de Amazon MSK y enviar las transacciones a la base de datos mediante un procesamiento de alto rendimiento y baja latencia para aplicaciones de misión crítica (niveles 0 y 1). En el siguiente diagrama se ilustra este proceso. ![\[Uso de conectores de bases de datos para replicar datos de unidad central en AWS\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/79479634-becb-4212-bbfc-1a3b17ae1bed.png) Este patrón permite desarrollar una aplicación personalizada con un consumo de un solo subproceso mediante un motor de procesamiento de subprocesos múltiples. 1. El proceso principal del conector consume los registros CDC de Amazon MSK y los envía al grupo de subprocesos para su procesamiento. 1. Los subprocesos del grupo de subprocesos procesan los registros de los CDC y los envían a la base de datos de destino. 1. Si todos los subprocesos están ocupados, la cola de subprocesos mantiene en espera los registros de la CDC. 1. El subproceso principal espera a que se borren todos los registros de la cola de subprocesos y envía las compensaciones a Amazon MSK. 1. Los subprocesos secundarios gestionan los errores. Si se producen errores durante el procesamiento, los mensajes fallidos se envían al tema DLQ (cola de mensajes fallidos). 1. Los subprocesos secundarios inician actualizaciones condicionales (consulte [Expresiones de condición](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html) en la documentación de DynamoDB), en función de la marca de tiempo del mainframe, para evitar cualquier duplicación o actualización en la base de datos. out-of-order Para obtener información sobre cómo implementar una aplicación de consumidor de Kafka con capacidades de subprocesos múltiples, consulte la entrada del blog [Consumo de mensajes multiprocesos con el consumidor de Apache Akfka](https://www.confluent.io/blog/kafka-consumer-multi-threaded-messaging/) en el sitio web de Confluent. ## Tools (Herramientas) **Servicios de AWS** + [Amazon Managed Streaming para Apache Kafka (Amazon MSK)](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html) es un servicio completamente administrado que le permite crear y ejecutar aplicaciones que utilizan Apache Kafka para procesar datos de streaming. + [Amazon Elastic Kubernetes Service (Amazon EKS)](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) le ayuda a ejecutar Kubernetes en AWS sin necesidad de instalar ni mantener su propio plano de control o nodos de Kubernetes. + [Amazon EKS Anywhere](https://anywhere.eks.amazonaws.com/docs/) le permite implementar, usar y administrar los clústeres de Kubernetes que se ejecutan en sus propios centros de datos. + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) es un servicio de base de datos de NoSQL completamente administrado que ofrece un rendimiento rápido, predecible y escalable. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) le ayuda a configurar, utilizar y escalar una base de datos relacional en la nube de AWS. + [Amazon](https://docs.aws.amazon.com/elasticache/) le ElastiCache ayuda a configurar, gestionar y escalar entornos de caché en memoria distribuidos en la nube de AWS. + [Amazon Keyspaces (para Apache Cassandra)](https://docs.aws.amazon.com/keyspaces/latest/devguide/what-is-keyspaces.html) es un servicio de base de datos administrada que le permite migrar, ejecutar y escalar sus cargas de trabajo de Cassandra en la nube de AWS. **Otras herramientas** + [Precisely Connect](https://www.precisely.com/product/precisely-connect/connect) integra los datos de los sistemas de unidad central heredados, como los conjuntos de datos de VSAM o las bases de datos de unidad central de IBM, en plataformas de datos y nube de próxima generación. ## Prácticas recomendadas + Encuentre la mejor combinación de particiones Kafka y conectores multiprocesos para lograr un equilibrio óptimo entre rendimiento y costo. Varias instancias de Precisely Capture y Dispatcher pueden aumentar el costo debido al mayor consumo de MIPS (millones de instrucciones por segundo). + Evite añadir lógica de manipulación y transformación de datos a los conectores de bases de datos. Para ello, utilice Precisely Apply Engine, que proporciona tiempos de procesamiento en microsegundos. + Cree solicitudes periódicas o llamadas de comprobación de estado a la base de datos (*latidos*) en los conectores de la base de datos para calentar la conexión con frecuencia y reducir la latencia. + Implemente una lógica de validación de grupos de subprocesos para comprender las tareas pendientes en la cola de subprocesos y espere a que se completen todos los subprocesos antes del siguiente sondeo de Kafka. Esto ayuda a evitar la pérdida de datos si un nodo, contenedor o proceso se bloquea. + Exponga las métricas de latencia a través de puntos de conexión de estado para mejorar las capacidades de observabilidad mediante paneles y mecanismos de rastreo. ## Epics ### Prepare el entorno de origen (en las instalaciones) | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Configure el proceso de la unidad central (por lotes o en línea) para iniciar el proceso de CDC desde las bases de datos de la unidad central. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Ingeniero de unidad central | | Active los flujos de registro de la base de datos de unidad central. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Especialista en bases de datos para unidad central | | Utilice el componente Capture para capturar los registros de los CDC. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Ingeniero de unidad central, Precisely Connect SME | | Configure el componente Publisher para que escuche al componente Capture. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Ingeniero de unidad central, Precisely Connect SME | | Aprovisione Amazon EKS Anywhere en el entorno distribuido en las instalaciones. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingeniero | | Implemente y configure el componente Dispatcher en el entorno distribuido para que publique los temas en la nube de AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingeniero, Precisely Connect SME | ### Prepare el entorno de destino (AWS) | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Aprovisione un clúster de Amazon EKS en la región de AWS designada. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingeniero, administrador de redes | | Aprovisione un clúster de MSK y configure los temas de Kafka aplicables. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingeniero, administrador de red | | Configure el componente Apply Engine para que escuche los temas de Kafka replicados. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Precisely Connect SME | | Aprovisione instancias de base de datos en la nube de AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Ingeniero de datos, DevOps ingeniero | | Configure e implemente conectores de bases de datos para que escuchen los temas publicados por Apply Engine. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Desarrollador de aplicaciones, arquitecto de la nube, ingeniero de datos | ### Configure la continuidad empresarial y la recuperación de desastres | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Defina los objetivos de recuperación de desastres para sus aplicaciones empresariales. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Arquitecto de la nube, ingeniero de datos, propietario de la aplicación | | Diseñe estrategias de recuperación de desastres basadas en un RTO/RPO definido. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Arquitecto de la nube, ingeniero de datos | | Aprovisione clústeres y configuraciones de recuperación de desastres. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingeniero, administrador de redes, arquitecto de nube | | Ponga a prueba la capacidad de recuperación de desastres de la canalización de CDC. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Propietario de aplicaciones, ingeniero de datos, arquitecto de la nube | ## Recursos relacionados **Recursos de AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) + [Expresiones de condición con 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 y Amazon Aurora](https://docs.aws.amazon.com/rds/index.html) + [Amazon VPC](https://docs.aws.amazon.com/vpc/index.html) **Recursos de Precisely Connect** + [Descripción general de Precisely Connect](https://www.precisely.com/product/precisely-connect/connect) + [Captura de datos de cambio con Precise Connect](https://help.precisely.com/r/Connect-CDC-SQData/4.1/en-US/Connect-CDC-SQData-Installation/Connect-CDC-SQData-Architecture) **Recursos Confluent** + [Consumo de mensajes multiproceso con Apache Kafka Consumer](https://www.confluent.io/blog/kafka-consumer-multi-threaded-messaging/) # Programe trabajos para Amazon RDS para PostgreSQL y Aurora PostgreSQL mediante Lambda y Secrets Manager *Yaser Raja, Amazon Web Services* ## Resumen En el caso de las bases de datos locales y las bases de datos alojadas en instancias de Amazon Elastic Compute Cloud (Amazon EC2), los administradores de bases de datos suelen utilizar la utilidad **cron** para programar los trabajos. Por ejemplo, un trabajo de extracción de datos o un trabajo de purga de datos se puede programar fácilmente mediante con **cron**. Para estos trabajos, las credenciales de la base de datos suelen tener una codificación rígida o estar almacenadas en un archivo de propiedades. Sin embargo, al migrar a Amazon Relational Database Service (Amazon RDS) o a Amazon Aurora PostgreSQL Compatible Edition, pierde la capacidad de iniciar sesión en la instancia host para programar trabajos **cron**. Este patrón describe cómo usar AWS Lambda y programar trabajos para bases de datos compatibles AWS Secrets Manager con Amazon RDS for PostgreSQL y Aurora PostgreSQL después de la migración. ## Requisitos previos y limitaciones **Requisitos previos ** + Un activo Cuenta de AWS + Una base de datos compatible con Amazon RDS para PostgreSQL o Aurora PostgreSQL **Limitaciones** + Un trabajo debe completarse en 15 minutos, que es el límite de tiempo de espera de la función de Lambda. Para ver otros límites, consulte la [documentación de AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/limits.html). + El código de trabajo debe escribirse en un [lenguaje compatible con Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). ## Arquitectura **Pila de tecnología de origen** Esta pila incluye tareas escritas en lenguajes como Bash, Python y Java. Las credenciales de la base de datos se almacenan en el archivo de propiedades y el trabajo se programa usando **cron** de Linux. **Pila de tecnología de destino** Esta pila tiene una función de Lambda que usa las credenciales almacenadas en Secrets Manager para conectarse a la base de datos y realizar la actividad. La función Lambda se inicia en el intervalo programado mediante Amazon CloudWatch Events. **Arquitectura de destino** ![\[CloudWatch evento que inicia una función Lambda que programa trabajos para la instancia de base de datos de RDS.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/8e0d1c90-0599-4909-a800-26a89b87f686/images/61f9ca34-9157-4565-96ba-5234d389ac2a.png) ## Tools (Herramientas) + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html) ofrece una transmisión casi en tiempo real de los eventos del sistema que describen los cambios en AWS los recursos. Con reglas sencillas que puede configurar rápidamente, puede hacer coincidir los eventos y dirigirlos a una o más funciones o transmisiones de destino. CloudWatch Los eventos se dan cuenta de los cambios operativos a medida que se producen. Responde a estos cambios operativos y toma medidas correctoras según sea necesario, enviando mensajes para responder al entorno, activando funciones, realizando cambios y captando información de estado. También puedes usar CloudWatch Events para programar acciones automatizadas que se inicien automáticamente en determinados momentos mediante expresiones **cron** o **rate**. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) es un servicio automático que permite ejecutar código sin aprovisionar ni administrar servidores. Lambda ejecuta su código solo cuando es necesario y escala de manera automática, desde unas pocas solicitudes por día hasta miles por segundo. Solo se paga el tiempo de computación que se consume; no hay ningún cargo mientras el código no se ejecuta. Con Lambda puede ejecutar código para prácticamente cualquier tipo de aplicación o servicio de backend, sin ningún esfuerzo de administración. Lambda ejecuta el código en una infraestructura informática de alta disponibilidad y realiza todas las tareas de administración de los recursos informáticos, incluidos el mantenimiento del servidor y del sistema operativo, el aprovisionamiento de capacidad y el escalado automático, así como la supervisión del código y las funciones de registro. Lo único que tiene que hacer es proporcionar el código en uno de los [lenguajes que admite 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) le permite proteger los secretos necesarios para acceder a sus aplicaciones, servicios y recursos de TI. Puede rotar, administrar y recuperar fácilmente credenciales de bases de datos, claves de API y otros datos confidenciales durante todo su ciclo de vida. Los usuarios y las aplicaciones recuperan los secretos llamando a Secrets Manager APIs, lo que elimina la necesidad de codificar información confidencial en texto plano. Secrets Manager ofrece una rotación de secretos con una integración incorporada para Amazon RDS, Amazon Redshift y Amazon DocumentDB. El servicio se puede extender a otros tipos de secretos, incluidas las claves y OAuth los tokens de API. Secrets Manager le permite controlar el acceso a los secretos mediante permisos detallados y auditar la rotación de secretos de forma centralizada para detectar los recursos en los Nube de AWS servicios de terceros y en las instalaciones. ## Epics ### Almacenar credenciales de base de datos en Secrets Manager | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Creación de un usuario de una base de datos para la función de Lambda. | Es una buena práctica utilizar usuarios de bases de datos independientes para las distintas partes de la aplicación. Si ya existe un usuario de base de datos independiente para sus trabajos cron, utilícelo. De lo contrario, cree un nuevo usuario de base de datos. Para obtener más información, consulte [Administración de usuarios y roles de PostgreSQL](https://aws.amazon.com/blogs/database/managing-postgresql-users-and-roles/)AWS (entrada del blog). | Administrador de base de datos | | Almacene las credenciales de las bases de datos como un secreto en Secrets Manager. | Siga las instrucciones de [Crear un secreto de base de datos](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_database_secret.html) (documentación de Secrets Manager). | DBA, DevOps | ### Autor del código para la función de Lambda | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Elija un lenguaje de programación compatible con Lambda. | Para obtener una lista de los lenguajes compatibles, consulte los [tiempos de ejecución de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html) (documentación de Lambda). | Desarrollador | | Escriba la lógica para obtener las credenciales de la base de datos de Secrets Manager. | Para ver un ejemplo de código, consulte [Cómo proporcionar de forma segura credenciales de bases de datos a funciones Lambda mediante AWS Secrets Manager](https://aws.amazon.com/blogs/security/how-to-securely-provide-database-credentials-to-lambda-functions-by-using-aws-secrets-manager/) (entrada del AWS blog). | Desarrollador | | Escriba la lógica para realizar la actividad programada de la base de datos. | Migre el código existente para el trabajo de programación que está utilizando en las instalaciones a la función de Lambda. Para más información, consulte [Implementación de funciones de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-deploy-functions.html) (documentación de Lambda). | Desarrollador | ### Implemente el código y cree la función de Lambda | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree el paquete de implementación de funciones de Lambda. | Este paquete contiene el código y sus dependencias. Para obtener más información, consulte [Paquetes de implementación](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) (documentación de Lambda). | Desarrollador | | Crear la función de Lambda. | En la consola de Lambda, elija **Crear función**, ingrese el nombre de una función, elija el entorno de tiempo de ejecución y, a continuación, elija **Crear función**. | DevOps | | Cargue el paquete de implementación. | Elija la función de Lambda que creó para abrir su configuración. Puede escribir el código directamente en la sección de códigos o cargar el paquete de implementación. Para cargar su paquete, vaya a la sección **Function code (Código de función)**, elija el **Code entry type (tipo de entrada de código)** para cargar un archivo .zip y, a continuación, seleccione el paquete. | DevOps | | Configure la función de Lambda según sus requisitos. | Por ejemplo, puede establecer el parámetro **Tiempo de espera** a la duración que espera que dure la función de Lambda. Para obtener más información, consulte [Configuración de las opciones de las funciones](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-common.html) (documentación de Lambda). | DevOps | | Establezca los permisos para que el rol de la función de Lambda acceda a Secrets Manager. | Para obtener instrucciones, consulte [Usar secretos en AWS Lambda las funciones](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets_lambda.html) (documentación de Secrets Manager). | DevOps | | Pruebe la función de Lambda. | Inicie la función de Lambda manualmente para asegurarse de que funciona según lo esperado. | DevOps | ### Programe la función Lambda mediante eventos CloudWatch | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree una regla para ejecutar su función de Lambda de manera programada. | Programe la función Lambda mediante CloudWatch Eventos. Para obtener instrucciones, consulte [Programar funciones de Lambda mediante CloudWatch eventos](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/RunLambdaSchedule.html) (tutorial sobre CloudWatch eventos). | DevOps | ## Recursos relacionados + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) + [Introducción a Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) + [Creación de una regla de CloudWatch eventos que se active en un evento](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-Rule.html) + [AWS Lambda Límites](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) + [Consulte su AWS base de datos desde su aplicación sin servidor](https://aws.amazon.com/blogs/database/query-your-aws-database-from-your-serverless-application/) (entrada de blog) # Envíe notificaciones para una instancia de base de datos de Amazon RDS para SQL Server mediante un servidor SMTP en las instalaciones y el Correo de base de datos *Nishad Mankar, Amazon Web Services* ## Resumen [Correo de base de datos](https://learn.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail?view=sql-server-ver16) (documentación de Microsoft) envía mensajes de correo electrónico, como notificaciones o alertas, desde una base de datos de Microsoft SQL Server mediante un servidor de Protocolo simple de transferencia de correo (SMTP). La documentación del Amazon Relational Database Service (Amazon RDS) para Microsoft SQL Server proporciona instrucciones para utilizar Amazon Simple Email Service (Amazon SES) como servidor SMTP para el Correo de base de datos. Para obtener más información, consulte [Uso de Database Mail en Amazon RDS for SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html). Como configuración alternativa, este patrón explica cómo configurar la base de datos para enviar correos electrónicos desde una instancia de base de datos (DB) de Amazon RDS para SQL Server mediante un servidor SMTP en las instalaciones como servidor de correo. ## Requisitos previos y limitaciones **Requisitos previos ** + Una cuenta de AWS activa + Una instancia de base de datos de Amazon RDS que ejecute una edición Standard o Enterprise de SQL Server + La dirección IP o el nombre de host del servidor SMTP local. + Una [regla de grupo de seguridad](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html#working-with-security-group-rules) entrante que permite las conexiones a la instancia de base de datos de Amazon RDS para SQL Server desde la dirección IP del servidor SMTP + Una conexión, como una conexión [AWS Direct Connect](https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html), entre la red en las instalaciones y la nube privada virtual (VPC) que contiene la instancia de base de datos de Amazon RDS **Limitaciones** + No se admiten las ediciones Express de SQL Server. + Para obtener más información sobre las limitaciones, consulte [Limitaciones](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html#SQLServer.Concepts.General.FeatureSupport.Limits) en *Uso del Correo de base de datos en Amazon RDS para SQL Server* en la documentación de Amazon RDS. **Versiones de producto** + RDS admite las versiones [Standard y Enterprise de SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html#SQLServer.Concepts.General.VersionSupport) ## Arquitectura **Pila de tecnología de destino** + Instancia de base de datos de Amazon RDS para SQL Server + Amazon Route 53 (Amazon Route 53) + Correo electrónico de base de datos + Host local del servidor SMTP + Microsoft SQL Server Management Studio (SSMS) **Arquitectura de destino** La siguiente imagen muestra la arquitectura de destino para este patrón. Cuando se produce un evento o una acción que inicia una notificación o alerta relativa a la instancia de base de datos, Amazon RDS para SQL Server utiliza el Correo de base de datos para enviar una notificación por correo electrónico. Correo de base de datos utiliza el servidor SMTP en las instalaciones para enviar el correo electrónico. ![\[Amazon RDS para SQL Server utiliza un servidor SMTP en las instalaciones para enviar notificaciones por correo electrónico a los usuarios.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/e5599724-43cf-4fe1-8c5a-8fca1a424993/images/47efb12f-3505-4a60-ac43-194a176e71c8.png) ## Tools (Herramientas) **Servicios de AWS** + Puede utilizar [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html) para configurar, utilizar y escalar una base de datos relacional de SQL Server en la nube de AWS. + [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) es un servicio web de sistema de nombres de dominio (DNS) escalable y de alta disponibilidad. **Otras herramientas** + [Correo de base de datos](https://learn.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail) es una herramienta que envía mensajes de correo electrónico, como notificaciones y alertas, desde el motor de base de datos de SQL Server a los usuarios. + [Microsoft SQL Server Management Studio (SSMS)](https://docs.microsoft.com/en-us/sql/ssms/sql-server-management-studio-ssms) es una herramienta para administrar SQL Server, que incluye el acceso, la configuración y la administración de los componentes de SQL Server. En este patrón, utiliza SSMS para ejecutar los comandos SQL para configurar Correo de base de datos en una instancia de base de datos de Amazon RDS para SQL Server. ## Epics ### Habilite la conectividad de red con el servidor SMTP en las instalaciones | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Elimine Multi-AZ de la instancia de base de datos de RDS. | Si utiliza una instancia de base de datos Multi-AZ, convierta la instancia Multi-AZ en una instancia Single-AZ. Cuando termine de configurar el Correo de base de datos, convertirá la instancia de base de datos de nuevo a una implementación Multi-AZ. La configuración de Database Mail funciona entonces tanto en el nodo primario como en el secundario. Para más información, consulte [Eliminación de Multi-AZ de una instancia de base de datos de Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerMultiAZ.html#USER_SQLServerMultiAZ.Removing). | Administrador de base de datos | | Cree una lista de direcciones IP o de punto de conexión de Amazon RDS en el servidor SMTP en las instalaciones. | El servidor SMTP está fuera de la red de AWS. En el servidor SMTP local, cree una lista de permisos que permita al servidor comunicarse con el punto de enlace saliente o la dirección IP de la instancia de Amazon RDS o la instancia de Amazon Elastic Compute Cloud (Amazon EC2) alojada en Amazon RDS. Este procedimiento varía de una organización a otra. Para obtener más información sobre el punto de conexión de la instancia de base de datos, consulte [Búsqueda del punto de conexión y el número de puerto de la instancia de base de datos](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html#sqlserver-endpoint). | Administrador de base de datos | | Elimine las restricciones del puerto 25. | De forma predeterminada, AWS restringe el puerto 25 en las EC2 instancias. Para eliminar la restricción del puerto 25, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/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/es_es/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 general | | Añada una regla de Route 53 para resolver las consultas de DNS para el servidor SMTP. | Utilice Route 53 para resolver las consultas de DNS entre los recursos de AWS y el servidor SMTP en las instalaciones. Debe crear una regla que reenvíe las consultas de DNS al dominio del servidor SMTP, por ejemplo `example.com`. Para obtener instrucciones, consulte [Creación de reglas de reenvío](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-rules-managing.html#resolver-rules-managing-creating-rules) en la documentación de Route 53. | Administrador de red | ### Configuración de Correo de base de datos en la instancia de base de datos de Amazon RDS para SQL Server | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Habilitación de Database Mail. | Cree un grupo de parámetros para el Correo de base de datos, defina el parámetro `database mail xps` en `1`, a continuación, asocie el grupo de parámetros del Correo de base de datos a la instancia de base de datos de RDS de destino. Para obtener instrucciones, consulte la [Habilitación de Database Mail](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html#SQLServer.DBMail.Enable) en la documentación de Amazon RDS. No continúe con la sección de *Configuración del correo de base de datos* de estas instrucciones. La configuración del servidor SMTP en las instalaciones es diferente a la de Amazon SES. | Administrador de base de datos | | Conéctese a la instancia de base de datos. | Desde un host bastión, utilice Microsoft SQL Server Management Studio (SSMS) para conectarse a la instancia de base de datos de Amazon RDS para SQL Server. Para obtener instrucciones, consulte [Conexión de una instancia de base de datos que ejecuta el motor de base de datos de Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html). Si encuentra algún error, consulte las referencias para la solución de problemas de conexión en la sección de [Recursos relacionados](#send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail-resources). | Administrador de base de datos | | Cree el perfil. | En SSMS, inserte la siguiente instrucción SQL para crear el perfil del Correo de base de datos. Reemplace los siguientes valores:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/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 obtener más información acerca de este procedimiento almacenado y sus argumentos, consulte [sysmail\$1add\$1profile\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profile-sp-transact-sql) en la documentación de Microsoft.
EXECUTE msdb.dbo.sysmail_add_profile_sp| Administrador de base de datos | | Añada las entidades principales al perfil. | Introduzca la siguiente instrucción SQL para añadir directores públicos o privados al perfil de correo de la base de datos. Una *entidad principal* es una entidad que puede solicitar recursos de SQL Server. Reemplace los siguientes valores:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/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 obtener más información acerca de este procedimiento almacenado y sus argumentos, consulte [sysmail\$1add\$1principalprofile\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-principalprofile-sp-transact-sql) en la documentación de Microsoft.
@profile_name = 'SQL Alerts profile',
@description = 'Profile used for sending outgoing notifications using OM SMTP Server.';
EXECUTE msdb.dbo.sysmail_add_principalprofile_sp| Administrador de base de datos | | Cree la cuenta. | Inserte la siguiente instrucción SQL para crear el perfil de la cuenta de Database Mail. Reemplace los siguientes valores:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/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 obtener más información acerca de este procedimiento almacenado y sus argumentos, consulte [sysmail\$1add\$1account\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-account-sp-transact-sql) en la documentación de Microsoft.
@profile_name = 'SQL Alerts profile',
@principal_name = 'public',
@is_default = 1 ;
EXECUTE msdb.dbo.sysmail_add_account_sp| Administrador de base de datos | | Agregue la cuenta al perfil | Inserte la siguiente instrucción SQL para agregar la cuenta de Database Mail al perfil de Database Mail. Reemplace los siguientes valores:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/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 obtener más información acerca de este procedimiento almacenado y sus argumentos, consulte [sysmail\$1add\$1profileaccount\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profileaccount-sp-transact-sql) en la documentación de 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| Administrador de base de datos | | (Opcional) Añada Multi-AZ a la instancia de base de datos de RDS. | Si desea agregar Multi-AZ con duplicación de bases de datos (DBM) o grupos de disponibilidad Always On (AGs), consulte las instrucciones de [Agregar Multi-AZ a una instancia de base de datos de Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerMultiAZ.html#USER_SQLServerMultiAZ.Adding). | Administrador de base de datos | ## Recursos relacionados + [Uso de Database Mail en Amazon RDS para SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html) (documentación de Amazon RDS) + [Trabajar con archivos adjuntos](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html#SQLServer.DBMail.MAZ) (documentación de Amazon RDS) + [Solución de problemas de conexión a la instancia de base de datos de SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html#USER_ConnectToMicrosoftSQLServerInstance.Troubleshooting) (documentación de Amazon RDS) + [No se puede conectar a la instancia de base de datos de Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Troubleshooting.html#CHAP_Troubleshooting.Connecting) (documentación de Amazon RDS) # Configurar la recuperación de desastres para SAP en IBM Db2 en AWS *Ambarish Satarkar y Debasis Sahoo, Amazon Web Services* ## Resumen Este patrón describe los pasos para configurar un sistema de recuperación de desastres (DR) para cargas de trabajo de SAP con IBM Db2 como plataforma de base de datos ejecutada en la nube de Amazon Web Services (AWS). El objetivo es proporcionar una solución de bajo costo para garantizar la continuidad empresarial en caso de interrupción. El patrón emplea el [enfoque de prueba piloto](https://aws.amazon.com/blogs/architecture/disaster-recovery-dr-architecture-on-aws-part-iii-pilot-light-and-warm-standby/). Al implementar una prueba piloto de DR en AWS, puede reducir el tiempo de inactividad y mantener la continuidad empresarial. Este enfoque piloto se centra en configurar un entorno de DR mínimo en AWS, con un sistema SAP y una base de datos Db2 en espera sincronizada con el entorno de producción. Esta solución es escalable. Puede ampliarla a un entorno de recuperación de desastres a gran escala si lo necesita. ## Requisitos previos y limitaciones **Requisitos previos ** + Una instancia de SAP que se ejecuta en una instancia de Amazon Elastic Compute Cloud (Amazon EC2) + Base de datos Db2 de IBM + Un sistema operativo compatible con la matriz de disponibilidad de producto (PAM) de SAP + Diferentes nombres de host de bases de datos físicas para los hosts de bases de datos de producción y espera + Un bucket de Amazon Simple Storage Service (Amazon S3) en cada región de AWS con la [replicación entre regiones (CRR)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/replication.html) habilitada **Versiones de producto** + Base de datos IBM Db2, versión 11.5.7 o posterior ## Arquitectura **Pila de tecnología de destino** + Amazon EC2 + Amazon Simple Storage Service (Amazon S3) + Nube privada virtual de Amazon (VPC peering) + Amazon Route 53 + Recuperación de desastres de alta disponibilidad (HADR) en IBM Db2 **Arquitectura de destino** Esta arquitectura implementa una solución de DR para cargas de trabajo de SAP con Db2 como plataforma de base de datos. La base de datos de producción se implementa en la región 1 de AWS, y la base de datos de espera se implementa en una segunda región. La base de datos de espera se denomina sistema DR. La base de datos Db2 admite varias bases de datos de espera (hasta tres). Emplea el HADR de Db2 para configurar la base de datos de recuperación de desastres y automatizar el envío de registros entre las bases de datos de producción y espera. Si la disponibilidad de la región 1 se interrumpe a causa de un desastre, la base de datos en espera de la región de DR asume la función de base de datos de producción. Los servidores de aplicaciones de SAP se pueden crear con antelación mediante [AWS Elastic Disaster Recovery](https://aws.amazon.com/disaster-recovery/) o con una imagen de máquina de Amazon (AMI) para satisfacer los requisitos del objetivo de tiempo de recuperación (RTO). Este patrón emplea un AMI. El HADR de Db2 implementa una configuración de producción en espera en la que producción actúa como servidor principal al que se conectan todos los usuarios. Todas las transacciones se escriben en archivos de registro que se transfieren al servidor en espera mediante TCP/IP. El servidor en espera actualiza su base de datos local enviando los registros transferidos, lo que ayuda a garantizar la sincronización con el servidor de producción. El emparejamiento de VPC permite que las instancias de la región de producción y la región de DR puedan comunicarse entre sí. Amazon Route 53 dirige a los usuarios finales a las aplicaciones de Internet. ![\[Db2 en AWS con replicación entre regiones\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/06edfa4c-0827-4d05-95cf-2d2651e74323/images/e77c1e4e-36f3-4af4-89d0-8eec72348f0a.png) 1. [Cree una AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html#creating-an-ami) del servidor de aplicaciones en la región 1 y [copie la AMI](https://repost.aws/knowledge-center/copy-ami-region) en la región 2. Use la AMI para lanzar servidores en la Región 2 en caso de desastre. 1. Configure la replicación HADR de Db2 entre la base de datos de producción (en la región 1) y la base de datos en espera (en la región 2). 1. En EC2 caso de desastre, cambie el tipo de instancia para que coincida con la instancia de producción. 1. En la Región 1, `LOGARCHMETH1` se establece en `db2remote: S3 path`. 1. En la Región 2, `LOGARCHMETH1` se establece en `db2remote: S3 path`. 1. La replicación entre regiones se realiza entre los buckets de S3. ## Tools (Herramientas) **Servicios de AWS** + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/ec2/) proporciona capacidad informática escalable en la nube de AWS. Puede lanzar tantos servidores virtuales como necesite y escalarlos o reducirlos con rapidez. + [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) es un servicio web de sistema de nombres de dominio (DNS) escalable y de alta disponibilidad. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) es un servicio de almacenamiento de objetos basado en la nube que le ayuda a almacenar, proteger y recuperar cualquier cantidad de datos. + [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) le permite lanzar recursos de AWS en una red virtual que haya definido. Esta red virtual es similar a la red tradicional que utiliza en su propio centro de datos, con los beneficios de usar la infraestructura escalable de AWS. Este patrón emplea [interconexión de VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-peering.html). ## Prácticas recomendadas + La red desempeña un papel crucial a la hora de decidir el modo de replicación HADR. Para la recuperación de desastres en todas las regiones de AWS, le recomendamos que use el modo Db2 HADR ASYNC o SUPERASYNC. + Para obtener más información sobre los modos de replicación de Db2 HADR, consulte la [documentación de IBM](https://ibm.github.io/db2-hadr-wiki/hadrSyncMode.html#Description_of_the_Modes). + Puede usar la consola de administración de AWS o la interfaz de la línea de comandos de AWS (AWS CLI) para [crear una nueva AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html#creating-an-ami) de su sistema SAP existente. A continuación, puede usar la AMI para recuperar su sistema SAP existente o crear un clon. + [AWS Systems Manager Automation](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-automation.html) puede ayudar con las tareas habituales de mantenimiento e implementación de las EC2 instancias y otros recursos de AWS. + AWS proporciona varios servicios nativos para supervisar y gestionar la infraestructura y las aplicaciones en AWS. CloudTrail Se pueden utilizar servicios como Amazon CloudWatch y AWS para supervisar la infraestructura subyacente y las operaciones de la API, respectivamente. Para obtener más información, consulte [SAP en AWS: IBM Db2 HADR con Pacemaker](https://docs.aws.amazon.com/sap/latest/sap-AnyDB/sap-ibm-pacemaker.html). ## Epics ### Prepare el entorno | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Compruebe el sistema y los registros. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador de AWS, administrador de SAP Basis | ### Configure los servidores y la replicación | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree los servidores de SAP y de bases de datos. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html)El estado pendiente de avance de transacciones se establece de forma predeterminada una vez restaurada la copia de seguridad completa. El estado pendiente de avance de transacciones indica que la base de datos está en proceso de restauración, y que es posible que se necesite aplicar algunos cambios. Para obtener más información, consulte la [documentación de IBM](https://www.ibm.com/docs/en/db2/11.5?topic=commands-rollforward-database). | Administrador de SAP Basis | | Compruebe la configuración. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador de AWS, administrador de SAP Basis | | Configure la replicación desde la base de datos de producción a la base de datos de DR (mediante el modo ASYNC). | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador de SAP Basis | ### Pruebe las tareas de conmutación por error de DR | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Planifique el tiempo de inactividad empresarial de producción para la prueba de DR. | Asegúrese de planificar el tiempo de inactividad empresarial necesario en el entorno de producción para probar el escenario de conmutación por error de DR. | Administrador de SAP Basis | | Crear un usuario de prueba. | Cree un usuario de prueba (o cualquier cambio de prueba) que pueda validarse en el host de DR para confirmar la replicación del registro tras la conmutación por error de DR. | Administrador de SAP Basis | | En la consola, detenga las instancias de producción EC2 . | En este paso se inicia un cierre imprevisto para simular un escenario de desastre. | Administrador de sistemas de AWS | | Amplíe la EC2 instancia de recuperación ante desastres para adaptarla a los requisitos. | En la EC2 consola, cambie el tipo de instancia en la región de DR.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador de SAP Basis | | Inicie la toma de control. | Desde el sistema de DR (`host2`), inicie el proceso de toma de control y active la base de datos de recuperación de desastres como principal.
@profile_name = 'SQL Alerts profile',
@account_name = 'SQL Alerts account',
@sequence_number = 1;
db2 takeover hadr on databaseSi lo desea, puede configurar los siguientes parámetros para ajustar automáticamente la asignación de memoria de la base de datos en función del tipo de instancia. El valor `INSTANCE_MEMORY` se puede decidir en función de la parte dedicada de la memoria que se va a asignar a la base de datos Db2.by force
db2 update db cfg forVerifique el cambio usando los siguientes comandos.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 de SAP Basis | | Inicie el servidor de aplicaciones para SAP en la región de DR. | Con la AMI que creó en el sistema de producción, [lance un nuevo servidor de aplicaciones adicional](https://aws.amazon.com/premiumsupport/knowledge-center/launch-instance-custom-ami/) en la región de DR. | Administrador de SAP Basis | | Realice la validación antes de iniciar la aplicación SAP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador de AWS, administrador de SAP Basis | | Inicie la aplicación SAP en el sistema de DR. | Inicie la aplicación SAP en el sistema de DR utilizando el usuario `| grep -i MEMORY
db2 get db cfg for| grep -i self_tuning_mem
sapconrol -nr XX -function StartService| Administrador de SAP Basis | | Realice la validación de SAP. | Esto se lleva a cabo como una prueba de DR para proporcionar pruebas o comprobar que la replicación de los datos en la región de DR se realiza correctamente. | Ingeniero de pruebas | ### Lleve a cabo tareas de conmutación por recuperación en DR | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Inicie los servidores de bases de datos y SAP de producción. | En la consola, inicie las EC2 instancias que alojan SAP y la base de datos en el sistema de producción. | Administrador de SAP Basis | | Iniciar la base de datos de producción y configurar HADR. | Inicie sesión en el sistema de producción (`host1`) y compruebe que la base de datos está en modo de recuperación ejecutando el siguiente comando.
sapconrol -nr XX -function StartSystem
sapconrol -nr YY -function StartService
sapconrol -nr YY -function StartSystem
db2startCompruebe que el estado de HADR sea `connected`. El estado de la replicación debe ser `peer`.
db2 start HADR on db P3V as standby
db2 connect to
db2pd -dSi la base de datos no es incoherente y no se encuentra en estado `connected` y `peer`, es posible que sea necesario realizar una copia de seguridad y una restauración para que la base de datos (en `host1`) se sincronice con la base de datos actualmente activa (`host2` en la región de DR). En ese caso, restaure la copia de seguridad de la base de datos de la región de DR `host2` a la base de datos de la región de producción `host1`. | Administrador de SAP Basis | | Conmute por recuperación la base de datos a la región de producción. | En un business-as-usual escenario normal, este paso se realiza en un tiempo de inactividad programado. Las aplicaciones que se ejecutan en el sistema de DR se detienen, y la base de datos se conmuta por recuperación a la región de producción (región 1) para reanudar las operaciones desde la región de producción.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador de SAP Basis | | Realice la validación antes de iniciar la aplicación SAP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador de AWS, administrador de SAP Basis | | Inicie la aplicación de SAP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrador de SAP Basis | ## Resolución de problemas | Problema | Solución | | --- | --- | | Archivos de registro de clave y comandos para solucionar problemas relacionados con HADR | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | | Nota de SAP para la resolución de problemas de HADR en Db2 UDB | Consulte la [nota 1154013 de SAP DB6: Problemas con la base de datos en un entorno HADR](https://service.sap.com/sap/support/notes/1154013). (Necesitará las credenciales del portal SAP para acceder a esta nota). | ## Recursos relacionados + [Enfoques de recuperación de desastres para bases de datos Db2 en AWS](https://aws.amazon.com/blogs/architecture/disaster-recovery-approaches-for-db2-databases-on-aws/) (publicación del blog) + [SAP en AWS: IBM Db2 HADR con Pacemaker](https://docs.aws.amazon.com/sap/latest/sap-AnyDB/sap-ibm-pacemaker.html) + [Procedimiento paso a paso para configurar la replicación de HADR entre bases de datos DB2 ](https://www.ibm.com/support/pages/step-step-procedure-set-hadr-replication-between-db2-databases) + [Wiki de HADR Db2](https://ibm.github.io/db2-hadr-wiki/index.html) ## Información adicional Con este patrón puede configurar un sistema de recuperación de desastres para un sistema SAP que se ejecute en una base de datos Db2. En una situación de desastre, la empresa debería poder mantener sus requisitos de Objetivo de tiempo de recuperación (RTO) y Objetivo de punto de recuperación (RPO): + El **RTO** es la máxima demora aceptable entre la interrupción del servicio y el restablecimiento del servicio. Este valor determina el período de tiempo que se considera aceptable cuando el servicio no está disponible. + El **RPO** es la cantidad máxima de tiempo aceptable desde el último punto de recuperación de datos. Esto determina qué se considera una pérdida de datos aceptable entre el último punto de recuperación y la interrupción del servicio. Para obtener FAQs información sobre el HADR, consulte la [nota \$11612105 de SAP DB6: Preguntas frecuentes sobre la recuperación ante desastres de alta disponibilidad (HADR) de Db2](https://launchpad.support.sap.com/#/notes/1612105). (Necesitará las credenciales del portal SAP para acceder a esta nota). # Configure una CI/CD canalización para la migración de bases de datos mediante Terraform *Dr. Rahul Sharad Gaikwad, Ashish Bhatt, Aniket Dekate, Ruchika Modi, Tamilselvan P, Nadeem Rahaman, Aarti Rajput y Naveen Suthar, Amazon Web Services* ## Resumen Este patrón consiste en establecer un proceso de integración e implementación continuas (CI/CD) para administrar migraciones de bases de datos de una manera confiable y automatizada. Abarca el proceso de aprovisionamiento de la infraestructura necesaria, migración de datos y personalización de los cambios de esquema mediante Terraform, que es una herramienta de infraestructura como código (IaC). En concreto, el patrón configura una CI/CD canalización para migrar una base de datos local de Microsoft SQL Server a Amazon Relational Database Service (Amazon RDS) en adelante. AWS También puede utilizar este patrón para migrar a Amazon RDS una base de datos de SQL Server que se encuentre en una máquina virtual (VM) o en otro entorno de nube. Este patrón aborda los desafíos siguientes relacionados con la administración y la implementación de bases de datos: + Las implementaciones manuales de bases de datos son tardadas, propensas a errores y carecen de coherencia en los entornos. + Coordinar el aprovisionamiento de la infraestructura, las migraciones de datos y los cambios de esquema puede resultar complejo y difícil de administrar. + Garantizar la integridad de los datos y minimizar el tiempo de inactividad durante las actualizaciones de las bases de datos es fundamental para los sistemas de producción. Este patrón proporciona los beneficios siguientes: + Simplifica el proceso de actualización e implementación de los cambios en la base de datos mediante la implementación de una CI/CD canalización para las migraciones de bases de datos. Esto reduce el riesgo de errores, garantiza la coherencia en todos los entornos y minimiza el tiempo de inactividad. + Ayuda a mejorar la fiabilidad, la eficiencia y la colaboración. Permite una comercialización más rápida y reduce el tiempo de inactividad durante las actualizaciones de las bases de datos. + Le ayuda a adoptar DevOps prácticas modernas para la administración de bases de datos, lo que se traduce en una mayor agilidad, confiabilidad y eficiencia en sus procesos de entrega de software. ## Requisitos previos y limitaciones **Requisitos previos ** + Un activo Cuenta de AWS + La versión 0.12 o posterior de Terraform instalada en su máquina local (para obtener instrucciones, consulte la [documentación de Terraform](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli)) + Terraform AWS Provider versión 3.0.0 o posterior de HashiCorp (consulte el [GitHub repositorio](https://github.com/hashicorp/terraform-provider-aws) de este proveedor) + Política de privilegios mínimos AWS Identity and Access Management (IAM) (consulte la entrada del blog [Técnicas para redactar políticas de IAM con privilegios mínimos](https://aws.amazon.com/blogs/security/techniques-for-writing-least-privilege-iam-policies/)) ## Arquitectura Este patrón implementa la arquitectura siguiente, que proporciona la infraestructura completa para el proceso de migración de la base de datos. ![\[Arquitectura de canalización de CI/CD para migrar una base de datos de SQL Server en las instalaciones a Amazon RDS en AWS.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/87845d9f-8e6e-4c51-b9ee-9e7833671d05/images/a1e95458-419a-4de9-85ef-b17d8340700a.png) En esta arquitectura: + La base de datos de origen es una base de datos de SQL Server en las instalaciones, en una máquina virtual (VM) o alojada por otro proveedor de nube. El diagrama asume que la base de datos de origen está en un centro de datos en las instalaciones. + El centro de datos local y AWS están conectados a través de una VPN o conexión. AWS Direct Connect Esto proporciona comunicaciones seguras entre la base de datos de origen y la AWS infraestructura. + La base de datos de destino es una base de datos de Amazon RDS que se aloja en la nube privada virtual (VPC) con la ayuda de una AWS canalización de aprovisionamiento de bases de datos. + AWS Database Migration Service (AWS DMS) replica su base de datos local en. AWS Se utiliza para configurar la replicación de la base de datos de origen en la base de datos de destino. El siguiente diagrama muestra la infraestructura configurada con diferentes niveles del proceso de migración de la base de datos, que implica el aprovisionamiento, la AWS DMS configuración y la validación. ![\[Detalles de la canalización de CI/CD del proceso de migración de las instalaciones a AWS.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/87845d9f-8e6e-4c51-b9ee-9e7833671d05/images/3aca17e5-6fd7-4317-b578-ab5e485c6efb.png) En este proceso: + El proceso de validación valida todos los controles. La canalización integrada pasará al próximo paso cuando se hayan completado todas las validaciones necesarias. + El proceso de aprovisionamiento de la base de datos consta de varias AWS CodeBuild etapas que realizan acciones de Terraform en el código de Terraform proporcionado para la base de datos. Cuando se completan estos pasos, implementa los recursos en la Cuenta de AWS de destino. + El AWS DMS proceso consta de varias CodeBuild etapas en las que se realizan las pruebas y, a continuación, se aprovisiona la AWS DMS infraestructura necesaria para realizar la migración mediante el uso de la IaC. ## Tools (Herramientas) **Servicios de AWS y herramientas** + [AWS CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html)es un servicio de integración continua totalmente gestionado que compila el código fuente, ejecuta pruebas y produce paquetes de ready-to-deploy software. + [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html) es un servicio de entrega continua totalmente administrado que ayuda a automatizar las canalizaciones de lanzamiento para actualizaciones de infraestructura y aplicaciones rápidas y fiables. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) lo ayuda a configurar, utilizar y escalar una base de datos relacional en la Nube de AWS. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) es un servicio de almacenamiento de objetos que ofrece escalabilidad, disponibilidad de datos, seguridad y rendimiento líderes del sector. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) le ayuda a migrar los almacenes de datos a una combinación de configuraciones locales y en la nube Nube de AWS o entre ellas. **Otros servicios** + [Terraform](https://www.terraform.io/) es una herramienta de iAC HashiCorp que le ayuda a crear y administrar recursos locales y en la nube. **Repositorio de código** El código de este patrón está disponible en el [ DevOps marco de migración de GitHub bases de datos mediante el repositorio de muestras de Terraform](https://github.com/aws-samples/aws-terraform-db-migration-framework-samples). ## Prácticas recomendadas + Implemente pruebas automatizadas para la migración de su base de datos a fin de verificar la exactitud de los cambios en el esquema y la integridad de los datos. Esto incluye pruebas unitarias, pruebas de integración y end-to-end pruebas. + Implemente una estrategia sólida de copia de seguridad y restauración para las bases de datos, sobre todo antes de la migración. Esto garantiza la integridad de los datos y proporciona una opción alternativa en caso de errores. + Implemente una estrategia sólida de reversión para revertir los cambios en la base de datos en caso de que se produzcan errores o problemas durante la migración. Esto podría implicar volver a un estado anterior de la base de datos o revertir los scripts de migración individuales. + Configure mecanismos de supervisión y registro para hacer un seguimiento del avance y el estado de las migraciones de bases de datos. Esto es útil para identificar y resolver los problemas de manera rápida. ## Epics ### Configure su equipo de trabajo local | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Defina y configure Git en su estación de trabajo local. | Instale y configure Git en su estación de trabajo local con las instrucciones de la [documentación de Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git). | DevOps ingeniero | | Cree una carpeta de proyecto y añada los archivos del GitHub repositorio. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps ingeniero | ### Aprovisionamiento de la arquitectura de destino | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Actualice los parámetros obligatorios. | El `ssm-parameters.sh` archivo almacena todos los AWS Systems Manager parámetros necesarios. Puede configurar estos parámetros con los valores personalizados de su proyecto.En la `setup/db-ssm-params` carpeta de la estación de trabajo local, abra el `ssm-parameters.sh` archivo y defina estos parámetros antes de ejecutar la CI/CD canalización. | DevOps ingeniero | | Inicialice la configuración de Terraform. | En la carpeta `db-cicd-integration`, ingrese el comando siguiente para inicializar el directorio de trabajo que contiene los archivos de configuración de Terraform:-hadr
terraform init| DevOps ingeniero | | Obtenga una vista previa del plan Terraform. | Para crear un plan de ejecución de Terraform, ingrese el comando siguiente:
terraform plan -var-file="terraform.sample"Terraform evalúa los archivos de configuración para determinar el estado objetivo de los recursos declarados. A continuación, compara el estado objetivo con el estado actual y crea un plan. | DevOps ingeniero | | Verifique el plan. | Revise el plan y confirme que configura la arquitectura requerida en su Cuenta de AWS de destino. | DevOps ingeniero | | Implemente la solución. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps ingeniero | ### Verifique la implementación | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Valide la implementación. | Verifique el estado de la canalización `db-cicd-integration` para confirmar que la migración de la base de datos se completó.1. Inicie sesión en la [AWS CodePipeline consola y Consola de administración de AWS, a continuación, ábrala](https://console.aws.amazon.com/codesuite/codepipeline/home).2. En el panel de navegación, seleccione **Canalizaciones**.3. Configure la canalización de `db-cicd-integration`.4. Valide que la ejecución de la canalización finalizó correctamente. | DevOps ingeniero | ### Limpieza de la infraestructura después de utilizarla | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Limpie la infraestructura. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps ingeniero | ## Recursos relacionados **AWS documentación** + [Cómo empezar con un producto de Terraform](https://docs.aws.amazon.com/servicecatalog/latest/adminguide/getstarted-Terraform.html) **Documentación de Terraform** + [Instalación de Terraform](https://learn.hashicorp.com/tutorials/terraform/install-cli) + [Terraform backend configuration](https://developer.hashicorp.com/terraform/language/backend) + [Documentación de Terraform Provider AWS](https://registry.terraform.io/providers/hashicorp/aws/latest/docs) # Configure un clúster de conmutación por error de Microsoft SQL Server en Amazon EC2 utilizando FSx Windows File Server *Sweta Krishna y Ramesh Babu Donti, Amazon Web Services* ## Resumen Microsoft SQL Server Standard Edition con una instancia de clúster de conmutación por error (FCI) puede proporcionar una alternativa más rentable a SQL Server Enterprise. La configuración de SQL FCI requiere un almacenamiento de archivos compartido entre los nodos, y [Amazon FSx for Windows File Server](https://aws.amazon.com/fsx/windows/) proporciona un almacenamiento totalmente gestionado que se replica automáticamente y de forma sincrónica en todas las zonas de disponibilidad. Amazon FSx reduce los costes de almacenamiento mediante el uso de la deduplicación de datos integrada para los recursos compartidos de archivos de uso general, lo que elimina la necesidad de mantener soluciones de terceros. Amazon FSx también admite lo siguiente: + Pague solo por lo que use, sin tarifas ni compromisos iniciales. + Configura la FCI manualmente FSx como almacenamiento compartido. + Úselo FSx como testigo del uso compartido de archivos para su clúster de SQL. + Amazon FSx para Windows File Server es compatible con Server Message Block (SMB) 3.0 para compartir archivos de forma continua, lo que lo hace adecuado para las implementaciones de FCI de SQL Server. ## Requisitos previos y limitaciones **Requisitos previos ** + Activo. [Cuenta de AWS](https://aws.amazon.com/account/) + Permisos para crear y gestionar los recursos de Amazon Virtual Private Cloud (Amazon VPC), la instancia de Amazon Elastic Compute Cloud (Amazon EC2), los grupos de seguridad y las funciones AWS Identity and Access Management (IAM). + AWS Managed Microsoft AD o su propio Active Directory local. + Un usuario de dominio de Active Directory con los [permisos necesarios](https://learn.microsoft.com/en-us/windows-server/failover-clustering/configure-failover-cluster-accounts) para configurar un clúster de conmutación por error. + Reglas de grupo de seguridad para la FCI de SQL Server y los [puertos de Microsoft Active Directory](https://docs.aws.amazon.com/whitepapers/latest/access-workspaces-with-access-cards/ip-address-and-port-requirements.html) para una conectividad híbrida segura. + Una [cuenta de servicio](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) en Active Directory para SQL Server configurada con los permisos adecuados en todos los nodos de SQL. + Amazon FSx para Windows File Server en un clúster de conmutación por error. + Archivos binarios de instalación de SQL Server. **Limitaciones** + Algunas Servicios de AWS no están disponibles en todos Regiones de AWS. Para conocer la disponibilidad de las regiones, consulte [Servicios de AWS by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para ver los puntos de conexión específicos, consulte la página [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) y elija el enlace del servicio. **Versiones de producto** + Amazon EC2 para Windows Server 2012 R2 o posterior + Amazon FSx para Windows File Server con todas las versiones actuales de Windows Server + Amazon FSx for NetApp ONTAP como alternativa de almacenamiento compartido + SQL Server 2012/2016/2019/2022 ## Arquitectura **Pila de tecnología** + Amazon EC2 + Servidor FSx de archivos Amazon para Windows + Amazon VPC + AWS Directory Service + AWS Systems Manager + IAM **Arquitectura de destino** El siguiente diagrama muestra la arquitectura de alto nivel de Microsoft SQL Server FCI en Amazon EC2 con Amazon File Server FSx para Windows. ![\[Diagrama de arquitectura para Microsoft Server FCI en Amazon EC2 con Amazon File Server FSx para Windows.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/208bf64a-8fef-4019-944a-723372450885/images/ba0c9169-9536-41c3-ae8e-7264dcc3e1ad.png) **Infraestructura de red** + Amazon VPC proporciona un contenedor de red que abarca tres zonas de disponibilidad. + Las subredes privadas proporcionan subredes aisladas en cada zona de disponibilidad para implementar recursos. **Capa de computación** + Amazon EC2 contiene un nodo 1 de clúster de SQL Server, implementado en la zona de disponibilidad 1 como parte del clúster de conmutación por error de Windows Server (WSFC). + Amazon EC2 contiene un nodo 2 de clúster de SQL Server, implementado en la zona de disponibilidad 2 como parte del WSFC. + El clúster WSFC conecta ambos nodos de SQL Server para ofrecer una capacidad de conmutación por error. **Capa de almacenamiento para Amazon FSx para Windows File Server** ** FSx Implementación Multi-AZ (que abarca las zonas de disponibilidad 1 y 2)** + Un sistema de FSx archivos principal de la zona de disponibilidad 1 aloja los archivos de registro y datos activos de SQL Server. + Un sistema de FSx archivos secundario en la zona de disponibilidad 2 proporciona una capacidad de conmutación por error automática. + Un recurso compartido de archivos SMB (\$1\$1fsx.domain\$1sqlshare) al que pueden acceder ambos nodos del clúster para las bases de datos de SQL Server. ** FSx Implementación en una zona de disponibilidad única (in) AZ3** + El testigo del servidor de FSx archivos de Amazon en la zona de disponibilidad 3 actúa como testigo del quórum del clúster. + El testigo del recurso compartido de archivos (`\\fsx.domain\witness`) mantiene el quorum del clúster y evita situaciones de cerebro dividido. **Servicios de directorio** + AWS Managed Microsoft AD proporciona los servicios de autenticación y dominio de Windows necesarios para la funcionalidad del clúster. **Características de alta disponibilidad** + Los componentes multi-AZ ofrecen tolerancia a errores en todas las zonas de disponibilidad. + FSx el servidor de archivos en espera proporciona una conmutación por error automática si el servidor principal falla. + El testigo del recurso compartido de archivos administra el quorum del clúster en la zona de disponibilidad 3 para garantizar el correcto funcionamiento del clúster durante los errores. + El dominio está integrado AWS Managed Microsoft AD para una autenticación de Windows perfecta. ## Tools (Herramientas) **Servicios de AWS** + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) proporciona una capacidad informática escalable en el Nube de AWS. Puede lanzar tantos servidores virtuales como necesite y escalarlos o reducirlos con rapidez. + [Amazon FSx](https://docs.aws.amazon.com/fsx/?id=docs_gateway) proporciona sistemas de archivos que admiten los protocolos de conectividad estándares del sector y ofrecen alta disponibilidad y replicación en todos Regiones de AWS los niveles. + [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) le ayuda a lanzar AWS recursos en una red virtual que haya definido. Esa red virtual es similar a la red tradicional que utiliza en su propio centro de datos, con los beneficios de usar la infraestructura escalable de AWS. + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)permite que sus cargas de trabajo y AWS recursos compatibles con directorios utilicen Microsoft Active Directory en. Nube de AWS + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) le ayuda a administrar de forma segura el acceso a sus AWS recursos al controlar quién está autenticado y autorizado a usarlos. + [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) lo ayuda a administrar las aplicaciones y la infraestructura que se ejecutan en la Nube de AWS. Simplifica la administración de aplicaciones y recursos, reduce el tiempo necesario para detectar y resolver problemas operativos y le ayuda a administrar sus AWS recursos de forma segura y a escala. ## Prácticas recomendadas + Coloque las instancias de bases de datos en subredes privadas para evitar que el público pueda acceder a ellas desde Internet y, al mismo tiempo, permitirles conectarse Servicios de AWS y realizar actualizaciones. + Para obtener información sobre las prácticas recomendadas generales, consulte [Prácticas recomendadas para implementar Microsoft SQL Server en Amazon EC2](https://docs.aws.amazon.com/prescriptive-guidance/latest/sql-server-ec2-best-practices/welcome.html). + Para usarlo PowerShell para administrar su servidor de archivos de Amazon FSx para Windows, consulte [Administración FSx de sistemas de archivos de Windows](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/administering-file-systems.html). ## Epics ### Creación y configuración de EC2 nodos de Amazon para SQL Server | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Agregar nombres y etiquetas. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | Administrador de base de datos | | Elegir una AMI de Windows. | Elija una Imagen de máquina de Amazon (AMI) para Windows que cumpla con sus requisitos de SQL Server. | Administrador de base de datos | | Seleccione un tipo de instancia. | Selecciona un tipo de EC2 instancia de Amazon que cumpla tus requisitos. | Administrador de base de datos | | Usar un par de claves. | Puede utilizar un par de claves para conectarse de forma segura a su instancia. Asegúrese de tener acceso al par de claves seleccionado antes de lanzar la instancia. | Administrador de base de datos | | Configure los valores de red. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | Administrador de base de datos | | Definir los ajustes de red avanzados. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | Administrador de base de datos | | Configurar almacenamiento. | Configure el almacenamiento total necesario y elija el tipo de almacenamiento requerido. | Administrador de base de datos | | Configurar los detalles avanzados y lanzar la instancia. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | Administrador de base de datos | | Crear el nodo 2. | Repita estos pasos para crear y configurar el nodo 2. | Administrador de base de datos | ### Instalación y configuración del clúster de conmutación por error de Windows Server en los nodos 1 y 2 | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Iniciar sesión en el nodo 1. | Inicie sesión en la EC2 instancia de Amazon de Windows como administrador. | Administrador de base de datos | | Instalar las características de la FCI en el nodo 1. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/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/es_es/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | Administrador de base de datos | | Iniciar sesión en el nodo 2. | Inicie sesión en la EC2 instancia de Amazon de Windows como administrador. | Administrador de base de datos | | Instalar las características de la FCI en el nodo 2. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/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/es_es/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | Administrador de base de datos | | Agregar nodos al clúster. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | Administrador de base de datos | | Poner en línea el clúster. | Para poner en línea el clúster, actualice las direcciones IP estáticas de ambos nodos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | Administrador de base de datos | | Validar el clúster. | Va a **Administrador de clústeres de conmutación por error** y compruebe que los recursos principales del clúster estén en línea. | Administrador de base de datos | ### Instalación de SQL Server en los nodos 1 y 2 | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Iniciar sesión en el servidor. | Inicia sesión en la EC2 instancia de Amazon como administrador. | Administrador de base de datos | | Montar los archivos binarios de SQL. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | | | Agregar el nodo 2 al clúster de conmutación por error. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | Administrador de base de datos | ### Configurar el testigo de FSx compartición de archivos de Amazon | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Configurar los ajustes de quorum. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | Administrador de base de datos | | Recuperar los detalles del DNS. | En la FSx consola de Amazon, selecciona **Managed AD** y, a continuación, **Attach**. El DNS debe tener el siguiente formato: `\\example.example.net\share`. | Administrador de base de datos | | Configurar el testigo de uso compartido de archivos. | Selecciona la **ruta de FSx compartición de archivos de Amazon** y, a continuación, **Finalizar**. | Administrador de base de datos | ## Recursos relacionados **AWS resources** + [Servidor de archivos Amazon FSx para Windows](https://www.youtube.com/watch?v=IMDWTIShlyI) (vídeo) + [Análisis profundo de Amazon FSx para Windows File Server](https://www.youtube.com/watch?v=_x_Geur93oc) (vídeo) + [Cómo implementar un clúster de conmutación por error de SQL Server con Amazon EBS Multi-Attach en 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 entrada del blog) + [Simplifique sus despliegues de alta disponibilidad de Microsoft SQL Server con Amazon FSx for Windows File Server](https://aws.amazon.com/blogs/storage/simplify-your-microsoft-sql-server-high-availability-deployments-using-amazon-fsx-for-windows-file-server/) (entrada del AWS blog) + [Implementaciones de alta disponibilidad de SQL Server con Amazon FSx for NetApp ONTAP](https://aws.amazon.com/blogs/modernizing-with-aws/sql-server-high-availability-amazon-fsx-for-netapp-ontap/) (AWS entrada del blog) + [Uso FSx para Windows File Server con Microsoft SQL Server](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/sql-server.html) + [¿Qué es FSx para Windows File Server?](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) **Otros recursos** + [Create a failover cluster](https://learn.microsoft.com/en-us/windows-server/failover-clustering/create-failover-cluster?pivots=windows-admin-center) ## Información adicional **Configurar el testigo de uso compartido de archivos** Asegúrese de estar conectado al sistema de archivos desde ambos nodos añadiendo reglas en el grupo de FSx seguridad de Amazon que permitan las conexiones entrantes. Se debe permitir el puerto SMB. Por ejemplo, si el nombre de DNS es `\\example.example.com\share`, use `\\example.example.com\share`. Utilice el mismo valor para el testigo de uso compartido de archivos en el clúster de disponibilidad Always On. Siga los pasos que se describen a continuación para configurar el testigo de uso compartido de archivos: 1. Usa RDP para conectarte a tu EC2 instancia de Amazon. 1. Vaya a **Administrador de clústeres de conmutación por error**. 1. Abra el menú contextual (clic con el botón derecho) y elija **Más acciones**. 1. Elija **Configurar los ajustes de quorum del clúster**. 1. Elija **Siguiente**. 1. Seleccione **Configuración de quorum** y configure un testigo de uso compartido de archivos. 1. Proporcione el nombre de DNS. 1. Revise el resumen y, a continuación, elija **Finalizar**. El testigo de uso compartido de archivos debe estar en línea en la sección de recursos **principales del clúster**. # Configure una HA/DR arquitectura para Oracle E-Business Suite en Amazon RDS Custom con una base de datos en espera activa *Simon Cunningham, Jaydeep Nandy y Nitin Saxena, Amazon Web Services* ## Resumen Este patrón describe cómo puede diseñar su solución Oracle E-Business en Amazon Relational Database Service (Amazon RDS) Custom para lograr una alta disponibilidad (HA) y recuperación de desastres (DR) configurando una base de datos de réplicas de lectura de Amazon RDS Custom en otra zona de disponibilidad de Amazon Web Services (AWS) y convirtiéndola en una base de datos en espera activa. La creación de la réplica de lectura de Amazon RDS Custom está totalmente automatizada mediante la consola de administración de AWS. Este patrón no describe los pasos para añadir niveles de aplicaciones adicionales y sistemas de archivos compartidos, que también pueden formar parte de una arquitectura. HA/DR Para obtener más información sobre estos temas, consulte las siguientes notas de soporte de Oracle: 1375769.1, 1375670.1 y 1383621.1 (sección 5, *Opciones de clonación avanzadas*). (El acceso requiere una cuenta de [Oracle Support](https://support.oracle.com/portal/)). Para migrar el sistema E-Business Suite a una arquitectura de un solo nivel y zona de disponibilidad única en Amazon Web Services (AWS), consulte el patrón [Migración de Oracle E-Business Suite a Amazon RDS Custom](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html). Oracle E-Business Suite es una solución de planificación de recursos empresariales (ERP) que automatiza procesos de toda la empresa, como finanzas, recursos humanos, cadena de suministro y fabricación. Ofrece una arquitectura de tres niveles: cliente, aplicación y base de datos. Anteriormente, tenía que ejecutar la base de datos de E-Business Suite en una [instancia autogestionada de Amazon Elastic Compute Cloud EC2 (Amazon),](https://aws.amazon.com/ec2/) pero ahora puede beneficiarse de [Amazon RDS](https://aws.amazon.com/rds/custom/) Custom. ## Requisitos previos y limitaciones **Requisitos previos ** + Una instalación existente de E-Business Suite en Amazon RDS Custom; consulte el patrón [Migración de Oracle E-Business Suite a Amazon RDS Custom](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html) + Si quiere cambiar la réplica de lectura a una de solo lectura y utilizarla para transferir los informes a los que están en espera, adquiera una [licencia de base de datos de Oracle Active Data Guard](https://www.oracle.com/corporate/pricing/) (consulte la *lista de precios comerciales de Oracle Technology*) **Limitaciones** + Limitaciones y configuraciones no compatibles con las [bases de datos de Oracle en Amazon RDS Custom](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.limits) + Limitaciones asociadas a las [réplicas de lectura de Amazon RDS Custom para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html#custom-rr.limitations) **Versiones de producto** Para ver las versiones de Oracle Database y clases de instancia compatibles con Amazon RDS Custom, consulte [Requisitos y limitaciones de Amazon RDS Custom para Oracle](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html). ## Arquitectura El siguiente diagrama ilustra una arquitectura representativa de E-Business Suite en AWS que incluye varias zonas de disponibilidad y niveles de aplicaciones en una active/passive configuración. La base de datos usa una instancia de base de datos de Amazon RDS Custom y una réplica de lectura de Amazon RDS Custom. La réplica de lectura utiliza Active Data Guard para replicarse en otra zona de disponibilidad. También puede usar la réplica de lectura para descargar el tráfico de lectura en la base de datos principal y para generar informes. ![\[Arquitectura de varias zonas de disponibilidad para Oracle E-Business Suite en AWS\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/a17947e8-56b1-4d92-91df-096c02ff4c19/images/ffdaa2d4-123b-44a0-8d52-b1352a4eee44.png) Para obtener más información, consulte [Trabajar con réplicas de lectura para Amazon RDS Custom para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html) en la documentación de Amazon RDS. La réplica de lectura de Amazon RDS Custom se crea de forma predeterminada cuando está montada. Sin embargo, si desea transferir algunas de sus cargas de trabajo de solo lectura a la base de datos en espera para reducir la carga de la base de datos principal, puede cambiar manualmente el modo de las réplicas montadas a las de solo lectura siguiendo los pasos de la sección [Epics](#set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database-epics). Un caso de uso típico sería ejecutar los informes desde la base de datos en espera. Para cambiar a una base de datos de solo lectura se requiere una licencia de base de datos en espera activa. Al crear una réplica de lectura en AWS, el sistema utiliza el agente Oracle Data Guard de forma clandestina. Esta configuración se genera automáticamente y se configura en el modo de máximo rendimiento de la siguiente manera: ``` 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) ``` ## Tools (Herramientas) **Servicios de AWS** + [Amazon RDS Custom para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/working-with-custom-oracle.html) es un servicio de base de datos administrado para aplicaciones heredadas, personalizadas y empaquetadas que requieren acceso al sistema operativo y al entorno de base de datos subyacentes. Amazon RDS Custom automatiza las tareas y operaciones de administración de bases de datos y le permite, como administrador de bases de datos, acceder y personalizar el entorno de base de datos y el sistema operativo. **Otras herramientas** + Oracle Data Guard es una herramienta que le ayuda a crear y gestionar las bases de datos en espera de Oracle. Este patrón utiliza Oracle Data Guard para configurar una base de datos en espera activa en Amazon RDS Custom. ## Epics ### Crear una réplica de lectura | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Crear una réplica de lectura para la instancia de base de datos de Amazon RDS Custom. | Para crear una réplica de lectura, siga las instrucciones de la [documentación de Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReadRepl.html#USER_ReadRepl.Create) y utilice la instancia de base de datos de Amazon RDS Custom que creó (consulte la sección [Requisitos previos](#set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database-prereqs)) como base de datos de origen.De forma predeterminada, la réplica de lectura de Amazon RDS Custom se crea como una copia física en espera y está en el estado montado. Esto tiene la intención de garantizar el cumplimiento de la licencia de Oracle Active Data Guard. Siga los siguientes pasos para convertir la réplica de lectura al modo de solo lectura. | Administrador de base de datos | ### Cambie la réplica de lectura a un modo de espera activo de solo lectura | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Conéctese a la réplica de lectura de Amazon RDS Custom. | Utilice los siguientes comandos para convertir la base de datos física en espera en una base de datos en espera activa. Estos comandos requieren una licencia de espera activa de Oracle. Para obtener una licencia, póngase en contacto con su representante de Oracle.
$ sudo su - rdsdb| Administrador de base de datos | | Inicie la recuperación multimedia con la aplicación de un registro en tiempo real. | Para activar la característica de aplicación de registros en tiempo real, utilice los siguientes comandos. Estos convierten y validan la base de datos en espera (réplica de lectura) como una base de datos en espera activa, de modo que pueda conectarse y ejecutar consultas de solo lectura.
-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;| Administrador de base de datos | | Compruebe el estado de la base de datos. | Para comprobar el estado de la base de datos, use el comando siguiente.
Database altered
SQL> select name, database_role, open_mode from v$database;| Administrador de base de datos | | Marque el modo de reaplicación. | Para comprobar el modo de reaplicación, utilice el siguiente comando.
NAME DATABASE_ROLE OPEN_MODE
--------- ---------------- --------------------
VIS PHYSICAL STANDBY READ ONLY WITH APPLY
SQL> select process,status,sequence# from v$managed_standby;| Administrador de base de datos | ## Recursos relacionados + [Migración de Oracle E-Business Suite a Amazon RDS Custom](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html) (Recomendaciones de AWS) + [Uso de Amazon RDS Custom](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-custom.html) (documentación de Amazon RDS) + [Trabajo con réplicas de lectura para Amazon RDS Custom para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html) (documentación de Amazon RDS) + [Amazon RDS Custom for Oracle – New Control Capabilities in Database Environment](https://aws.amazon.com/blogs/aws/amazon-rds-custom-for-oracle-new-control-capabilities-in-database-environment/) (blog de AWS News) + [Migración de Oracle E-Business Suite a AWS](https://d1.awsstatic.com/whitepapers/migrate-oracle-e-business-suite.pdf) (documento técnico de AWS) + [Arquitectura de Oracle E-Business Suite en AWS](https://docs.aws.amazon.com/whitepapers/latest/overview-oracle-e-business-suite/oracle-e-business-suite-architecture-on-aws.html) (documento técnico de AWS) # Transmita datos desde IBM Db2, SAP, Sybase y otras bases de datos a MongoDB Atlas en AWS *Battulga Purevragchaa e Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Resumen Este patrón describe los pasos para migrar los datos de IBM Db2 y otras bases de datos, como bases de datos de mainframe y Sybase a MongoDB Atlas en la Nube de AWS. Utiliza [AWS Glue](https://aws.amazon.com/glue/) para acelerar la migración de los datos a MongoDB Atlas. El patrón acompaña a la guía [Migración a MongoDB Atlas que se encuentra en AWS el sitio](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) web de orientación prescriptiva. AWS Proporciona los pasos de implementación para uno de los escenarios de migración que se analizan en esa guía. Para ver otros escenarios de migración, consulte los siguientes patrones en el sitio web de la Guía prescriptiva: AWS + [Migre un entorno MongoDB autohospedado a MongoDB Atlas en 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 bases de datos relacionales a MongoDB Atlas en AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-relational-database-to-mongodb-atlas.html) El patrón está destinado a [socios y AWS usuarios de AWS Managed Services](https://aws.amazon.com/managed-services/partners/). ## Requisitos previos y limitaciones **Requisitos previos ** + Una base de datos de origen como SAP, Sybase, IBM Db2 y otras para migrar a MongoDB Atlas. + Familiaridad con bases de datos como SAP, Sybase, IBM Db2, MongoDB Atlas y. Servicios de AWS **Versiones de producto** + MongoDB versión 5.0 o posterior. ## Arquitectura El siguiente diagrama ilustra la carga de datos por lotes y la transmisión de datos mediante AWS Glue Studio Amazon Kinesis Data Streams y MongoDB Atlas. Esta arquitectura de referencia se utiliza AWS Glue Studio para crear canalizaciones de extracción, transformación y carga (ETL) para migrar datos a MongoDB Atlas. An Rastreador de AWS Glue se integra con MongoDB Atlas para facilitar la gobernanza de los datos. Los datos pueden transferirse por lotes o transmitirse a MongoDB Atlas mediante Amazon Kinesis Data Streams. **Carga de datos por lotes** ![\[Migración de datos a MongoDB Atlas en el modo por lotes.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/805a376f-35f4-44cc-b4b0-8bf4d95c1e5d/images/68d87202-95ba-4e2a-9b3b-27dd6db6165e.png) Para obtener más información sobre la migración de datos por lotes, consulte la entrada del AWS blog [Componga sus trabajos de ETL para MongoDB Atlas](https://aws.amazon.com/blogs/big-data/compose-your-etl-jobs-for-mongodb-atlas-with-aws-glue/) con. AWS Glue **Transmisión de datos** ![\[Migración de datos a MongoDB Atlas en el modo de flujo de datos.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/805a376f-35f4-44cc-b4b0-8bf4d95c1e5d/images/b007a116-f463-418f-9721-647d80177e3b.png) Para ver las arquitecturas de referencia de MongoDB Atlas que admiten diferentes escenarios de uso, consulte [Migración a MongoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) Atlas en el sitio web de orientación prescriptiva. AWS AWS ## Tools (Herramientas) ● [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html) es un servicio de ETL completamente administrado. Ayuda a clasificar, limpiar, enriquecer y mover datos de forma fiable entre almacenes de datos y flujos de datos. ● [Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/) ayuda a recopilar y procesar grandes secuencias de registros de datos en tiempo real. ● [MongoDB Atlas](https://www.mongodb.com/atlas) es una base de datos como servicio (DbaaS) completamente administrada para implementar y administrar bases de datos de MongoDB en la nube. ## Prácticas recomendadas Para obtener pautas, consulte la [Guía de mejores prácticas para MongoDB](https://github.com/mongodb-partners/mongodb_atlas_as_aws_bedrock_knowledge_base/blob/main/data/MongoDB_Best_Practices_Guide.pdf) en el repositorio de MongoDB. GitHub ## Epics ### Descubrimiento y evaluación | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Determine el tamaño del clúster. | Calcule el tamaño del conjunto de trabajo utilizando la información de `db.stats()` para el espacio total del índice. Presuponga que se accederá con frecuencia a un porcentaje de su espacio de datos. O bien, puede estimar las necesidades de memoria según sus presuposiciones. Esta tarea puede necesitar aproximadamente una semana. Para obtener más información y ejemplos de esta y otras historias de esta épica, consulte los enlaces de la sección [Recursos relacionados](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | Administrador de base de datos de MongoDB, arquitecto de aplicaciones | | Calcule los requisitos de ancho de banda de la red. | Para calcular los requisitos de ancho de banda de la red, multiplique el tamaño medio de los documentos por el número de documentos servidos por segundo. Tenga en cuenta el tráfico máximo que soportará cualquier nodo del clúster como base. Para calcular las velocidades de transferencia de datos descendentes del clúster a las aplicaciones cliente, utilice la suma del total de documentos devueltos durante un período de tiempo. Si sus aplicaciones leen desde nodos secundarios, divida este número total de documentos por el número de nodos que pueden realizar operaciones de lectura. Para encontrar el tamaño medio de los documentos de una base de datos, utilice el comando `db.stats().avgObjSize`. Esta tarea suele necesitar un día. | Administrador de base de datos de MongoDB | | Seleccione la capa de Atlas. | Siga las instrucciones de la [documentación de MongoDB](https://www.mongodb.com/docs/atlas/manage-clusters/) para seleccionar la capa del clúster de Atlas correcta. | Administrador de base de datos de MongoDB | | Planifique la transición. | Planifique la transición de la aplicación. | Administrador de base de datos de MongoDB, arquitecto de aplicaciones | ### Configurar un nuevo entorno de MongoDB Atlas en AWS | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree un nuevo clúster de MongoDB Atlas en. AWS | En MongoDB Atlas, **elija Crear un** clúster y AWS selecciónelo como proveedor de nube. | Administrador de base de datos de MongoDB | | Seleccione una Regiones de AWS configuración de clúster global. | Seleccione una opción de la lista de disponibles Regiones de AWS para su clúster de Atlas. Configure clústeres globales si es necesario. | Administrador de base de datos de MongoDB | | Seleccione la capa del clúster. | Seleccione la capa del clúster que prefiera. La selección de la capa determina factores como la memoria, el almacenamiento y las especificaciones de IOPS. | Administrador de base de datos de MongoDB | | Configure los ajustes adicionales del clúster. | Configure los ajustes adicionales del clúster, como la versión de MongoDB, la copia de seguridad y las opciones de cifrado. Para obtener más información sobre estas opciones, consulte la sección [Recursos relacionados](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | Administrador de base de datos de MongoDB | ### Configure la seguridad y el cumplimiento | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Configure la lista de acceso. | Para conectarse al clúster de Atlas, debe agregar una entrada a la [lista de acceso del proyecto](https://www.mongodb.com/docs/atlas/setup-cluster-security/#configure-security-features-for-clusters). Atlas utiliza seguridad de la capa de transporte (TLS) / Capa de conexión segura (SSL) para cifrar las conexiones a la nube privada virtual (VPC) de su base de datos. Para configurar la lista de acceso al proyecto y obtener más información sobre las historias de esta epic, consulte los enlaces de la sección [Recursos relacionados](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | Administrador de base de datos de MongoDB | | Autentique y autorice a los usuarios. | Debe crear y autenticar a los usuarios de la base de datos que accederán a los clústeres de MongoDB Atlas. Para acceder a los clústeres de un proyecto, los usuarios deben pertenecer a ese proyecto y pueden pertenecer a varios proyectos. También puedes habilitar la autorización con AWS Identity and Access Management (IAM). Para más información, consulte [Set Up Authentication with IAM](https://www.mongodb.com/docs/atlas/security/aws-iam-authentication/#set-up-authentication-with-aws-iam) en la documentación de MongoDB. | Administrador de base de datos de MongoDB | | Cree roles personalizados. | (Opcional) Atlas admite la creación de [roles personalizados](https://www.mongodb.com/docs/atlas/reference/custom-role-actions/) en los casos en que los privilegios de usuario integrados en la base de datos Atlas no cubran el conjunto de privilegios deseado. | Administrador de base de datos de MongoDB | | Configure las interconexiones con VPC. | (Opcional) Atlas admite el emparejamiento de [VPC con otros sistemas de](https://www.mongodb.com/docs/atlas/security-vpc-peering/#set-up-a-network-peering-connection) AWS. VPCs | Administrador de base de datos de MongoDB | | Configure un punto final AWS PrivateLink . | (Opcional) Puede configurar puntos de conexión privados AWS utilizando [AWS PrivateLink](https://www.mongodb.com/docs/atlas/security-private-endpoint/). | Administrador de base de datos de MongoDB | | Habilitar la autenticación en dos pasos. | (Opcional) Atlas admite la autenticación en dos pasos (2FA) para ayudar a los usuarios a controlar el acceso a sus cuentas de Atlas. | Administrador de base de datos de MongoDB | | Configure la autenticación y la autorización de los usuarios con LDAP. | (Opcional) Atlas admite realizar la autenticación y autorización de los usuarios con el Protocolo ligero de acceso a directorios (LDAP). | Administrador de base de datos de MongoDB | | Configure el AWS acceso unificado. | (Opcional) Algunas características de Atlas, como Atlas Data Lake y el cifrado en reposo mediante la administración de claves de cliente, utilizan los roles de IAM para la autenticación. | Administrador de base de datos de MongoDB | | Configure el cifrado en reposo mediante AWS KMS. | (Opcional) Atlas admite el uso de AWS Key Management Service (AWS KMS) para cifrar los motores de almacenamiento y las copias de seguridad de los proveedores de servicios en la nube. | Administrador de base de datos de MongoDB | | Configure CSFLE. | (Opcional) Atlas admite el [cifrado en el nivel de campo del cliente (CSFLE)](https://www.mongodb.com/docs/upcoming/core/csfle/#client-side-field-level-encryption), como el cifrado automático de los campos. | Administrador de base de datos de MongoDB | ### Migración de datos | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Lance el conjunto de réplicas de destino en MongoDB Atlas. | Lance el conjunto de réplicas de destino en MongoDB Atlas. En Atlas Live Migration Service, seleccione **Todo está listo para migrar**. | Administrador de base de datos de MongoDB | | Establezca la conexión de AWS Glue con MongoDB Atlas. | Use an Rastreador de AWS Glue para conectarse AWS Glue con MongoDB Atlas (base de datos de destino). Este paso ayuda a preparar el entorno de destino para la migración. Para obtener más información, consulte la [Documentación de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-connections.html). | Administrador de base de datos de MongoDB | | Establezca la conexión AWS Glue con la base de datos de origen o el flujo de origen. | Esto ayuda a preparar el entorno de destino para la migración. | Administrador de base de datos de MongoDB | | Configure la transformación de los datos. | Configure la lógica de transformación para migrar los datos del esquema estructurado heredado al esquema flexible de MongoDB. | Administrador de base de datos de MongoDB | | Migre los datos. | Programe la migración en AWS Glue Studio. | Administrador de base de datos de MongoDB | ### Configurar la integración operativa | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Conecte el clúster. | Conéctese al clúster de MongoDB Atlas. | Desarrollador de aplicaciones | | Interactúe con los datos. | Interactúe con los datos del clúster. | Desarrollador de aplicaciones | | Supervise los clústeres. | Supervise los clústeres de MongoDB Atlas. | Administrador de base de datos de MongoDB | | Haga una copia de seguridad de los datos y una restauración. | Realice copias de seguridad y restaure los datos del clúster. | Administrador de base de datos de MongoDB | ## Resolución de problemas | Problema | Solución | | --- | --- | | En caso de tener problemas | Consulte [Solución de problemas](https://github.com/mongodb/mongodbatlas-cloudformation-resources/tree/master#troubleshooting) en el repositorio de MongoDB Atlas Resources CloudFormation . | ## Recursos relacionados Todos los enlaces siguientes, a menos que se indique lo contrario, van a páginas web de la documentación de MongoDB. **Guía de migración** + [Migración a MongoDB Atlas AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) en (Guía prescriptiva)AWS **Detectar y evaluar** + [Memoria](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Ejemplo de dimensionamiento con conjuntos de datos de muestra de Atlas](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Ejemplo de dimensionamiento para aplicaciones móviles](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Tráfico de red](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Escalado automático de clústeres](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Plantilla de dimensionamiento de Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Configure la seguridad y el cumplimiento** + [Configurar entradas de la lista de acceso IP](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Configure Database Users](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Configure Access to the Atlas UI](https://docs.atlas.mongodb.com/organizations-projects/) + [Configure Custom Database Roles](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 un emparejamiento de red](https://docs.atlas.mongodb.com/security-vpc-peering/) + [Learn About Private Endpoints in Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Manage Your Multi-Factor Authentication Options](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Configurar la autenticación y la autorización de usuarios con LDAP](https://docs.atlas.mongodb.com/security-ldaps/) + [Lago de datos Atlas](https://docs.mongodb.com/datalake/) + [Cifrado en reposo mediante la administración de claves de cliente](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Métodos para asumir un rol ](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (documentación de IAM) + [Configurar el cifrado en el nivel de campo del cliente](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Automatic Encryption](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) + [Centro de confianza de MongoDB](https://www.mongodb.com/cloud/trust) + [Configure Security Features for Clusters](https://docs.atlas.mongodb.com/setup-cluster-security/) **Configuración de un nuevo entorno de MongoDB Atlas en ****AWS** + [Proveedores y regiones de la nube](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Manage Global Clusters](https://docs.atlas.mongodb.com/global-clusters/) + [Select Cluster Tier](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Configure Additional Settings](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Introducción a Atlas](https://docs.atlas.mongodb.com/getting-started/) + [Configure Access to the Atlas UI](https://docs.atlas.mongodb.com/organizations-projects/) **Migración de datos** + [Migrate or Import Data](https://www.mongodb.com/docs/atlas/import/) **Monitorear clústeres** + [Monitor Your Clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) **Integrar operaciones** + [Conectarse a un clúster](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interact with Your Data](https://docs.atlas.mongodb.com/data-explorer/) + [Monitor Your Clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Back Up, Restore, and Archive Data](https://docs.atlas.mongodb.com/backup-restore-cluster/) **GitHub repositorio** + [Transmita datos a MongoDB Atlas usando AWS Glue](https://github.com/mongodb-partners/Stream_Data_into_MongoDB_AWS_Glue?tab=readme-ov-file#troubleshooting) # Funciones de transición para una PeopleSoft aplicación de Oracle en Amazon RDS Custom for Oracle *Sampath Kathirvel, Amazon Web Services* ## Resumen Para ejecutar la solución de planificación de recursos PeopleSoft empresariales (ERP) de [Oracle](https://www.oracle.com/applications/peoplesoft/) en Amazon Web Services (AWS), puede utilizar [Amazon Relational Database Service (Amazon RDS) o Amazon RDS](https://aws.amazon.com/rds/) [Custom for](https://aws.amazon.com/rds/custom/) Oracle, que admite aplicaciones heredadas, personalizadas y empaquetadas que requieren acceso al sistema operativo (SO) y al entorno de base de datos subyacentes. Para conocer los factores clave a tener en cuenta durante la planificación de una migración, consulte [Estrategias de migración de bases de datos de Oracle](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/strategies.html) en Recomendaciones de AWS. Este patrón se centra en los pasos para realizar un cambio de Oracle Data Guard, o transición de funciones, para una base de datos de PeopleSoft aplicaciones que se ejecuta en Amazon RDS Custom como base de datos principal con una base de datos de réplica de lectura. El patrón incluye los pasos para configurar la [conmutación por error de inicio 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 este proceso, las bases de datos de la configuración de Oracle Data Guard siguen funcionando en sus nuevos roles. Los casos de uso típicos de transición a Oracle Data Guard son simulacros de recuperación de desastres (DR), actividades de mantenimiento programadas de las bases de datos y parches progresivos de [aplicación de parches en espera](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 obtener más información, consulte la publicación de blog [Reducir los tiempos de inactividad al parchear bases de datos en 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/). ## Requisitos previos y limitaciones **Requisitos previos** + Finalización del proceso [Add HA to Oracle PeopleSoft on Amazon RDS Custom mediante un patrón de réplica de lectura](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/add-ha-to-oracle-peoplesoft-on-amazon-rds-custom-by-using-a-read-replica.html). **Limitaciones ** + Limitaciones y configuraciones no compatibles con las [RDS Custom for Oracle](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.limits) + Limitaciones asociadas a las [réplicas de lectura de Amazon RDS Custom para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html#custom-rr.limitations) **Versiones de producto** + Para ver las versiones de la base de datos de Oracle compatibles con Amazon RDS Custom, consulte [RDS Custom para 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 ver las clases de instancias de la base de datos de Oracle compatibles con Amazon RDS Custom, consulte [Compatibilidad de clases de instancias de base de datos con RDS Custom para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.instances). ## Arquitectura **Pila de tecnología** + Amazon RDS Custom para Oracle **Arquitectura de destino** El siguiente diagrama muestra una instancia de base de datos de Amazon RDS Custom y una réplica de lectura de Amazon RDS Custom. Oracle Data Guard proporciona transición de roles durante la conmutación por error para la DR. ![\[Transición de Oracle Data Guard a una instancia de base de datos personalizada de RDS principal con una base de datos de réplica de lectura.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/da3b011c-1668-4de4-9079-0982888a74b4/images/4e2a2f3b-b5bd-44b7-9b5a-13a663ee3be6.png) Para ver una arquitectura representativa con Oracle PeopleSoft en AWS, consulte [Configurar una PeopleSoft arquitectura de alta disponibilidad en AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/set-up-a-highly-available-peoplesoft-architecture-on-aws.html). ## Tools (Herramientas) **Servicios de AWS** + [Amazon RDS Custom para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/working-with-custom-oracle.html) es un servicio de base de datos administrado para aplicaciones heredadas, personalizadas y empaquetadas que requieren acceso al sistema operativo y al entorno de base de datos subyacentes. + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) le permite reemplazar las credenciales codificadas en el código, incluidas las contraseñas, con una llamada a la API de Secrets Manager para recuperar el secreto mediante programación. En este patrón, recupera las contraseñas de usuario de la base de datos de Secrets Manager para `RDS_DATAGUARD` con el nombre 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| Administrador de base de datos | | Verifique el rol de instancia. | Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS. En la sección **Replicación** de la base de datos, en la pestaña **Conectividad y seguridad**, verifique el rol de instancia para la instancia principal y la réplica.El rol principal debe coincidir con la base de datos principal de Oracle Data Guard, y el rol de réplica debe coincidir con la base de datos física en espera de Oracle Data Guard. | Administrador de la nube, administrador de bases de datos | | Realice la transición. | Para realizar la transición, conéctese a `DGMGRL` desde el nodo principal.**No 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| Administrador de base de datos | | Verifique la conexión de Oracle Data Guard. | Tras la transición, compruebe la conexión de Oracle Data Guard desde el nodo principal a `DGMGRL`.**No 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| Administrador de base de datos | | Verifique el rol de instancia en la consola de Amazon RDS. | Tras realizar el cambio de rol, la consola de Amazon RDS muestra los nuevos roles en la sección **Replicación** de la pestaña **Conectividad y seguridad**, en **Bases de datos.** Es posible que el **Estado de replicación** tarde unos minutos en actualizarse de vacío a **Replicando**. | Administrador de base de datos | ### Configure la FSFO | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Restablezca la transición. | Vuelva a establecer la transición en el nodo principal. | Administrador de base de datos | | Instale e inicie el observador. | Un proceso de observación es un componente del cliente `DGMGRL` que, por lo general, se ejecuta en una máquina diferente a la de las bases de datos principal y en espera. La instalación de ORACLE HOME para el observador puede ser una instalación de Oracle Client Administrator. También puede instalar Oracle Database Enterprise Edition o Personal Edition. Para obtener más información sobre la instalación del observador para su versión de base de datos, consulte [Instalar e iniciar el 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 la alta disponibilidad para el proceso de observación, puede hacer lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/transition-roles-for-an-oracle-peoplesoft-application-on-amazon-rds-custom-for-oracle.html)En la versión 2 de Oracle 12c y versiones posteriores, puede implementar hasta tres observadores. Uno es el observador principal, y el resto son observadores de respaldo. Cuando el observador principal falla, uno de los observadores de respaldo asume el rol de principal. | Administrador de base de datos | | Conéctese a DGMGRL desde el host del observador. | El host del observador está configurado con entradas `tnsnames.ora` para la conectividad de las bases de datos principal y en espera. Puede habilitar la FSFO con el modo de protección de máximo rendimiento siempre que la pérdida de datos esté dentro de la [FastStartFailoverLagLimit](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/oracle-data-guard-broker-properties.html)configuración (valor en segundos). Sin embargo, debe utilizar el modo de protección de máxima disponibilidad para lograr una pérdida de datos cero (RPO=0).**No 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| Administrador de base de datos | | Modifique la base de datos en espera para que sea el objetivo de la conmutación por error. | Conéctese desde el nodo principal o desde el nodo de observador a una base de datos en espera. (Aunque su configuración puede tener varias bases de datos en espera, solo necesita conectarse a una en este momento).**No 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';| Administrador de base de datos | | Configure la conexión FastStartFailoverThreshold a la DGMGRL. | El valor predeterminado es de 30 segundos en Oracle 19c. El valor mínimo es de 6 segundos. Un valor inferior puede acortar el objetivo de tiempo de recuperación (RTO) durante la conmutación por error. Un valor superior ayuda a reducir la posibilidad de que se produzcan errores transitorios de conmutación por error innecesarios en la base de datos principal.El marco de automatización de RDS Custom para Oracle supervisa el estado de la base de datos y lleva a cabo acciones correctivas cada pocos segundos. Por lo tanto, se recomienda establecer un valor superior FastStartFailoverThreshold a 10 segundos. En el siguiente ejemplo, se configura el valor de umbral en 35 segundos.**No CBD o 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;| Administrador de base de datos | | Habilite la FSFO conectándose a DGMGRL desde el nodo principal o el nodo de observador. | Si la base de datos no tiene activada la [base de datos Flashback](https://docs.oracle.com/en/database/oracle/oracle-database/19/rcmrf/FLASHBACK-DATABASE.html#GUID-584AC79A-40C5-45CA-8C63-DED3BE3A4511), aparecerá el mensaje de advertencia `ORA-16827`. La base de datos retrospectiva opcional ayuda a restablecer automáticamente las bases de datos principales con errores a un punto en el tiempo anterior a la conmutación por error si la propiedad 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)configuración está establecida en `TRUE` (que es la predeterminada).**No 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;| Administrador de base de datos | | Inicie el observador para la supervisión de la FSFO y verifique el estado. | Puede iniciar el observador antes o después de activar la FSFO. Si la FSFO ya está habilitada, el observador comienza inmediatamente a supervisar el estado y las conexiones a las bases de datos principal y en espera. Si la FSFO no está habilitada, el observador no comienza a supervisar hasta que la FSFO esté habilitada.Al iniciar el observador, la configuración de base de datos principal se mostrará sin ningún mensaje de error, como demuestra el comando anterior `show configuration`.**No 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;| Administrador de base de datos | | Verifique la conmutación por error. | En este escenario, se puede realizar una prueba de conmutación por error deteniendo manualmente la instancia principal. EC2 Antes de detener la EC2 instancia, usa el `tail` comando para monitorear el archivo de registro del observador en función de tu configuración. Use `DGMGRL` para iniciar sesión en la base de datos en espera `orcl_d` con el usuario `RDS_DATAGUARD` y compruebe el estado de Oracle Data Guard. Debería mostrar que `orcl_d` es la nueva base de datos principal.En este escenario de prueba de conmutación por error, `orcl_d` es una base de datos no relacionada con CDB.Antes de la conmutación por error, la base de datos Flashback se ha habilitado en `orcl_a`. Cuando la anterior base de datos principal vuelva a estar en línea y regrese al estado `MOUNT`, el observador la restablecerá en una nueva base de datos en espera. La base de datos restablecida actúa como destino de la FSFO para la nueva base de datos principal. Puede verificar los detalles en los registros del 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 continuación se muestra un ejemplo de salida`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| Administrador de base de datos | ### Configure la conectividad entre la aplicación Oracle Peoplesoft y la base de datos | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree e inicie el servicio en la base de datos principal. | Puede evitar los cambios en la configuración de la aplicación durante la transición de rol con una entrada de TNS que contenga en la configuración los puntos de conexión de las bases de datos principal y en espera. Puede definir dos servicios de bases de datos basados en roles para admitir cargas de trabajo tanto como cargas de trabajo de read/write solo lectura. En el siguiente ejemplo, `orcl_rw` es el read/write servicio que está activo en la base de datos principal. `orcl_ro`es el servicio de solo lectura y está activo en la base de datos en espera que se ha abierto en modo de solo lectura.
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;| Administrador de base de datos | | Inicie el servicio en la base de datos en espera. | Para iniciar el servicio en la base de datos en espera de solo lectura, ejecute el siguiente código.
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;| Administrador de base de datos | | Automatice el inicio del servicio cuando se reinicie la base de datos principal. | Para iniciar automáticamente el servicio en la base de datos principal cuando se reinicie, ejecute el siguiente código.
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| Administrador de base de datos | | Configure una conexión entre la base de datos y la read/write de solo lectura. | Puede usar el siguiente ejemplo de configuración de aplicaciones para la conexión de solo lectura. read/write
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 =| Administrador de base de datos | ## Recursos relacionados + [Habilitar la alta disponibilidad con Data Guard en Amazon RDS Custom para Oracle](https://d1.awsstatic.com/whitepapers/enabling-high-availability-with-data-guard-on-amazon-rds-custom-for-oracle.pdf) (guía técnica de AWS) + [Configuración de Amazon RDS como una PeopleSoft base de datos de Oracle](https://d1.awsstatic.com/whitepapers/configuring-amazon-rds-as-peoplesoft-database.pdf) (documento técnico de AWS) + [Guía de agente de Oracle Data Guard](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/index.html) (documentación de referencia de Oracle) + [Oracle Data Guard Concepts and Administration](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/index.html)(documentación de referencia de Oracle) + [Requisitos de configuración de FAN y FCF específicos de 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) (documentación de referencia de Oracle) # Descarga de datos de un clúster de Amazon Redshift entre las cuentas a Amazon S3 *Andrew Kamel, Amazon Web Services* ## Resumen Al probar aplicaciones, resulta útil disponer de datos de producción en el entorno de pruebas. El uso de los datos de producción puede proporcionarle una evaluación más precisa de la aplicación que desarrolla. Este patrón extrae los datos de un clúster de Amazon Redshift en un entorno de producción para colocarlos en un bucket de Amazon Simple Storage Service (Amazon S3) en un entorno de desarrollo de Amazon Web Services (AWS). El patrón sigue los pasos de configuración de las cuentas de DEV y PROD, lo que incluye lo siguiente: + Recursos necesarios de + AWS Identity and Access Management Funciones (IAM) + Ajustes de red para subredes, grupos de seguridad y la nube privada virtual (VPC) para admitir la conexión de Amazon Redshift + Un ejemplo de AWS Lambda función con un tiempo de ejecución de Python para probar la arquitectura Para conceder acceso al clúster de Amazon Redshift, el patrón se utiliza AWS Secrets Manager para almacenar las credenciales pertinentes. La ventaja es disponer de toda la información necesaria para conectarse de manera directa al clúster de Amazon Redshift sin necesidad de saber dónde reside el clúster de Amazon Redshift. Además, puede [supervisar el uso del secreto](https://docs.aws.amazon.com/secretsmanager/latest/userguide/monitoring.html). El secreto guardado en Secrets Manager incluye el host del clúster de Amazon Redshift, el nombre de la base de datos, el puerto y las credenciales pertinentes. Para obtener información acerca de las consideraciones de seguridad al utilizar este patrón, consulte la sección [Prácticas recomendadas](#unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3-best-practices). ## Requisitos previos y limitaciones **Requisitos previos ** + Un [clúster de Amazon Redshift que se ejecuta](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html) en la cuenta de PROD + Un [bucket de S3 creado](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) en la cuenta de DEV. + [Emparejamiento de VPC](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html) entre las cuentas de DEV y PROD, con [tablas de rutas ajustadas](https://docs.aws.amazon.com/vpc/latest/peering/vpc-peering-routing.html) de manera adecuada. + [Los nombres de host de DNS y la resolución de DNS están habilitados para ambos sistemas](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html) interconectados VPCs **Limitaciones** + Según la cantidad de datos que quiera consultar, es posible que se agote el tiempo de espera de la función de Lambda. Si la ejecución tarda más tiempo que el tiempo de espera máximo de Lambda (15 minutos), utilice un enfoque asíncrono para el código de Lambda. El ejemplo de código de este patrón utiliza la biblioteca [psycopg2](https://github.com/psycopg/psycopg2) para Python, que actualmente no admite el procesamiento asíncrono. + Algunos Servicios de AWS no están disponibles en todos. Regiones de AWS Para conocer la disponibilidad de las regiones, consulte [Servicios de AWS by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para los puntos de conexión específicos, consulte la página [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) y elija el enlace del servicio. ## Arquitectura En el diagrama siguiente, se muestra la arquitectura de destino, con cuentas de DEV y PROD. ![\[La VPC de Lambda en la cuenta de DEV y la VPC de Amazon Redshift en la cuenta de PROD.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/fa4d01df-483d-4454-9711-b391ebbe4629.png) En el diagrama, se muestra el siguiente flujo de trabajo: 1. La función de Lambda de la cuenta de DEV asume el rol de IAM necesario para acceder a las credenciales de Amazon Redshift en Secrets Manager de la cuenta de PROD. A continuación, la función de Lambda recupera el secreto del clúster de Amazon Redshift. 1. La función Lambda de la cuenta DEV utiliza la información para conectarse al clúster de Amazon Redshift de la cuenta PROD a través del peered. VPCs A continuación, la función de Lambda envía un comando de descarga para consultar el clúster de Amazon Redshift en la cuenta de PROD. 1. El clúster de Amazon Redshift de la cuenta de PROD asume el rol de IAM correspondiente para acceder al bucket de S3 de la cuenta de DEV. El clúster de Amazon Redshift descarga los datos consultados en el bucket de S3 de la cuenta de DEV. **Consulta de datos de Amazon Redshift** En el diagrama siguiente se muestran los roles que se utilizan para recuperar las credenciales de Amazon Redshift y conectarse al clúster de Amazon Redshift. El flujo de trabajo lo inicia la función de Lambda. ![\[El proceso de tres pasos para asumir roles en las cuentas.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/ab25b72c-773c-4d58-9012-4a3755c181ff.png) En el diagrama, se muestra el siguiente flujo de trabajo: 1. El rol `CrossAccount-SM-Read-Role` en la cuenta de DEV asume que el rol `SM-Read-Role` se encuentra en la cuenta de PROD. 1. El rol `SM-Read-Role` utiliza la política adjunta para recuperar el secreto de Secrets Manager. 1. Las credenciales se utilizan para acceder al clúster de Amazon Redshift. **Descarga de datos en Amazon S3** En el diagrama siguiente se muestra el proceso de lectura y escritura entre cuentas para extraer los datos y cargarlo a Amazon S3. El flujo de trabajo lo inicia la función de Lambda. El patrón [encadena los roles de IAM en Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html#authorizing-redshift-service-chaining-roles). El comando unload que proviene del clúster de Amazon Redshift asume el rol `CrossAccount-S3-Write-Role` y, a continuación, asume el rol `S3-Write-Role`. Este encadenamiento de roles da a Amazon Redshift acceso a Amazon S3. ![\[Los roles que obtienen credenciales acceden a Amazon Redshift y cargan datos en Amazon S3.\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/d2982fc6-1d12-4f9d-9493-a99ce691d693.png) En el flujo de trabajo se incluyen los pasos siguientes: 1. El rol `CrossAccount-SM-Read-Role` en la cuenta de DEV asume que el rol `SM-Read-Role` se encuentra en la cuenta de PROD. 1. El rol `SM-Read-Role` recupera las credenciales de Amazon Redshift de Secrets Manager. 1. La función de Lambda se conecta al clúster de Amazon Redshift y envía una consulta. 1. El clúster de Amazon Redshift asume el rol `CrossAccount-S3-Write-Role`. 1. El rol `CrossAccount-S3-Write-Role` supone que el rol `S3-Write-Role` se encuentra en la cuenta de DEV. 1. Los resultados de la consulta se descargan en el bucket de S3 de la cuenta de DEV. ## Tools (Herramientas) **Servicios de AWS** + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) le ayuda a crear y controlar claves criptográficas para proteger sus datos. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) es un servicio de computación que ayuda a ejecutar código sin necesidad de aprovisionar ni administrar servidores. Ejecuta el código solo cuando es necesario y amplía la capacidad de manera automática, por lo que solo pagará por el tiempo de procesamiento que utilice. + [Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html) es un servicio de almacenamiento de datos administrado de varios petabytes en la nube de AWS. + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) lo ayuda a reemplazar las credenciales codificadas en su código, incluidas contraseñas, con una llamada a la API de Secrets Manager para recuperar el secreto mediante programación. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) es un servicio de almacenamiento de objetos basado en la nube que lo ayuda a almacenar, proteger y recuperar cualquier cantidad de datos. **Repositorio de código** El código de este patrón está disponible en el repositorio GitHub [unload-redshift-to-s3-python](https://github.com/aws-samples/unload-redshift-to-s3-python/). ## Prácticas recomendadas **Exención de responsabilidad de seguridad** Antes de implementar esta solución, tenga en cuenta las siguientes recomendaciones de seguridad importantes: + Recuerde que conectar las cuentas de desarrollo y producción puede aumentar el alcance y reducir la posición de seguridad general. Recomendamos implementar esta solución solo de manera temporal, extraer la parte de los datos necesaria y, a continuación, destruir de inmediato los recursos implementados. Para destruir los recursos, debe eliminar la función de Lambda, eliminar todos los roles y políticas de IAM que se crearon para esta solución y revocar el acceso a la red que se haya concedido entre las cuentas. + Consulte a sus equipos de seguridad y cumplimiento antes de copiar los datos de los entornos de producción a los de desarrollo. Por lo general, la información de identificación personal (PII), la información de salud protegida (PHI) y otros datos confidenciales o regulados no deben copiarse de esta manera. Copie solo la información no confidencial que esté disponible al público (por ejemplo, datos bursátiles públicos del frontend de una tienda). Considere la posibilidad de tokenizar o anonimizar los datos, o de generar datos de prueba sintéticos, en lugar de utilizar los datos de producción siempre que sea posible. Uno de los [principios de seguridad de AWS](https://docs.aws.amazon.com/en_us/wellarchitected/2022-03-31/framework/sec-design.html) es mantener a las personas alejadas de los datos. En otras palabras, los desarrolladores no deben realizar operaciones en la cuenta de producción. + Restrinja el acceso a la función de Lambda en la cuenta de desarrollo porque puede leer datos del clúster de Amazon Redshift en el entorno de producción. + Para evitar interrumpir el entorno de producción, implemente las recomendaciones siguientes: + Utilice una cuenta de desarrollo independiente y dedicada para las actividades de prueba y desarrollo. + Implemente controles estrictos de acceso a la red y limite el tráfico entre las cuentas a solo lo necesario. + Supervise y audite el acceso al entorno de producción y a los orígenes de datos. + Implemente controles de acceso con privilegios mínimos para todos los recursos y servicios implicados. + Revise y modifique periódicamente las credenciales, como AWS Secrets Manager los secretos y las claves de acceso a los roles de IAM. + Consulte la documentación de seguridad siguiente para ver los servicios que se utilizan en este artículo: + [AWS Lambda seguridad](https://docs.aws.amazon.com/lambda/latest/dg/lambda-security.html) + [Seguridad de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/iam-redshift-user-mgmt.html) + [Seguridad de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/security.html) + [AWS Secrets Manager seguridad](https://docs.aws.amazon.com/secretsmanager/latest/userguide/security.html) + [Prácticas recomendadas de seguridad de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) La seguridad es una de las prioridades principales al acceder a los datos y recursos de producción. Siga siempre las prácticas recomendadas, implemente controles de acceso con privilegios mínimos y revise y actualice de manera periódica sus medidas de seguridad. ## Epics ### Datos de consulta de Amazon Redshift | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree un secreto para el clúster de Amazon Redshift. | Para crear el secreto para el clúster de Amazon Redshift, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingeniero | | Cree un rol para acceder a Secrets Manager. | Para crear el rol, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingeniero | ### Descargar datos en Amazon S3 | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Cree un rol para acceder al bucket de S3. | Para crear el rol y acceder al bucket de S3, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingeniero | | Cree el rol de Amazon Redshift. | Para crear el rol de Amazon Redshift, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingeniero | ### Implementación de la función de Lambda | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Implemente la función de Lambda. | Para implementar una función de Lambda en la VPC emparejada, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingeniero | ### Prueba de la arquitectura | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Importe los recursos necesarios. | Para importar los recursos necesarios, ejecute los comandos siguientes:
(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| Desarrollador de aplicaciones | | Ejecute la función de controlador de Lambda. | La función Lambda usa AWS Security Token Service (AWS STS) para el acceso entre cuentas y la administración temporal de credenciales. La función utiliza la operación AssumeRole API para asumir temporalmente los permisos de la `sm_read_role` función de IAM.Para ejecutar la función de Lambda, utilice el código de ejemplo siguiente:
import boto3
import psycopg2
import base64
from botocore.exceptions import ClientError
def lambda_handler(event, context):| Desarrollador de aplicaciones | | Obtenga el secreto. | Para obtener el secreto de Amazon Redshift, utilice el código de ejemplo siguiente:
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):| Desarrollador de aplicaciones | | Ejecute el comando unload. | Para descargar los datos en el bucket de S3 utilice el código de ejemplo siguiente:
# 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):| Desarrollador de aplicaciones | ### Limpieza | Tarea | Descripción | Habilidades requeridas | | --- | --- | --- | | Elimine la función de Lambda. | Para evitar incurrir en costos imprevistos, elimine los recursos y la conexión entre las cuentas de DEV y PROD.Para quitar la función de Lambda, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingeniero | | Elimine las políticas y los roles de IAM. | Elimine las políticas y los roles de IAM de las cuentas de DEV y PROD.En la cuenta de DEV, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html)En la cuenta de PROD, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingeniero | | Elimine el secreto en Secrets Manager. | Para eliminar el secreto, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingeniero | | Elimine las reglas de grupos de seguridad y emparejamiento de VPC. | Para eliminar las reglas de grupos de seguridad y emparejamiento de VPC, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingeniero | | Elimine los datos del bucket de S3. | Para eliminar los datos de Amazon S3, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingeniero | | Limpia AWS KMS las llaves. | Si ha creado alguna AWS KMS clave personalizada para el cifrado, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingeniero | | Revisa y elimina los CloudWatch registros de Amazon. | Para eliminar los CloudWatch registros, haga lo siguiente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingeniero | ## Recursos relacionados + [ CloudWatch Documentación de Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) + [documentación de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) + [Documentación de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) + [Documentación de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html) + [Documentación de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) + [AWS Secrets Manager documentación](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) + [AWS principios de seguridad](https://docs.aws.amazon.com/en_us/wellarchitected/2022-03-31/framework/sec-design.html) ## Información adicional Después de descargar los datos de Amazon Redshift en Amazon S3, puede analizarlos mediante Amazon Athena. [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/getting-started.html) es un servicio de consultas de macrodatos que resulta útil cuando es necesario acceder a volúmenes grandes de datos. Puede utilizar Athena sin tener que aprovisionar servidores ni bases de datos. Athena admite consultas complejas y puede ejecutarla en objetos distintos. Como ocurre con la mayoría Servicios de AWS, la principal ventaja de usar Athena es que proporciona una gran flexibilidad en la forma de ejecutar las consultas sin la complejidad adicional. Cuando utiliza Athena, puede consultar distintos tipos de datos, como CSV y JSON, en Amazon S3 sin cambiar el tipo de datos. Puede consultar datos de diversas fuentes, incluso externas AWS. Athena reduce la complejidad porque no es necesario que administre los servidores. Athena lee los datos de manera directa de Amazon S3 sin cargarlos ni cambiarlos antes de ejecutar la consulta. # Patrones de migración de bases de datos según carga de trabajo **Topics** + [IBM](databases-database-migration-patterns-by-workload-ibm-pattern-list.md) + [Microsoft](databases-database-migration-patterns-by-workload-microsoft-pattern-list.md) + [N/A](databases-database-migration-patterns-by-workload-notapplicable-pattern-list.md) + [Código abierto](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 una base de datos Db2 de Amazon EC2 a Aurora compatible con MySQL mediante AWS DMS](migrate-a-db2-database-from-amazon-ec2-to-aurora-mysql-compatible-by-using-aws-dms.md) + [Migre Db2 for LUW a Amazon EC2 mediante el envío de registros para reducir el tiempo de interrupción](migrate-db2-for-luw-to-amazon-ec2-by-using-log-shipping-to-reduce-outage-time.md) + [Migración de Db2 para LUW a Amazon EC2 con recuperación de desastres de alta disponibilidad](migrate-db2-for-luw-to-amazon-ec2-with-high-availability-disaster-recovery.md) + [Migre de IBM Db2 en Amazon EC2 a Aurora compatible con PostgreSQL mediante AWS DMS y AWS SCT](migrate-from-ibm-db2-on-amazon-ec2-to-aurora-postgresql-compatible-using-aws-dms-and-aws-sct.md) + [Migre de IBM WebSphere Application Server a Apache Tomcat en Amazon EC2](migrate-from-ibm-websphere-application-server-to-apache-tomcat-on-amazon-ec2.md) + [Transmita datos desde IBM Db2, SAP, Sybase y otras bases de datos a MongoDB Atlas en AWS](stream-data-from-ibm-db2-to-mongodb-atlas.md) # Microsoft **Topics** + [Acelere el descubrimiento y la migración de las cargas de trabajo de Microsoft a AWS](accelerate-the-discovery-and-migration-of-microsoft-workloads-to-aws.md) + [Acceda a tablas locales de Microsoft SQL Server desde Microsoft SQL Server en Amazon EC2 mediante servidores enlazados](access-on-premises-microsoft-sql-server-tables-from-microsoft-sql-server-on-amazon-ec2-using-linked-servers.md) + [Evaluar el rendimiento de las consultas para migrar bases de datos de SQL Server a MongoDB Atlas en AWS](assess-query-performance-for-migrating-sql-server-databases-to-mongodb-atlas-on-aws.md) + [Automatice las tareas de bases de datos en la edición SQL Server Express que se ejecuta en Amazon EC2 mediante AWS Lambda un programador de tareas](automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.md) + [Cambie las aplicaciones de Python y Perl para que admitan la migración de bases de datos de Microsoft SQL Server a una edición compatible con PostgreSQL de Amazon Aurora](change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.md) + [Configure el enrutamiento de solo lectura en un grupo de disponibilidad Always On en SQL Server en AWS](configure-read-only-routing-in-an-always-on-availability-group-in-sql-server-on-aws.md) + [Configure la autenticación de Windows para Amazon RDS for Microsoft SQL Server mediante AWS Managed Microsoft AD](configure-windows-authentication-for-amazon-rds-using-microsoft-ad.md) + [Cree CloudFormation plantillas de AWS para las tareas de AWS DMS con Microsoft Excel y Python](create-aws-cloudformation-templates-for-aws-dms-tasks-using-microsoft-excel-and-python.md) + [Implemente instancias de clústeres de conmutación por error de SQL Server en Amazon EC2 y Amazon FSx mediante Terraform](deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.md) + [Exportación de una base de datos de Microsoft SQL Server a Amazon S3 mediante AWS DMS](export-a-microsoft-sql-server-database-to-amazon-s3-by-using-aws-dms.md) + [Exporte tablas de Amazon RDS para SQL Server a un bucket de S3 mediante AWS DMS](export-amazon-rds-for-sql-server-tables-to-an-s3-bucket-by-using-aws-dms.md) + [Implemente SHA1 el hash para los datos de PII al migrar de SQL Server a PostgreSQL](implement-sha1-hashing-for-pii-data-when-migrating-from-sql-server-to-postgresql.md) + [Incorpore y migre instancias de EC2 Windows a una cuenta de AWS Managed Services](ingest-and-migrate-ec2-windows-instances-into-an-aws-managed-services-account.md) + [Configure un clúster de conmutación por error de Microsoft SQL Server en Amazon EC2 utilizando FSx Windows File Server](microsoft-sql-failover-cluster-on-amazon-ec2.md) + [Migración de una cola de mensajes de Microsoft Azure Service Bus a Amazon SQS](migrate-a-messaging-queue-from-microsoft-azure-service-bus-to-amazon-sqs.md) + [Migre una base de datos de Microsoft SQL Server de Amazon EC2 a Amazon DocumentDB mediante AWS DMS](migrate-a-microsoft-sql-server-database-from-amazon-ec2-to-amazon-documentdb-by-using-aws-dms.md) + [Migración de una base de datos de Microsoft SQL Server a Aurora MySQL mediante AWS DMS y AWS SCT](migrate-a-microsoft-sql-server-database-to-aurora-mysql-by-using-aws-dms-and-aws-sct.md) + [Migración de una aplicación .NET de Microsoft Azure App Service a AWS Elastic Beanstalk](migrate-a-net-application-from-microsoft-azure-app-service-to-aws-elastic-beanstalk.md) + [Migre una base de datos local de Microsoft SQL Server a Amazon EC2](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-ec2.md) + [Migración de una base de datos de Microsoft SQL Server en las instalaciones a Amazon RDS para SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server.md) + [Migración de bases de datos en las instalaciones de Microsoft SQL Server a Amazon RDS para SQL Server mediante servidores vinculados](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-linked-servers.md) + [Migración de una base de datos de Microsoft SQL Server en las instalaciones a Amazon RDS para SQL Server mediante métodos nativos de copia de seguridad y restauración](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-native-backup-and-restore-methods.md) + [Migración de una base de datos de Microsoft SQL Server en las instalaciones a Amazon Redshift mediante AWS DMS](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-dms.md) + [Migración de una base de datos en las instalaciones de Microsoft SQL Server a Amazon Redshift mediante agentes de extracción de datos de AWS SCT](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.md) + [Migre una base de datos local de Microsoft SQL Server a Microsoft SQL Server en Amazon EC2 con Linux](migrate-an-on-premises-microsoft-sql-server-database-to-microsoft-sql-server-on-amazon-ec2-running-linux.md) + [Migración de datos de Microsoft Azure Blob a Amazon S3 mediante Rclone](migrate-data-from-microsoft-azure-blob-to-amazon-s3-by-using-rclone.md) + [Migre aplicaciones alojadas en IIS a Amazon EC2 mediante appcmd.exe](migrate-iis-hosted-applications-to-amazon-ec2-by-using-appcmd.md) + [Migre el grupo de disponibilidad Always On de Microsoft SQL Server mediante AWS Application Migration Service](migrate-microsoft-sql-server-always-on-group-using-mgn.md) + [Migre una base de datos local de Microsoft SQL Server a Amazon EC2 mediante Application Migration Service](migrate-microsoft-sql-server-to-amazon-ec2-using-aws-mgn.md) + [Migrar una base de datos relacional a MongoDB Atlas en AWS](migrate-relational-database-to-mongodb-atlas.md) + [Migración de SQL Server a AWS mediante grupos de disponibilidad distribuidos](migrate-sql-server-to-aws-using-distributed-availability-groups.md) + [Migración de los certificados SSL de Windows a un equilibrador de carga de aplicación mediante ACM](migrate-windows-ssl-certificates-to-an-application-load-balancer-using-acm.md) + [Vuelva a alojar las cargas de trabajo en las instalaciones en la nube de AWS: lista de verificación de migración](rehost-on-premises-workloads-in-the-aws-cloud-migration-checklist.md) + [Resolver los errores de conexión después de migrar Microsoft SQL Server a la nube de AWS](resolve-connection-errors-after-migrating-microsoft-sql-server-to-the-aws-cloud.md) + [Envíe notificaciones para una instancia de base de datos de Amazon RDS para SQL Server mediante un servidor SMTP en las instalaciones y el Correo de base de datos](send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.md) + [Configure una CI/CD canalización para la migración de bases de datos mediante Terraform](set-up-ci-cd-pipeline-for-db-migration-with-terraform.md) + [Configure una infraestructura Multi-AZ para una FCI Always On de SQL Server mediante Amazon FSx](set-up-multi-az-infrastructure-for-a-sql-server-always-on-fci-by-using-amazon-fsx.md) # N/A **Topics** + [Cree un proceso de aprobación para las solicitudes de firewall durante una migración de realojamiento a AWS](create-an-approval-process-for-firewall-requests-during-a-rehost-migration-to-aws.md) + [Cifrar una instancia de base de datos de Amazon RDS para PostgreSQL existente](encrypt-an-existing-amazon-rds-for-postgresql-db-instance.md) + [Costos de almacenamiento estimados para una tabla de Amazon DynamoDB](estimate-storage-costs-for-an-amazon-dynamodb-table.md) + [Implemente recuperación de desastres entre regiones con AWS DMS y Amazon Aurora](implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.md) # Código abierto **Topics** + [Generación automática de un modelo de PynamoDB y funciones CRUD para Amazon DynamoDB mediante una aplicación de Python](automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.md) + [Conectar mediante un túnel SSH en pgAdmin](connect-by-using-an-ssh-tunnel-in-pgadmin.md) + [Crear usuarios y roles de aplicaciones en Aurora compatible con PostgreSQL](create-application-users-and-roles-in-aurora-postgresql-compatible.md) + [Habilite conexiones cifradas para instancias de base de datos de PostgreSQL en Amazon RDS](enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.md) + [Migre Amazon RDS for Oracle a Amazon RDS for PostgreSQL con y utilizando y AWS SCT 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) + [Migración de una base de datos de MariaDB en las instalaciones hasta Amazon RDS para MariaDB mediante herramientas nativas](migrate-an-on-premises-mariadb-database-to-amazon-rds-for-mariadb-using-native-tools.md) + [Migración de una base de datos MySQL en las instalaciones a Amazon EC2](migrate-an-on-premises-mysql-database-to-amazon-ec2.md) + [Migración de una base de datos MySQL en las instalaciones a Amazon RDS para MySQL](migrate-an-on-premises-mysql-database-to-amazon-rds-for-mysql.md) + [Migración de una base de datos de MySQL en las instalaciones a Aurora MySQL](migrate-an-on-premises-mysql-database-to-aurora-mysql.md) + [Migración de una base de datos PostgreSQL en las instalaciones a Aurora PostgreSQL](migrate-an-on-premises-postgresql-database-to-aurora-postgresql.md) + [Migrar una base de datos de Couchbase Server a Amazon EC2](migrate-couchbase-server-ec2.md) + [Migre de IBM WebSphere Application Server a Apache Tomcat en Amazon EC2 con Auto Scaling](migrate-from-ibm-websphere-application-server-to-apache-tomcat-on-amazon-ec2-with-auto-scaling.md) + [Migre de Oracle 8i o 9i a Amazon RDS para Oracle con AWS DMS SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.md) + [Migre de PostgreSQL en EC2 Amazon a Amazon RDS para PostgreSQL mediante pglogical](migrate-from-postgresql-on-amazon-ec2-to-amazon-rds-for-postgresql-using-pglogical.md) + [Migración de aplicaciones Java locales en las instalaciones a AWS mediante AWS App2Container](migrate-on-premises-java-applications-to-aws-using-aws-app2container.md) + [Migre bases de datos MySQL locales a Aurora MySQL mediante Percona, XtraBackup Amazon EFS y Amazon S3](migrate-on-premises-mysql-databases-to-aurora-mysql-using-percona-xtrabackup-amazon-efs-and-amazon-s3.md) + [Migración de tablas externas de Oracle a Amazon Aurora compatible con PostgreSQL](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md) + [Migración de funciones y procedimientos de Oracle con más de 100 argumentos a PostgreSQL](migrate-oracle-functions-and-procedures-that-have-more-than-100-arguments-to-postgresql.md) + [Migración de las cargas de trabajo de Redis a Redis Enterprise Cloud en AWS](migrate-redis-workloads-to-redis-enterprise-cloud-on-aws.md) + [Supervisar Amazon Aurora en busca de instancias sin cifrado](monitor-amazon-aurora-for-instances-without-encryption.md) + [Reinicie el AWS Replication Agent automáticamente sin deshabilitarlo SELinux después de reiniciar un servidor fuente de RHEL](restart-the-aws-replication-agent-automatically-without-disabling-selinux-after-rebooting-a-rhel-source-server.md) + [Programe trabajos para Amazon RDS para PostgreSQL y Aurora PostgreSQL mediante Lambda y Secrets Manager](schedule-jobs-for-amazon-rds-for-postgresql-and-aurora-postgresql-by-using-lambda-and-secrets-manager.md) + [Transportar bases de datos PostgreSQL entre dos instancias de base de datos de Amazon RDS utilizando pg\$1transport](transport-postgresql-databases-between-two-amazon-rds-db-instances-using-pg-transport.md) + [Descarga de datos de un clúster de Amazon Redshift entre las cuentas a Amazon S3](unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.md) # Oracle **Topics** + [Agregue HA a Oracle PeopleSoft en Amazon RDS Custom mediante una réplica de lectura](add-ha-to-oracle-peoplesoft-on-amazon-rds-custom-by-using-a-read-replica.md) + [Convertir consultas JSON de Oracle en SQL de bases de datos PostgreSQL](convert-json-oracle-queries-into-postgresql-database-sql.md) + [Convierta VARCHAR2 (1) el tipo de datos de Oracle en un tipo de datos booleano para Amazon Aurora PostgreSQL](convert-varchar2-1-data-type-for-oracle-to-boolean-data-type-for-amazon-aurora-postgresql.md) + [Emule Oracle DR mediante una base de datos global de Aurora compatible con PostgreSQL](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md) + [Emule las matrices PL/SQL asociativas de Oracle en Amazon Aurora PostgreSQL y Amazon RDS for PostgreSQL](emulate-oracle-plsql-associative-arrays-in-aurora-and-rds-postgresql.md) + [Calcule el tamaño del motor de Amazon RDS para una base de datos de Oracle mediante informes de AWR](estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.md) + [Gestionar bloques anónimos en instrucciones SQL dinámicas en Aurora PostgreSQL](handle-anonymous-blocks-in-dynamic-sql-statements-in-aurora-postgresql.md) + [Migración gradual de Amazon RDS para Oracle a Amazon RDS para PostgreSQL con Oracle SQL Developer y AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md) + [Cargar archivos BLOB en TEXT mediante la codificación de archivos en Aurora compatible con PostgreSQL](load-blob-files-into-text-by-using-file-encoding-in-aurora-postgresql-compatible.md) + [Migración de Amazon RDS para Oracle a Amazon RDS para PostgreSQL en modo SSL mediante AWS DMS](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-in-ssl-mode-by-using-aws-dms.md) + [Migre una base de datos de Amazon RDS for Oracle a Cuenta de AWS otra Región de AWS y AWS DMS utilícela para la replicación continua](migrate-an-amazon-rds-for-oracle-database-to-another-aws-account-and-aws-region-using-aws-dms-for-ongoing-replication.md) + [Migre una base de datos Oracle local a Amazon EC2 mediante Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-ec2-by-using-oracle-data-pump.md) + [Migre una base de datos Oracle local a Amazon OpenSearch Service mediante Logstash](migrate-an-on-premises-oracle-database-to-amazon-opensearch-service-using-logstash.md) + [Migración de una base de datos de Oracle en las instalaciones a Amazon RDS para MySQL con AWS DMS y AWS SCT](migrate-an-on-premises-oracle-database-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migración de una base de datos de Oracle en las instalaciones a Amazon RDS para Oracle](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle.md) + [Migración de una base de datos de Oracle en las instalaciones a Amazon RDS para Oracle mediante Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-by-using-direct-oracle-data-pump-import-over-a-database-link.md) + [Migración de una base de datos de Oracle en las instalaciones a Amazon RDS para Oracle mediante Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-using-oracle-data-pump.md) + [Migración de una base de datos de Oracle en las instalaciones a Amazon RDS para PostgreSQL mediante Oracle Bystander y AWS DMS](migrate-an-on-premises-oracle-database-to-amazon-rds-for-postgresql-by-using-an-oracle-bystander-and-aws-dms.md) + [Migre una base de datos Oracle local a Oracle on Amazon EC2](migrate-an-on-premises-oracle-database-to-oracle-on-amazon-ec2.md) + [Migre una base de datos Oracle de Amazon EC2 a Amazon RDS para MariaDB con AWS DMS y AWS SCT](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-mariadb-using-aws-dms-and-aws-sct.md) + [Migre una base de datos Oracle de Amazon EC2 a Amazon RDS for Oracle mediante AWS DMS](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-oracle-using-aws-dms.md) + [Migración de una base de datos de Oracle a Amazon DynamoDB mediante AWS DMS](migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.md) + [Migre una base de datos Oracle a Amazon RDS for Oracle mediante adaptadores de archivos planos de GoldenGate Oracle](migrate-an-oracle-database-to-amazon-rds-for-oracle-by-using-oracle-goldengate-flat-file-adapters.md) + [Migración de una base de datos de Oracle a Amazon Redshift con AWS DMS y AWS SCT](migrate-an-oracle-database-to-amazon-redshift-using-aws-dms-and-aws-sct.md) + [Migración de una base de datos de Oracle a Aurora PostgreSQL con AWS DMS y AWS SCT](migrate-an-oracle-database-to-aurora-postgresql-using-aws-dms-and-aws-sct.md) + [Migre una EnterpriseOne base de datos de Oracle JD Edwards a AWS mediante Oracle Data Pump y AWS DMS](migrate-an-oracle-jd-edwards-enterpriseone-database-to-aws-by-using-oracle-data-pump-and-aws-dms.md) + [Migración de una tabla particionada de Oracle a PostgreSQL mediante AWS DMS](migrate-an-oracle-partitioned-table-to-postgresql-by-using-aws-dms.md) + [Migre una PeopleSoft base de datos de Oracle a AWS mediante AWS DMS](migrate-an-oracle-peoplesoft-database-to-aws-by-using-aws-dms.md) + [Migración de datos de una base de datos de Oracle en las instalaciones a Aurora PostgreSQL](migrate-data-from-an-on-premises-oracle-database-to-aurora-postgresql.md) + [Migración de de Amazon RDS para Oracle a Amazon RDS para MySQL](migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-mysql.md) + [Migración de Oracle 8i o 9i a Amazon RDS para PostgreSQL mediante la vista materializada y AWS DMS](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-materialized-views-and-aws-dms.md) + [Migre de Oracle 8i o 9i a Amazon RDS para PostgreSQL mediante AWS DMS SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-shareplex-and-aws-dms.md) + [Migre de Oracle Database a Amazon RDS for PostgreSQL mediante Oracle GoldenGate](migrate-from-oracle-database-to-amazon-rds-for-postgresql-by-using-oracle-goldengate.md) + [Migración de Oracle en Amazon EC2 a Amazon RDS para MySQL con AWS DMS y AWS SCT](migrate-from-oracle-on-amazon-ec2-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migre de Oracle WebLogic a Apache Tomcat (ToMEE) en Amazon ECS](migrate-from-oracle-weblogic-to-apache-tomcat-tomee-on-amazon-ecs.md) + [Migración de índices basados en funciones de Oracle a PostgreSQL](migrate-function-based-indexes-from-oracle-to-postgresql.md) + [Migración de aplicaciones heredadas de Oracle Pro\$1C a ECPG](migrate-legacy-applications-from-oracle-pro-c-to-ecpg.md) + [Migración de valores CLOB de Oracle a filas individuales en PostgreSQL en AWS](migrate-oracle-clob-values-to-individual-rows-in-postgresql-on-aws.md) + [Migración de códigos de error de Oracle Database a una base de datos Amazon Aurora compatible con PostgreSQL](migrate-oracle-database-error-codes-to-an-amazon-aurora-postgresql-compatible-database.md) + [Migración de las funciones nativas de Oracle a PostgreSQL mediante extensiones](migrate-oracle-native-functions-to-postgresql-using-extensions.md) + [Migre Oracle PeopleSoft a Amazon RDS Custom](migrate-oracle-peoplesoft-to-amazon-rds-custom.md) + [Migración de la funcionalidad ROWIdentificador de Oracle a PostgreSQL en AWS](migrate-oracle-rowid-functionality-to-postgresql-on-aws.md) + [Migración de los paquetes pragma SERIALLY\$1REUTILIZABLE de Oracle a PostgreSQL](migrate-oracle-serially-reusable-pragma-packages-into-postgresql.md) + [Migración de columnas generadas de forma virtual de Oracle a PostgreSQL](migrate-virtual-generated-columns-from-oracle-to-postgresql.md) + [Supervise GoldenGate los registros de Oracle mediante Amazon CloudWatch](monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.md) + [Análisis de las dependencias de los objetos para realizar migraciones parciales de bases de datos de Oracle a PostgreSQL](multilevel-object-analysis-for-database-migration-from-oracle-to-postgresql.md) + [Redefina la plataforma de Oracle Database Enterprise Edition a Standard Edition 2 en Amazon RDS para Oracle](replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.md) + [Configure una HA/DR arquitectura para Oracle E-Business Suite en Amazon RDS Custom con una base de datos en espera activa](set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database.md) + [Configure la funcionalidad UTL\$1FILE de Oracle en Aurora compatible con PostgreSQL](set-up-oracle-utl_file-functionality-on-aurora-postgresql-compatible.md) + [Funciones de transición para una PeopleSoft aplicación de Oracle en Amazon RDS Custom for Oracle](transition-roles-for-an-oracle-peoplesoft-application-on-amazon-rds-custom-for-oracle.md) + [Validar los objetos de la base de datos después de migrar de Oracle a Amazon Aurora PostgreSQL](validate-database-objects-after-migrating-from-oracle-to-amazon-aurora-postgresql.md) # SAP **Topics** + [Realice copias de seguridad automáticas de las bases de datos de SAP HANA mediante Systems Manager y EventBridge](automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.md) + [Migración de SAP ASE a Amazon RDS para SQL Server utilizando AWS DMS](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md) + [Migre SAP ASE de Amazon EC2 a Amazon Aurora compatible con PostgreSQL mediante AWS SCT y AWS DMS](migrate-sap-ase-on-amazon-ec2-to-amazon-aurora-postgresql-compatible-using-aws-sct-and-aws-dms.md) + [Migración de SAP HANA a AWS mediante SAP HSR con el mismo nombre de host](migrate-sap-hana-to-aws-using-sap-hsr-with-the-same-hostname.md) + [Configurar la recuperación de desastres para SAP en IBM Db2 en AWS](set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.md) # Más patrones **Topics** + [Acceso a una base de datos de Amazon Neptune desde un contenedor de Amazon EKS](access-amazon-neptune-database-from-amazon-eks-container.md) + [Acceder, consultar y unirse a las tablas de Amazon DynamoDB con Athena](access-query-and-join-amazon-dynamodb-tables-using-athena.md) + [Permitir a EC2 las instancias el acceso de escritura a los buckets de S3 en las cuentas de AMS](allow-ec2-instances-write-access-to-s3-buckets-in-ams-accounts.md) + [Analice y visualice datos JSON anidados con Amazon Athena y Amazon Quick Sight](analyze-and-visualize-nested-json-data-with-amazon-athena-and-amazon-quicksight.md) + [Automatizar las copias de seguridad de las instancias de base de datos de Amazon RDS para PostgreSQL mediante AWS Batch](automate-backups-for-amazon-rds-for-postgresql-db-instances-by-using-aws-batch.md) + [Archivar automáticamente los elementos en Amazon S3 con DynamoDB TTL](automatically-archive-items-to-amazon-s3-using-dynamodb-ttl.md) + [Corrija automáticamente las instancias y los clústeres de bases de datos de Amazon RDS no cifrados](automatically-remediate-unencrypted-amazon-rds-db-instances-and-clusters.md) + [Detener e iniciar automáticamente una instancia de base de datos de Amazon RDS mediante AWS Systems Manager Maintenance Windows](automatically-stop-and-start-an-amazon-rds-db-instance-using-aws-systems-manager-maintenance-windows.md) + [Construye una AWS landing zone que incluya MongoDB Atlas](build-aws-landing-zone-that-includes-mongodb-atlas.md) + [Cree programas COBOL Db2 mediante y AWS Mainframe Modernization AWS CodeBuild](build-cobol-db2-programs-mainframe-modernization-codebuild.md) + [Cree una malla de datos empresarial con Amazon DataZone y AWS CDK AWS CloudFormation](build-enterprise-data-mesh-amazon-data-zone.md) + [Cambie las aplicaciones de Python y Perl para que admitan la migración de bases de datos de Microsoft SQL Server a una edición compatible con PostgreSQL de Amazon Aurora](change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.md) + [Convierta y desempaquete datos EBCDIC a ASCII en AWS mediante Python](convert-and-unpack-ebcdic-data-to-ascii-on-aws-by-using-python.md) + [Convierta la característica temporal NORMALIZE de Teradata en Amazon Redshift SQL](convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql.md) + [Convierta la característica RESET WHEN de Teradata en Amazon Redshift SQL](convert-the-teradata-reset-when-feature-to-amazon-redshift-sql.md) + [Convierta VARCHAR2 (1) el tipo de datos de Oracle en un tipo de datos booleano para Amazon Aurora PostgreSQL](convert-varchar2-1-data-type-for-oracle-to-boolean-data-type-for-amazon-aurora-postgresql.md) + [Crear usuarios y roles de aplicaciones en Aurora compatible con PostgreSQL](create-application-users-and-roles-in-aurora-postgresql-compatible.md) + [Cree CloudFormation plantillas de AWS para las tareas de AWS DMS con Microsoft Excel y Python](create-aws-cloudformation-templates-for-aws-dms-tasks-using-microsoft-excel-and-python.md) + [Entregue registros de DynamoDB a Amazon S3 mediante Kinesis Data Streams y Firehose con AWS CDK](deliver-dynamodb-records-to-amazon-s3-using-kinesis-data-streams-and-amazon-data-firehose-with-aws-cdk.md) + [Implemente un clúster de Cassandra en Amazon EC2 con estática privada IPs para evitar el reequilibrio](deploy-a-cassandra-cluster-on-amazon-ec2-with-private-static-ips-to-avoid-rebalancing.md) + [Implemente un clúster de CockroachDB en Amazon EKS mediante Terraform](deploy-cockroachdb-on-eks-using-terraform.md) + [Desarrolle asistentes avanzados de IA generativa basados en chat mediante RAG y solicitudes ReAct](develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.md) + [Emule Oracle DR mediante una base de datos global de Aurora compatible con PostgreSQL](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md) + [Habilite el archivado de DB2 registros directamente en Amazon S3 en una base de datos IBM Db2](enable-db2-logarchive-directly-to-amazon-s3-in-ibm-db2-database.md) + [Habilitar el cifrado transparente de datos en Amazon RDS para SQL Server](enable-transparent-data-encryption-in-amazon-rds-for-sql-server.md) + [Exportación de una base de datos de Microsoft SQL Server a Amazon S3 mediante AWS DMS](export-a-microsoft-sql-server-database-to-amazon-s3-by-using-aws-dms.md) + [Implemente SHA1 el hash para los datos de PII al migrar de SQL Server a PostgreSQL](implement-sha1-hashing-for-pii-data-when-migrating-from-sql-server-to-postgresql.md) + [Migración gradual de Amazon RDS para Oracle a Amazon RDS para PostgreSQL con Oracle SQL Developer y AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md) + [Cargar archivos BLOB en TEXT mediante la codificación de archivos en Aurora compatible con PostgreSQL](load-blob-files-into-text-by-using-file-encoding-in-aurora-postgresql-compatible.md) + [Administrar credenciales mediante AWS Secrets Manager](manage-credentials-using-aws-secrets-manager.md) + [Migre una base de datos Db2 de Amazon EC2 a Aurora compatible con MySQL mediante AWS DMS](migrate-a-db2-database-from-amazon-ec2-to-aurora-mysql-compatible-by-using-aws-dms.md) + [Migre una base de datos de Microsoft SQL Server de Amazon EC2 a Amazon DocumentDB mediante AWS DMS](migrate-a-microsoft-sql-server-database-from-amazon-ec2-to-amazon-documentdb-by-using-aws-dms.md) + [Migración de una base de datos de Microsoft SQL Server a Aurora MySQL mediante AWS DMS y AWS SCT](migrate-a-microsoft-sql-server-database-to-aurora-mysql-by-using-aws-dms-and-aws-sct.md) + [Migración de Amazon RDS para Oracle a Amazon RDS para PostgreSQL en modo SSL mediante AWS DMS](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-in-ssl-mode-by-using-aws-dms.md) + [Migre Amazon RDS for Oracle a Amazon RDS for PostgreSQL con y utilizando y AWS SCT 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) + [Migración de una instancia de base de datos de Amazon RDS a otra VPC o cuenta](migrate-an-amazon-rds-db-instance-to-another-vpc-or-account.md) + [Migre una base de datos de Amazon RDS for Oracle a Cuenta de AWS otra Región de AWS y AWS DMS utilícela para la replicación continua](migrate-an-amazon-rds-for-oracle-database-to-another-aws-account-and-aws-region-using-aws-dms-for-ongoing-replication.md) + [Migración de un clúster de Amazon Redshift a una región de AWS en China](migrate-an-amazon-redshift-cluster-to-an-aws-region-in-china.md) + [Migración de una base de datos de MariaDB en las instalaciones hasta Amazon RDS para MariaDB mediante herramientas nativas](migrate-an-on-premises-mariadb-database-to-amazon-rds-for-mariadb-using-native-tools.md) + [Migre una base de datos local de Microsoft SQL Server a Amazon EC2](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-ec2.md) + [Migración de una base de datos de Microsoft SQL Server en las instalaciones a Amazon RDS para SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server.md) + [Migración de bases de datos en las instalaciones de Microsoft SQL Server a Amazon RDS para SQL Server mediante servidores vinculados](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-linked-servers.md) + [Migración de una base de datos de Microsoft SQL Server en las instalaciones a Amazon RDS para SQL Server mediante métodos nativos de copia de seguridad y restauración](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-native-backup-and-restore-methods.md) + [Migración de una base de datos de Microsoft SQL Server en las instalaciones a Amazon Redshift mediante AWS DMS](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-dms.md) + [Migración de una base de datos en las instalaciones de Microsoft SQL Server a Amazon Redshift mediante agentes de extracción de datos de AWS SCT](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.md) + [Migre una base de datos local de Microsoft SQL Server a Microsoft SQL Server en Amazon EC2 con Linux](migrate-an-on-premises-microsoft-sql-server-database-to-microsoft-sql-server-on-amazon-ec2-running-linux.md) + [Migración de una base de datos MySQL en las instalaciones a Amazon RDS para MySQL](migrate-an-on-premises-mysql-database-to-amazon-rds-for-mysql.md) + [Migración de una base de datos de MySQL en las instalaciones a Aurora MySQL](migrate-an-on-premises-mysql-database-to-aurora-mysql.md) + [Migre una base de datos Oracle local a Amazon EC2 mediante Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-ec2-by-using-oracle-data-pump.md) + [Migre una base de datos Oracle local a Amazon OpenSearch Service mediante Logstash](migrate-an-on-premises-oracle-database-to-amazon-opensearch-service-using-logstash.md) + [Migración de una base de datos de Oracle en las instalaciones a Amazon RDS para MySQL con AWS DMS y AWS SCT](migrate-an-on-premises-oracle-database-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migración de una base de datos de Oracle en las instalaciones a Amazon RDS para Oracle](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle.md) + [Migración de una base de datos de Oracle en las instalaciones a Amazon RDS para Oracle mediante Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-by-using-direct-oracle-data-pump-import-over-a-database-link.md) + [Migración de una base de datos de Oracle en las instalaciones a Amazon RDS para Oracle mediante Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-using-oracle-data-pump.md) + [Migración de una base de datos de Oracle en las instalaciones a Amazon RDS para PostgreSQL mediante Oracle Bystander y AWS DMS](migrate-an-on-premises-oracle-database-to-amazon-rds-for-postgresql-by-using-an-oracle-bystander-and-aws-dms.md) + [Migre una base de datos Oracle local a Oracle on Amazon EC2](migrate-an-on-premises-oracle-database-to-oracle-on-amazon-ec2.md) + [Migración de una base de datos PostgreSQL en las instalaciones a Aurora PostgreSQL](migrate-an-on-premises-postgresql-database-to-aurora-postgresql.md) + [Migre una base de datos ThoughtSpot Falcon local a Amazon Redshift](migrate-an-on-premises-thoughtspot-falcon-database-to-amazon-redshift.md) + [Migre una base de datos Oracle de Amazon EC2 a Amazon RDS para MariaDB con AWS DMS y AWS SCT](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-mariadb-using-aws-dms-and-aws-sct.md) + [Migre una base de datos Oracle de Amazon EC2 a Amazon RDS for Oracle mediante AWS DMS](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-oracle-using-aws-dms.md) + [Migre una base de datos Oracle a Amazon RDS for Oracle mediante adaptadores de archivos planos de GoldenGate Oracle](migrate-an-oracle-database-to-amazon-rds-for-oracle-by-using-oracle-goldengate-flat-file-adapters.md) + [Migración de una base de datos de Oracle a Amazon Redshift con AWS DMS y AWS SCT](migrate-an-oracle-database-to-amazon-redshift-using-aws-dms-and-aws-sct.md) + [Migración de una base de datos de Oracle a Aurora PostgreSQL con AWS DMS y AWS SCT](migrate-an-oracle-database-to-aurora-postgresql-using-aws-dms-and-aws-sct.md) + [Migre una EnterpriseOne base de datos de Oracle JD Edwards a AWS mediante Oracle Data Pump y AWS DMS](migrate-an-oracle-jd-edwards-enterpriseone-database-to-aws-by-using-oracle-data-pump-and-aws-dms.md) + [Migración de una tabla particionada de Oracle a PostgreSQL mediante AWS DMS](migrate-an-oracle-partitioned-table-to-postgresql-by-using-aws-dms.md) + [Migre una PeopleSoft base de datos de Oracle a AWS mediante AWS DMS](migrate-an-oracle-peoplesoft-database-to-aws-by-using-aws-dms.md) + [Migrar una base de datos de Couchbase Server a Amazon EC2](migrate-couchbase-server-ec2.md) + [Migración de datos de una base de datos de Oracle en las instalaciones a Aurora PostgreSQL](migrate-data-from-an-on-premises-oracle-database-to-aurora-postgresql.md) + [Migre datos al Nube de AWS mediante Starburst](migrate-data-to-the-aws-cloud-by-using-starburst.md) + [Migre Db2 for LUW a Amazon EC2 mediante el envío de registros para reducir el tiempo de interrupción](migrate-db2-for-luw-to-amazon-ec2-by-using-log-shipping-to-reduce-outage-time.md) + [Migración de Db2 para LUW a Amazon EC2 con recuperación de desastres de alta disponibilidad](migrate-db2-for-luw-to-amazon-ec2-with-high-availability-disaster-recovery.md) + [Migración de de Amazon RDS para Oracle a Amazon RDS para MySQL](migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-mysql.md) + [Migración de Couchbase Server a Couchbase Capella en AWS](migrate-from-couchbase-server-to-couchbase-capella-on-aws.md) + [Migre de IBM Db2 en Amazon EC2 a Aurora compatible con PostgreSQL mediante AWS DMS y AWS SCT](migrate-from-ibm-db2-on-amazon-ec2-to-aurora-postgresql-compatible-using-aws-dms-and-aws-sct.md) + [Migración de Oracle 8i o 9i a Amazon RDS para PostgreSQL mediante la vista materializada y AWS DMS](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-materialized-views-and-aws-dms.md) + [Migre de Oracle 8i o 9i a Amazon RDS para PostgreSQL mediante AWS DMS SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-shareplex-and-aws-dms.md) + [Migre de Oracle Database a Amazon RDS for PostgreSQL mediante Oracle GoldenGate](migrate-from-oracle-database-to-amazon-rds-for-postgresql-by-using-oracle-goldengate.md) + [Migración de Oracle en Amazon EC2 a Amazon RDS para MySQL con AWS DMS y AWS SCT](migrate-from-oracle-on-amazon-ec2-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migre de PostgreSQL en EC2 Amazon a Amazon RDS para PostgreSQL mediante pglogical](migrate-from-postgresql-on-amazon-ec2-to-amazon-rds-for-postgresql-using-pglogical.md) + [Migración de SAP ASE a Amazon RDS para SQL Server utilizando AWS DMS](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md) + [Migración de índices basados en funciones de Oracle a PostgreSQL](migrate-function-based-indexes-from-oracle-to-postgresql.md) + [Migración de aplicaciones heredadas de Oracle Pro\$1C a ECPG](migrate-legacy-applications-from-oracle-pro-c-to-ecpg.md) + [Migre una base de datos local de Microsoft SQL Server a Amazon EC2 mediante Application Migration Service](migrate-microsoft-sql-server-to-amazon-ec2-using-aws-mgn.md) + [Migración de cargas de trabajo de Cloudera en las instalaciones a la plataforma de datos de Cloudera en AWS](migrate-on-premises-cloudera-workloads-to-cloudera-data-platform-on-aws.md) + [Migre bases de datos MySQL locales a Aurora MySQL mediante Percona, XtraBackup Amazon EFS y Amazon S3](migrate-on-premises-mysql-databases-to-aurora-mysql-using-percona-xtrabackup-amazon-efs-and-amazon-s3.md) + [Migración de Oracle Business Intelligence 12c a la nube de AWS desde servidores en las instalaciones](migrate-oracle-business-intelligence-12c-to-the-aws-cloud-from-on-premises-servers.md) + [Migración de valores CLOB de Oracle a filas individuales en PostgreSQL en AWS](migrate-oracle-clob-values-to-individual-rows-in-postgresql-on-aws.md) + [Migración de códigos de error de Oracle Database a una base de datos Amazon Aurora compatible con PostgreSQL](migrate-oracle-database-error-codes-to-an-amazon-aurora-postgresql-compatible-database.md) + [Migración de tablas externas de Oracle a Amazon Aurora compatible con PostgreSQL](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md) + [Migración de las funciones nativas de Oracle a PostgreSQL mediante extensiones](migrate-oracle-native-functions-to-postgresql-using-extensions.md) + [Migre Oracle PeopleSoft a Amazon RDS Custom](migrate-oracle-peoplesoft-to-amazon-rds-custom.md) + [Migración de la funcionalidad ROWIdentificador de Oracle a PostgreSQL en AWS](migrate-oracle-rowid-functionality-to-postgresql-on-aws.md) + [Migración de los paquetes pragma SERIALLY\$1REUTILIZABLE de Oracle a PostgreSQL](migrate-oracle-serially-reusable-pragma-packages-into-postgresql.md) + [Migre SAP ASE de Amazon EC2 a Amazon Aurora compatible con PostgreSQL mediante AWS SCT y AWS DMS](migrate-sap-ase-on-amazon-ec2-to-amazon-aurora-postgresql-compatible-using-aws-sct-and-aws-dms.md) + [Migración de columnas generadas de forma virtual de Oracle a PostgreSQL](migrate-virtual-generated-columns-from-oracle-to-postgresql.md) + [Configuración de un espacio de datos mínimo viable para compartir datos entre organizaciones](minimum-viable-data-space-share-data-organizations.md) + [Supervise ElastiCache los clústeres de Amazon para comprobar el cifrado en reposo](monitor-amazon-elasticache-clusters-for-at-rest-encryption.md) + [Consulta de las tablas de Amazon DynamoDB con SQL mediante Amazon Athena](query-amazon-dynamodb-tables-sql-amazon-athena.md) + [Proteja y optimice el acceso de los usuarios a una base de datos de federación DB2 en AWS mediante contextos de confianza](secure-and-streamline-user-access-in-a-db2-federation-database-on-aws-by-using-trusted-contexts.md) + [Configure una PeopleSoft arquitectura de alta disponibilidad en AWS](set-up-a-highly-available-peoplesoft-architecture-on-aws.md) + [Configure la funcionalidad UTL\$1FILE de Oracle en Aurora compatible con PostgreSQL](set-up-oracle-utl_file-functionality-on-aurora-postgresql-compatible.md) + [Simplificación de las implementaciones de PostgreSQL en Amazon EKS mediante PGO](streamline-postgresql-deployments-amazon-eks-pgo.md) + [Transfiera z/OS datos de Db2 a gran escala a Amazon S3 en archivos CSV](transfer-large-scale-db2-z-os-data-to-amazon-s3-in-csv-files.md) + [Transportar bases de datos PostgreSQL entre dos instancias de base de datos de Amazon RDS utilizando pg\$1transport](transport-postgresql-databases-between-two-amazon-rds-db-instances-using-pg-transport.md) + [Validar los objetos de la base de datos después de migrar de Oracle a 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()