$ dgmgrl RDS_DATAGUARD@RDS_CUSTOM_ORCL_D**CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Fri Sep 30 22:44:49 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "ORCL_D"
Connected as SYSDG.
DGMGRL>
DGMGRL> show database orcl_d
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Average Apply Rate: 11.00 KByte/s
Instance(s):
ORCL
SUCCESS
DGMGRL>
-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B| DBA | | Modifiez le paramètre de transport du journal en vous connectant à DGMGRL depuis le nœud principal. | Changez le mode de transport du journal en`FastSync`, correspondant au paramètre `SYNC+NOAFFIRM` de rétablissement du transport. Pour vous assurer que vous disposez de paramètres valides après le changement de rôle, modifiez-les à la fois pour la base de données principale et pour la base de données de secours.**Non CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 11 20:24:11 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_B"
Connected as SYSDG.
DGMGRL>
DGMGRL> show database rdscdb_b
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 2.00 KByte/s
Real Time Query: OFF
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL>
DGMGRL>**CDB**
DGMGRL> edit database orcl_d set property logxptmode=fastsync;
Property "logxptmode" updated
DGMGRL> show database orcl_d LogXptMode;
LogXptMode = 'fastsync'
DGMGRL> edit database orcl_a set property logxptmode=fastsync;
Property "logxptmode" updated
DGMGRL> show database orcl_a logxptmode;
LogXptMode = 'fastsync'
DGMGRL>
DGMGRL> edit database rdscdb_b set property logxptmode=fastsync;DGMGRL> edit database rdscdb_b set property logxptmode=fastsync;| DBA | | Changez le mode de protection en MaxAvailability. | Changez le mode de protection `MaxAvailability` en vous connectant `DGMGRL` depuis le nœud principal.**Non CDB**
Property "logxptmode" updated
DGMGRL> show database rdscdb_b LogXptMode;
LogXptMode = 'fastsync'
DGMGRL> edit database rdscdb_a set property logxptmode=fastsync;
Property "logxptmode" updated
DGMGRL> show database rdscdb_a logxptmode;
LogXptMode = 'fastsync'
DGMGRL>
DGMGRL> edit configuration set protection mode as maxavailability;**CDB**
Succeeded.
DGMGRL> show configuration;
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 38 seconds ago)
DGMGRL>
DGMGRL> show configuration| DBA | ### Changez le statut de la réplique de montage à lecture seule et activez Redo Apply | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Arrêtez Redo Apply pour la base de données de secours. | La réplique de lecture est créée en `MOUNT` mode par défaut. Pour l'ouvrir en mode lecture seule, vous devez d'abord désactiver la fonction Redo Apply en vous connectant `DGMGRL` depuis le nœud principal ou le nœud de secours.**Non CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 57 seconds ago)
DGMGRL>
DGMGRL> show database orcl_dDGMGRL> show database orcl_d**CDB**
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 11.00 KByte/s
Real Time Query: OFF
Instance(s):
ORCL
Database Status:
SUCCESS
DGMGRL> edit database orcl_d set state=apply-off;
Succeeded.
DGMGRL> show database orcl_d
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-OFF
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 42 seconds (computed 1 second ago)
Average Apply Rate: (unknown)
Real Time Query: OFF
Instance(s):
ORCL
Database Status:
SUCCESS
DGMGRL>
DGMGRL> show configurationDGMGRL> show configuration| DBA | | Ouvrez l'instance de réplique en lecture seule. | Connectez-vous à la base de données de secours à l'aide de l'entrée TNS et ouvrez-la en mode lecture seule en vous y connectant depuis le nœud principal ou de secours.**Non CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 57 seconds ago)
DGMGRL> show database rdscdb_b;
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 2.00 KByte/s
Real Time Query: OFF
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL> edit database rdscdb_b set state=apply-off;
Succeeded.
DGMGRL> show database rdscdb_b;
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-OFF
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: (unknown)
Real Time Query: OFF
Instance(s):
RDSCDB
Database Status:
SUCCESS
$ sqlplus RDS_DATAGUARD@RDS_CUSTOM_ORCL_D as sysdg**CDB**
-bash-4.2$ sqlplus RDS_DATAGUARD@RDS_CUSTOM_ORCL_D as sysdg
SQL*Plus: Release 19.0.0.0.0 - Production on Fri Sep 30 23:00:14 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2020, Oracle. All rights reserved.
Enter password:
Last Successful login time: Fri Sep 30 2022 22:48:27 +00:00
Connected to:
Oracle Database 19c Enterprise Edition Release 19.0.0.0.0 - Production
Version 19.10.0.0.0
SQL> select open_mode from v$database;
OPEN_MODE
--------------------
MOUNTED
SQL> alter database open read only;
Database altered.
SQL> select open_mode from v$database;
OPEN_MODE
--------------------
READ ONLY
SQL>
-bash-4.2$ sqlplus C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B as sysdg| DBA | | Activez Redo Apply sur l'instance de réplique lue. | Activez Redo Apply sur l'instance de réplique en lecture en utilisant `DGMGR` L depuis le nœud principal ou de secours.**Non CDB**
SQL*Plus: Release 19.0.0.0.0 - Production on Wed Jan 11 21:14:07 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2022, Oracle. All rights reserved.
Enter password:
Last Successful login time: Wed Jan 11 2023 21:12:05 +00:00
Connected to:
Oracle Database 19c Enterprise Edition Release 19.0.0.0.0 - Production
Version 19.16.0.0.0
SQL> select name,open_mode from v$database;
NAME OPEN_MODE
--------- --------------------
RDSCDB MOUNTED
SQL> alter database open read only;
Database altered.
SQL> select name,open_mode from v$database;
NAME OPEN_MODE
--------- --------------------
RDSCDB READ ONLY
SQL>
$ dgmgrl RDS_DATAGUARD@RDS_CUSTOM_ORCL_D**CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Fri Sep 30 23:02:16 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "ORCL_D"
Connected as SYSDG.
DGMGRL>
edit database orcl_d set state=apply-on;
DGMGRL> edit database orcl_d set state=apply-on;
Succeeded.
DGMGRL> show database orcl_d
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Average Apply Rate: 496.00 KByte/s
Real Time Query: ON
Instance(s):
ORCL
Database Status:
SUCCESS
DGMGRL>
-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B| DBA | ## Ressources connexes + [Configuration d'Amazon RDS en tant que PeopleSoft base de données Oracle](https://d1.awsstatic.com/whitepapers/configuring-amazon-rds-as-peoplesoft-database.pdf) (livre blanc AWS) + [Guide Oracle Data Guard Broker](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/index.html) (documentation de référence Oracle) + [Concepts et administration de Data Guard](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/index.html) (documentation de référence Oracle) ## Informations supplémentaires **Sélectionnez le mode de protection de votre base de données** Oracle Data Guard propose trois modes de protection pour configurer votre environnement Data Guard en fonction de vos exigences en matière de disponibilité, de protection et de performances. Le tableau suivant récapitule ces trois modes. | | | Mode de protection | Refaire le réglage du transport | Description | | --- |--- |--- | | ***PERFORMANCE MAXIMALE*** | `ASYNC` | Pour les transactions effectuées sur la base de données principale, les données de rétablissement sont transmises de manière asynchrone et écrites dans le journal de rétablissement de la base de données de secours. Par conséquent, l'impact sur les performances est minime.`MaxPerformance`Impossible de fournir RPO=0 en raison de l'expédition asynchrone des journaux. | | ***PROTECTION MAXIMALE*** | `SYNC+AFFIRM` | Pour les transactions sur la base de données principale, les données de rétablissement sont transmises de manière synchrone et écrites dans le journal de rétablissement de la base de données de secours sur disque avant que la transaction ne soit reconnue. Si la base de données de secours devient indisponible, la base de données principale s'arrête d'elle-même pour garantir la protection des transactions. | | ***DISPONIBILITÉ MAXIMALE*** | `SYNC+AFFIRM` | Ceci est similaire au `MaxProtection` mode, sauf lorsqu'aucun accusé de réception n'est reçu de la base de données de secours. Dans ce cas, il fonctionne comme s'il était en `MaxPerformance` mode pour préserver la disponibilité de la base de données principale jusqu'à ce qu'il soit à nouveau en mesure d'écrire son flux de restauration dans une base de données de secours synchronisée. | | `SYNC+NOAFFIRM` | Pour les transactions sur la base de données principale, le rétablissement est transmis de manière synchrone à la base de données de secours, et la base attend uniquement un accusé de réception indiquant que le rétablissement a été reçu sur le serveur de secours, et non qu'il a été écrit sur le disque de secours. Ce mode, également connu sous le nom de`FastSync`, peut apporter un avantage en termes de performances au détriment de l'exposition potentielle à la perte de données dans un cas particulier de défaillances simultanées multiples. | Les répliques de lecture dans RDS Custom for Oracle sont créées avec le mode de protection maximale des performances, qui est également le mode de protection par défaut pour Oracle Data Guard. Le mode de performance maximale a le plus faible impact sur les performances de la base de données principale, ce qui peut vous aider à atteindre l'objectif de point de restauration (RPO) mesuré en secondes. Pour atteindre l'objectif de zéro perte de données (RPO=0), vous pouvez personnaliser le mode de protection d'Oracle Data Guard `MaxAvailability` avec le `SYNC+NOAFFIRM` paramètre Redo Transport pour de meilleures performances. Comme les validations sur la base de données principale ne sont reconnues qu'une fois que les vecteurs de rétablissement correspondants ont été transmis avec succès à la base de données de secours, la latence du réseau entre l'instance principale et la réplique peut être cruciale pour les charges de travail sensibles aux validations. Nous vous recommandons d'effectuer des tests de charge pour votre charge de travail afin d'évaluer l'impact sur les performances lorsque la réplique en lecture est personnalisée pour s'exécuter en `MaxAvailability` mode. Le déploiement de la réplique en lecture dans la même zone de disponibilité que la base de données principale permet de réduire la latence du réseau par rapport au déploiement de la réplique en lecture dans une autre zone de disponibilité. Cependant, le déploiement des répliques principale et en lecture dans la même zone de disponibilité peut ne pas répondre à vos exigences en matière de haute disponibilité car, dans le cas peu probable d'une indisponibilité de la zone de disponibilité, l'instance principale et l'instance de réplique en lecture sont affectées. # Analyser les dépendances des objets pour les migrations partielles de bases de données d'Oracle vers PostgreSQL *anuradha chintha, Amazon Web Services* ## Résumé Ce modèle décrit l'importance d'identifier et de gérer systématiquement les dépendances du système lors de la migration d'une base de données Oracle partielle vers Amazon Relational Database Service (Amazon RDS) ou Amazon Aurora PostgreSQL. Lors d'une migration partielle, seul un sous-ensemble d'objets de base de données et de données de la base de données d'origine est migré, tandis que la base de données source continue de fonctionner et de servir les applications qui dépendent de composants non migrés. Vous devez identifier et analyser l'étendue de la migration lorsque vous manipulez des bases de données à grande échelle comportant des applications étroitement couplées avec des dépendances en amont et en aval. Pour commencer une migration partielle, identifiez les objets du scope, notamment les tables, les déclencheurs, les vues, les procédures stockées, les fonctions et les packages. Le processus d'identification du périmètre suit une approche globale : + Les objets du scope de premier niveau sont identifiés par des références directes dans le code de l'application et dans les tâches critiques spécifiques aux modules. + Les objets de second niveau sont dérivés grâce à une analyse complète des dépendances. Lorsque vous comprenez comment les différentes parties de votre système interagissent, vous pouvez mieux planifier l'ordre correct pour déplacer les composants de base de données et réduire le risque d'échec de la migration. Le tableau suivant répertorie les différents types d'analyse de dépendance. | | | Type d'analyse | Domaines d'intérêt | Objectif | | --- |--- |--- | | Dépendances des objets | TablesVuesProcédures stockéesFonctionsTriggers | Identifie les relations entre les objets de base de données et leurs structures hiérarchiques | | Dépendances des segments | Relations clés avec des acteurs étrangersPorte-clés primairesRéférences entre schémas | Cartographie les relations entre les données et préserve l'intégrité référentielle | | Dépendances de sécurité | Autorisations des utilisateursHiérarchies de rôlesPrivilèges d'objet | Garantit une migration appropriée du contrôle d'accès et de la maintenance de la sécurité | | Modèles d’accès | Opérations de lectureOpérations d’écriture | Détermine les modèles d'interaction avec les bases | Pour maintenir la cohérence entre les systèmes source et cible, établissez des mécanismes de synchronisation des données pendant la période de transition. Vous devez également modifier le code et les fonctions de l'application pour gérer la distribution des données dans les bases de données Oracle source et PostgreSQL cible. ## Conditions préalables et limitations **Conditions préalables** + Un actif Compte AWS + Une base de données Oracle (source) + Amazon RDS ou Amazon Aurora PostgreSQL (cible) **Versions du produit** + Oracle 19c ou version ultérieure + PostgreSQL 16 ou version ultérieure ## Architecture **Pile technologique source** + Oracle 19c ou version ultérieure **Pile technologique cible** + Amazon RDS ou Amazon Aurora PostgreSQL **Architecture cible** Le schéma suivant montre le processus de migration d'une base de données Oracle sur site vers Amazon RDS for Oracle, qui implique les étapes suivantes : + Identifier les dépendances des bases de données + Migration du code et des objets de base de données à l'aide de AWS Schema Conversion Tool ()AWS SCT + Migration de données à l'aide de AWS Database Migration Service ()AWS DMS + Répliquer les changements en cours grâce à la capture des données sur les modifications (CDC) à l'aide de AWS DMS Pour plus d'informations, consultez la section [Intégration AWS Database Migration Service avec AWS Schema Conversion Tool](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_DMSIntegration.html) dans la AWS documentation. ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/90160825-3199-4382-95a8-ad63139c5c89/images/b09c36a4-27fa-412e-877e-57a31bcce0dc.png) ## Outils **Services AWS** + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html)) pour Oracle vous aide à configurer, exploiter et dimensionner une base de données relationnelle Oracle dans le. AWS Cloud + Amazon Aurora est un moteur de base de données relationnelle entièrement géré conçu pour le cloud et compatible avec MySQL et PostgreSQL. + AWS Schema Conversion Tool (AWS SCT) prend en charge les migrations de bases de données hétérogènes en convertissant automatiquement le schéma de base de données source et la majorité du code personnalisé dans un format compatible avec la base de données cible. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) vous aide à migrer les banques de données vers AWS Cloud ou entre des combinaisons de configurations cloud et sur site. **Autres services** + [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) est un environnement de développement intégré qui simplifie le développement et la gestion des bases de données Oracle dans les déploiements traditionnels et basés sur le cloud. Pour ce modèle, vous pouvez utiliser [SQL\$1Plus](https://docs.oracle.com/cd/B19306_01/server.102/b14357/qstart.htm). ## Bonnes pratiques Pour connaître les meilleures pratiques relatives au provisionnement et à la migration d'une base de données Oracle, consultez la section [Meilleures pratiques pour la migration vers Amazon](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html) RDS for Oracle. ## Épopées ### Identifier les dépendances des objets | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une table d'objets. | Identifiez les objets essentiels aux fonctionnalités de l'application et créez une table nommée`DEPENDENT_ANALYSIS_BASELINE`. Ajoutez des enregistrements pour chaque objet dans le tableau. Pour un exemple, consultez la section *Informations supplémentaires*. | Ingénieur de données, DBA | | Créez une procédure de base de données. | Créez une procédure stockée nommée `sp_object_dependency_analysis` pour analyser les dépendances des objets dans les deux sens (avant et arrière) en utilisant les données du `DBA_DEPENDENCIES` tableau. Pour un exemple, consultez la section *Informations supplémentaires*. | Ingénieur de données, DBA | | Exécutez la procédure. | Exécutez les scripts à chaque niveau successif jusqu'à ce qu'aucune nouvelle dépendance d'objet ne soit trouvée. Toutes les dépendances et tous les niveaux sont stockés dans le `DEPENDENT_ANALYSIS_BASELINE` tableau. | DBA, Ingénieur de données | ### Création d'une procédure pour les dépendances au niveau des segments | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une table de dépendances. | Créez une table de dépendance au niveau du segment nommée. `REFERENTIAL_ANALYSIS_BASELINE` Lorsque toutes les dépendances au niveau de l'objet sont découvertes, vérifiez les tables parents de `DEPENDENT_ANALYSIS_BASELINE` en interrogeant la table. `DBA_CONSTRAINT`Excluez les dépendances lorsque les tables de référence sont référencées par d'autres tables. Le remblayage gère ces relations. Voici un exemple 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| Ingénieur de données, DBA | | Créez une procédure de base de données. | Créez une procédure appelée `SP_OBJECT_REFERENTIAL_ANALYSIS` et générez une analyse référentielle pour tous les objets identifiés. Pour un exemple, consultez la section *Informations supplémentaires*. | Ingénieur de données, DBA | | Exécutez la procédure. | Exécutez la procédure pour obtenir les dépendances référentielles. Générez les détails des objets d'analyse référentielle dans. `REFERENTIAL_ANALYSIS_BASELINE` | Ingénieur de données, DBA | ### Identifiez les objets qui lisent et écrivent | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez des tables pour les objets de lecture et d'écriture. | Utilisez le script suivant pour créer une table d'objets de lecture nommée `TABLE_READ_OBJECT_DETAILS` et une table d'objets d'écriture nommée `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| Ingénieur de données, DBA | | Créez une procédure d'analyse. | Créez les procédures `SP_READER_OBJECTS_ANALYSIS` et `SP_WRITER_OBJECTS_ANALYSIS` pour analyser les objets de lecture et les objets d'écriture, respectivement. Ces procédures utilisent la correspondance de modèles pour rechercher les objets associés. Pour un exemple, consultez la section *Informations supplémentaires*. | Ingénieur de données, DBA | | Exécutez les procédures. | Exécutez ces procédures pour identifier les objets dépendants. | DBA, Ingénieur de données | ### Vérifier les privilèges de base de données | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un tableau pour vérifier les privilèges. | Créez un tableau pour analyser les privilèges nommés`OBJECT_PRIVS_ANALYSIS`. Pour capturer de manière récursive les privilèges des objets dans le `DEPENDENT_ANALYSIS_BASELINE` tableau, utilisez le script suivant :
(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| Ingénieur de données, DBA | | Créez une procédure de révision des privilèges. | Créez une procédure nommée`SP_OBJECT_PRIVS_ANALYSIS`. Générez une analyse des privilèges pour les objets identifiés. Pour un exemple, consultez la section *Informations supplémentaires*. | DBA, Ingénieur de données | | Exécutez la procédure. | Exécutez la procédure pour les capturer dans le `OBJECT_PRIVS_ANALYSIS` tableau. | DBA, Ingénieur de données | ## Résolution des problèmes | Problème | Solution | | --- | --- | | Impossible d'accéder aux tables du dictionnaire | Assurez-vous que l'utilisateur qui a créé les objets d'analyse peut accéder aux tables DBA. | ## Ressources connexes **Documentation AWS** + [Documentation Amazon RDS et Aurora](https://docs.aws.amazon.com/rds/) + [Manuel de migration de la base de données Oracle 19c vers Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/dms/latest/oracle-to-aurora-postgresql-migration-playbook/chap-oracle-aurora-pg.html) + [Qu'est-ce que c'est AWS Database Migration Service ?](https://docs.aws.amazon.com/dms/latest/userguide/) + [Qu'est-ce que l'AWS Schema Conversion Tool ?](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/) **Autres documentations** + [Objets de base de données Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Database-Objects.html) ## Informations supplémentaires **Script pour `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)); ``` **Procédure pour `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 pour `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 pour `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 pour `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; ``` **Procédure pour `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; ``` # Évaluez les performances des requêtes pour la migration des bases de données SQL Server vers MongoDB Atlas sur AWS *Battulga Purevragchaa, Amazon Web Services* *Krishnakumar Sathyanarayana, États-Unis Inc. PeerIslands * *Babu Srinivasan, MongoDB* ## Résumé Ce modèle fournit des conseils pour charger MongoDB avec des données quasiment réelles et évaluer les performances des requêtes MongoDB aussi proches que possible du scénario de production. L'évaluation fournit des informations pour vous aider à planifier votre migration vers MongoDB à partir d'une base de données relationnelle. Le modèle utilise le [générateur de données de PeerIslands test et l'analyseur de performances](https://tools.peerislands.io/) pour tester les performances des requêtes. Ce modèle est particulièrement utile pour la migration de Microsoft SQL Server vers MongoDB, car l'exécution de transformations de schéma et le chargement de données à partir d'instances SQL Server actuelles vers MongoDB peuvent s'avérer très complexes. Au lieu de cela, vous pouvez charger des données quasiment réelles dans MongoDB, comprendre les performances de MongoDB et affiner la conception du schéma avant de commencer la migration proprement dite. ## Conditions préalables et limitations **Conditions préalables** + Un compte AWS actif + Connaissance de [MongoDB Atlas](https://www.mongodb.com/docs/atlas/getting-started/) + Schéma MongoDB cible + Modèles de requête typiques **Limites** + Les temps de chargement des données et les performances seront limités par la taille de l'instance du cluster MongoDB. Nous vous recommandons de choisir des instances recommandées pour une utilisation en production afin de comprendre les performances réelles. + PeerIslands Le générateur de données de test et l'analyseur de performances ne prennent actuellement en charge que les chargements de données et les requêtes en ligne. Le traitement par lots hors ligne (par exemple, le chargement de données dans MongoDB à l'aide de connecteurs Spark) n'est pas encore pris en charge. + PeerIslands Le générateur de données de test et l'analyseur de performances prennent en charge les relations de terrain au sein d'une collection. Il ne prend pas en charge les relations entre les collections. **Éditions de produits** + Ce modèle prend en charge [MongoDB Atlas](https://www.mongodb.com/atlas) et [MongoDB](https://www.mongodb.com/products/mongodb-enterprise-advanced) Enterprise Advanced. ## Architecture **Pile technologique cible** + MongoDB Atlas ou MongoDB Enterprise Advanced **Architecture** ![\[Architecture permettant d'évaluer les performances des requêtes pour la migration de la base de données SQL Server vers MongoDB Atlas on AWS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/25f0ab73-d587-4bd0-9fc0-ac675d5aa349/images/717caae4-d52e-4c78-bb7d-2ecb5acccd42.png) PeerIslands Le générateur de données de test et l'analyseur de performances sont conçus à l'aide de Java et d'Angular, et stockent les données générées sur Amazon Elastic Block Store (Amazon EBS). L'outil comprend deux flux de travail : la génération de données de test et les tests de performance. + Lors de la génération de données de test, vous créez un modèle, qui est la représentation JSON du modèle de données à générer. Après avoir créé le modèle, vous pouvez générer les données dans une collection cible, telle que définie par la configuration de génération de charge. + Lors des tests de performance, vous créez un profil. Un profil est un scénario de test en plusieurs étapes dans lequel vous pouvez configurer les opérations de création, de lecture, de mise à jour et de suppression (CRUD), les pipelines d'agrégation, le poids de chaque opération et la durée de chaque étape. Après avoir créé le profil, vous pouvez exécuter des tests de performance sur la base de données cible en fonction de la configuration. PeerIslands Le générateur de données de test et l'analyseur de performances stockent leurs données sur Amazon EBS. Vous pouvez donc connecter Amazon EBS à MongoDB en utilisant n'importe quel mécanisme de connexion pris en charge par MongoDB, notamment le peering, les listes d'autorisation et les points de terminaison privés. Par défaut, l'outil n'inclut pas de composants opérationnels ; toutefois, il peut être configuré avec Amazon Managed Service for Prometheus, Amazon Managed Grafana CloudWatch, Amazon et AWS Secrets Manager si nécessaire. ## Outils + PeerIslands Le [générateur de données de test et l'analyseur de performances](https://tools.peerislands.io/) incluent deux composants. Le composant Test Data Generator vous aide à générer des données réelles très spécifiques au client en fonction de votre schéma MongoDB. L'outil est entièrement piloté par l'interface utilisateur avec une riche bibliothèque de données et peut être utilisé pour générer rapidement des milliards d'enregistrements sur MongoDB. L'outil fournit également des fonctionnalités pour implémenter des relations entre les champs du schéma MongoDB. Le composant Performance Analyzer vous permet de générer des requêtes et des agrégations très spécifiques au client, et de réaliser des tests de performances réalistes sur MongoDB. Vous pouvez utiliser l'analyseur de performances pour tester les performances de MongoDB à l'aide de profils de charge complets et de requêtes paramétrées pour votre cas d'utilisation spécifique. ## Bonnes pratiques Consultez les ressources suivantes : + [Meilleures pratiques de conception de schémas MongoDB](https://www.mongodb.com/developer/products/mongodb/mongodb-schema-design-best-practices/) (site Web du développeur MongoDB) + [Bonnes pratiques de déploiement de MongoDB Atlas sur AWS (site Web](https://www.mongodb.com/presentation/best-practices-of-deploying-mongodb-atlas-on-aws) MongoDB) + [Connexion sécurisée d'applications à un plan de données MongoDB Atlas avec AWS](https://aws.amazon.com/blogs/apn/connecting-applications-securely-to-a-mongodb-atlas-data-plane-with-aws-privatelink/) (article de blog PrivateLink AWS) + [Guide des meilleures pratiques pour les performances de MongoDB (site Web de](https://www.mongodb.com/basics/best-practices) MongoDB) ## Épopées ### Comprenez vos données sources | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Comprenez l'encombrement de la base de données de la source SQL Server actuelle. | Comprenez votre empreinte SQL Server actuelle. Cela peut être réalisé en exécutant des requêtes sur le `INFORMATION` schéma de la base de données. Déterminez le nombre de tables et la taille de chaque table. Analysez l'index associé à chaque table. Pour plus d'informations sur l'analyse SQL, consultez le billet de blog [SQL2Mongo : Data Migration Journey](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) sur le PeerIslands site Web. | DBA | | Comprenez le schéma source. | Déterminez le schéma de table et la représentation commerciale des données (par exemple, codes postaux, noms et devises). Utilisez votre diagramme de relation entre entités (ER) existant ou générez le diagramme ER à partir de la base de données existante. Pour plus d'informations, consultez le billet de blog [SQL2Mongo : Data Migration Journey](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) sur le PeerIslands site Web. | DBA | | Comprenez les modèles de requêtes. | Documentez les 10 principales requêtes SQL que vous utilisez. Vous pouvez utiliser les tables **performance\$1schema.events\$1statements\$1summary\$1by\$1digest** disponibles dans la base de données pour comprendre les principales requêtes. Pour plus d'informations, consultez le billet de blog [SQL2Mongo : Data Migration Journey](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) sur le PeerIslands site Web. | DBA | | Comprenez les engagements en matière de SLA. | Documentez les accords de niveau de service cibles (SLAs) pour les opérations de base de données. Les mesures typiques incluent la latence des requêtes et les requêtes par seconde. Les mesures et leurs cibles sont généralement disponibles dans des documents relatifs aux exigences non fonctionnelles (NFR). | DBA | ### Définir le schéma MongoDB | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Définissez le schéma cible. | Définissez différentes options pour le schéma MongoDB cible. Pour plus d'informations, consultez la section [Schémas](https://www.mongodb.com/docs/atlas/app-services/schemas/) dans la documentation de l'atlas MongoDB. Tenez compte des meilleures pratiques et des modèles de conception basés sur les relations entre les tables. | Ingénieur MongoDB | | Définissez les modèles de requêtes cibles. | Définissez les requêtes MongoDB et les pipelines d'agrégation. Ces requêtes sont l'équivalent des principales requêtes que vous avez capturées pour votre charge de travail SQL Server. [Pour comprendre comment créer des pipelines d'agrégation MongoDB, consultez la documentation MongoDB.](https://www.mongodb.com/docs/manual/core/aggregation-pipeline/) | Ingénieur MongoDB | | Définissez le type d'instance MongoDB. | Déterminez la taille de l'instance que vous prévoyez d'utiliser pour les tests. Pour obtenir des conseils, consultez la documentation de [MongoDB.](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) | Ingénieur MongoDB | ### Préparation de la base de données cible | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Configurez le cluster MongoDB Atlas. | [Pour configurer un cluster MongoDB sur AWS, suivez les instructions de la documentation MongoDB.](https://www.mongodb.com/docs/atlas/tutorial/create-new-cluster/) | Ingénieur MongoDB | | Créez des utilisateurs dans la base de données cible. | [Configurez le cluster MongoDB Atlas pour l'accès et la sécurité du réseau en suivant les instructions de la documentation MongoDB.](https://www.mongodb.com/docs/atlas/connect-to-database-deployment/) | Ingénieur MongoDB | | Créez des rôles appropriés dans AWS et configurez le contrôle d'accès basé sur les rôles pour Atlas. | Si nécessaire, configurez des utilisateurs supplémentaires en suivant les instructions de la documentation [MongoDB](https://www.mongodb.com/docs/atlas/security/set-up-unified-aws-access/). Configurez [l'authentification et l'autorisation](https://www.mongodb.com/docs/atlas/security/config-db-auth/) via les rôles AWS. | Ingénieur MongoDB | | Configurez Compass pour accéder à MongoDB Atlas. | Configurez l'[utilitaire graphique MongoDB Compass](https://www.mongodb.com/products/compass) pour faciliter la navigation et l'accès. | Ingénieur MongoDB | ### Configurer la charge de base à l'aide du générateur de données de test | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Installez le générateur de données de test. | Installez [PeerIsland Test Data Generator](https://github.com/PeerIslands/loadgen_binary) dans votre environnement. | Ingénieur MongoDB | | Configurez le générateur de données de test pour générer les données appropriées. | Créez un modèle en utilisant la bibliothèque de données pour générer des données spécifiques pour chaque champ du schéma MongoDB. Pour plus d'informations, consultez le [générateur de données et les performances MongoDB. Vidéo de l'analyseur](https://vimeo.com/570068857). | Ingénieur MongoDB | | Mise à l'échelle horizontale du générateur de données de test pour générer la charge requise. | Utilisez le modèle que vous avez créé pour démarrer la génération de charge par rapport à la collection cible en configurant le parallélisme requis. Déterminez les délais et l'échelle nécessaires pour générer les données nécessaires. | Ingénieur MongoDB | | Validez le chargement dans MongoDB Atlas. | Vérifiez les données chargées dans MongoDB Atlas. | Ingénieur MongoDB | | Générez les index requis sur MongoDB. | Définissez les index selon les besoins, en fonction des modèles de requête. Pour connaître les meilleures pratiques, consultez la documentation de [MongoDB.](https://www.mongodb.com/docs/manual/applications/indexes/) | Ingénieur MongoDB | ### Procéder à des tests de performance | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Configurez les profils de charge dans Performance Analyzer. | Créez un profil de test de performance dans Performance Analyzer en configurant des requêtes spécifiques et leur pondération, la durée du test et les étapes correspondantes. Pour plus d'informations, consultez le [générateur de données et les performances MongoDB. Vidéo de l'analyseur](https://vimeo.com/570068857). | Ingénieur MongoDB | | Effectuez des tests de performance. | Utilisez le profil de test de performance que vous avez créé pour démarrer le test par rapport à la collection cible en configurant le parallélisme requis. Faites évoluer horizontalement l'outil de test de performance pour exécuter des requêtes sur MongoDB Atlas. | Ingénieur MongoDB | | Enregistrez les résultats des tests. | Enregistrez les temps de latence P95, P99 pour les requêtes. | Ingénieur MongoDB | | Ajustez votre schéma et vos modèles de requêtes. | Modifiez les index et les modèles de requêtes pour résoudre les éventuels problèmes de performances. | Ingénieur MongoDB | ### Fermez le projet | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Arrêtez les ressources AWS temporaires. | Supprimez toutes les ressources temporaires que vous avez utilisées pour Test Data Generator et Performance Analyzer. | Administrateur AWS | | Mettez à jour les résultats des tests de performance. | Comprenez les performances des requêtes MongoDB et comparez-les aux vôtres. SLAs Si nécessaire, affinez le schéma MongoDB et relancez le processus. | Ingénieur MongoDB | | Conclure le projet. | Clôturez le projet et faites part de vos commentaires. | Ingénieur MongoDB | ## Ressources connexes + GitHub référentiel : [S3toAtlas](https://github.com/mongodb-partners/S3toAtlas) + Schéma : Conception du schéma [MongoDB](https://www.mongodb.com/developer/products/mongodb/mongodb-schema-design-best-practices/) + Pipelines d'agrégation : pipelines d'agrégation [MongoDB](https://www.mongodb.com/docs/manual/core/aggregation-pipeline/) + [Dimensionnement de l'Atlas MongoDB : sélection du niveau de dimensionnement](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) + Vidéo : [Générateur de données MongoDB et Perf](https://vimeo.com/570068857). Analyseur + Références : documentation [MongoDB](https://www.mongodb.com/docs/) + [Tutoriels : [guide du développeur**** MongoDB, MongoDB Jumpstart](https://www.mongodb.com/docs/develop-applications/)](https://www.youtube.com/playlist?list=PL4RCxklHWZ9v2lcat4oEVGQhZg6r4IQGV) + AWS Marketplace : [Atlas**** MongoDB sur](https://aws.amazon.com/marketplace/seller-profile?id=c9032c7b-70dd-459f-834f-c1e23cf3d092) AWS Marketplace + Solutions pour les partenaires AWS : [Atlas**** MongoDB sur le déploiement de référence AWS](https://aws.amazon.com/quickstart/architecture/mongodb-atlas/) Ressources supplémentaires : + [Analyse SQL](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) + [Forums de la communauté des développeurs MongoDB](https://www.mongodb.com/community/forums/) + [Questions relatives au réglage des performances de MongoDB](https://www.mongodb.com/developer/products/mongodb/performance-tuning-tips/) + [Analyses opérationnelles avec Atlas et Redshift](https://github.com/mongodb-partners/Atlas_to_Redshift) + [Modernisation des applications avec MongoDB Atlas et AWS Elastic Beanstalk](https://github.com/mongodb-partners/MEANStack_with_Atlas_on_AWS_EB) # Automatisez blue/green les déploiements de bases de données mondiales Amazon Aurora en utilisant les principes IaC *Ishwar Chauthaiwale, ANKIT JAIN, et Ramu Jagini, Amazon Web Services* ## Résumé La gestion des mises à jour des bases de données, des migrations ou des efforts de mise à l'échelle peut s'avérer difficile pour les entreprises qui exécutent des charges de travail critiques sur les [bases de données mondiales Amazon Aurora](https://aws.amazon.com/rds/aurora/global-database/). Il est essentiel de veiller à ce que ces opérations soient effectuées de manière fluide, sans interruption de service, pour maintenir la disponibilité des services et éviter les perturbations pour vos utilisateurs. Une stratégie de blue/green déploiement offre une solution à ce défi en vous permettant d'exécuter deux environnements identiques simultanément : le bleu (l'environnement actuel) et le vert (le nouvel environnement). Une blue/green stratégie vous permet de mettre en œuvre des modifications, d'effectuer des tests et de transférer le trafic entre les environnements avec un minimum de risques et de temps d'arrêt. Ce modèle vous aide à automatiser le processus de blue/green déploiement des bases de données globales Aurora en utilisant les principes de l'infrastructure en tant que code (IaC). Il utilise [AWS CloudFormation[AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html), et [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) pour simplifier les blue/green déploiements. Pour améliorer la fiabilité, il utilise des identificateurs de transaction globaux (GTIDs) pour la réplication. La réplication basée sur le GTID offre une meilleure cohérence des données et des capacités de basculement entre les environnements par rapport à la réplication de journaux binaires (binlog). **Note** Ce modèle suppose que vous utilisez un cluster de base de données global Aurora MySQL Edition compatible. Si vous utilisez plutôt la version compatible avec Aurora PostgreSQL, veuillez utiliser les équivalents PostgreSQL des commandes MySQL. En suivant les étapes de ce modèle, vous pouvez : + Fournir une base de données globale Aurora verte : à l'aide de CloudFormation modèles, vous créez un environnement vert qui reflète votre environnement bleu existant. + Configurer la réplication basée sur le GTID : vous configurez la réplication GTID pour que les environnements bleu et vert restent synchronisés. + Changez de trafic en toute simplicité : vous utilisez Route 53 et Lambda pour faire passer automatiquement le trafic de l'environnement bleu à l'environnement vert après une synchronisation complète. + Finalisation du déploiement : vous confirmez que l'environnement écologique est pleinement opérationnel en tant que base de données principale, puis vous arrêtez la réplication et nettoyez toutes les ressources temporaires. L'approche adoptée dans ce modèle offre les avantages suivants : + Réduit les temps d'arrêt lors des mises à jour ou des migrations critiques des bases de données : l'automatisation garantit une transition fluide entre les environnements avec une interruption de service minimale. + Permet des annulations rapides : si un problème survient après le passage du trafic vers l'environnement vert, vous pouvez rapidement revenir à l'environnement bleu et maintenir la continuité du service. + Améliore les tests et la vérification : l'environnement vert peut être entièrement testé sans affecter l'environnement bleu vif, ce qui réduit le risque d'erreurs de production. + Garantit la cohérence des données : la réplication basée sur le GTID permet de synchroniser vos environnements bleu et vert, ce qui évite les pertes de données ou les incohérences lors de la migration. + Maintient la continuité des activités : l'automatisation de vos blue/green déploiements permet d'éviter de longues interruptions et des pertes financières en maintenant vos services disponibles pendant les mises à jour ou les migrations. ## Conditions préalables et limitations **Conditions préalables** + Un actif Compte AWS. + Un cluster de bases de données global source compatible avec Aurora MySQL (environnement bleu). Les bases de données mondiales fournissent une configuration multirégionale pour une haute disponibilité et une reprise après sinistre. Pour obtenir des instructions sur la configuration d'un cluster de bases de données global, consultez la [documentation Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html). + La [réplication basée sur le GTID](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) est activée sur le cluster source. **Limites** + Certains Services AWS ne sont pas disponibles du tout Régions AWS. Pour connaître la disponibilité par région, voir [Services AWS par région](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Pour des points de terminaison spécifiques, consultez la page [Points de terminaison et quotas du service](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html), puis choisissez le lien vers le service. **Versions du produit** + Aurora MySQL compatible 8.0 ou version ultérieure ## Architecture ![\[Utilisation de la réplication GTID pour synchroniser les environnements bleu et vert dans différentes régions.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/19922266-c2e5-460b-9a0f-22e6d6736094/images/7a8c3095-7904-4080-906f-0c403c289a4f.png) Le diagramme illustre les éléments suivants : + Configuration de base de données globale : un cluster de bases de données global Aurora est déployé stratégiquement sur deux Régions AWS. Cette configuration permet la distribution géographique et la redondance régionale pour améliorer les capacités de reprise après sinistre. + Réplication de la région principale vers la région secondaire : le mécanisme de réplication logique garantit une synchronisation fluide des données entre la région principale et la région secondaire. Cette réplication assure la cohérence des données avec une latence minimale sur toutes les distances géographiques. + Réplication basée sur le GTID entre les clusters : la réplication basée sur le GTID préserve la cohérence transactionnelle et le flux de données ordonné entre le cluster principal bleu et le cluster principal vert, et garantit une synchronisation fiable des données. + Réplication primaire vers secondaire bleue : la réplication logique établit un pipeline de données robuste entre le cluster principal bleu et son cluster secondaire. Cette réplication permet une synchronisation continue des données et une haute disponibilité. + Configuration DNS Route 53 : les enregistrements de zone hébergée Route 53 gèrent la résolution DNS pour tous les points de terminaison de base de données de clusters bleus et verts. Cette configuration fournit un mappage fluide des terminaux et permet un routage efficace du trafic lors des scénarios de basculement. ## Outils **Services AWS** + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) est un moteur de base de données relationnelle entièrement géré conçu pour le cloud et compatible avec MySQL et PostgreSQL. + [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)vous aide à modéliser et à configurer vos AWS ressources afin que vous puissiez passer moins de temps à gérer ces ressources et plus de temps à vous concentrer sur les applications qui s'exécutent sur AWS. Vous créez un modèle qui décrit toutes les AWS ressources que vous souhaitez, et vous vous CloudFormation occupez de leur provisionnement et de leur configuration. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)est un service de calcul qui prend en charge l'exécution de code sans provisionnement ni gestion de serveurs. Lambda exécute le code uniquement lorsque cela est nécessaire et se met à l’échelle automatiquement, qu’il s’agisse de quelques requêtes par jour ou de milliers de requêtes par seconde. + [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) est un service Web DNS hautement disponible et évolutif. ## Bonnes pratiques Nous vous recommandons de consulter attentivement AWS la documentation afin de mieux comprendre la [stratégie de déploiement bleu/vert](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-overview.html), la [réplication basée sur le GTID](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) et les politiques de [routage pondérées](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) de Route 53. Ces connaissances sont cruciales pour mettre en œuvre et gérer efficacement les migrations de vos bases de données, garantir la cohérence des données et optimiser le routage du trafic. En acquérant une compréhension complète de ces AWS fonctionnalités et des meilleures pratiques, vous serez mieux équipé pour gérer les futures mises à jour, minimiser les temps d'arrêt et maintenir un environnement de base de données résilient et sécurisé. Pour obtenir des instructions d'utilisation du modèle Services AWS pour ce modèle, consultez la AWS documentation suivante : + [Bonnes pratiques avec Amazon Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.BestPractices.html) + [CloudFormation meilleures pratiques](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/best-practices.html) + [Bonnes pratiques d'utilisation des AWS Lambda fonctions](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) + [Bonnes pratiques pour Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/best-practices.html) ## Épopées ### Créez un environnement vert | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une sauvegarde instantanée à partir du cluster bleu. | Lors d'un blue/green déploiement, l'environnement vert représente une nouvelle version identique de votre environnement de base de données actuel (bleu). Vous utilisez l'environnement écologique pour tester les mises à jour en toute sécurité, valider les modifications et garantir la stabilité avant de changer de trafic de production. Il sert de point de départ pour la mise en œuvre de modifications de base de données avec une perturbation minimale de l'environnement réel.Pour créer un environnement écologique, vous devez d'abord créer un instantané du cluster principal (bleu) dans votre base de données globale compatible Aurora MySQL. Cet instantané sert de base à la création d'un environnement vert.Pour créer un instantané, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Vous pouvez également utiliser le AWS Command Line Interface (AWS CLI) pour créer l'instantané :
(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-1Assurez-vous que le cliché se termine correctement avant de passer à l'étape suivante. | DBA | | Générez le CloudFormation modèle pour votre base de données globale et ses ressources. | Le générateur CloudFormation IaC vous aide à générer des CloudFormation modèles à partir de AWS ressources existantes. Utilisez cette fonctionnalité pour créer un CloudFormation modèle pour votre base de données globale compatible Aurora MySQL existante et ses ressources associées. Ce modèle configure les groupes de sous-réseaux, les groupes de sécurité, les groupes de paramètres et d'autres paramètres.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html) | DBA | | Modifiez le CloudFormation modèle pour l'environnement vert. | Personnalisez le CloudFormation modèle pour qu'il reflète les paramètres de l'environnement vert. Cela inclut la mise à jour des noms et des identifiants des ressources pour garantir que l'environnement vert fonctionne indépendamment du cluster bleu.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Si vous utilisez la `SnapshotIdentifier` propriété pour restaurer un cluster de base de données, évitez de spécifier des propriétés telles que `GlobalClusterIdentifier``MasterUsername`, ou`MasterUserPassword`. | DBA | | Déployez la CloudFormation pile pour créer des ressources pour l'environnement vert. | Au cours de cette étape, vous déployez le CloudFormation modèle personnalisé pour créer les ressources pour l'environnement vert.Pour déployer la CloudFormation pile, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)CloudFormation lance le processus de création des ressources de l'environnement vert. Ce processus peut prendre plusieurs minutes. | DBA | | Validez la CloudFormation pile et les ressources. | Lorsque le déploiement de la CloudFormation pile sera terminé, vous devrez vérifier que l'environnement écologique a été créé avec succès :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Après vérification, votre environnement vert est prêt à être configuré ultérieurement, y compris la réplication à partir de l'environnement bleu. | DBA | ### Configuration de la réplication basée sur le GTID | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Vérifiez les paramètres GTID sur le cluster bleu. | GTIDs fournissent une méthode très fiable pour répliquer les données entre vos environnements bleu et vert. [La réplication basée sur le GTID](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) offre une approche résiliente et simplifiée en attribuant un identifiant unique à chaque transaction dans l'environnement bleu. Cette méthode garantit que la synchronisation des données entre les environnements est fluide, cohérente et plus facile à gérer que la réplication binlog traditionnelle.Avant de configurer la réplication, vous devez vous assurer que la réplication basée sur le GTID est correctement activée sur le cluster bleu. Cette étape garantit que chaque transaction dans l'environnement bleu fait l'objet d'un suivi unique et peut être reproduite dans l'environnement vert.Pour vérifier que le GTID est activé, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Ces paramètres permettent le suivi GTID pour toutes les futures transactions dans l'environnement bleu. Après avoir confirmé ces paramètres, vous pouvez commencer à configurer la réplication. | DBA | | Créez un utilisateur de réplication. | Pour répliquer les données de l'environnement bleu vers l'environnement vert, vous devez créer un utilisateur de réplication dédié sur le cluster bleu. Cet utilisateur sera chargé de gérer le processus de réplication.Pour configurer l'utilisateur de réplication :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Cet utilisateur dispose désormais des autorisations nécessaires pour répliquer les données entre les deux environnements. | DBA | | Configurez la réplication basée sur le GTID sur le cluster vert. | L'étape suivante consiste à configurer le cluster vert pour la réplication basée sur le GTID. Cette configuration garantit que l'environnement vert reflétera en permanence toutes les transactions effectuées dans l'environnement bleu.Pour configurer le cluster vert, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html) | DBA | | Démarrez la réplication sur le cluster vert. | Vous pouvez à présent démarrer le processus de réplication. Sur le cluster vert, exécutez la commande :
START SLAVE;Cela permet à l'environnement vert de commencer à synchroniser les données et à recevoir et appliquer des transactions depuis l'environnement bleu. | DBA | | Vérifiez le processus de réplication. | Pour vérifier que l'environnement vert reproduit correctement les données du cluster bleu :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Si tous les indicateurs sont corrects, la réplication basée sur le GTID fonctionne correctement et l'environnement vert est entièrement synchronisé avec l'environnement bleu. | DBA | ### Basculer le trafic du cluster bleu au cluster vert | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Configurez les politiques de routage pondérées Route 53. | Après avoir vérifié la cohérence des données entre les environnements bleu et vert, vous pouvez transférer le trafic du cluster bleu vers le cluster vert. Cette transition doit se faire en douceur, minimiser les temps d'arrêt et garantir l'intégrité de la base de données de votre application. Pour répondre à ces exigences, vous pouvez utiliser Route 53 pour le routage DNS et Lambda pour automatiser le changement de trafic. De plus, un plan de restauration bien défini vous permet de revenir au cluster bleu en cas de problème.La première étape consiste à configurer le routage pondéré dans Route 53. Le routage pondéré vous permet de contrôler la distribution du trafic entre les clusters bleus et verts, et de déplacer progressivement le trafic d'un environnement à l'autre.Pour configurer le routage pondéré :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Pour plus d'informations sur les politiques de routage pondérées, consultez la [documentation Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html). | AWS DevOps | | Déployez une fonction Lambda pour surveiller le délai de réplication. | Pour garantir que l'environnement vert est entièrement synchronisé avec l'environnement bleu, déployez une fonction Lambda qui surveille le délai de réplication entre les clusters. Cette fonction peut vérifier l'état de réplication, en particulier la métrique **Seconds\$1Behind\$1Master**, afin de déterminer si le cluster vert est prêt à gérer tout le trafic.Voici un exemple de fonction Lambda que vous pouvez utiliser :
import boto3Cette fonction vérifie le délai de réplication et renvoie la valeur. Si le décalage est nul, le cluster vert est entièrement synchronisé avec le cluster bleu. | AWS DevOps | | Automatisez l'ajustement du poids du DNS à l'aide de Lambda. | Lorsque le délai de réplication atteint zéro, il est temps de transférer tout le trafic vers le cluster vert. Vous pouvez automatiser cette transition à l'aide d'une autre fonction Lambda qui ajuste les pondérations DNS dans Route 53 afin de diriger 100 % du trafic vers le cluster vert.Voici un exemple de fonction Lambda qui automatise le changement de trafic :
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 boto3Cette fonction vérifie le délai de réplication et met à jour les pondérations DNS de Route 53 lorsque le décalage est nul afin de transférer complètement le trafic vers le cluster vert.****Pendant le processus de transition, si le cluster bleu est confronté à un trafic d'écriture important, envisagez de suspendre temporairement les opérations d'écriture pendant la transition. Cela garantit que la réplication rattrape son retard et évite les incohérences de données entre les clusters bleus et verts. | AWS DevOps | | Vérifiez le commutateur de trafic. | Une fois que la fonction Lambda a ajusté les pondérations DNS, vous devez vérifier que tout le trafic est dirigé vers le cluster vert et que le changement a été effectué avec succès.Pour vérifier :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Si tout fonctionne comme prévu, le changement de trafic est terminé. | AWS DevOps | | Si vous rencontrez des problèmes, annulez les modifications. | Il est essentiel de disposer d'un plan de réduction en cas de problème après le changement de trafic. Voici comment revenir rapidement au cluster bleu si nécessaire :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)En mettant en œuvre ce plan de restauration, vous pouvez garantir un minimum de perturbations à vos utilisateurs en cas de problèmes imprévus. | AWS DevOps | ### Valider et arrêter la réplication basée sur le GTID | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Arrêtez la réplication basée sur le GTID sur le cluster vert. | Après avoir transféré le trafic de l'environnement bleu à l'environnement vert, vous devez valider le succès de la transition et vous assurer que le cluster vert fonctionne comme prévu. En outre, la réplication basée sur le GTID entre les clusters bleu et vert doit être arrêtée, car l'environnement vert sert désormais de base de données principale. L'exécution de ces tâches garantit que votre environnement est sécurisé, rationalisé et optimisé pour les opérations en cours.Pour arrêter la réplication, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Lorsque vous arrêtez la réplication, le cluster vert devient totalement indépendant et fonctionne comme environnement de base de données principal pour vos charges de travail. | DBA | | nettoyer les ressources. | Le nettoyage de toutes les ressources temporaires ou inutilisées créées lors de la migration du cluster bleu vers le cluster vert garantit que votre environnement reste optimisé, sécurisé et rentable. Le nettoyage inclut l'ajustement des paramètres de sécurité, la réalisation des sauvegardes finales et la mise hors service des ressources inutiles.Pour nettoyer les ressources, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Le nettoyage des ressources permet de maintenir un environnement sécurisé et rationalisé, de réduire les coûts et de garantir que seule l'infrastructure nécessaire reste disponible. | AWS DevOps | ## Ressources connexes CloudFormation: + [CloudFormation Guide de l'utilisateur](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) + [CloudFormation meilleures pratiques](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/best-practices.html) + [Générez des modèles à partir de ressources existantes avec iAc Generator](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/generate-IaC.html) + [Importer des applications entières dans CloudFormation](https://aws.amazon.com/blogs/devops/import-entire-applications-into-aws-cloudformation/) (article de AWS blog) Amazon Aurora : + [Guide de l'utilisateur Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Welcome.html) + [Gestion d'un cluster de base de données Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_Aurora.html) Stratégie de déploiement bleu/vert : + [Présentation des Blue/Green déploiements d'Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-overview.html) Réplication basée sur le GTID : + [Utilisation de la réplication basée sur GTID (documentation Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) AWS Lambda: + [AWS Lambda Manuel du développeur](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) + [Bonnes pratiques d'utilisation des AWS Lambda fonctions](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) Amazon Route 53 : + [Guide du développeur Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) + [Routage pondéré](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) Outils client MySQL : + [PyMySQL](https://github.com/PyMySQL/PyMySQL) # Automatisez la réplication des instances Amazon RDS sur Comptes AWS *Parag Nagwekar et Arun Chanapillai, Amazon Web Services* ## Résumé Ce modèle vous montre comment automatiser le processus de réplication, de suivi et de restauration de vos instances de base de données Amazon Relational Database Service (Amazon RDS) sur Comptes AWS différentes instances en utilisant et. AWS Step Functions AWS Lambda Vous pouvez utiliser cette automatisation pour effectuer une réplication à grande échelle d'instances de base de données RDS sans impact sur les performances ni surcharge opérationnelle, quelle que soit la taille de votre organisation. Vous pouvez également utiliser ce modèle pour aider votre entreprise à se conformer aux stratégies obligatoires de gouvernance des données ou aux exigences de conformité qui exigent que vos données soient répliquées et redondantes entre différents Comptes AWS et. Régions AWS La réplication multicompte des données Amazon RDS à grande échelle est un processus manuel inefficace et sujet aux erreurs qui peut être coûteux et chronophage, mais l'automatisation selon ce modèle peut vous aider à réaliser une réplication entre comptes de manière sûre, efficace et efficiente. ## Conditions préalables et limitations **Conditions préalables** + Deux Comptes AWS + Une instance de base de données RDS, opérationnelle dans la source Compte AWS + Un groupe de sous-réseaux pour l'instance de base de données RDS dans la destination Compte AWS + Une clé AWS Key Management Service (AWS KMS) créée dans la source Compte AWS et partagée avec le compte de destination (pour plus d'informations sur les détails de la politique, consultez la section [Informations supplémentaires](#automate-the-replication-of-amazon-rds-instances-across-aws-accounts-additional) de ce modèle.) + Un AWS KMS key dans la destination Compte AWS pour chiffrer la base de données dans le compte de destination **Limites** + Certains Services AWS ne sont pas disponibles du tout Régions AWS. Pour connaître la disponibilité par région, voir [Services AWS par région](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Pour des points de terminaison spécifiques, consultez la page [Points de terminaison et quotas du service](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html), puis choisissez le lien vers le service. **Versions du produit** + Python 3.9 (en utilisant AWS Lambda) + PostgreSQL 11.3, 13.x et 14.x ## Architecture **Pile technologique** + 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 **Architecture cible** Le schéma suivant montre une architecture permettant d'utiliser Step Functions pour orchestrer la réplication planifiée et à la demande d'instances de base de données RDS d'un compte source (compte A) vers un compte de destination (compte B). ![\[Réplication d'instances de base de données Amazon RDS sur des comptes source et de destination à l'aide de Step Functions.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/6310ad9b-1b1a-4a67-b684-ef605fef3e87/images/001550bb-cf6b-493d-9de9-0229a43753a1.png) Dans le compte source (compte A dans le schéma), la machine d'état Step Functions effectue les opérations suivantes : 1. Crée un instantané à partir de l'instance de base de données RDS dans le compte A. 1. Copie et chiffre le cliché avec un compte AWS KMS key de provenance A. Pour garantir le chiffrement pendant le transfert, le cliché est chiffré, que l'instance de base de données soit chiffrée ou non. 1. Partage l'instantané de base de données avec le compte B en donnant au compte B l'accès à l'instantané. 1. Envoie une notification à la rubrique SNS, puis la rubrique SNS invoque la fonction Lambda dans le compte B. Dans le compte de destination (compte B dans le schéma), la fonction Lambda exécute la machine d'état Step Functions pour orchestrer les opérations suivantes : 1. Copie l'instantané partagé du compte A vers le compte B, tout en utilisant le AWS KMS key compte A pour déchiffrer les données, puis les chiffrer AWS KMS key à l'aide du compte B intégré. 1. Lit le secret depuis Secrets Manager pour capturer le nom de l'instance de base de données actuelle. 1. Restaure l'instance de base de données à partir du snapshot avec un nouveau nom et un nouveau nom par défaut AWS KMS key pour Amazon RDS. 1. Lit le point de terminaison de la nouvelle base de données et met à jour le secret dans Secrets Manager avec le nouveau point de terminaison de base de données, puis étiquette l'instance de base de données précédente afin qu'elle puisse être supprimée ultérieurement. 1. Conserve les N dernières instances des bases de données et supprime toutes les autres instances. ## Outils **Services AWS** + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) vous aide à configurer, exploiter et dimensionner une base de données relationnelle dans le. AWS Cloud + [Amazon Simple Notification Service (Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)) vous aide à coordonner et à gérer l'échange de messages entre les éditeurs et les clients, y compris les serveurs Web et les adresses e-mail. + [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)vous aide à configurer les AWS ressources, à les approvisionner rapidement et de manière cohérente, et à les gérer tout au long de leur cycle de vie à travers Comptes AWS et Régions AWS. + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) vous aide à créer et à contrôler des clés cryptographiques pour protéger vos données. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) est un service de calcul qui vous aide à exécuter du code sans avoir à allouer ni à gérer des serveurs. Il exécute votre code uniquement lorsque cela est nécessaire et évolue automatiquement, de sorte que vous ne payez que pour le temps de calcul que vous utilisez. + [AWS SDK pour Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html)est un kit de développement logiciel qui vous aide à intégrer votre application, bibliothèque ou script Python à Services AWS. + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) vous aide à remplacer les informations d'identification codées en dur dans votre code, y compris les mots de passe, par un appel d'API à Secrets Manager pour récupérer le secret par programmation. + [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html)est un service d'orchestration sans serveur qui vous aide à combiner des fonctions Lambda et d'autres fonctions pour créer des applications critiques Services AWS pour l'entreprise. **Référentiel de code** Le code de ce modèle est disponible dans le référentiel GitHub [Crossaccount RDS Replication.](https://github.com/aws-samples/aws-rds-crossaccount-replication) ## Épopées ### Automatisez la réplication des instances de base de données RDS Comptes AWS en un seul clic | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Déployez la CloudFormation pile dans le compte source. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Administrateur cloud, architecte cloud | | Déployez la CloudFormation pile dans le compte de destination. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Architecte cloud, DevOps ingénieur, administrateur cloud | | Vérifiez la création de l'instance de base de données RDS dans le compte de destination. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Administrateur cloud, architecte cloud, DevOps ingénieur | | Abonnez la fonction Lambda à la rubrique SNS. | Vous devez exécuter les commandes suivantes AWS Command Line Interface (AWS CLI) pour abonner la fonction Lambda du compte de destination (compte B) à la rubrique SNS du compte source (compte A).Dans le compte A, exécutez la commande suivante :
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 \Dans le compte B, exécutez la commande suivante :
--label lambda-access --aws-account-id\
--topic-arn\
--action-name Subscribe ListSubscriptionsByTopic
aws lambda add-permission \Dans le compte B, exécutez la commande suivante :
--function-name\
--source-arn\
--statement-id function-with-sns \
--action lambda:InvokeFunction \
--principal sns.amazonaws.com
aws sns subscribe \| Administrateur cloud, architecte cloud, DBA | | Synchronisez l'instance de base de données RDS depuis le compte source avec le compte de destination. | Lancez la réplication de base de données à la demande en démarrant la machine d'état Step Functions dans le compte source.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html)Un planificateur est en place pour vous aider à exécuter la réplication automatiquement comme prévu, mais il est désactivé par défaut. Vous trouverez le nom de la CloudWatch règle Amazon pour le planificateur dans l'onglet **Ressources** de la CloudFormation pile du compte de destination. Pour savoir comment modifier la règle CloudWatch des événements, consultez la section [Supprimer ou désactiver une règle d' CloudWatch événements](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Delete-or-Disable-Rule.html) dans la CloudWatch documentation. | Architecte cloud, DevOps ingénieur, administrateur cloud | | Restaurez votre base de données à l'une des copies précédentes si nécessaire. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Administrateur cloud, DBA, ingénieur DevOps | ## Ressources connexes + [Répliques de lecture entre régions](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.CrossRegionReadReplicas.html) (documentation Amazon RDS) + [Déploiements bleu/vert (documentation Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.BlueGreenDeployments.html) ## Informations supplémentaires Vous pouvez utiliser l'exemple de politique suivant pour partager AWS KMS key le vôtre Comptes 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/fr_fr/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html)
| AWS DevOps, ADMINISTRATEUR DE BASE DE DONNÉES | | Créez des tâches dans le planificateur de tâches. | Pour créer une tâche dans le planificateur de tâches, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html)Pour exécuter la tâche manuellement, cliquez avec le bouton droit sur la tâche nouvellement créée, puis sélectionnez **Exécuter**. | DBA | | Afficher le statut de la tâche. | Pour afficher le statut d'une tâche dans le planificateur de tâches, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html) | ADMINISTRATEUR DE BASES DE DONNÉES, AWS DevOps | ### Automatisez les tâches avec AWS Lambda | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Implémentez la solution. | Pour implémenter la solution de ce modèle, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html) | AWS DevOps, DevOps ingénieur | ## Résolution des problèmes | Problème | Solution | | --- | --- | | Problèmes liés à Lambda | Pour obtenir de l'aide concernant les erreurs et les problèmes que vous pourriez rencontrer lors de l'utilisation AWS Lambda, consultez la section [Résolution des problèmes dans Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-troubleshooting.html) dans la AWS documentation. | ## Ressources connexes + [Types d' EC2 instances Amazon](https://aws.amazon.com/ec2/instance-types/) + [AWS Lambda documentation](https://docs.aws.amazon.com/lambda/latest/dg/with-eventbridge-scheduler.html) + [AWS Lambda tarification](https://aws.amazon.com/lambda/pricing/) + [Planificateur de tâches pour les développeurs](https://learn.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-start-page) (site Web de Microsoft) # Automatisez le basculement et le retour en arrière entre régions à l'aide de DR Orchestrator Framework *Jitendra Kumar, Pavithra Balasubramanian et Oliver Francis, Amazon Web Services* ## Résumé Ce modèle décrit comment utiliser [DR Orchestrator Framework pour orchestrer](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/dr-orchestrator-framework-overview.html) et automatiser les étapes manuelles, sujettes aux erreurs, pour effectuer une reprise après sinistre dans les régions Amazon Web Services ().AWS Le modèle couvre les bases de données suivantes : + Amazon Relational Database Service (Amazon RDS) pour MySQL, Amazon RDS pour PostgreSQL ou Amazon RDS pour MariaDB + Édition compatible avec Amazon Aurora MySQL ou édition compatible avec Amazon Aurora PostgreSQL (à l'aide d'un fichier centralisé) + Amazon ElastiCache (Redis OSS) Pour démontrer les fonctionnalités de DR Orchestrator Framework, vous devez créer deux instances ou clusters de base de données. Le primaire est dans le Région AWS `us-east-1`, et le secondaire est dans`us-west-2`. Pour créer ces ressources, vous devez utiliser les AWS CloudFormation modèles contenus dans le `App-Stack` dossier du GitHub référentiel [aws-cross-region-dr-databases](https://github.com/aws-samples/aws-cross-region-dr-databases). ## Conditions préalables et limitations **Prérequis généraux** + Framework DR Orchestrator déployé à la fois dans le primaire et le secondaire Régions AWS + Deux [compartiments Amazon Simple Storage Service](https://aws.amazon.com/s3/) + Un [cloud privé virtuel (VPC)](https://aws.amazon.com/vpc/) avec deux sous-réseaux et un groupe de sécurité AWS **Prérequis spécifiques au moteur** + **Amazon Aurora** — Au moins une base de données globale Aurora doit être disponible sur deux Régions AWS. Vous pouvez l'utiliser `us-east-1` comme région principale et l'utiliser `us-west-2` comme région secondaire. + **Amazon ElastiCache (Redis OSS)** — Une banque de données ElastiCache globale doit être disponible en deux. Régions AWS Vous pouvez le faire `use us-east-1` comme région principale et l'utiliser `us-west-2` comme région secondaire. **Limitations d'Amazon RDS** + DR Orchestrator Framework ne vérifie pas le délai de réplication avant d'effectuer un basculement ou un retour en arrière. Le délai de réplication doit être vérifié manuellement. + Cette solution a été testée à l'aide d'une instance de base de données principale avec une réplique en lecture. Si vous souhaitez utiliser plusieurs répliques de lecture, testez soigneusement la solution avant de l'implémenter dans un environnement de production. **Limites d'Aurora** + La disponibilité et le support des fonctionnalités varient en fonction des versions spécifiques de chaque moteur de base de données et d'une version à l'autre Régions AWS. Pour plus d'informations sur la disponibilité des fonctionnalités et des régions pour la réplication entre régions, voir Répliques de [lecture entre régions](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.CrossRegionReadReplicas.html). + Les bases de données globales Aurora ont des exigences de configuration spécifiques pour les classes d'instances de base de données Aurora prises en charge et le nombre maximum de Régions AWS. Pour plus d'informations, consultez [la section Exigences de configuration d'une base de données globale Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html#aurora-global-database.configuration.requirements). + Cette solution a été testée à l'aide d'une instance de base de données principale avec une réplique en lecture. Si vous souhaitez utiliser plusieurs répliques de lecture, testez soigneusement la solution avant de l'implémenter dans un environnement de production. **ElastiCache limites** + Pour plus d'informations sur la disponibilité des régions pour Global Datastore et les exigences ElastiCache de configuration, consultez la section [Conditions préalables et limites](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastores-Getting-Started.html) de la ElastiCache documentation. Versions des produits **Amazon **RDS**** Amazon RDS prend en charge les versions de moteur suivantes : + **MySQL** — Amazon RDS prend en charge les instances de base de données exécutant les versions suivantes de [MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_MySQL.html) : MySQL 8.0 et MySQL 5.7 + **PostgreSQL** [— Pour plus d'informations sur les versions prises en charge d'Amazon RDS pour PostgreSQL, consultez la section Versions de base de données PostgreSQL disponibles.](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html#PostgreSQL.Concepts.General.DBVersions) + **MariaDB** [— Amazon RDS prend en charge les instances de base de données exécutant les versions suivantes de MariaDB :](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_MariaDB.html) + MariaDB 10.11 + MariaDB 10.6 + MariaDB 10.5 **Versions des produits Aurora** + Le passage à la base de données globale Amazon Aurora nécessite la compatibilité entre Aurora MySQL et MySQL 5.7, version 2.09.1 et supérieure Pour plus d'informations, consultez [Limitations des bases de données mondiales Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html#aurora-global-database.limitations). **ElastiCache Versions du produit (Redis OSS)** Amazon ElastiCache (Redis OSS) prend en charge les versions Redis suivantes : + Redis 7.1 (améliorée) + Redis 7.0 (améliorée) + Redis 6.2 (améliorée) + Redis 6.0 (améliorée) + Redis 5.0.6 (améliorée) Pour plus d'informations, voir [Versions prises en charge ElastiCache (Redis OSS)](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastores-Getting-Started.html). ## Architecture ****Architecture Amazon RDS**** L'architecture Amazon RDS inclut les ressources suivantes : + L'instance de base de données Amazon RDS principale créée dans la région principale (`us-east-1`) avec read/write accès pour les clients + Une réplique en lecture Amazon RDS créée dans la région secondaire (`us-west-2`) avec un accès en lecture seule pour les clients + Framework DR Orchestrator déployé dans les régions principale et secondaire ![\[Schéma de l'architecture RDS à deux régions dans un seul compte AWS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/ad217033-600c-40da-929c-b9f9aecb4c2c.png) Le diagramme décrit les éléments suivants : 1. Réplication asynchrone entre l'instance principale et l'instance secondaire 1. Accès en lecture/écriture pour les clients de la région principale 1. Accès en lecture seule pour les clients de la région secondaire **Architecture Aurora** L'architecture Amazon Aurora inclut les ressources suivantes : + Le cluster de base de données Aurora principal créé dans la région principale (`us-east-1`) avec un point de terminaison d'écriture active + Un cluster de base de données Aurora créé dans la région secondaire (`us-west-2`) avec un point de terminaison d'écriture inactif + Framework DR Orchestrator déployé dans les régions principale et secondaire ![\[Schéma du déploiement d'Aurora dans deux régions dans un seul compte AWS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/524ec002-5aa7-47b2-8c8d-6d1a3b535e9e.png) Le diagramme décrit les éléments suivants : 1. Réplication asynchrone entre le cluster principal et le cluster secondaire 1. Le cluster de base de données principal avec un point de terminaison d'écriture active 1. Le cluster de base de données secondaire avec un point de terminaison d'écriture inactif **ElastiCache Architecture (Redis OSS)** L'architecture Amazon ElastiCache (Redis OSS) inclut les ressources suivantes : + Une banque de données globale ElastiCache (Redis OSS) créée avec deux clusters : 1. Le cluster principal de la région principale (`us-east-1`) 1. Le cluster secondaire de la région secondaire (`us-west-2`) + Un lien interrégional Amazon avec chiffrement TLS 1.2 entre les deux clusters + Framework DR Orchestrator déployé dans les régions principale et secondaire ![\[Schéma d'un ElastiCache déploiement dans deux régions avec un lien entre les régions d'Amazon.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/cf6620a0-dd42-4042-8dc2-012bf514ffc0.png) **Automatisation et mise à l'échelle** DR Orchestrator Framework est évolutif et prend en charge le basculement ou le repli de plusieurs bases de données AWS en parallèle. Vous pouvez utiliser le code de charge utile suivant pour basculer entre plusieurs AWS bases de données de votre compte. Dans cet exemple, trois AWS bases de données (deux bases de données globales telles que Aurora MySQL compatible ou Aurora PostgreSQL compatible, et une instance Amazon RDS for MySQL) basculent vers la région 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" } } ] } ] } ``` ## Outils **AWS services** + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) est un moteur de base de données relationnelle entièrement géré conçu pour le cloud et compatible avec MySQL et PostgreSQL. + [Amazon](https://docs.aws.amazon.com/elasticache/) vous ElastiCache aide à configurer, à gérer et à faire évoluer des environnements de cache en mémoire distribués dans le AWS Cloud. Ce modèle utilise Amazon ElastiCache (Redis OSS). + [AWS Lambda](https://aws.amazon.com/lambda/) est un service de calcul qui vous aide à exécuter du code sans avoir à allouer ni à gérer des serveurs. Il exécute votre code uniquement lorsque cela est nécessaire et évolue automatiquement, de sorte que vous ne payez que pour le temps de calcul que vous utilisez. Dans ce modèle, les fonctions Lambda sont utilisées pour AWS Step Functions effectuer les étapes. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) vous aide à configurer, exploiter et dimensionner une base de données relationnelle dans le. AWS Cloud Ce modèle prend en charge Amazon RDS pour MySQL, Amazon RDS pour PostgreSQL et Amazon RDS pour MariaDB. + [AWS SDK pour Python (Boto3)](https://aws.amazon.com/sdk-for-python/)vous permet d'intégrer votre application, bibliothèque ou script Python à Services AWS. Dans ce modèle, les Boto3 APIs sont utilisés pour communiquer avec les instances de base de données ou les bases de données globales. + [AWS Step Functions](https://aws.amazon.com/step-functions/)est un service d'orchestration sans serveur qui vous aide à combiner des AWS Lambda fonctions et d'autres fonctions Services AWS pour créer des applications critiques pour l'entreprise. Dans ce modèle, les machines d'état Step Functions sont utilisées pour orchestrer et exécuter le basculement et le retour en arrière entre régions des instances de base de données ou des bases de données globales. **Référentiel de code** Le code de ce modèle est disponible dans le référentiel [aws-cross-region-dr-databases](https://github.com/aws-samples/aws-cross-region-dr-databases/tree/main/App-Stack) sur GitHub. ## Épopées ### Installez DR Orchestrator Framework | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Clonez le GitHub dépôt. | Pour cloner le dépôt, exécutez la commande suivante :
@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, administrateur AWS | | Package Lambda utilise le code des fonctions dans une archive de fichier .zip. | Créez les fichiers d'archive pour les fonctions Lambda afin d'inclure les dépendances du DR Orchestrator Framework :
cd| Administrateur AWS | | Créez des compartiments S3. | Les compartiments S3 sont nécessaires pour stocker le framework DR Orchestrator ainsi que votre dernière configuration. Créez deux compartiments S3, l'un dans la région principale (`us-east-1`) et l'autre dans la région secondaire (`us-west-2`) :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html)`xxxxxx`Remplacez-le par une valeur aléatoire pour que les noms des compartiments soient uniques. | Administrateur AWS | | Créez des sous-réseaux et des groupes de sécurité. | Dans la région principale (`us-east-1`) et la région secondaire (`us-west-2`), créez deux sous-réseaux et un groupe de sécurité pour le déploiement de la fonction Lambda dans votre VPC :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | Administrateur AWS | | Mettez à jour les fichiers de paramètres de DR Orchestrator. | Dans le `/DR-Orchestration-artifacts
bash scripts/deploy-orchestrator-sh.sh
[| Administrateur AWS | | Téléchargez le code DR Orchestrator Framework dans le compartiment S3. | Le code sera plus sûr dans un compartiment S3 que dans le répertoire local. Téléchargez le `DR-Orchestration-artifacts` répertoire, y compris tous les fichiers et sous-dossiers, dans les compartiments S3.Pour télécharger le code, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | Administrateur AWS | | Déployez DR Orchestrator Framework dans la région principale. | Pour déployer DR Orchestrator Framework dans la région principale (`us-east-1`), exécutez les commandes suivantes :
{
"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| Administrateur AWS | | Déployez DR Orchestrator Framework dans la région secondaire. | Dans la région secondaire (`us-west-2`), exécutez les commandes suivantes :/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| Administrateur AWS | | Vérifier le déploiement. | Si la CloudFormation commande s'exécute correctement, elle renvoie le résultat suivant :/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-orchestratorVous pouvez également accéder à la CloudFormation console et vérifier l'état de la `dr-orchestrator` pile. | Administrateur AWS | ### Création des instances ou des clusters de base de données | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez les sous-réseaux de base de données et les groupes de sécurité. | Dans votre VPC, créez deux sous-réseaux et un groupe de sécurité pour l'instance de base de données ou la base de données globale dans les régions principale (`us-east-1`) et secondaire (`us-west-2`) :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | Administrateur AWS | | Mettez à jour le fichier de paramètres pour l'instance ou le cluster de base de données principal. | Dans le `
{
"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** Dans le `Aurora-MySQL-parameter-us-east-1.json` fichier, mettez à jour `SubnetIds` et `DBSecurityGroup` avec les noms des ressources que vous avez créées :{
"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)**Dans le `ElastiCache-parameter-us-east-1.json` fichier, mettez à jour `SubnetIds` et `DBSecurityGroup` avec les noms des ressources que vous avez créées.{
"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"
}
} | Administrateur AWS |
| Déployez votre instance ou cluster de base de données dans la région principale. | Pour déployer votre instance ou votre cluster dans la région principale (`us-east-1`), exécutez les commandes suivantes en fonction de votre moteur de base de données.**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
cdVérifiez que les CloudFormation ressources ont été déployées avec succès. | Administrateur AWS | | Mettez à jour le fichier de paramètres pour l'instance ou le cluster de base de données secondaire. | Dans le `/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**Dans le `Aurora-MySQL-parameter-us-west-2.json` fichier, mettez à jour `SubnetIDs` et `DBSecurityGroup` avec les noms des ressources que vous avez créées. Mettez à jour le `PrimaryRegionKMSKeyArn` avec la valeur `AuroraKmsKeyId` extraite de la section **Outputs** de la CloudFormation pile pour l'instance de base de données principale :{
"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)**Dans le `ElastiCache-parameter-us-west-2.json` fichier, mettez à jour `SubnetIDs` et `DBSecurityGroup` avec les noms des ressources que vous avez créées. Mettez à jour le `PrimaryRegionKMSKeyArn` avec la valeur `ElastiCacheKmsKeyId` extraite de la section **Outputs** de la CloudFormation pile pour l'instance de base de données principale :{
"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"
}
} | Administrateur AWS |
| Déployez votre instance ou cluster de base de données dans la région secondaire. | Exécutez les commandes suivantes, en fonction de votre moteur de base de données.**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
cdVérifiez que les CloudFormation ressources ont été déployées avec succès. | Administrateur AWS | ## Ressources connexes + [Stratégie de reprise après sinistre pour les bases de données sur AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/strategy-database-disaster-recovery/welcome.html) (stratégie d'orientation AWS prescriptive) + [Automatisez votre solution de reprise après sinistre pour les bases de données relationnelles sur AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/dr-orchestrator-framework-overview.html) (AWS guide prescriptif) + [Utilisation de bases de données globales Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html) + [Réplication à Régions AWS l'aide de banques de données globales](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastore.html) + [Automatisez votre solution de reprise après sinistre pour les bases de données relationnelles sur AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/introduction.html) (AWS guide prescriptif) # Sauvegardez automatiquement les bases de données SAP HANA à l'aide de Systems Manager et EventBridge *Ambarish Satarkar et Gaurav Rath, Amazon Web Services* ## Résumé Ce modèle décrit comment automatiser les sauvegardes de bases de données SAP HANA à l'aide d'AWS Systems Manager, d'Amazon EventBridge, d'Amazon Simple Storage Service (Amazon S3) et d'AWS Backint Agent pour SAP HANA. Ce modèle fournit une approche basée sur un script shell utilisant la `BACKUP DATA` commande et élimine le besoin de gérer les scripts et les configurations de travail pour chaque instance de système d'exploitation (OS) sur de nombreux systèmes. | | | Remarque : En avril 2023, AWS Backup a annoncé la prise en charge des bases de données SAP HANA sur Amazon Elastic Compute Cloud (Amazon EC2). Pour plus d'informations, consultez la section [Bases de données SAP HANA sur la sauvegarde EC2 des instances Amazon](https://docs.aws.amazon.com/aws-backup/latest/devguide/backup-saphana.html).Selon les besoins de votre organisation, vous pouvez utiliser le service AWS Backup pour sauvegarder automatiquement vos bases de données SAP HANA ou vous pouvez utiliser ce modèle. | | --- | ## Conditions préalables et limitations **Conditions préalables** + Une instance SAP HANA existante avec une version prise en charge en cours d'exécution sur une instance Amazon Elastic Compute Cloud (Amazon EC2) gérée et configurée pour Systems Manager + Systems Manager Agent (SSM Agent) 2.3.274.0 ou version ultérieure installé + Un compartiment S3 dont l'accès public n'est pas activé + Une `hdbuserstore` clé nommée `SYSTEM` + Un rôle AWS Identity and Access Management (IAM) pour que le runbook d'automatisation s'exécute dans les délais + `AmazonSSMManagedInstanceCore`et `ssm:StartAutomationExecution` les politiques sont associées au rôle de service Systems Manager Automation. **Limites** + AWS Backint Agent pour SAP HANA ne prend pas en charge la déduplication. + AWS Backint Agent pour SAP HANA ne prend pas en charge la compression des données. **Versions du produit** AWS Backint Agent est pris en charge sur les systèmes d'exploitation suivants : + SUSE Linux Enterprise Server + Serveur SUSE Linux Enterprise pour SAP + Red Hat Enterprise Linux pour SAP AWS Backint Agent prend en charge les bases de données suivantes : + SAP HANA 1.0 SP12 (nœud unique et nœuds multiples) + SAP HANA 2.0 et versions ultérieures (nœud unique et nœuds multiples) ## Architecture **Pile technologique cible** + Agent de backint AWS + Amazon S3 + AWS Systems Manager + Amazon EventBridge + SAP HANA **Architecture cible** Le schéma suivant montre les scripts d'installation qui installent AWS Backint Agent, le compartiment S3 et Systems Manager EventBridge et qui utilisent un document de commande pour planifier des sauvegardes régulières. ![\[Flux de travail pour planifier des sauvegardes régulières.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/0aa22a27-d100-483d-95f9-c3101f40402c/images/201d2b9a-b88e-4432-82cd-240b81da981e.png) **Automatisation et mise à l'échelle** + Plusieurs agents AWS Backint peuvent être installés à l'aide d'un runbook d'automatisation de Systems Manager. + *Chaque exécution du runbook Systems Manager peut être étendue à un certain nombre d'instances SAP HANA, en fonction de la sélection des cibles.* + EventBridge peut automatiser les sauvegardes SAP HANA. ## Outils + [AWS Backint Agent pour SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-sap-hana.html) est une application autonome qui s'intègre à vos flux de travail existants pour sauvegarder votre base de données SAP HANA dans un compartiment S3 que vous spécifiez dans le fichier de configuration. AWS Backint Agent prend en charge les sauvegardes complètes, incrémentielles et différentielles des bases de données SAP HANA. Il s'exécute sur un serveur de base de données SAP HANA, où les sauvegardes et les catalogues sont transférés de la base de données SAP HANA vers l'agent AWS Backint. + [Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html) est un service de bus d'événements sans serveur que vous pouvez utiliser pour connecter vos applications à des données provenant de diverses sources. EventBridge fournit un flux de données en temps réel provenant de vos applications, de vos applications SaaS et des services AWS à des cibles telles que les fonctions AWS Lambda, les points de terminaison d'invocation HTTP utilisant des destinations d'API ou les bus d'événements d'autres comptes. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) est un service de stockage d'objets. Vous pouvez utiliser Amazon S3 pour stocker et récupérer n'importe quelle quantité de données, n'importe quand et depuis n'importe quel emplacement sur le Web. + [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) vous aide à visualiser et à contrôler votre infrastructure sur AWS. À l'aide de la console Systems Manager, vous pouvez consulter les données opérationnelles de plusieurs services AWS et automatiser les tâches opérationnelles sur l'ensemble de vos ressources AWS. **Code** Le code de ce modèle est disponible dans le [aws-backint-automated-backup](https://github.com/aws-samples/aws-backint-automated-backup) GitHub référentiel. ## Épopées ### Créez un système de clés hdbuserstore | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une clé hdbuserstore. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html) | Administrateur AWS, administrateur SAP HANA | ### Installation de l'agent AWS Backint | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Installez AWS Backint Agent. | Suivez les instructions de la section [Installation et configuration d'AWS Backint Agent pour SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-installing-configuring.html) dans la documentation d'AWS Backint Agent. | Administrateur AWS, administrateur SAP HANA | ### Création du document de commande de Systems Manager | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez le document de commande de Systems Manager. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html) | Administrateur AWS, administrateur SAP HANA | ### Planifiez des sauvegardes à une fréquence régulière | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Planifiez des sauvegardes régulières à l'aide d'Amazon EventBridge. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html)Vous pouvez vérifier le succès de la sauvegarde à partir du chemin du compartiment 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:/Vous pouvez également vérifier les sauvegardes à partir du catalogue de sauvegarde SAP HANA. | Administrateur AWS, administrateur SAP HANA | ## Ressources connexes + [Agent de backint AWS pour SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-sap-hana.html) + [Installation et configuration d'AWS Backint Agent pour SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-installing-configuring.html) # Générez automatiquement un modèle PynamoDB et des fonctions CRUD pour Amazon DynamoDB à l'aide d'une application Python *Vijit Vashishtha, Dheeraj Alimchandani et Dhananjay Karanjkar, Amazon Web Services* ## Résumé Il est courant d'avoir besoin d'entités et de fonctions d'opérations de création, de lecture, de mise à jour et de suppression (CRUD) pour exécuter efficacement les opérations de base de données Amazon DynamoDB. PynamoDB est une interface basée sur Python qui supporte Python 3. Il fournit également des fonctionnalités telles que la prise en charge des transactions Amazon DynamoDB, la sérialisation et la désérialisation automatiques des valeurs d'attributs, ainsi que la compatibilité avec les frameworks Python courants, tels que Flask et Django. Ce modèle aide les développeurs travaillant avec Python et DynamoDB en fournissant une bibliothèque qui rationalise la création automatique de modèles Pynamodb et de fonctions d'opération CRUD. Bien qu'il génère des fonctions CRUD essentielles pour les tables de base de données, il peut également rétroconcevoir des modèles Pynamodb et des fonctions CRUD à partir de tables Amazon DynamoDB. Ce modèle est conçu pour simplifier les opérations de base de données en utilisant une application basée sur Python. Les principales caractéristiques de cette solution sont les suivantes : + **Schéma JSON vers modèle Pynamodb — Générez automatiquement des modèles Pynamodb** en Python en important un fichier de schéma JSON. + Génération de **fonctions CRUD — Génère** automatiquement des fonctions pour effectuer des opérations CRUD sur des tables DynamoDB. + **Rétro-ingénierie à partir de DynamoDB** : utilisez le mappage relationnel objet (ORM) PynamoDB pour rétroconcevoir les modèles PynamoDB et les fonctions CRUD pour les tables Amazon DynamoDB existantes. ## Conditions préalables et limitations **Conditions préalables** + Un actif Compte AWS + Python version 3.8 ou ultérieure, [téléchargée](https://www.python.org/downloads/) et installée + [Jinja2 version 3.1.2 ou ultérieure, téléchargée et installée](https://pypi.org/project/Jinja2/#files) + Tables Amazon DynamoDB pour lesquelles vous souhaitez générer un ORM + AWS Command Line Interface (AWS CLI), [installé](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) et [configuré](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) + [Pynamodb version 5.4.1 ou ultérieure, installée](https://pynamodb.readthedocs.io/en/stable/tutorial.html#installation) ## Architecture **Pile technologique cible** + Script JSON + Application Python + Modèle PynamoDB + Instance de base de données Amazon DynamoDB **Architecture cible** ![\[Utilisation d'une application Python pour générer des fonctions CRUD et un modèle PynamoDB à partir de tables DynamoDB.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/74cc4c73-5c8b-448d-98fb-b681cfa5f860/images/c2c367d6-d88a-4f49-8571-89160539eb08.png) 1. Vous créez un fichier de schéma JSON d'entrée. Ce fichier de schéma JSON représente les attributs des tables DynamoDB respectives à partir desquelles vous souhaitez créer des modèles Pynamodb et des fonctions CRUD pour lesquelles vous souhaitez créer des fonctions CRUD. Il contient les trois clés importantes suivantes : + `name`: nom de la table DynamoDB cible. + `region`— L' Région AWS endroit où la table est hébergée + `attributes`[— Les attributs qui font partie de la table cible, tels que la [clé de partition](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey) (également appelée *attribut de hachage*), la [clé de tri](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey), les [index secondaires locaux, les index](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSI.html)[secondaires globaux](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html) et tout attribut non clé.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.TablesItemsAttributes) Cet outil s'attend à ce que le schéma d'entrée fournisse uniquement les attributs non clés, car l'application extrait les attributs clés directement depuis la table cible. Pour un exemple de la manière de spécifier des attributs dans le fichier de schéma JSON, consultez la section [Informations supplémentaires](#automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application-additional) de ce modèle. 1. Exécutez l'application Python et fournissez le fichier de schéma JSON en entrée. 1. L'application Python lit le fichier de schéma JSON. 1. L'application Python se connecte aux tables DynamoDB pour dériver le schéma et les types de données. L'application exécute l'opération [describe\$1table](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/describe_table.html) et récupère les attributs de clé et d'index de la table. 1. L'application Python combine les attributs du fichier de schéma JSON et de la table DynamoDB. Il utilise le moteur de modèles Jinja pour générer un modèle Pynamodb et les fonctions CRUD correspondantes. 1. Vous accédez au modèle PynamoDB pour effectuer des opérations CRUD sur la table DynamoDB. ## Outils **Services AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) est un service de base de données NoSQL entièrement géré, offrant des performances rapides, prévisibles et évolutives. **Autres outils** + [Jinja](https://jinja.palletsprojects.com/en/) est un moteur de création de modèles extensible qui compile des modèles dans du code Python optimisé. Ce modèle utilise Jinja pour générer du contenu dynamique en intégrant des espaces réservés et de la logique dans les modèles. + [PynamoDB](https://pynamodb.readthedocs.io/en/stable/) est une interface basée sur Python pour Amazon DynamoDB. + [Python](https://www.python.org/) est un langage de programmation informatique polyvalent. **Référentiel de code** Le code de ce modèle est disponible dans le référentiel de modèles [Pynamodb et de fonctions CRUD à GitHub générer automatiquement](https://github.com/aws-samples/amazon-reverse-engineer-dynamodb). Le référentiel est divisé en deux parties principales : le package du contrôleur et les modèles. *Package de contrôleur* Le package Python du contrôleur contient la logique d'application principale qui permet de générer le modèle Pynamodb et les fonctions CRUD. Il contient les éléments suivants : + `input_json_validator.py`— Ce script Python valide le fichier de schéma JSON d'entrée et crée les objets Python contenant la liste des tables DynamoDB cibles et les attributs requis pour chacune d'elles. + `dynamo_connection.py`— Ce script établit une connexion à la table DynamoDB et utilise `describe_table` l'opération pour extraire les attributs nécessaires à la création du modèle PynamoDB. + `generate_model.py`— Ce script contient une classe Python `GenerateModel` qui crée le modèle Pynamodb en fonction du fichier de schéma JSON d'entrée et de l'opération. `describe_table` + `generate_crud.py`— Pour les tables DynamoDB définies dans le fichier de schéma JSON, ce script utilise `GenerateCrud` l'opération de création des classes Python. *Modèles* Ce répertoire Python contient les modèles Jinja suivants : + `model.jinja`— Ce modèle Jinja contient l'expression du modèle permettant de générer le script du modèle Pynamodb. + `crud.jinja`— Ce modèle Jinja contient l'expression du modèle permettant de générer le script des fonctions CRUD. ## Épopées ### Configuration de l'environnement | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Pour cloner le référentiel. | Entrez la commande suivante pour cloner le référentiel de modèles [Pynamodb et de fonctions CRUD générés automatiquement](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| Développeur d’applications | | Configurez l'environnement Python. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Développeur d’applications | ### Génération du modèle Pynamodb et des fonctions CRUD | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Modifiez le fichier de schéma JSON. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Développeur d’applications | | Exécutez l'application Python. | Entrez la commande suivante pour générer les modèles Pynamodb et les fonctions CRUD, `
python main.py --file| Développeur d’applications | ### Vérifiez le modèle Pynamodb et les fonctions CRUD | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Vérifiez le modèle Pynamodb généré. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Développeur d’applications | | Vérifiez les fonctions CRUD générées. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | Développeur d’applications | ## Ressources connexes + [Composants principaux d'Amazon DynamoDB (documentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html) DynamoDB) + [Améliorer l'accès aux données grâce aux index secondaires (documentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) DynamoDB) ## Informations supplémentaires **Exemples d'attributs pour le fichier de schéma JSON** ``` [ { "name": "test_table", "region": "ap-south-1", "attributes": [ { "name": "id", "type": "UnicodeAttribute" }, { "name": "name", "type": "UnicodeAttribute" }, { "name": "age", "type": "NumberAttribute" } ] } ] ``` # Bloquez l'accès public à Amazon RDS à l'aide de Cloud Custodian *abhay kumar et Dwarika Patra, Amazon Web Services* ## Résumé De nombreuses entreprises exécutent leurs charges de travail et leurs services auprès de plusieurs fournisseurs de cloud. Dans ces environnements de cloud hybride, l'infrastructure cloud a besoin d'une gouvernance cloud stricte, en plus de la sécurité fournie par les différents fournisseurs de cloud. Une base de données cloud telle qu'Amazon Relational Database Service (Amazon RDS) est un service important qui doit être surveillé pour détecter toute vulnérabilité en matière d'accès et d'autorisation. Bien que vous puissiez restreindre l'accès à la base de données Amazon RDS en configurant un groupe de sécurité, vous pouvez ajouter une deuxième couche de protection pour interdire des actions telles que l'accès public. Le blocage de l'accès public vous aide à respecter le règlement général sur la protection des données (RGPD), la loi HIPAA (Health Insurance Portability and Accountability Act), le National Institute of Standards and Technology (NIST) et la norme de sécurité des données de l'industrie des cartes de paiement (PCI DSS). Cloud Custodian est un moteur de règles open source que vous pouvez utiliser pour appliquer des restrictions d'accès aux ressources Amazon Web Services (AWS) telles qu'Amazon RDS. Avec Cloud Custodian, vous pouvez définir des règles qui valident l'environnement par rapport aux normes de sécurité et de conformité définies. Vous pouvez utiliser Cloud Custodian pour gérer vos environnements cloud en garantissant le respect des politiques de sécurité, des politiques en matière de balises, la collecte des ressources inutilisées et la gestion des coûts. Avec Cloud Custodian, vous pouvez utiliser une interface unique pour mettre en œuvre la gouvernance dans un environnement cloud hybride. Par exemple, vous pouvez utiliser l'interface Cloud Custodian pour interagir avec Microsoft Azure AWS et ainsi réduire les efforts liés à l'utilisation de mécanismes tels que AWS Config les groupes AWS de sécurité et les politiques Azure. Ce modèle fournit des instructions pour utiliser Cloud Custodian AWS afin de restreindre l'accessibilité publique aux instances Amazon RDS. ## Conditions préalables et limitations **Conditions préalables** + Un actif Compte AWS + [Une paire de clés](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-creds-create) + AWS Lambda installé ## Architecture Le schéma suivant montre le déploiement de la politique par Cloud Custodian AWS Lambda, le AWS CloudTrail lancement de l'`CreateDBInstance`événement et le `PubliclyAccessible` paramétrage de la fonction Lambda sur false sur Amazon RDS. ![\[Utilisation de Cloud Custodian sur AWS pour restreindre l'accès public aux instances Amazon RDS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/90f9537e-9365-4da2-8a28-da0ff374743c/images/6d04ca3b-6aa4-4c62-ade9-8b7474928c5e.png) ## Outils **Services AWS** + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html)vous aide à auditer la gouvernance, la conformité et le risque opérationnel de votre Compte AWS + [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) est un outil open source qui vous permet d'interagir Services AWS par le biais de commandes dans votre interface de ligne de commande. + [Gestion des identités et des accès AWS (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) vous aide à gérer en toute sécurité l'accès à vos AWS ressources en contrôlant qui est authentifié et autorisé à les utiliser. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) est un service de calcul qui vous aide à exécuter du code sans avoir à allouer ni à gérer des serveurs. Il exécute votre code uniquement lorsque cela est nécessaire et évolue automatiquement, de sorte que vous ne payez que pour le temps de calcul que vous utilisez. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) vous aide à configurer, exploiter et dimensionner une base de données relationnelle dans le. AWS Cloud **Autres outils** + [Cloud Custodian](https://cloudcustodian.io/) unifie les outils et les scripts utilisés par de nombreuses entreprises pour gérer leurs comptes de cloud public en un seul outil open source. Il utilise un moteur de règles sans état pour la définition et l'application des politiques, avec des métriques, des résultats structurés et des rapports détaillés pour l'infrastructure cloud. Il s'intègre étroitement à un environnement d'exécution sans serveur pour fournir une correction et une réponse en temps réel avec une faible charge opérationnelle. ## Épopées ### Configurez le AWS CLI | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Installez le AWS CLI. | Pour l'installer AWS CLI, suivez les instructions de la [AWS documentation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html). | Administrateur AWS | | Configurez les AWS informations d'identification. | Configurez les paramètres avec lesquels les AWS CLI utilisateurs doivent interagir AWS, y compris le Région AWS format de sortie que vous souhaitez utiliser.
$>aws configurePour plus d’informations, consultez la [documentation AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html). | Administrateur AWS | | Créez un rôle IAM. | Pour créer un rôle IAM avec le rôle d'exécution Lambda, exécutez la commande suivante.
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 |
### Configurer Cloud Custodian
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Installez Cloud Custodian. | Pour installer Cloud Custodian pour votre système d'exploitation et votre environnement, suivez les instructions de la documentation [Cloud Custodian](https://cloudcustodian.io/docs/quickstart/index.html#install-cc). | DevOps ingénieur |
| Vérifiez le schéma Cloud Custodian. | Pour consulter la liste complète des ressources Amazon RDS sur lesquelles vous pouvez exécuter des politiques, utilisez la commande suivante.custodian schema aws.rds| DevOps ingénieur | | Créez la politique Cloud Custodian. | Enregistrez le code qui se trouve sous le *fichier de politique Cloud Custodian* dans la section [Informations supplémentaires](#block-public-access-to-amazon-rds-by-using-cloud-custodian-additional) à l'aide d'une extension YAML. | DevOps ingénieur | | Définissez les actions du Cloud Custodian pour modifier le drapeau accessible au public. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/block-public-access-to-amazon-rds-by-using-cloud-custodian.html) | DevOps ingénieur | | Effectuez un essai à sec. | (Facultatif) Pour vérifier quelles ressources sont identifiées par la politique sans exécuter aucune action sur les ressources, utilisez la commande suivante.
custodian run -dryrun| DevOps ingénieur | ### Déployer la politique | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Déployez la politique à l'aide de Lambda. | Pour créer la fonction Lambda qui exécutera la politique, utilisez la commande suivante..yaml -s
custodian run -s policy.yamlCette politique sera ensuite initiée par l' AWS CloudTrail `CreateDBInstance`événement.Par conséquent, le drapeau accessible au public AWS Lambda sera défini sur `false` les instances qui répondent aux critères. | DevOps ingénieur | ## Ressources connexes + [AWS Lambda website](https://aws.amazon.com/lambda/) + [Site Web Amazon RDS](https://aws.amazon.com/rds/) + [Documentation Cloud Custodian](https://cloudcustodian.io/docs/quickstart/index.html) ## Informations supplémentaires **Fichier YAML de politique 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 ``` **fichier rds.py de ressources 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 ``` **Intégration au Security Hub CSPM** Cloud Custodian peut être intégré [AWS Security Hub CSPM](https://aws.amazon.com/security-hub/)pour envoyer des résultats de sécurité et tenter de prendre des mesures correctives. Pour plus d'informations, consultez [Annonce de l'intégration de Cloud Custodian avec AWS Security Hub CSPM](https://aws.amazon.com/blogs/opensource/announcing-cloud-custodian-integration-aws-security-hub/). # Configurez l'authentification Windows pour Amazon RDS pour Microsoft SQL Server à l'aide de AWS Managed Microsoft AD *Ramesh Babu Donti, Amazon Web Services* ## Résumé Ce modèle montre comment configurer l'authentification Windows pour une instance Amazon Relational Database Service (Amazon RDS) pour les instances de SQL Server à AWS Directory Service for Microsoft Active Directory l'aide AWS Managed Microsoft AD de (). L'authentification Windows permet aux utilisateurs de se connecter à l'instance RDS en utilisant leurs informations d'identification de domaine au lieu de noms d'utilisateur et de mots de passe spécifiques à la base de données. Vous pouvez activer l'authentification Windows soit lors de la création d'une nouvelle base de données RDS SQL Server, soit en l'ajoutant à une instance de base de données existante. L'instance de base de données s'intègre AWS Managed Microsoft AD pour fournir une authentification et une autorisation centralisées aux utilisateurs du domaine accédant à la base de données SQL Server. Cette configuration améliore la sécurité en tirant parti de l'infrastructure Active Directory existante et élimine le besoin de gérer des informations d'identification de base de données distinctes pour les utilisateurs du domaine. ## Conditions préalables et limitations **Conditions préalables** + Un actif Compte AWS avec les autorisations appropriées + Un cloud privé virtuel (VPC) avec les éléments suivants : + Passerelles Internet et tables de routage configurées + Passerelles NAT dans les sous-réseaux publics (si un accès Internet est requis pour les instances) + Gestion des identités et des accès AWS Rôles (IAM) : + Un rôle de domaine avec les politiques AWS gérées suivantes : + `AmazonSSMManagedInstanceCore`pour activer AWS Systems Manager + `AmazonSSMDirectoryServiceAccess`pour fournir des autorisations permettant de joindre des instances à des annuaires + Un rôle de surveillance améliorée RDS (si la surveillance améliorée est activée) + Groupes de sécurité : + Groupe de sécurité du service d'annuaire autorisant les ports de communication Active Directory + Un groupe de sécurité Amazon Elastic Compute Cloud (Amazon EC2) pour autoriser les communications RDP `3389` et de domaine + Un groupe de sécurité RDS pour autoriser le port SQL Server à `1433` partir de sources autorisées + Connectivité réseau : + Résolution DNS et connectivité réseau appropriées entre les sous-réseaux **Limites** + Pour plus d'informations sur Régions AWS cette prise en charge AWS Managed Microsoft AD avec RDS pour SQL Server, consultez [la section Disponibilité des régions et des versions](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerWinAuth.html#USER_SQLServerWinAuth.RegionVersionAvailability). + Certains Services AWS ne sont pas disponibles du tout Régions AWS. Pour connaître la disponibilité par région, voir [Services AWS par région](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Pour des points de terminaison spécifiques, consultez la page [Points de terminaison et quotas du service](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html), puis choisissez le lien vers le service. ## Architecture **Pile technologique source** + Un Active Directory sur site ou AWS Managed Microsoft AD **Pile technologique cible** + Amazon EC2 + Amazon RDS for Microsoft SQL Server + AWS Managed Microsoft AD **Architecture cible** ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/e02f6059-6631-46f6-819c-5961af7ba4ae/images/1aa50e3b-b4f6-4d44-9f9e-6cbb248a159c.png) L'architecture inclut les éléments suivants : + Rôle IAM qui joint l' EC2 instance Amazon au AWS Managed Microsoft AD domaine. + Une instance Amazon EC2 Windows pour l'administration et les tests de bases de données. + Un Amazon VPC doté d'un sous-réseau privé pour héberger l'instance Amazon RDS et les ressources internes dans les zones de disponibilité. + Groupes de sécurité pour le contrôle d'accès au réseau : + Un groupe de sécurité Amazon RDS pour contrôler l'accès entrant au port SQL Server à `1433` partir de sources autorisées. + Un groupe EC2 de sécurité Amazon pour gérer l'accès RDP via les ports de communication `3389` des ports et des domaines. + Un groupe de sécurité des services d'annuaire pour les communications Active Directory via les ports `53` `88``389`,, et`445`. + AWS Managed Microsoft AD pour fournir des services d'authentification et d'autorisation centralisés pour les ressources Windows. + Une instance de base de données Amazon RDS for SQL Server dans le sous-réseau privé avec l'authentification Windows activée. ## Outils **Services AWS** + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) fournit une capacité de calcul évolutive dans le AWS Cloud. Vous pouvez lancer autant de serveurs virtuels que vous le souhaitez et les augmenter ou les diminuer rapidement. + Amazon Relational Database Service (Amazon RDS) vous aide à configurer, exploiter et dimensionner une base de données relationnelle dans le. AWS Cloud + [AWS Directory Service](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/what_is.html)propose plusieurs manières d'utiliser Microsoft Active Directory (AD) avec d'autres, Services AWS comme Amazon Elastic Compute Cloud (Amazon EC2), Amazon Relational Database Service (Amazon RDS) pour SQL Server et FSx Amazon pour Windows File Server. + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)permet à vos charges de travail et à vos AWS ressources sensibles aux annuaires d'utiliser Microsoft Active Directory dans le. AWS Cloud + [Gestion des identités et des accès AWS (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) vous aide à gérer en toute sécurité l'accès à vos AWS ressources en contrôlant qui est authentifié et autorisé à les utiliser. **Autres services** + [Microsoft SQL Server Management Studio (SSMS)](https://learn.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms) est un outil de gestion de SQL Server, y compris l'accès, la configuration et l'administration des composants de SQL Server. ## Bonnes pratiques + Pour connaître les meilleures pratiques générales, consultez la section [Meilleures pratiques pour Amazon RDS.](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_BestPractices.html) ## Épopées ### Configuration AWS Managed Microsoft AD | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Configurez le type de répertoire. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Configurez les informations du répertoire. | Dans la section **Informations du répertoire**, entrez les informations requises et conservez les valeurs facultatives :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Configurez le VPC et les sous-réseaux. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Révisez et créez le répertoire. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | ### Création et configuration d'une EC2 instance Amazon | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Configurez une AMI pour Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Configurer les paramètres réseau. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Configurez le stockage. | Configurez les volumes Amazon EBS selon vos besoins. | DBA, ingénieur DevOps | | Configurez les détails avancés et lancez l'instance. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | ### Création et configuration de RDS pour SQL Server avec authentification Windows | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une base de données et configurez les options du moteur. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Choisir un modèle. | Choisissez un exemple de modèle qui répond à vos exigences. | DBA, ingénieur DevOps | | Configurer les paramètres de base de données. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Configurez l'instance. | Dans la section **Configuration de l'instance**, sous **Classe d'instance** de base de données, sélectionnez une taille d'instance qui répond à vos besoins. | DBA, ingénieur DevOps | | Configurez le stockage. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Configurez la connectivité. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Configurez l'authentification Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Configurez la surveillance. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html)Remarque : Les métriques sont utiles lorsque vous souhaitez voir comment différents processus ou threads utilisent le processeur. Vous pouvez également exporter les journaux d'erreurs vers Amazon CloudWatch si le **journal des erreurs** est activé. | DBA, ingénieur DevOps | | Configurez des paramètres supplémentaires. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Passez en revue les coûts et créez une base de données. | Consultez la section **Coûts mensuels estimés**, puis choisissez **Créer une base de données**. | DBA, ingénieur DevOps | ### Configurer l'accès à la base de données et tester les connexions | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Connect à la machine Windows. | Connectez-vous à votre ordinateur Windows et lancez SQL Server Management Studio.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Configurez la connexion SSMS. | Configurez la connexion à la base de données à l'aide de l'authentification Windows.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Configurez les paramètres de sécurité. | Définissez les paramètres de sécurité requis pour la version 20 ou ultérieure de SSMS.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | | Créez un identifiant Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html)
CREATE LOGIN [| DBA, ingénieur DevOps | | Testez l'authentification Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, ingénieur DevOps | ## Ressources connexes + [Création de votre AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html) + [Joindre une instance Amazon EC2 Windows à votre AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/launching_instance.html) + [Régions et moteurs de base de données pris en charge pour l'authentification Kerberos dans Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.KerberosAuthentication.html) + [Qu'est-ce que SQL Server Management Studio (SSMS) ?](https://learn.microsoft.com/en-us/ssms/sql-server-management-studio-ssms) # Configuration de l’accès intercompte à Amazon DynamoDB *Shashi Dalmia, Imhoertha Ojior et Esteban Serna Parra, Amazon Web Services* ## Résumé Ce modèle explique les étapes de configuration de l'accès entre comptes à Amazon DynamoDB à l'aide de politiques basées sur les ressources. Pour les charges de travail qui utilisent DynamoDB, il est de plus en plus courant d'[utiliser des stratégies d'isolation des charges de travail](https://aws.amazon.com/solutions/guidance/workload-isolation-on-aws/?did=sl_card&trk=sl_card) afin de minimiser les menaces de sécurité et de répondre aux exigences de conformité. La mise en œuvre de stratégies d'isolation des charges de travail nécessite souvent un accès entre comptes et entre régions aux ressources DynamoDB à l'aide Gestion des identités et des accès AWS de politiques basées sur l'identité (IAM). Cela implique de définir des autorisations IAM et d'établir une relation de confiance entre les Comptes AWS. Les [politiques basées sur les ressources pour DynamoDB simplifient considérablement le dispositif de sécurité pour les charges](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/access-control-resource-based.html) de travail entre comptes. Ce modèle fournit des étapes et un exemple de code pour montrer comment configurer les AWS Lambda fonctions d'un compte Compte AWS pour écrire des données dans une table de base de données DynamoDB d'un autre compte. ## Conditions préalables et limitations **Conditions préalables** + Deux actifs Comptes AWS. Dans ce schéma, ces comptes sont appelés *compte A* et *compte B.* + AWS Command Line Interface (AWS CLI) [installé](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) et [configuré pour](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) accéder au compte A, afin de créer la table DynamoDB. Les autres étapes de ce modèle fournissent des instructions d'utilisation des consoles IAM, DynamoDB et Lambda. Si vous prévoyez de l'utiliser à la AWS CLI place, configurez-le pour accéder aux deux comptes. **Limites** + Certains Services AWS ne sont pas disponibles du tout Régions AWS. Pour connaître la disponibilité par région, voir [Services AWS par région](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Pour des points de terminaison spécifiques, consultez la page [Points de terminaison et quotas du service](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html), puis choisissez le lien vers le service. ## Architecture Le schéma suivant montre une architecture à compte unique. AWS Lambda, Amazon Elastic Compute Cloud (Amazon EC2) et DynamoDB appartiennent tous au même compte. Dans ce scénario, les fonctions Lambda et les EC2 instances Amazon peuvent accéder à DynamoDB. Pour accorder l'accès à la table DynamoDB, vous pouvez créer une stratégie basée sur l'identité dans IAM ou une stratégie basée sur les ressources dans DynamoDB. ![\[Utilisation des autorisations IAM pour accéder à une table DynamoDB dans le même compte.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/bfc32fe8-5db0-4cac-a30f-b870a1a82875/images/cbb009eb-422d-4833-a1bc-0c571d83c21f.png) Le schéma suivant montre une architecture multi-comptes. Si les ressources d'un compte Compte AWS nécessitent l'accès à une table DynamoDB dans un autre compte, vous devez configurer une politique basée sur les ressources dans DynamoDB pour accorder l'accès requis. Par exemple, dans le schéma suivant, l'accès à la table DynamoDB du compte A est accordé à une fonction Lambda du compte B à l'aide d'une politique basée sur les ressources. ![\[Utilisation d'une politique basée sur les ressources pour accéder à une table DynamoDB dans un autre compte.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/bfc32fe8-5db0-4cac-a30f-b870a1a82875/images/9f9165a8-b767-4427-a2ae-31b5b8c83326.png) Ce modèle décrit l'accès entre comptes entre Lambda et DynamoDB. Vous pouvez suivre des étapes similaires pour les autres comptes Services AWS si les autorisations appropriées sont configurées sur les deux comptes. Par exemple, si vous souhaitez fournir à une fonction Lambda un accès à un bucket Amazon Simple Storage Service (Amazon S3) dans le compte A, vous pouvez créer une [politique basée sur](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-policies.html) les ressources dans Amazon S3 et ajouter les autorisations au rôle d'exécution Lambda dans le compte [B.](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) ## Outils **Services AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) est un service de base de données NoSQL entièrement géré, offrant des performances rapides, prévisibles et évolutives. + [Gestion des identités et des accès AWS (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) vous aide à gérer en toute sécurité l'accès à vos ressources AWS en contrôlant qui est authentifié et autorisé à les utiliser. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) est un service de calcul qui vous aide à exécuter du code sans avoir à allouer ni à gérer des serveurs. Il exécute votre code uniquement lorsque cela est nécessaire et évolue automatiquement, de sorte que vous ne payez que pour le temps de calcul que vous utilisez. **Code** Ce modèle inclut un exemple de code dans la section [Informations supplémentaires](#configure-cross-account-access-to-amazon-dynamodb-additional) pour montrer comment configurer une fonction Lambda dans le compte B pour écrire dans la table DynamoDB du compte A. Le code est fourni uniquement à des fins d'illustration et de test. Si vous implémentez ce modèle dans un environnement de production, utilisez le code comme référence et personnalisez-le pour votre propre environnement. ## Bonnes pratiques + Suivez les [meilleures pratiques relatives aux politiques basées sur les ressources](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/rbac-best-practices.html) dans la documentation DynamoDB. + Respectez le principe du moindre privilège et accordez les autorisations minimales requises pour effectuer une tâche. Pour plus d'informations, consultez les sections [Accorder le moindre privilège](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#grant-least-priv) et [Bonnes pratiques en matière de sécurité](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) dans la documentation IAM. ## Épopées ### Création d'une politique et d'un rôle IAM pour la fonction Lambda dans le compte B | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une politique dans le compte B. | Cette politique IAM autorise l'[PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html)action pour une table DynamoDB dans le compte A.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | AWS général | | Créez un rôle dans le compte B. | La fonction Lambda du compte B utilise ce rôle IAM pour accéder à la table DynamoDB du compte A.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)Pour plus d'informations sur la création de rôles, consultez la [documentation IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html). | AWS général | | Notez l'ARN du rôle. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | AWS général | ### Création d'une table DynamoDB dans le compte A | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une table DynamoDB. | Utilisez la AWS CLI commande suivante pour créer une table DynamoDB.\ ] FROM WINDOWS;
GO
aws dynamodb create-table \Remplacez le code suivant dans cet exemple de code :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)Vous spécifiez la configuration de la politique basée sur les ressources dans l'`create-table`instruction à l'aide de l'`--resource-policy`indicateur. Cette politique fait référence à l'ARN de la table DynamoDB dans le compte A.Pour plus d'informations sur la création de tables, consultez la documentation [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html). | AWS général | ### Création d'une fonction Lambda dans le compte B | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une fonction Lambda pour écrire des données dans DynamoDB. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)[Pour plus d'informations sur la création de fonctions Lambda, consultez la documentation Lambda.](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html) | AWS général | ### Nettoyage | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Supprimer des ressources . | Pour éviter les coûts associés aux ressources créées selon ce modèle, procédez comme suit pour supprimer ces ressources :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | AWS général | ## Résolution des problèmes | Problème | Solution | | --- | --- | | Lorsque vous créez la fonction Lambda, vous recevez un `ResourceNotFoundException` message d'erreur. | Vérifiez que vous avez correctement saisi le Région AWS et l'ID du compte A. Ils font partie de l'ARN de la table DynamoDB. | ## Ressources connexes + [Démarrage avec DynamoDB (documentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) DynamoDB) + [Commencer à utiliser Lambda (documentation](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) Lambda) + [Utilisation de politiques basées sur les ressources pour DynamoDB (documentation DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/access-control-resource-based.html)) + [Création de politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) (documentation IAM) + [Logique d'évaluation des politiques entre comptes](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html) (documentation IAM) + [Référence des éléments de politique JSON IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) (documentation IAM) ## Informations supplémentaires *Exemple de code* ``` 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') .La sortie affichera le nom de la réplique secondaire actuelle (`WSFCNODE1`). | DBA |
## Résolution des problèmes
| Problème | Solution |
| --- | --- |
| La création de l'écouteur échoue avec le message « Le cluster WSFC n'a pas pu mettre la ressource de nom de réseau en ligne ». | Pour plus d'informations, consultez le billet de blog Microsoft [Create Listener Fails with Message « The WSFC cluster could not bring the Network Name resource online](https://techcommunity.microsoft.com/t5/sql-server-support-blog/create-listener-fails-with-message-the-wsfc-cluster-could-not/ba-p/318235) ». |
| Problèmes potentiels, notamment d'autres problèmes liés à l'écouteur ou à l'accès au réseau. | Consultez la section [Résolution des problèmes de configuration des groupes de disponibilité 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) dans la documentation Microsoft. |
## Ressources connexes
+ [Configurer le routage en lecture seule pour un groupe de disponibilité 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)
+ [Résolution des problèmes de configuration des groupes de disponibilité 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)
## Informations supplémentaires
**Étape 1. Mettre à jour les répliques en lecture seule**
```
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
```
**Étape 2. Création de l'URL de routage**
```
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
```
**Étape 3. Création de la liste de routage**
```
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
```
**Étape 4. Valider la liste de routage**
```
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
```
**Étape 5. Utilitaire de commande SQL**
```
sqlcmd -S SQLAG1,1433 -E -d test -K ReadOnly
```
# Connectez-vous en utilisant un tunnel SSH dans pgAdmin
*Jeevan Shetty et Bhanu Ganesh Gudivada, Amazon Web Services*
## Résumé
Pour des raisons de sécurité, il est toujours préférable de placer les bases de données dans un sous-réseau privé. Les requêtes sur la base de données peuvent être exécutées en se connectant via un hôte bastion Amazon Elastic Compute Cloud (Amazon EC2) dans un sous-réseau public du cloud Amazon Web Services (AWS). Cela nécessite l'installation de logiciels tels que pgAdmin DBeaver ou, couramment utilisés par les développeurs ou les administrateurs de bases de données, sur l'hôte Amazon. EC2
L'exécution de pgAdmin sur un serveur Linux et l'accès à celui-ci via un navigateur Web nécessitent l'installation de dépendances, d'autorisations et de configurations supplémentaires.
Comme solution alternative, les développeurs ou les administrateurs de base de données peuvent se connecter à une base de données PostgreSQL en utilisant pgAdmin pour activer un tunnel SSH depuis leur système local. Dans cette approche, pgAdmin utilise l'hôte EC2 Amazon du sous-réseau public comme hôte intermédiaire avant de se connecter à la base de données. Le schéma de la section *Architecture* montre la configuration.
**Note**
Assurez-vous que le groupe de sécurité attaché à la base de données PostgreSQL autorise la connexion sur le port 5432 depuis l'hôte Amazon. EC2
## Conditions préalables et limitations
**Conditions préalables**
+ Un compte AWS existant
+ Un cloud privé virtuel (VPC) avec un sous-réseau public et un sous-réseau privé
+ Une EC2 instance associée à un groupe de sécurité
+ Une base de données Amazon Aurora PostgreSQL Edition associée à un groupe de sécurité
+ Une paire de clés Secure Shell (SSH) pour configurer le tunnel
**Versions du produit**
+ Version 6.2\$1 de pgAdmin
+ Édition compatible avec Amazon Aurora PostgreSQL version 12.7\$1
## Architecture
**Pile technologique cible**
+ Amazon EC2
+ Compatible avec Amazon Aurora PostgreSQL
**Architecture cible**
Le schéma suivant montre l'utilisation de pgAdmin avec un tunnel SSH pour se connecter via une passerelle Internet à l'instance, qui se connecte à EC2 la base de données.
![\[pgAdmin avec un tunnel SSH se connecte via une passerelle Internet à une instance qui se connecte EC2 à la base de données.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/7d25d570-5685-4f1a-bef0-212e257cb589/images/4556d930-f9b3-4b65-be5d-d40dd9437d5a.png)
## Outils
**Services AWS**
+ [Amazon Aurora PostgreSQL Compatible Edition](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) est un moteur de base de données relationnelle entièrement géré et compatible ACID qui vous aide à configurer, exploiter et dimensionner les déploiements PostgreSQL.
+ [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/ec2/) fournit une capacité de calcul évolutive dans le cloud AWS. Vous pouvez lancer autant de serveurs virtuels que vous le souhaitez et les augmenter ou les diminuer rapidement.
**Autres services**
+ [pgAdmin](https://www.pgadmin.org/) est un outil de gestion open source pour PostgreSQL. Il fournit une interface graphique qui vous permet de créer, de gérer et d'utiliser des objets de base de données.
## Épopées
### Créez la connexion
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez un serveur. | **Dans pgAdmin, **choisissez** Create, puis Server.** *Pour obtenir de l'aide supplémentaire sur la configuration de pgAdmin afin d'enregistrer un serveur, de configurer une connexion et de se connecter via le tunneling SSH à l'aide de la boîte de dialogue du serveur, consultez les liens dans la section Ressources connexes.* | DBA |
| Donnez un nom au serveur. | Dans l'onglet **Général**, entrez un nom. | DBA |
| Entrez les détails de la base de données. | Dans l'onglet **Connexion**, entrez les valeurs suivantes :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/connect-by-using-an-ssh-tunnel-in-pgadmin.html) | DBA |
| Entrez les détails EC2 du serveur Amazon. | Dans l'onglet **Tunnel SSH**, fournissez les détails de l' EC2 instance Amazon qui se trouve dans le sous-réseau public.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/connect-by-using-an-ssh-tunnel-in-pgadmin.html) | DBA |
| Enregistrez et connectez-vous. | Choisissez **Enregistrer** pour terminer la configuration et vous connecter à la base de données compatible Aurora PostgreSQL à l'aide du tunnel SSH. | DBA |
## Ressources connexes
+ [Boîte de dialogue du serveur](https://www.pgadmin.org/docs/pgadmin4/latest/server_dialog.html)
+ [Se connecter au serveur](https://www.pgadmin.org/docs/pgadmin4/latest/connect_to_server.html)
# Convertir les requêtes Oracle JSON en base de données PostgreSQL SQL SQL SQL
*Pinesh Singal et Lokesh Gurram, Amazon Web Services*
## Résumé
Ce processus de migration pour passer d'une solution sur site au cloud Amazon Web Services (AWS) utilise l'outil AWS Schema Conversion Tool (AWS SCT) pour convertir le code d'une base de données Oracle en une base de données PostgreSQL. La majeure partie du code est automatiquement convertie par AWS SCT. Toutefois, les requêtes Oracle liées à JSON ne sont pas automatiquement converties.
À partir de la version Oracle 12.2, Oracle Database prend en charge diverses fonctions JSON qui aident à convertir les données JSON en données basées sur les lignes. Cependant, AWS SCT ne convertit pas automatiquement les données basées sur JSON dans un langage pris en charge par PostgreSQL.
Ce modèle de migration se concentre principalement sur la conversion manuelle des requêtes Oracle liées au JSON avec des fonctions telles que `JSON_OBJECT``JSON_ARRAYAGG`, et d'une base `JSON_TABLE` de données Oracle vers une base de données PostgreSQL.
## Conditions préalables et limitations
**Conditions préalables**
+ Un compte AWS actif
+ Une instance de base de données Oracle sur site (opérationnelle)
+ Une instance de base de données Amazon Relational Database Service (Amazon RDS) pour PostgreSQL ou Amazon Aurora PostgreSQL Edition compatible (opérationnelle)
**Limites**
+ Les requêtes liées au JSON nécessitent un format fixe `KEY` et un format. `VALUE` Le fait de ne pas utiliser ce format renvoie un résultat erroné.
+ Si une modification de la structure JSON ajoute de nouvelles `VALUE` paires `KEY` et de nouvelles paires dans la section des résultats, la procédure ou la fonction correspondante doit être modifiée dans la requête SQL.
+ Certaines fonctions liées au JSON sont prises en charge dans les versions antérieures d'Oracle et de PostgreSQL, mais avec moins de fonctionnalités.
**Versions du produit**
+ Oracle Database version 12.2 et versions ultérieures
+ Version 9.5 et ultérieure compatible avec Amazon RDS for PostgreSQL ou Aurora PostgreSQL
+ Dernière version d'AWS SCT (testée à l'aide de la version 1.0.664)
## Architecture
**Pile technologique source**
+ Une instance de base de données Oracle avec la version 19c
**Pile technologique cible**
+ Une instance de base de données compatible avec Amazon RDS for PostgreSQL ou Aurora PostgreSQL avec la version 13
**Architecture cible**
![\[La description suit le schéma.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/5e2c3b07-9ef5-417f-b049-bcea58f2c3ec/images/2ff8b00b-8849-4ef1-9be1-579f7b51be10.png)
1. Utilisez AWS SCT avec le code de fonction JSON pour convertir le code source d'Oracle vers PostgreSQL.
1. La conversion produit des fichiers .sql migrés compatibles avec PostgreSQL.
1. Convertissez manuellement les codes de fonction Oracle JSON non convertis en codes de fonction JSON PostgreSQL.
1. Exécutez les fichiers .sql sur l'instance de base de données cible compatible Aurora PostgreSQL.
## Outils
**Services AWS**
+ [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) est un moteur de base de données relationnelle entièrement géré conçu pour le cloud et compatible avec MySQL et PostgreSQL.
+ [Amazon Relational Database Service (Amazon RDS) pour PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) vous aide à configurer, exploiter et dimensionner une base de données relationnelle PostgreSQL dans le cloud AWS.
+ [AWS Schema Conversion Tool (AWS SCT)](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html) prend en charge les migrations de bases de données hétérogènes en convertissant automatiquement le schéma de base de données source et la majorité du code personnalisé dans un format compatible avec la base de données cible.
**Autres services**
+ [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) est un environnement de développement intégré qui simplifie le développement et la gestion des bases de données Oracle dans les déploiements traditionnels et basés sur le cloud.
+ pgAdmin ou. DBeaver [pgAdmin](https://www.pgadmin.org/) est un outil de gestion open source pour PostgreSQL. Il fournit une interface graphique qui vous permet de créer, de gérer et d'utiliser des objets de base de données. [DBeaver](https://dbeaver.io/)est un outil de base de données universel.
## Bonnes pratiques
La requête Oracle utilise `CAST` le type par défaut lors de l'utilisation de la `JSON_TABLE` fonction. Il est recommandé de l'utiliser également `CAST` dans PostgreSQL, en utilisant deux fois plus de caractères (). `>>`
*Pour plus d'informations, consultez *Postgres\$1SQL\$1Read\$1JSON* dans la section Informations supplémentaires.*
## Épopées
### Générez les données JSON dans les bases de données Oracle et PostgreSQL
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Stockez les données JSON dans la base de données Oracle. | Créez une table dans la base de données Oracle et stockez les données JSON dans la `CLOB` colonne. *Utilisez le script *Oracle\$1Table\$1Creation\$1Insert\$1Script qui se trouve dans la section Informations supplémentaires*.* | Ingénieur en migration |
| Stockez les données JSON dans la base de données PostgreSQL. | Créez une table dans la base de données PostgreSQL et stockez les données JSON dans la colonne. `TEXT` *Utilisez le *Postgres\$1Table\$1Creation\$1Insert\$1Script* qui se trouve dans la section Informations supplémentaires.* | Ingénieur en migration |
### Convertissez le JSON au format ROW
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Convertissez les données JSON dans la base de données Oracle. | Rédigez une requête Oracle SQL pour lire les données JSON au format ROW. *Pour plus de détails et des exemples de syntaxe, consultez *Oracle\$1SQL\$1Read\$1JSON* dans la section Informations supplémentaires.* | Ingénieur en migration |
| Convertissez les données JSON dans la base de données PostgreSQL. | Rédigez une requête PostgreSQL pour lire les données JSON au format ROW. *Pour plus de détails et des exemples de syntaxe, consultez *Postgres\$1SQL\$1Read\$1JSON* dans la section Informations supplémentaires.* | Ingénieur en migration |
### Convertissez manuellement les données JSON à l'aide de la requête SQL et rapportez le résultat au format JSON
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Effectuez des agrégations et des validations sur la requête SQL Oracle. | Pour convertir manuellement les données JSON, effectuez une jointure, une agrégation et une validation sur la requête SQL Oracle, puis rapportez le résultat au format JSON. *Utilisez le code sous *Oracle\$1SQL\$1JSON\$1Aggregation\$1Join dans la section Informations supplémentaires*.*[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/convert-json-oracle-queries-into-postgresql-database-sql.html) | Ingénieur en migration |
| Effectuez des agrégations et des validations sur la requête SQL Postgres. | Pour convertir manuellement les données JSON, effectuez une jointure, une agrégation et une validation sur la requête PostgreSQL, puis rapportez le résultat au format JSON. *Utilisez le code situé sous *Postgres\$1SQL\$1JSON\$1Aggregation\$1Join dans la section* Informations supplémentaires.*[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/convert-json-oracle-queries-into-postgresql-database-sql.html) | Ingénieur en migration |
### Convertir la procédure Oracle en une fonction PostgreSQL contenant des requêtes JSON
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Convertissez les requêtes JSON de la procédure Oracle en lignes. | *Pour l'exemple de procédure Oracle, utilisez la requête Oracle précédente et le code situé sous *Oracle\$1Procedure\$1with\$1JSON\$1Query* dans la section Informations supplémentaires.* | Ingénieur en migration |
| Convertissez les fonctions PostgreSQL qui comportent des requêtes JSON en données basées sur des lignes. | **Pour les exemples de fonctions PostgreSQL, utilisez la requête PostgreSQL précédente et le code qui se trouve sous Postgres\$1Function\$1with\$1JSON\$1Query dans la section Informations supplémentaires.** | Ingénieur en migration |
## Ressources connexes
+ [Fonctions Oracle JSON](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/adjsn/generation.html)
+ [Fonctions JSON de PostgreSQL](https://www.postgresql.org/docs/13/functions-json.html)
+ [Exemples de fonctions Oracle JSON](https://oracle-base.com/articles/12c/sql-json-functions-12cr2)
+ [Exemples de fonctions JSON PostgreSQL](https://dba.stackexchange.com/questions/69655/select-columns-inside-json-agg)
+ [Outil de conversion de schéma AWS](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html)
## Informations supplémentaires
Pour convertir le code JSON de la base de données Oracle vers la base de données PostgreSQL, utilisez les scripts suivants, dans l'ordre.
**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**
Les blocs de code suivants montrent comment convertir des données Oracle JSON au format de ligne.
*Exemple de requête et de syntaxe*
```
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 );
```
Le document JSON stocke les données sous forme de collections. Chaque collection peut avoir `KEY` et être `VALUE` associée. Chacun `VALUE` peut avoir des nids `KEY` et des `VALUE` paires. Le tableau suivant fournit des informations sur la lecture `VALUE` du document JSON spécifique.
|
|
| KEY | HIÉRARCHIE ou CHEMIN à utiliser pour obtenir la VALEUR | VALUE |
| --- |--- |--- |
| `profileType` | `metadata` -> `profileType` | « P » |
| `positionId` | `data` -> `positionId` | « 0100" |
| `accountNumber` | `data`-> compte -> `accountNumber` | 42000 |
Dans le tableau précédent, `KEY` `profileType` il s'agit `VALUE` d'un des `metadata``KEY`. `KEY``positionId`C'est `VALUE` l'un des `data``KEY`. Le `KEY` `accountNumber` est un `VALUE` du `account``KEY`, et le `account` `KEY` est un `VALUE` du `data``KEY`.
*Exemple de document 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"
}
]
}
}
```
*Requête SQL utilisée pour obtenir les champs sélectionnés à partir du document 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
```
Dans la requête précédente, `JSON_TABLE` il existe une fonction intégrée à Oracle qui convertit les données JSON au format de ligne. La fonction JSON\$1TABLE attend des paramètres au format JSON.
Chaque élément `COLUMNS` possède un élément prédéfini`PATH`, et un élément approprié `VALUE` pour un élément donné `KEY` est renvoyé sous forme de ligne.
*Résultat de la requête précédente*
|
|
| NUMÉRO\$1COMPTE\$1PARENT | NUMÉRO\$1COMPTE | IDENTIFIANT\$1UNITÉ\$1ENTREPRISE | IDENTIFIANT\$1POSITION |
| --- |--- |--- |--- |
| 32000 | 42000 | 7 | 0100 |
| 32001 | 42001 | 6 | 0090 |
**4. Postgres\$1SQL\$1Read\$1JSON**
*****Exemple de requête et de syntaxe*
```
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 ;
```
Dans Oracle, `PATH` est utilisé pour identifier le `KEY` et spécifique`VALUE`. Cependant, PostgreSQL utilise `HIERARCHY` un modèle pour `KEY` lire `VALUE` et à partir de JSON. Les mêmes données JSON mentionnées ci-dessous `Oracle_SQL_Read_JSON` sont utilisées dans les exemples suivants.
*Requête SQL de type CAST non autorisée*
(Si vous forcez le `CAST` texte, la requête échoue avec une erreur de syntaxe.)
```
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 ;
```
L'utilisation d'un seul opérateur supérieur à (`>`) renverra le résultat `VALUE` défini pour cela. `KEY` Par exemple, `KEY` :`positionId`, et `VALUE` :`"0100"`.
`CAST`Le type n'est pas autorisé lorsque vous utilisez le seul opérateur supérieur à ()`>`.
*Requête SQL de type CAST autorisée*
```
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 ;
```
Pour utiliser le type`CAST`, vous devez utiliser l'opérateur double supérieur à. Si vous utilisez l'opérateur unique supérieur à, la requête renvoie le paramètre `VALUE` défini (par exemple, `KEY` :`positionId`, et `VALUE` :`"0100"`). L'utilisation de l'opérateur double supérieur à (`>>`) renvoie la valeur réelle définie pour cela `KEY` (par exemple, `KEY` :, et `VALUE` : `positionId``0100`, sans guillemets doubles).
Dans le cas précédent, `parentAccountNumber` est de type `CAST` to`INT`, `accountNumber` de type `CAST` to`INT`, `businessUnitId` de type `CAST` to `INT` et `positionId` de type `CAST` to`VARCHAR`.
Les tableaux suivants présentent les résultats des requêtes qui expliquent le rôle de l'opérateur supérieur unique (`>`) et de l'opérateur double supérieur (). `>>`
Dans le premier tableau de table, la requête utilise l'opérateur unique supérieur à ()`>`. Chaque colonne est de type JSON et ne peut pas être convertie en un autre type de données.
|
|
| parentAccountNumber | Numéro de compte | businessUnitId | Identifiant du poste |
| --- |--- |--- |--- |
| 2003565430 | 2003564830 | 7 | « 0100" |
| 2005284042 | 2005284042 | 6 | « 0090" |
| 2000272719 | 2000272719 | 1 | « 0100" |
Dans le second tableau, la requête utilise l'opérateur double supérieur à ()`>>`. Chaque colonne prend en charge le type en `CAST` fonction de la valeur de la colonne. Par exemple, `INTEGER` dans ce contexte.
|
|
| parentAccountNumber | Numéro de compte | businessUnitId | Identifiant du poste |
| --- |--- |--- |--- |
| 2003565430 | 2003564830 | 7 | 0100 |
| 2005284042 | 2005284042 | 6 | 0090 |
| 2000272719 | 2000272719 | 1 | 0100 |
**5. Oracle\$1SQL\$1JSON\$1Aggregation\$1Join**
*Exemple de requête*
```
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
);
```
Pour convertir les données au niveau des lignes au format JSON, Oracle dispose de fonctions intégrées telles que`JSON_OBJECT`, `JSON_ARRAY``JSON_OBJECTAGG`, et. `JSON_ARRAYAGG`
+ `JSON_OBJECT`accepte deux paramètres : `KEY` et`VALUE`. Le `KEY` paramètre doit être codé en dur ou de nature statique. Le `VALUE` paramètre est dérivé de la sortie de la table.
+ `JSON_ARRAYAGG`accepte `JSON_OBJECT` en tant que paramètre. Cela permet de regrouper l'ensemble d'`JSON_OBJECT`éléments sous forme de liste. Par exemple, si vous avez un `JSON_OBJECT` élément comportant plusieurs enregistrements (plusieurs `KEY` et `VALUE` paires dans le jeu de données), il `JSON_ARRAYAGG` ajoute l'ensemble de données et crée une liste. Selon le langage de structure de données, `LIST` il s'agit d'un groupe d'éléments. Dans ce contexte, `LIST` il y a un groupe d'`JSON_OBJECT`éléments.
L'exemple suivant montre un `JSON_OBJECT` élément.
```
{
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
```
L'exemple suivant montre deux `JSON_OBJECT` éléments, `LIST` indiqués par des accolades (`[ ]`).
```
[
{
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
,
{
"taxProfessionalCount": 2,
"attorneyCount": 1,
"nonAttorneyCount": 3,
"clerkCount":4
}
]
```
*Exemple de requête 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
);
```
*Exemple de résultat de la requête SQL précédente*
```
{
"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**
Les `JSON_BUILD_OBJECT` fonctions intégrées de PostgreSQL convertissent les données au niveau `JSON_AGG` des lignes au format JSON. `JSON_BUILD_OBJECT`PostgreSQL `JSON_AGG` et sont équivalents à Oracle et. `JSON_OBJECT` `JSON_ARRAYAGG`
*Exemple de requête*
```
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;
```
*Exemple de résultat de la requête précédente*
Les résultats d'Oracle et de PostgreSQL sont exactement les mêmes.
```
{
"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. Procedure\$1Oracle\$1with\$1json\$1query**
Ce code convertit la procédure Oracle en une fonction PostgreSQL dotée de requêtes SQL JSON. Il montre comment la requête transpose le JSON en lignes et inversement.
```
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;
/
```
*Exécution de la procédure*
Le bloc de code suivant explique comment exécuter la procédure Oracle créée précédemment avec un exemple d'entrée JSON dans la procédure. Il vous donne également le résultat ou le résultat de cette procédure.
```
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;
/
```
*Sortie de procédure*
```
{
"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. Fonction\$1Postgres\$1avec\$1requête JSON**
*Exemple de fonction*
```
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;
$$;
```
*Exécution de la fonction*
```
select f_pg_json_test('{
"accounts": [{
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}, {
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}]
}') ;
```
*Sortie de fonction*
La sortie suivante est similaire à la sortie de la procédure Oracle. La différence est que cette sortie est au format texte.
```
{
"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
}
}
]
}
```
# Copiez les tables Amazon DynamoDB entre les comptes à l'aide de AWS Backup
*Ramkumar Ramanujam, Amazon Web Services*
## Résumé
Lorsque vous travaillez avec Amazon DynamoDB AWS sur, un cas d'utilisation courant consiste à copier ou à synchroniser des tables DynamoDB dans des environnements de développement, de test ou de préparation avec les données des tables présentes dans l'environnement de production. En règle générale, chaque environnement utilise un élément différent Compte AWS.
AWS Backup prend en charge la sauvegarde et la restauration des données entre régions et entre comptes pour DynamoDB, Amazon Simple Storage Service (Amazon S3), etc. Services AWS Ce modèle décrit les étapes d'utilisation de la sauvegarde et de la restauration AWS Backup entre comptes pour copier des tables DynamoDB entre les comptes. Comptes AWS
## Conditions préalables et limitations
**Conditions préalables**
+ Deux actifs Comptes AWS appartenant à la même organisation dans AWS Organizations
+ Autorisations pour créer des tables DynamoDB dans les deux comptes
+ Gestion des identités et des accès AWS Autorisations (IAM) pour créer et utiliser AWS Backup des coffres-forts
**Limites**
+ La source et la cible Comptes AWS doivent faire partie de la même organisation dans AWS Organizations.
## Architecture
**Pile technologique cible**
+ AWS Backup
+ Amazon DynamoDB
**Architecture cible**
![\[La description de la copie de tables entre des coffres-forts de sauvegarde suit le schéma.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/ef6e7393-edb6-4744-be26-43f1cbff9de9/images/fa9f3f2f-7a01-4093-9bd5-fc355e57ba67.png)
1. Créez la sauvegarde de la table DynamoDB dans AWS Backup le coffre de sauvegarde du compte source.
1. Copiez la sauvegarde dans le coffre de sauvegarde du compte cible.
1. Restaurez la table DynamoDB dans le compte cible en utilisant la sauvegarde du coffre de sauvegarde du compte cible.
**Automatisation et mise à l'échelle**
Vous pouvez l'utiliser AWS Backup pour planifier des sauvegardes afin qu'elles s'exécutent à des intervalles spécifiques.
## Outils
+ [AWS Backup](https://docs.aws.amazon.com/aws-backup/latest/devguide/whatisbackup.html)est un service entièrement géré destiné à centraliser et à automatiser la protection des données sur site Services AWS, dans le cloud et sur site. Ce service vous permet de configurer des politiques de sauvegarde et de surveiller l'activité de vos AWS ressources en un seul endroit. Il vous permet d'automatiser et de consolider les tâches de sauvegarde qui étaient auparavant effectuées service par service, et élimine le besoin de créer des scripts personnalisés et des processus manuels.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) est un service de base de données NoSQL entièrement géré qui fournit des performances rapides et prévisibles avec une évolutivité sans faille.
## Épopées
### Activer les AWS Backup fonctionnalités dans les comptes source et cible
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Activez les fonctionnalités avancées pour DynamoDB et la sauvegarde entre comptes. | Dans la source et dans la cible Comptes AWS, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, ingénieur en migration |
### Créez des coffres-forts de sauvegarde dans les comptes source et cible
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez des coffres-forts de sauvegarde. | Dans la source et dans la cible Comptes AWS, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html)Les coffres-forts ARNs de sauvegarde source et cible seront nécessaires lorsque vous copiez la sauvegarde de la table DynamoDB entre les comptes source et cible. | AWS DevOps, ingénieur en migration |
### Effectuez des sauvegardes et des restaurations à l'aide de coffres-forts de sauvegarde
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Dans le compte source, créez une sauvegarde de table DynamoDB. | Pour créer une sauvegarde de la table DynamoDB dans le compte source, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html)Une nouvelle tâche de sauvegarde est créée. Pour surveiller l'état de la tâche de sauvegarde, sur la page AWS Backup **Tâches**, choisissez l'onglet **Tâches de sauvegarde**. Toutes les tâches de sauvegarde actives, en cours et terminées sont répertoriées dans cet onglet. | AWS DevOps, DBA, ingénieur en migration |
| Copiez la sauvegarde du compte source vers le compte cible. | Une fois la tâche de sauvegarde terminée, copiez la sauvegarde de la table DynamoDB depuis le coffre de sauvegarde du compte source vers le coffre de sauvegarde du compte cible.Pour copier le coffre de sauvegarde, dans le compte source, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, ingénieur en migration, DBA |
| Restaurez la sauvegarde dans le compte cible. | Dans la cible Compte AWS, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, DBA, ingénieur en migration |
## Ressources connexes
+ [Utilisation AWS Backup avec DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/backuprestore_HowItWorksAWS.html)
+ [Création de copies de sauvegarde sur Comptes AWS](https://docs.aws.amazon.com/aws-backup/latest/devguide/create-cross-account-backup.html)
+ [AWS Backup tarification](https://aws.amazon.com/backup/pricing/)
# Copiez les tables Amazon DynamoDB entre les comptes à l'aide d'une implémentation personnalisée
*Ramkumar Ramanujam, Amazon Web Services*
## Résumé
Lorsque vous travaillez avec Amazon DynamoDB sur Amazon Web Services (AWS), un cas d'utilisation courant consiste à copier ou à synchroniser des tables DynamoDB dans des environnements de développement, de test ou de préparation avec les données des tables présentes dans l'environnement de production. En règle générale, chaque environnement utilise un compte AWS différent.
DynamoDB prend désormais en charge la sauvegarde entre comptes à l'aide d'AWS Backup. Pour plus d'informations sur les coûts de stockage associés à l'utilisation d'AWS Backup, consultez la [tarification d'AWS Backup](https://aws.amazon.com/backup/pricing/). Lorsque vous utilisez AWS Backup pour effectuer des copies entre comptes, les comptes source et cible doivent appartenir à une organisation AWS Organizations. Il existe d'autres solutions de sauvegarde et de restauration entre comptes à l'aide de services AWS tels qu'AWS Glue. L'utilisation de ces solutions augmente toutefois l'encombrement des applications, car il y a davantage de services AWS à déployer et à gérer.
Vous pouvez également utiliser Amazon DynamoDB Streams pour capturer les modifications de table dans le compte source. Vous pouvez ensuite lancer une fonction AWS Lambda et apporter les modifications correspondantes dans la table cible du compte cible. Mais cette solution s'applique aux cas d'utilisation dans lesquels les tables source et cible doivent toujours être synchronisées. Cela peut ne pas s'appliquer aux environnements de développement, de test et de préparation dans lesquels les données sont fréquemment mises à jour.
Ce modèle fournit les étapes permettant de mettre en œuvre une solution personnalisée pour copier une table Amazon DynamoDB d'un compte à un autre. Ce modèle peut être implémenté à l'aide de langages de programmation courants tels que C\$1, Java et Python. Nous vous recommandons d'utiliser un langage pris en charge par un [kit SDK AWS](https://aws.amazon.com/tools/).
## Conditions préalables et limitations
**Conditions préalables**
+ Deux comptes AWS actifs
+ Tables DynamoDB dans les deux comptes
+ Connaissance des rôles et des politiques d'AWS Identity and Access Management (IAM)
+ Connaissance de l'accès aux tables Amazon DynamoDB à l'aide de n'importe quel langage de programmation courant, tel que C\$1, Java ou Python
**Limites**
Ce modèle s'applique aux tables DynamoDB dont la taille est inférieure ou égale à 2 Go environ. Grâce à une logique supplémentaire permettant de gérer les interruptions de connexion ou de session, les ralentissements, les échecs et les nouvelles tentatives, il peut être utilisé pour des tables plus volumineuses.
L'opération d'analyse DynamoDB, qui lit les éléments de la table source, ne peut récupérer que 1 Mo de données en un seul appel. Pour les tables plus grandes, supérieures à 2 Go, cette limitation peut augmenter le temps total nécessaire pour effectuer une copie complète de la table.
## Architecture
Le schéma suivant montre l'implémentation personnalisée entre les comptes AWS source et cible. Les politiques IAM et les jetons de sécurité sont utilisés dans le cadre de l'implémentation personnalisée. Les données sont lues depuis Amazon DynamoDB dans le compte source et écrites dans DynamoDB dans le compte cible.
![\[Architecture du compte source et cible à copier à l'aide de l'implémentation personnalisée.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/ba8175be-9809-4c2e-b2d1-6b9180ed056c/images/d9d4c2c8-ff04-443f-9137-e37b8e23ccb5.png)
**Automatisation et mise à l'échelle**
Ce modèle s'applique aux tables DynamoDB dont la taille est plus petite, environ 2 Go.
Pour appliquer ce modèle à des tables de plus grande taille, vous devez résoudre les problèmes suivants :
+ Pendant l'opération de copie de table, deux sessions actives sont maintenues à l'aide de jetons de sécurité différents. Si l'opération de copie de table prend plus de temps que les délais d'expiration des jetons, vous devez mettre en place une logique pour actualiser les jetons de sécurité.
+ Si un nombre suffisant d'unités de capacité de lecture (RCUs) et d'unités de capacité d'écriture (WCUs) ne sont pas provisionnées, les lectures ou les écritures sur la table source ou cible peuvent être limitées. Assurez-vous de détecter et de gérer ces exceptions.
+ Gérez tout autre échec ou exception et mettez en place un mécanisme de nouvelle tentative pour réessayer ou continuer à partir de l'endroit où l'opération de copie a échoué.
## Outils
**Outils**
+ [Amazon DynamoDB — Amazon](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) DynamoDB est un service de base de données NoSQL entièrement géré qui fournit des performances rapides et prévisibles ainsi qu'une évolutivité sans faille.
+ Les outils supplémentaires requis varient en fonction du langage de programmation que vous choisissez pour l'implémentation. Par exemple, si vous utilisez C\$1, vous aurez besoin de Microsoft Visual Studio et des NuGet packages suivants :
+ `AWSSDK`
+ `AWSSDK.DynamoDBv2`
**Code**
L'extrait de code Python suivant supprime et recrée une table DynamoDB à l'aide de la bibliothèque Boto3.
N'utilisez pas le `AWS_ACCESS_KEY_ID` et `AWS_SECRET_ACCESS_KEY` d'un utilisateur IAM car il s'agit d'informations d'identification à long terme, qui doivent être évitées pour l'accès programmatique aux services AWS. Pour plus d'informations sur les informations d'identification temporaires, consultez la section *Bonnes pratiques*.
Les `AWS_ACCESS_KEY_ID` et `TEMPORARY_SESSION_TOKEN` utilisés dans l'extrait de code suivant sont des informations d'identification temporaires extraites d'AWS Security Token Service (AWS STS). `AWS_SECRET_ACCESS_KEY`
```
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.')
```
## Bonnes pratiques
**Informations d’identification temporaires**
Pour des raisons de sécurité, lorsque vous accédez aux services AWS par programmation, évitez d'utiliser le `AWS_ACCESS_KEY_ID` et d'un utilisateur IAM, car il s'agit `AWS_SECRET_ACCESS_KEY` d'informations d'identification à long terme. Essayez toujours d'utiliser des informations d'identification temporaires pour accéder aux services AWS par programmation.
Par exemple, un développeur code en dur le code `AWS_ACCESS_KEY_ID` et `AWS_SECRET_ACCESS_KEY` d'un utilisateur IAM dans l'application pendant le développement, mais ne supprime pas les valeurs codées en dur avant de transférer les modifications au référentiel de code. Ces informations d'identification exposées peuvent être utilisées par des utilisateurs involontaires ou malveillants, ce qui peut avoir de graves conséquences (en particulier si les informations d'identification exposées ont des privilèges d'administrateur). Ces informations d'identification exposées doivent être désactivées ou supprimées immédiatement à l'aide de la console IAM ou de l'AWS Command Line Interface (AWS CLI).
Pour obtenir des informations d'identification temporaires pour un accès programmatique aux services AWS, utilisez AWS STS. Les informations d'identification temporaires ne sont valides que pour la durée spécifiée (de 15 minutes à 36 heures). La durée maximale autorisée des informations d'identification temporaires varie en fonction de facteurs tels que les paramètres des rôles et le chaînage des rôles. Pour plus d'informations sur AWS STS, consultez la [documentation](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html).
## Épopées
### Configuration des tables DynamoDB
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez des tables DynamoDB. | Créez des tables DynamoDB, avec des index, dans les comptes AWS source et cible.Définissez le provisionnement des capacités en mode à la demande, ce qui permet à DynamoDB de read/write dimensionner les capacités de manière dynamique en fonction de la charge de travail. Vous pouvez également utiliser une capacité provisionnée de 4 000 RCUs et 4 000 WCUs. | Développeur d'applications, DBA, ingénieur en migration |
| Renseignez le tableau source. | Remplissez la table DynamoDB du compte source avec des données de test. Le fait de disposer d'au moins 50 Mo de données de test vous permet de connaître le pic et la RCUs consommation moyenne pendant la copie de la table. Vous pouvez ensuite modifier le provisionnement de capacité selon vos besoins. | Développeur d'applications, DBA, ingénieur en migration |
### Configurer les informations d'identification pour accéder aux tables DynamoDB
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Créez des rôles IAM pour accéder aux tables DynamoDB source et cible. | Créez un rôle IAM dans le compte source avec les autorisations nécessaires pour accéder (lire) à la table DynamoDB du compte source.Ajoutez le compte source en tant qu'entité de confiance pour ce rôle.Créez un rôle IAM dans le compte cible avec des autorisations d'accès (création, lecture, mise à jour, suppression) à la table DynamoDB du compte cible. Ajoutez le compte cible en tant qu'entité de confiance pour ce rôle. | Développeur d'applications, AWS DevOps |
### Copier les données d'une table d'un compte à un autre
| Sous-tâche | Description | Compétences requises |
| --- | --- | --- |
| Obtenez des informations d'identification temporaires pour les rôles IAM. | Obtenez des informations d'identification temporaires pour le rôle IAM créé dans le compte source.Obtenez des informations d'identification temporaires pour le rôle IAM créé dans le compte cible.L'un des moyens d'obtenir les informations d'identification temporaires pour le rôle IAM consiste à utiliser AWS STS à partir de l'AWS CLI.aws sts assume-role --role-arn arn:aws:iam::Utilisez le profil AWS approprié (correspondant au compte source ou cible).Pour plus d'informations sur les différentes manières d'obtenir des informations d'identification temporaires, consultez les rubriques suivantes :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html) | Développeur d'applications, ingénieur en migration | | Initialisez les clients DynamoDB pour accéder à DynamoDB source et cible. | Initialisez les clients DynamoDB, fournis par le SDK AWS, pour les tables DynamoDB source et cible.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html)Pour plus d'informations sur l'envoi de demandes à l'aide d'informations d'identification temporaires IAM, consultez la [documentation AWS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/AuthUsingTempSessionToken.html). | Développeur d’applications | | Supprimez et recréez la table cible. | Supprimez et recréez la table DynamoDB cible (ainsi que les index) dans le compte cible, à l'aide du client DynamoDB du compte cible.La suppression de tous les enregistrements d'une table DynamoDB est une opération coûteuse car elle consomme des ressources provisionnées. WCUs La suppression et la recréation du tableau permettent d'éviter ces coûts supplémentaires.Vous pouvez ajouter des index à une table après l'avoir créée, mais cela prend 2 à 5 minutes de plus. La création d'index lors de la création d'une table, en transmettant la collection d'index à l'`createTable`appel, est plus efficace. | Développeur d’applications | | Effectuez la copie du tableau. | Répétez les étapes suivantes jusqu'à ce que toutes les données soient copiées :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html)Pour plus d'informations, consultez l'implémentation de référence en C\$1 (pour supprimer, créer et remplir des tables) dans la section *Pièces jointes*. Un exemple de fichier de configuration de table JavaScript Object Notation (JSON) est également joint. | Développeur d’applications | ## Ressources connexes + [Documentation Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) + [Création d'un utilisateur IAM dans votre compte AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html) + [AWS SDKs](https://aws.amazon.com/tools/) + [Utilisation d'informations d'identification temporaires avec les ressources AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) ## Informations supplémentaires Ce modèle a été implémenté à l'aide de C\$1 pour copier une table DynamoDB contenant 200 000 éléments (taille moyenne des éléments de 5 Ko et taille de table de 250 Mo). La table DynamoDB cible a été configurée avec une capacité provisionnée de 4 000 et 4 000. RCUs WCUs L'opération complète de copie du tableau (du compte source vers le compte cible), y compris la suppression et la recréation du tableau, a pris 5 minutes. Capacité totale d'unités consommées : 30 000 RCUs et environ 400 000 WCUs. Pour plus d'informations sur les modes de capacité DynamoDB, [consultez la section Mode de capacité de lecture/écriture dans la](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html) documentation AWS. ## Pièces jointes [Pour accéder au contenu supplémentaire associé à ce document, décompressez le fichier suivant : attachment.zip](samples/p-attach/ba8175be-9809-4c2e-b2d1-6b9180ed056c/attachments/attachment.zip) # Créez des rapports détaillés sur les coûts et l'utilisation pour Amazon RDS et Amazon Aurora *Lakshmanan Lakshmanan et Sudarshan Narasimhan, Amazon Web Services* ## Résumé Ce modèle montre comment suivre les coûts d'utilisation des clusters Amazon Relational Database Service (Amazon RDS) ou Amazon Aurora en [configurant des balises de répartition des coûts définies par l'utilisateur](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/custom-tags.html). Vous pouvez utiliser ces balises pour créer des rapports détaillés sur les coûts et l'utilisation dans AWS Cost Explorer pour les clusters à plusieurs dimensions. Par exemple, vous pouvez suivre les coûts d'utilisation au niveau de l'équipe, du projet ou du centre de coûts, puis analyser les données dans Amazon Athena. ## Conditions préalables et limitations **Conditions préalables** + Un compte AWS actif + Une ou plusieurs [instances Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateDBInstance.html) ou [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.CreateInstance.html) **Limites** Pour connaître les restrictions relatives au balisage, consultez le [guide de l'utilisateur d'AWS Billing](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/allocation-tag-restrictions.html). ## Architecture **Pile technologique cible** + Amazon RDS ou Amazon Aurora + AWS Rapport sur les coûts et l'utilisation + AWS Cost Explorer + Amazon Athena **Flux de travail et architecture** Le flux de travail de balisage et d'analyse comprend les étapes suivantes : 1. Un ingénieur de données, un administrateur de base de données ou un administrateur AWS crée des balises de répartition des coûts définies par l'utilisateur pour les clusters Amazon RDS ou Aurora. 1. Un administrateur AWS active les balises. 1. Les balises transmettent les métadonnées à AWS Cost Explorer. 1. Un ingénieur de données, un administrateur de base de données ou un administrateur AWS crée un [rapport mensuel de répartition des coûts](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/configurecostallocreport.html#allocation-viewing). 1. Un ingénieur de données, un administrateur de base de données ou un administrateur AWS analyse le rapport mensuel de répartition des coûts à l'aide d'Amazon Athena. Le schéma suivant montre comment appliquer des balises pour suivre les coûts d'utilisation des instances Amazon RDS ou Aurora. ![\[Appliquer des balises pour suivre les coûts d'utilisation des instances de base de données et des clusters\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/eab5001d-5115-4aa6-bdd2-23063b08b262/images/63292b18-01d6-4523-b8ac-2c3b12b11b84.png) Le schéma d'architecture suivant montre comment le rapport de répartition des coûts est intégré à Amazon Athena à des fins d'analyse. ![\[Consultation des rapports de répartition des coûts dans Athena\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/eab5001d-5115-4aa6-bdd2-23063b08b262/images/9c028405-1e93-4f6a-a0e5-36154e2b8eab.png) Le rapport mensuel de répartition des coûts est stocké dans un compartiment Amazon S3 que vous spécifiez. Lorsque vous configurez Athena avec le CloudFormation modèle AWS, comme décrit dans la section *Epics*, le modèle fournit plusieurs ressources supplémentaires, notamment un robot d'exploration AWS Glue, une base de données AWS Glue, un événement Amazon Simple Notification System (Amazon SNS), des fonctions AWS Lambda et des rôles AWS Identity and Access Management (IAM) pour les fonctions Lambda. Lorsque de nouveaux fichiers de données de coûts arrivent dans le compartiment S3, les notifications d'événements sont utilisées pour transmettre ces fichiers à une fonction Lambda en vue de leur traitement. La fonction Lambda lance une tâche d'explorateur AWS Glue pour créer ou mettre à jour la table dans le catalogue de données AWS Glue. Cette table est ensuite utilisée pour interroger des données dans Athena. ## Outils + [Amazon Athena](https://aws.amazon.com/athena/) est un service de requête interactif qui facilite l'analyse des données dans Amazon S3 à l'aide du SQL standard. + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) est un moteur de base de données relationnelle entièrement géré conçu pour le cloud et compatible avec MySQL et PostgreSQL. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) vous aide à configurer, exploiter et dimensionner une base de données relationnelle dans le cloud AWS. + [AWS CloudFormation](https://aws.amazon.com/cloudformation/) est un service d'infrastructure sous forme de code (IaC) qui vous permet de modéliser, de provisionner et de gérer facilement des ressources AWS et tierces. + [AWS Cost Explorer](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/ce-what-is.html) vous permet de visualiser et d'analyser vos coûts et votre utilisation d'AWS. ## Épopées ### Création et activation de balises pour votre cluster Amazon RDS ou Aurora | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez des balises de répartition des coûts définies par l'utilisateur pour votre cluster Amazon RDS ou Aurora. | Pour ajouter des balises à un cluster Amazon RDS ou Aurora nouveau ou existant, suivez les instructions de la section [Ajouter, répertorier et supprimer des balises](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html#Tagging.HowTo) dans le *guide de l'utilisateur Amazon Aurora*.Pour plus d'informations sur la configuration d'un cluster Amazon Aurora, consultez les instructions relatives à [MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.Aurora.html) et [PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.AuroraPostgreSQL.html) dans le guide de l'utilisateur *Amazon Aurora*. | Administrateur AWS, ingénieur de données, DBA | | Activez les balises de répartition des coûts définies par l'utilisateur. | Suivez les instructions de la section [Activation des balises de répartition des coûts définies par](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/activating-tags.html) l'utilisateur dans le *guide de l'utilisateur d'AWS Billing*. | Administrateur AWS | ### Création de rapports sur les coûts et l'utilisation | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez et configurez des rapports de coûts et d'utilisation pour vos clusters. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/create-detailed-cost-and-usage-reports-for-amazon-rds-and-amazon-aurora.html)Les données seront disponibles dans 24 heures. | Propriétaire de l'application, administrateur AWS, administrateur de base de données, AWS général, ingénieur de données | ### Analyser les données des rapports sur les coûts et l'utilisation | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Analysez les données du rapport sur les coûts et l'utilisation. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/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_statusPour plus d'informations, consultez la section [Exécution de requêtes Amazon Athena](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-run.html) dans le guide de l'*utilisateur d'AWS Cost and Usage Reports*.Lorsque vous exécutez votre requête SQL, assurez-vous que la bonne base de données est sélectionnée dans la liste déroulante. | Propriétaire de l'application, administrateur AWS, administrateur de base de données, AWS général, ingénieur de données | ## Ressources connexes **Références** + [Configuration d'Athena à l'aide de CloudFormation modèles AWS (recommandé](https://docs.aws.amazon.com/cur/latest/userguide/use-athena-cf.html)) + [Configuration manuelle d'Athena](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-manual.html) + [Exécution de requêtes Amazon Athena](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-run.html) + [Chargement des données du rapport vers d'autres ressources](https://docs.aws.amazon.com/cur/latest/userguide/cur-query-other.html) **Tutoriels et vidéos** + [Analyser les rapports de coûts et d'utilisation à l'aide d'Amazon Athena (vidéo](https://youtu.be/KEeJEZTYE8E)) YouTube # Déployez des instances de cluster de basculement SQL Server sur Amazon EC2 et Amazon à l'aide FSx de Terraform *Mark Hudson et Matt Burgess, Amazon Web Services* ## Résumé Ce modèle utilise Terraform pour déployer des instances de cluster de basculement SQL Server (FCIs) sur des nœuds Windows Server Failover Cluster (WSFC) sur Amazon Elastic Compute Cloud (Amazon). EC2 En outre, le modèle utilise le stockage FSx partagé d'Amazon pour les données et les fichiers journaux. Lorsque les bases de données SQL Server sont migrées vers AWS, le premier choix est Amazon RDS for SQL Server. Cependant, Amazon RDS for SQL Server n'est parfois pas adapté et SQL Server doit être déployé sur EC2 Amazon dans une architecture à haute disponibilité. Dans cette solution, SQL Server FCIs est installé sur les nœuds WSFC. Le module Terraform inclus dans ce modèle fournit jusqu'à deux instances Amazon EC2 SQL Server. Un système de fichiers Amazon FSx pour Windows File Server agit en tant que témoin du quorum et stocke les données partagées et les fichiers journaux. Quel que soit le nombre d'instances configurées, les nœuds d'instance SQL Server créeront et rejoindront toujours un cluster FCI afin de garantir la parité environnementale. (Généralement, une instance est configurée pour le développement et deux instances pour les environnements de production.) Pour les configurations qui utilisent deux nœuds pour une haute disponibilité, un Network Load Balancer interne est configuré. Le Network Load Balancer utilise une sonde de santé configurée sur le cluster FCI pour identifier le nœud principal. ## Conditions préalables et limitations **Conditions préalables** + Un actif Compte AWS. + Amazon Virtual Private Cloud (Amazon VPC) avec deux sous-réseaux dans des zones de disponibilité distinctes. + Ensemble d'options [DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/DHCPOptionSet.html) Amazon VPC. Configurez le nom de domaine pour qu'il corresponde à votre nom de domaine Active Directory et le domaine et les serveurs de noms NetBIOS pour qu'ils pointent vers vos contrôleurs de domaine Active Directory. Pour plus d'informations, consultez la section *Configuration du VPC* dans [Informations supplémentaires](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). + AWS Directory Service for Microsoft Active Directory (AWS Managed Microsoft AD). + Image de machine Amazon personnalisée (AMI). Pour plus de détails, consultez la section *Configuration de l'AMI* dans [Informations supplémentaires](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). + Compartiment Amazon Simple Storage Service (Amazon S3) contenant l'image ISO de SQL Server. Cette condition préalable n'est requise que si vous utilisez [EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html) avec le `component.yaml` fichier fourni pour créer l'AMI personnalisée. + AWS Key Management Service (AWS KMS) clé de chiffrement. + Par défaut, SQL Server est installé à l'aide d'une clé de produit de l'édition développeur. Les systèmes de production sont censés utiliser une clé de produit valide transmise au module par la variable correspondante. **Limites** + Cette solution nécessite AWS Managed Microsoft AD. Toutefois, si vous préférez, vous pouvez plutôt utiliser une implémentation Active Directory autogérée. Pour ce faire, modifiez le module Amazon FSx Terraform inclus pour supprimer l'`active_directory_id`attribut. Ajoutez ensuite les quatre attributs requis pour l'autogestion d'Active Directory, comme indiqué dans la documentation [Terraform](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/fsx_windows_file_system). + SQL Server est configuré pour utiliser l'authentification en mode mixte. Si vous préférez, vous pouvez utiliser l'authentification Windows uniquement. Pour ce faire, dans le script de données utilisateur fourni, supprimez les `/SAPWD` paramètres `/SECURITYMODE` et fournis à la `setup.exe` commande. Vous pouvez supprimer le `sql_accounts.tf` fichier et le `instances.tf` modifier pour supprimer l'`sql_sa_password`entrée. + Lorsque vous supprimez un cluster déployé, vous devez supprimer les objets informatiques virtuels correspondants et les objets informatiques individuels dans Active Directory. Pour supprimer les objets, utilisez les outils d'administration Active Directory. + Certains Services AWS ne sont pas disponibles du tout Régions AWS. Pour connaître la disponibilité par région, consultez la section [AWS Services par région](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Pour des points de terminaison spécifiques, consultez [Points de terminaison de service et quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html), puis choisissez le lien correspondant au service. **Versions du produit** Cette solution a été testée avec les versions suivantes : + Windows Server 2019 + SQL Server 2019 + [Terraform v0.13.0](https://developer.hashicorp.com/terraform/language/v1.1.x/upgrade-guides/0-13) ## Architecture **Pile technologique source** + SQL Server **Pile technologique cible** + SQL Server FCI sur les nœuds WSFC à l'aide d'Amazon EC2 + Serveur FSx de fichiers Amazon pour Windows + Compartiment Amazon S3 + AWS Secrets Manager + AWS Managed Microsoft AD + AWS KMS + Gestion des identités et des accès AWS (JE SUIS) **Architecture cible** Le schéma suivant montre l'architecture de cette solution. ![\[Architecture permettant de déployer des instances de cluster de basculement SQL Server sur des nœuds de cluster de basculement Windows Server sur Amazon. EC2\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/45f3ab19-d240-4353-ab6e-f6e565f537a4/images/0bff16f2-94e7-4e86-91ea-7ab5f3725620.png) Le diagramme décrit les éléments suivants : + Rôle IAM fournissant aux EC2 instances l'accès à Secrets Manager AWS KMS et à Secrets Manager + Deux nœuds SQL Server déployés sur des EC2 instances Amazon dans des sous-réseaux privés répartis sur deux zones de disponibilité + Un Network Load Balancer pour faciliter les connexions à l'instance SQL Server active (non déployé lors de la configuration d'un cluster à nœud unique) + Système de fichiers Amazon FSx pour Windows File Server déployé dans les deux sous-réseaux privés pour un stockage partagé par les nœuds SQL Server + Secrets Manager pour le stockage des informations d'identification et de configuration d'Active Directory et de SQL Server + Compartiment Amazon S3 pour stocker l'image d'installation de SQL Server + AWS Managed Microsoft AD pour l'authentification Windows + AWS KMS pour créer la clé de chiffrement **Automatisation et évolutivité** [Vous pouvez automatiser le déploiement de l'architecture cible en utilisant les modules Terraform présents dans le GitHub référentiel.](https://github.com/aws-samples/cluster-amazon-elastic-compute-cloud-amazon-fsx-microsoft-sql-server) Vous devez modifier le `terraform.tfvars` fichier pour inclure des valeurs de variables spécifiques à votre environnement. Le compartiment Amazon S3, AWS Managed Microsoft AD les composants, la clé de AWS KMS chiffrement et certains secrets sont des conditions préalables à ce déploiement et ne sont pas inclus dans le code Terraform. ## Outils **Services AWS** + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)permet à vos charges de travail et à vos AWS ressources sensibles aux annuaires d'utiliser Microsoft Active Directory dans le. AWS Cloud Dans ce modèle, AWS Managed Microsoft AD il est utilisé pour l'authentification Windows Server et SQL Server et pour le DNS. + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) fournit une capacité de calcul évolutive dans le AWS Cloud. Vous pouvez lancer autant de serveurs virtuels que vous le souhaitez et les augmenter ou les diminuer rapidement. Dans ce modèle, les instances de cluster de basculement SQL Server sont installées sur les EC2 instances Amazon. + [EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html) vous aide à automatiser la création, la gestion et le déploiement d'images de serveur personnalisées. + [Amazon FSx pour Windows File Server](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) fournit un stockage partagé entièrement géré sur Windows Server. Dans ce modèle, FSx le serveur de fichiers Windows fournit un stockage partagé pour les données et les fichiers journaux de SQL Server ainsi que pour le témoin du quorum. + [Gestion des identités et des accès AWS (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) vous aide à gérer en toute sécurité l'accès à vos AWS ressources en contrôlant qui est authentifié et autorisé à les utiliser. + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) vous aide à créer et à contrôler des clés cryptographiques pour protéger vos données. Dans ce modèle, il est utilisé pour chiffrer les secrets de Secrets Manager, le stockage SQL Server sur les volumes Amazon Elastic Block Store (Amazon EBS) et le système de fichiers FSx pour Windows File Server. + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) vous aide à remplacer les informations d'identification codées en dur dans votre code, y compris les mots de passe, par un appel d'API à Secrets Manager pour récupérer le secret par programmation. Dans ce modèle, les informations d'identification Active Directory pour l'installation et l'exécution de SQL Server, les informations `sa` d'identification utilisateur et les informations de connexion à la base de données sont stockées dans Secrets Manager. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) est un service de stockage d'objets basé sur le cloud qui vous permet de stocker, de protéger et de récupérer n'importe quel volume de données. Ce modèle utilise un compartiment Amazon S3 pour stocker l'image d'installation de SQL Server. + [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) vous aide à lancer AWS des ressources dans un réseau virtuel que vous avez défini. Ce réseau virtuel ressemble à un réseau traditionnel que vous pourriez exécuter dans votre propre centre de données et présente l'avantage d'utiliser l'infrastructure évolutive d' AWS. ******Autres outils** + [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) est installé sur les nœuds de cluster Windows Server. En outre, ils peuvent être installés sur plusieurs sous-réseaux. Dans ce modèle, les instances FCI de SQL Server sont installées sur les nœuds WSFC. + [Terraform](https://www.terraform.io/) est un outil d'infrastructure en tant que code (IaC) qui vous aide à utiliser le code pour provisionner et gérer l'infrastructure et les ressources du cloud. Dans ce modèle, Terraform est utilisé pour créer les ressources et configurer les instances FCI de SQL Server. + Le [clustering Windows Server Failover](https://learn.microsoft.com/en-us/sql/sql-server/failover-clusters/windows/windows-server-failover-clustering-wsfc-with-sql-server?view=sql-server-ver15) fournit des fonctionnalités d'infrastructure qui prennent en charge la haute disponibilité des applications de serveur hébergées telles que SQL Server. Dans ce modèle, les nœuds FCI utilisent la fonctionnalité WSFC pour fournir une haute disponibilité locale grâce à la redondance au niveau de l'instance. **Référentiel de code** Le code de ce modèle est disponible dans le dépôt 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). Les ressources suivantes sont disponibles dans le référentiel : + Un `README.md` fichier qui fournit une vue d'ensemble de la solution et des informations supplémentaires sur l'installation et l'utilisation + Un ensemble de base de fichiers de configuration Terraform et un module FSx spécifique à Amazon pour approvisionner les composants de ce modèle + Un script de configuration d'instance exécuté en tant que script de données EC2 utilisateur Amazon + Un fichier `component.yam` L que Image Builder peut utiliser pour créer une AMI personnalisée ## Bonnes pratiques **Sécurité et correctifs** + Les installations et configurations préalables de l'AMI constituent la configuration minimale requise pour déployer des clusters SQL Server FCI. Des logiciels et des configurations supplémentaires peuvent être nécessaires pour se conformer aux normes et aux exigences de sécurité de votre entreprise. + Après le déploiement, appliquez régulièrement des correctifs à Windows. Corrigez directement les instances en cours d'exécution ou créez une nouvelle AMI avec les derniers correctifs Windows et remplacez les instances (une par une) à l'aide de la nouvelle AMI. AWS publie AMIs chaque mois un nouveau Windows contenant les derniers correctifs, pilotes et agents de lancement du système d'exploitation. Nous vous recommandons de vérifier la dernière AMI lorsque vous lancez de nouvelles instances ou lorsque vous créez vos propres images personnalisées. + Les EC2 instances Amazon sont configurées pour autoriser tout le trafic sortant. Lors du déploiement dans un environnement de production, les règles de sortie du groupe de sécurité doivent être mises en place pour limiter ce trafic aux destinations requises. + Le système de fichiers FSx pour Windows File Server peut enregistrer automatiquement des journaux d'audit pour le partage de fichiers et l'accès aux fichiers et aux dossiers et les expédier à la destination souhaitée si cela est requis dans votre environnement. + Faites régulièrement pivoter les secrets de Secrets Manager automatiquement. Pour la paire de clés d' EC2 instance Amazon, envisagez une solution de rotation automatique telle que décrite dans [Comment utiliser AWS Secrets Manager pour stocker et faire pivoter des paires de clés SSH en toute sécurité](https://aws.amazon.com/blogs/security/how-to-use-aws-secrets-manager-securely-store-rotate-ssh-key-pairs/). Pour les informations d'identification Active Directory et les secrets des `sa` informations d'identification SQL Server, configurez la rotation automatique conformément à vos politiques de gestion des mots de passe. **Gestion d'Active Directory** + Dans le cadre du cluster FCI, Windows génère un objet de nom d'ordinateur (CNO) dans Active Directory. Le CNO répond aux requêtes DNS et transmet le trafic au nœud SQL actif. Nous vous *déconseillons* d'utiliser ce DNS fourni par Active Directory. Le TTL est trop élevé pour fournir un temps de basculement raisonnable et prend souvent jusqu'à 5 minutes pour refléter la nouvelle adresse IP principale. En revanche, pour les installations à haute disponibilité, le Network Load Balancer interne est configuré pour basculer en 30 secondes. + Un administrateur de domaine Active Directory est requis pour créer le cluster. Cette exigence est due aux autorisations élevées requises pour créer les objets du cluster et modifier les autorisations dans Active Directory. Toutefois, les services SQL Server n'ont pas besoin de s'exécuter en tant qu'administrateur de domaine. Nous vous recommandons donc de créer un deuxième utilisateur Active Directory à cette fin. Toutefois, vous pouvez éliminer cet utilisateur si les services s'exécutent en tant qu'administrateur de domaine. Dans ce cas, l'utilisateur administrateur du domaine doit être ajouté au groupe d'administrateurs Active Directory créé dans le cadre de ce modèle. ## Épopées ### Configurer les informations d'identification du cluster | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez des groupes Active Directory. | Dans AWS Managed Microsoft AD, créez les groupes suivants :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Pour plus de détails, consultez [la section Création d'un AWS Managed Microsoft AD groupe](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_create_group.html) dans la AWS documentation. | Administrateur AD | | Créez des utilisateurs Active Directory. | Dans AWS Managed Microsoft AD, créez les utilisateurs suivants[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Pour plus de détails, consultez [la section Création AWS Managed Microsoft AD d'un utilisateur](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_manage_users_groups_create_user.html) dans la AWS documentation. | Administrateur AD | | Ajoutez les informations d'identification Active Directory aux secrets. | Utilisez Secrets Manager pour créer quatre secrets afin de stocker les informations suivantes :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Pour plus de détails, consultez la section [Créer un AWS Secrets Manager secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) dans la AWS documentation. | Administrateur AWS | ### Préparez l'environnement | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez l'AMI Windows. | Créez une AMI Windows personnalisée qui inclut les logiciels et les configurations requis. Pour plus de détails, consultez la section [Informations supplémentaires](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). | Administrateur AWS, AWS DevOps | | Installez Terraform. | Pour installer Terraform, suivez les instructions sur le site Web de [Terraform](https://learn.hashicorp.com/tutorials/terraform/install-cli). | AWS DevOps | | Pour cloner le référentiel. | Clonez le [référentiel](https://github.com/aws-samples/cluster-amazon-elastic-compute-cloud-amazon-fsx-microsoft-sql-server) de ce modèle. Pour plus de détails, consultez la section [Clonage d'un dépôt](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) sur le GitHub site Web. | AWS DevOps | ### Installation du cluster | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Modifiez les variables Terraform. | Mettez à jour le `terraform.tfvars` fichier fourni pour définir toutes les variables sur des valeurs adaptées à votre environnement.Par exemple, mettez à jour les `domain_group_rdp_users` variables `domain_group_administrators` et pour utiliser votre nom de domaine Active Directory et le nom des groupes Active Directory créés précédemment. | AWS DevOps | | Initialisez Terraform. | Pour voir le déploiement proposé, accédez à la racine du référentiel. Utilisez l'interface de ligne de commande (CLI) Terraform pour exécuter `terraform init` puis exécuter. `terraform plan` | AWS DevOps | | Déployez des ressources. | Pour déployer le cluster SQL et les ressources associées, utilisez la CLI Terraform pour l'exécuter. `terraform apply` | AWS DevOps, administrateur AWS | | Validez le déploiement. | Pour valider le déploiement, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html) | DBA, administrateur système AWS | ## Résolution des problèmes | Problème | Solution | | --- | --- | | Le provisionnement de Terraform est terminé mais Windows Failover Cluster Manager n'indique pas qu'un cluster a été créé ou que le cluster est dans un état inutilisable. | L'installation complète des ressources et la configuration des clusters peuvent prendre de 45 à 60 minutes. Une fois Terraform terminé, le script de données utilisateur doit s'exécuter jusqu'à la fin, ce qui nécessite plusieurs redémarrages. Pour suivre la progression, vous pouvez utiliser le `Checkpoints` répertoire du `C:\` lecteur et l'installation de SQL Server se connecte`C:\Program Data\Microsoft SQL Server\150\Log`. Lorsque vous avez terminé, le message **Installation terminée** est disponible dans le `C:\ProgramData\Amazon\EC2-Windows\Launch\Log\UserdataExecution.log` fichier. | | Après avoir provisionné un cluster fonctionnel, l'utilisation de Terraform pour supprimer et recréer le cluster échoue. Terraform est terminé, mais le cluster n'est pas correctement configuré. | Une partie du processus de provisionnement implique l'enregistrement des machines et des objets virtuels dans Active Directory et Active Directory DNS. Lorsque des noms d'ordinateur existent pour les nœuds du EC2 cluster Amazon et le nœud du cluster, FCI ne peut pas s'initialiser correctement et échouera au provisionnement.Pour résoudre ce problème, effectuez les opérations suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html) | ## Ressources connexes **AWS documentation** + [Créez des images personnalisées avec Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-images.html) + [Création d'une clé KMS](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) + [Création d'un bucket à usage général](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) + [Création d'une politique clé](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) + [Création de votre AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html) ## Informations supplémentaires **Informations sur le module Terraform** Ce module utilise à la fois la configuration de l'AMI et la configuration des données utilisateur pour obtenir un bon équilibre entre le temps de provisionnement et la stabilité. Pendant le provisionnement, Windows nécessite plusieurs redémarrages et des temps d'attente. Une méthode de points de contrôle a été mise en œuvre pour se protéger contre les boucles infinies lors des redémarrages des données utilisateur persistantes. Les données utilisateur sont configurées pour être persistantes. Par conséquent, les scripts de configuration des données utilisateur doivent et doivent continuer à être développés pour être idempotents. L'idempotencie rationalise le processus de mise à jour, permettant aux instances d'être échangées au cours d'un cycle de mise à jour sans configuration manuelle pour rejoindre ou recréer des clusters FCI. **Chaînes de connexion SQL Server et clustering en cas de basculement** Le module publiera un secret contenant l'adresse du point de terminaison qui doit être utilisée dans les chaînes de connexion de cette base de données. Le nom du secret suit le format`{environment_name}/sqlserver/{cluster_name}/endpoint`. Pour les installations où un seul nœud est utilisé, vous pouvez vous attendre à ce qu'il s'agisse de l'adresse IP de l'interface SQL Server de l' EC2 instance Amazon. Pour les installations à haute disponibilité (deux instances), vous pouvez vous attendre à ce qu'il s'agisse du nom DNS du Network Load Balancer interne. Le clustering virtuel par basculement n'est IPs pas pris en charge dans ce module. Une adresse IP virtuelle doit rester dans le même sous-réseau pour fonctionner. En AWS effet, un seul sous-réseau ne peut pas couvrir plusieurs zones de disponibilité. Par conséquent, l'utilisation du virtuel IPs empêcherait ce module d'être considéré comme hautement disponible. Chaque EC2 instance Amazon reçoit trois adresses IP privées. Leur utilisation est la suivante : + **IP principale pour le trafic réseau** : adresse IP source pour le trafic de sortie. + **Communications FCI** : utilisées pour maintenir l'état et la synchronisation du cluster de basculement. + **SQL Server (port TCP 1433)** : écoute également le trafic cardiaque afin de déterminer quelle instance est principale. **Configuration VPC** Les [prérequis](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-prereqs) répertorient un ensemble d'options DHCP configuré pour utiliser Active Directory pour la résolution DNS. Cependant, cette condition préalable n'est pas une exigence stricte. L'exigence absolue est que les EC2 instances soient capables de résoudre votre nom de domaine Active Directory. Il est possible de répondre à cette exigence par d'autres moyens, par exemple en utilisant des Amazon Route 53 Resolver points de terminaison. Pour plus d'informations, consultez [Intégrer la résolution DNS de votre service d'annuaire aux résolveurs Amazon Route 53](https://aws.amazon.com/blogs/networking-and-content-delivery/integrating-your-directory-services-dns-resolution-with-amazon-route-53-resolvers/) (article de AWS blog). **Configuration de l'AMI** L'AMI utilisée dans ce modèle doit contenir les logiciels et configurations prérequis suivants : 1. Téléchargez et étendez les fichiers d'installation de SQL Server 2019 dans`C:\SQL_Install_media`. 1. Installez les fonctionnalités Windows suivantes : + `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. Désactivez le pare-feu Windows comme suit : + `Get-NetFirewallProfile | Set-NetFirewallProfile -Enabled False` 1. Activez la méthode d'authentification CredSSP (`
DECLARE| DBA | | Exécutez le PL/SQL bloc. | Exécutez le PL/SQL bloc source dans Oracle. S'il existe des écarts entre les valeurs d'index d'un tableau associatif, aucune donnée n'est stockée dans ces espaces. Cela permet à la boucle Oracle d'itérer uniquement sur les positions de l'index. | DBA | | Vérifiez la sortie. | Cinq éléments ont été insérés dans le tableau (`cc`) à des intervalles non consécutifs. Le nombre de tableaux est indiqué dans le résultat suivant :
TYPE country_codes IS TABLE OF VARCHAR2(100) INDEX BY pls_integer;
cc country_codes;
cc_idx NUMBER := NULL;
BEGIN
cc(7) := 'India';
cc(3) := 'UK';
cc(5) := 'USA';
cc(0) := 'China';
cc(-2) := 'Invalid';
dbms_output.put_line('cc_length:' || cc.COUNT);
IF (cc.COUNT > 0) THEN
cc_idx := cc.FIRST;
FOR i IN 1..cc.COUNT LOOP
dbms_output.put_line('cc_idx:' || cc_idx || ' country:' || cc(cc_idx));
cc_idx := cc.next(cc_idx);
END LOOP;
END IF;
END;
cc_length:5| DBA | ### Comportement du tableau associatif PostgreSQL (cible) | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un PL/pgSQL bloc cible dans PostgreSQL. | Créez un PL/pgSQL bloc cible dans PostgreSQL qui utilise le tableau associatif suivant :
cc_idx:-2 country:Invalid
cc_idx:0 country:China
cc_idx:3 country:UK
cc_idx:5 country:USA
cc_idx:7 country:India
DO $$| DBA | | Exécutez le PL/pgSQL bloc. | Exécutez le PL/pgSQL bloc cible dans PostgreSQL. S'il existe des écarts entre les valeurs d'index d'un tableau associatif, aucune donnée n'est stockée dans ces espaces. Cela permet à la boucle Oracle d'itérer uniquement sur les positions de l'index. | DBA | | Vérifiez la sortie. | La longueur du tableau est supérieure à 5 car elle `NULL` est stockée dans les espaces entre les positions d'index. Comme indiqué dans le résultat suivant, la boucle effectue 10 itérations pour récupérer 5 valeurs dans le tableau.
DECLARE
cc character varying(100)[];
cc_idx integer := NULL;
BEGIN
cc[7] := 'India';
cc[3] := 'UK';
cc[5] := 'USA';
cc[0] := 'China';
cc[-2] := 'Invalid';
RAISE NOTICE 'cc_length: %', ARRAY_LENGTH(cc, 1);
IF (ARRAY_LENGTH(cc, 1) > 0) THEN
FOR i IN ARRAY_LOWER(cc, 1)..ARRAY_UPPER(cc, 1)
LOOP
RAISE NOTICE 'cc_idx:% country:%', i, cc[i];
END LOOP;
END IF;
END;
$$;
cc_length:10| DBA | ### Émuler le comportement d'un tableau associatif Oracle | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un PL/pgSQL bloc cible avec un tableau et un type défini par l'utilisateur. | Pour optimiser les performances et correspondre aux fonctionnalités d'Oracle, nous pouvons créer un type défini par l'utilisateur qui stocke à la fois les positions de l'indice et les données correspondantes. Cette approche réduit les itérations inutiles en maintenant des associations directes entre les indices et les valeurs.
cc_idx:-2 country:Invalid
cc_idx:-1 country:
cc_idx:0 country:China
cc_idx:1 country:
cc_idx:2 country:
cc_idx:3 country:UK
cc_idx:4 country:
cc_idx:5 country:USA
cc_idx:6 country:
cc_idx:7 country:India
DO $$| DBA | | Exécutez le PL/pgSQL bloc. | Exécutez le PL/pgSQL bloc cible. S'il existe des écarts entre les valeurs d'index d'un tableau associatif, aucune donnée n'est stockée dans ces espaces. Cela permet à la boucle Oracle d'itérer uniquement sur les positions de l'index. | DBA | | Vérifiez la sortie. | Comme indiqué dans le résultat suivant, le type défini par l'utilisateur ne stocke que les éléments de données renseignés, ce qui signifie que la longueur du tableau correspond au nombre de valeurs. Par conséquent, `LOOP` les itérations sont optimisées pour traiter uniquement les données existantes, éliminant ainsi le besoin de suivre les positions vides.
DECLARE
cc country_codes[];
cc_append country_codes := NULL;
i record;
BEGIN
cc_append.idx = 7;
cc_append.val = 'India';
cc := array_append(cc, cc_append);
cc_append.idx = 3;
cc_append.val = 'UK';
cc := array_append(cc, cc_append);
cc_append.idx = 5;
cc_append.val = 'USA';
cc := array_append(cc, cc_append);
cc_append.idx = 0;
cc_append.val = 'China';
cc := array_append(cc, cc_append);
cc_append.idx = - 2;
cc_append.val = 'Invalid';
cc := array_append(cc, cc_append);
RAISE NOTICE 'cc_length: %', ARRAY_LENGTH(cc, 1);
IF (ARRAY_LENGTH(cc, 1) > 0) THEN
FOR i IN (
SELECT
*
FROM
unnest(cc)
ORDER BY
idx)
LOOP
RAISE NOTICE 'cc_idx:% country:%', i.idx, i.val;
END LOOP;
END IF;
END;
$$;
cc_length:5| DBA | ## Ressources connexes **AWS documentation** + [AWS blog de base de données](https://aws.amazon.com/blogs/database/) + [Manuel de migration d'Oracle vers Aurora PostgreSQL](https://docs.aws.amazon.com/dms/latest/oracle-to-aurora-postgresql-migration-playbook/chap-oracle-aurora-pg.html) **Autres documentations** + [Tableaux associatifs Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/23/lnpls/associative-arrays.html#GUID-8060F01F-B53B-48D4-9239-7EA8461C2170) + [Fonctions et opérateurs de tableaux PostgreSQL](https://www.postgresql.org/docs/current/functions-array.html) + [Types de PostgreSQL définis par l'utilisateur](https://www.postgresql.org/docs/current/sql-createtype.html) # Activer les connexions chiffrées pour les instances de base de données PostgreSQL dans Amazon RDS *Rohit Kapoor, Amazon Web Services* ## Résumé Amazon Relational Database Service (Amazon RDS) prend en charge le chiffrement SSL pour les instances de base de données PostgreSQL. À l'aide du protocole SSL, vous pouvez chiffrer une connexion PostgreSQL entre vos applications et vos instances de base de données Amazon RDS for PostgreSQL. Par défaut, Amazon RDS for SSL/TLS PostgreSQL utilise le chiffrement et s'attend à ce que tous les clients se connectent à l'aide du chiffrement. SSL/TLS Amazon RDS pour PostgreSQL prend en charge les versions 1.1 et 1.2 du protocole TLS. Ce modèle décrit comment activer les connexions chiffrées pour une instance de base de données Amazon RDS for PostgreSQL. Vous pouvez utiliser le même processus pour activer les connexions chiffrées pour Amazon Aurora PostgreSQL Compatible Edition. ## Conditions préalables et limitations + Un compte AWS actif + Une instance de [base de données Amazon RDS pour PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_RDS_Configuring.html) + Un [bundle SSL](https://www.postgresql.org/docs/current/ssl-tcp.html) ## Architecture ![\[Activation des connexions chiffrées pour les instances de base de données PostgreSQL dans Amazon RDS\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/4f87c6a3-b4ff-4248-96d3-a4a498659735/images/ccc5c880-1191-4c12-a255-6908b96b96a5.png) ## Outils + [pgAdmin](https://www.pgadmin.org/) est une plateforme d'administration et de développement open source pour PostgreSQL. Vous pouvez utiliser pgAdmin sous Linux, Unix, macOS et Windows pour gérer vos objets de base de données dans PostgreSQL 10 et versions ultérieures. + Les éditeurs [PostgreSQL](https://wiki.postgresql.org/wiki/PostgreSQL_Clients) fournissent une interface plus conviviale pour vous aider à créer, développer et exécuter des requêtes, ainsi qu'à modifier le code en fonction de vos besoins. ## Bonnes pratiques + Surveillez les connexions de base de données non sécurisées. + Audit les droits d'accès aux bases de données. + Assurez-vous que les sauvegardes et les instantanés sont chiffrés au repos. + Surveillez l'accès aux bases de données. + Évitez les groupes d'accès illimité. + Améliorez vos notifications avec [Amazon GuardDuty](https://docs.aws.amazon.com/guardduty/latest/ug/what-is-guardduty.html). + Surveillez régulièrement le respect des politiques. ## Épopées ### Téléchargez un certificat fiable et importez-le dans votre magasin de confiance | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Chargez un certificat sécurisé sur votre ordinateur. | Pour ajouter des certificats au magasin Trusted Root Certification Authorities de votre ordinateur, procédez comme suit. (Ces instructions utilisent Window Server comme exemple.)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html) | DevOps ingénieur, ingénieur en migration, DBA | ### Forcer les connexions SSL | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un groupe de paramètres et définissez le paramètre rds.force\$1ssl. | Si l'instance de base de données PostgreSQL possède un groupe de paramètres personnalisé, modifiez le groupe de paramètres et `rds.force_ssl` passez à 1.Si l'instance de base de données utilise le groupe de paramètres par défaut qui n'`rds.force_ssl`est pas activé, créez un nouveau groupe de paramètres. Vous pouvez modifier le nouveau groupe de paramètres à l'aide de l'API Amazon RDS ou manuellement comme indiqué dans les instructions suivantes.Pour créer un nouveau groupe de paramètres :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Pour associer le groupe de paramètres à votre instance de base de données PostgreSQL :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Pour plus d'informations, consultez la [documentation Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithDBInstanceParamGroups.html). | DevOps ingénieur, ingénieur en migration, DBA | | Forcez les connexions SSL. | Connectez-vous à l'instance de base de données Amazon RDS for PostgreSQL. Les tentatives de connexion qui n'utilisent pas le protocole SSL sont rejetées avec un message d'erreur. Pour plus d'informations, consultez la [documentation Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html#PostgreSQL.Concepts.General.SSL.Requiring). | DevOps ingénieur, ingénieur en migration, DBA | ### Installer l'extension SSL | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Installez l'extension SSL. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Pour plus d'informations, consultez la [documentation Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html). | DevOps ingénieur, ingénieur en migration, DBA | ### Configuration de votre client PostgreSQL pour le protocole SSL | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Configurez un client pour le protocole SSL. | En utilisant le protocole SSL, vous pouvez démarrer le serveur PostgreSQL en prenant en charge les connexions chiffrées utilisant les protocoles TLS. Le serveur écoute les connexions standard et SSL sur le même port TCP, et négocie avec tout client qui se connecte pour savoir s'il convient d'utiliser le protocole SSL. Par défaut, il s'agit d'une option client.Si vous utilisez le client PSQL :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Pour les autres clients PostgreSQL :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Consultez les pages suivantes pour ces clients :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html) | DevOps ingénieur, ingénieur en migration, DBA | ## Résolution des problèmes | Problème | Solution | | --- | --- | | Impossible de télécharger le certificat SSL. | Vérifiez votre connexion au site Web et réessayez de télécharger le certificat sur votre ordinateur local. | ## Ressources connexes + [Documentation Amazon RDS pour PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) + [Utilisation du protocole SSL avec une instance de base de données PostgreSQL (documentation](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html) Amazon RDS) + [ TCP/IP Connexions sécurisées avec SSL](https://www.postgresql.org/docs/9.1/ssl-tcp.html) (documentation PostgreSQL) + [Utilisation du protocole SSL](https://jdbc.postgresql.org/documentation/ssl/) (documentation JDBC) # Chiffrer une instance de base de données Amazon RDS pour PostgreSQL existante *Piyush Goyal, Shobana Raghu et Yaser Raja, Amazon Web Services* ## Résumé Ce modèle explique comment chiffrer une instance de base de données Amazon Relational Database Service (Amazon RDS) existante pour PostgreSQL dans le cloud AWS avec un temps d'arrêt minimal. Ce processus fonctionne également pour les instances de base de données Amazon RDS for MySQL. Vous pouvez activer le chiffrement pour une instance de base de données Amazon RDS lorsque vous la créez, mais pas après sa création. Toutefois, vous pouvez ajouter du chiffrement à une instance de base de données non chiffrée en créant un instantané de votre instance de base de données, puis en créant une copie chiffrée de cet instantané. Vous pouvez ensuite restaurer une instance de base de données à partir de l'instantané chiffré pour obtenir une copie chiffrée de votre instance de base de données d'origine. Si votre projet prévoit des temps d'arrêt (au moins pour les transactions d'écriture) pendant cette activité, c'est tout ce que vous devez faire. Lorsque la nouvelle copie chiffrée de l'instance de base de données est disponible, vous pouvez faire pointer vos applications vers la nouvelle base de données. Toutefois, si votre projet ne prévoit pas de temps d'arrêt important pour cette activité, vous avez besoin d'une autre approche permettant de minimiser le temps d'arrêt. Ce modèle utilise le service AWS Database Migration Service (AWS DMS) pour migrer et répliquer en continu les données afin que le passage à la nouvelle base de données chiffrée puisse être effectué avec un temps d'arrêt minimal. Les instances de base de données chiffrées Amazon RDS utilisent l'algorithme de chiffrement standard AES-256 pour chiffrer vos données sur le serveur qui héberge vos instances de base de données Amazon RDS. Une fois vos données chiffrées, Amazon RDS gère l'authentification de l'accès et le déchiffrement de vos données de manière transparente, avec un impact minimal sur les performances. Vous n’avez pas besoin de modifier vos applications clientes de base de données pour utiliser le chiffrement. ## Conditions préalables et limitations **Conditions préalables** + Un compte AWS actif + Une instance de base de données Amazon RDS pour PostgreSQL non chiffrée + Expérience de travail avec (création, modification ou arrêt) de tâches AWS DMS (voir [Utilisation des tâches AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.html) dans la documentation AWS DMS) + Connaissance d'AWS Key Management Service (AWS KMS) pour le chiffrement des bases de données (voir la documentation [AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)) **Limites** + Vous pouvez activer le chiffrement pour une instance de base de données Amazon RDS uniquement lorsque vous la créez, et non après la création de l'instance de base de données. + Les données des [tables non enregistrées](https://www.postgresql.org/docs/current/sql-createtable.html) ne seront pas restaurées à l'aide de snapshots. Pour plus d'informations, consultez [les meilleures pratiques d'utilisation de PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_BestPractices.html#CHAP_BestPractices.PostgreSQL). + Vous ne pouvez pas avoir un réplica en lecture chiffré d’une instance de base de données non chiffrée ni un réplica en lecture non chiffré d’une instance de base de données chiffrée. + Vous ne pouvez pas restaurer un instantané non chiffré ou une sauvegarde non chiffrée vers une instance de base de données chiffrée. + AWS DMS ne transfère pas automatiquement les séquences. Des étapes supplémentaires sont donc nécessaires pour gérer cela. Pour plus d'informations, consultez la section [Limitations des instances de base de données chiffrées Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html#Overview.Encryption.Limitations) dans la documentation Amazon RDS. ## Architecture **Architecture source** + Instance de base de données RDS non chiffrée **Architecture cible** + Instance de base de données RDS cryptée + L'instance de base de données RDS de destination est créée en restaurant la copie instantanée de base de données de l'instance de base de données RDS source. + Une clé AWS KMS est utilisée pour le chiffrement lors de la restauration du snapshot. + Une tâche de réplication AWS DMS est utilisée pour migrer les données. ![\[Le processus utilise AWS DMS pour chiffrer une instance de base de données Amazon RDS for PostgreSQL existante vers une nouvelle base de données.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/820d17c0-0eed-4ed9-9f43-cbada081d924/images/44dd8420-d89d-466e-b7fb-1bdafab8f7f9.png) ## Outils **Outils utilisés pour activer le chiffrement :** + Clé AWS KMS pour le chiffrement : lorsque vous créez une instance de base de données chiffrée, vous pouvez choisir une clé gérée par le client ou la clé gérée par AWS pour Amazon RDS afin de chiffrer votre instance de base de données. Si vous ne spécifiez pas l'identifiant de clé pour une clé gérée par le client, Amazon RDS utilise la clé gérée AWS pour votre nouvelle instance de base de données. Amazon RDS crée une clé gérée par AWS pour Amazon RDS pour votre compte AWS. Votre compte AWS possède une clé gérée AWS différente pour Amazon RDS pour chaque région AWS. Pour plus d'informations sur l'utilisation des clés KMS pour le chiffrement Amazon RDS, consultez la section [Chiffrement des ressources Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html). **Outils utilisés pour la réplication continue** : + AWS DMS — Vous pouvez utiliser AWS Database Migration Service (AWS DMS) pour répliquer les modifications de la base de données source vers la base de données cible. Il est important de synchroniser les bases de données source et cible afin de minimiser les temps d'arrêt. Pour plus d'informations sur la configuration d'AWS DMS et la création de tâches, consultez la documentation [AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html). ## Épopées ### Créez un instantané de l'instance de base de données source et chiffrez-le | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Vérifiez les détails de l'instance de base de données PostgreSQL source. | Sur la console Amazon RDS, choisissez l'instance de base de données PostgreSQL source. Dans l'onglet **Configuration**, assurez-vous que le chiffrement n'est pas activé pour l'instance. Pour une illustration d'écran, consultez la section [Informations supplémentaires](#encrypt-an-existing-amazon-rds-for-postgresql-db-instance-additional). | DBA | | Créez le snapshot de base de données. | Créez un instantané de base de données de l'instance que vous souhaitez chiffrer. Le temps nécessaire à la création d'un instantané dépend de la taille de votre base de données. Pour obtenir des instructions, consultez [la section Création d'un instantané](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html) de base de données dans la documentation Amazon RDS. | DBA | | Chiffrez le cliché. | Dans le volet de navigation de la console Amazon RDS, choisissez **Snapshots**, puis sélectionnez l'instantané de base de données que vous avez créé. Sous **Actions**, choisissez **Copier un instantané**. Indiquez la région AWS de destination et le nom de la copie instantanée de base de données dans les champs correspondants. Cochez la case **Activer le chiffrement**. Pour **Clé principale**, spécifiez l'identifiant de clé KMS à utiliser pour chiffrer la copie de l'instantané de base de données. Choisissez **Copier l'instantané**. Pour plus d'informations, consultez [Copier un instantané](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CopySnapshot.html) dans la documentation Amazon RDS. | DBA | ### Préparer l'instance de base de données cible | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Restaurez le snapshot de base de données. | Sur la console Amazon RDS, choisissez **Snapshots**. Choisissez l'instantané chiffré que vous avez créé. Pour **Actions**, choisissez **Restore Snapshot (Restaurer l'instantané)**. Pour l'**identifiant d'instance** de base de données, fournissez un nom unique pour la nouvelle instance de base de données. Passez en revue les détails de l'instance, puis choisissez **Restore DB Instance**. Une nouvelle instance de base de données cryptée sera créée à partir de votre instantané. Pour plus d'informations, consultez [la section Restauration à partir d'un instantané](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_RestoreFromSnapshot.html) de base de données dans la documentation Amazon RDS. | DBA | | Migrez les données à l'aide d'AWS DMS. | Sur la console AWS DMS, créez une tâche AWS DMS. Pour le **type de migration**, choisissez **Migrer les données existantes et répliquer les modifications en cours**. Dans **Paramètres des tâches**, pour le **mode de préparation de la table cible**, choisissez **Truncate**. Pour plus d'informations, consultez [la section Création d'une tâche](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) dans la documentation AWS DMS. | DBA | | Activez la validation des données. | Dans **Paramètres des tâches**, choisissez **Activer la validation**. Cela vous permet de comparer les données source aux données cibles afin de vérifier que les données ont été migrées correctement. | DBA | | Désactivez les contraintes sur l'instance de base de données cible. | [Désactivez les déclencheurs et les contraintes de clé étrangère](https://www.postgresql.org/docs/current/sql-altertable.html) sur l'instance de base de données cible, puis lancez la tâche AWS DMS. Pour plus d'informations sur la désactivation des déclencheurs et des contraintes liées aux clés étrangères, consultez la documentation [AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.PostgreSQL.html). | DBA | | Vérifiez les données. | Une fois le chargement complet terminé, vérifiez les données de l'instance de base de données cible pour voir si elles correspondent aux données source. Pour plus d'informations, consultez la section [Validation des données AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Validating.html) dans la documentation AWS DMS. | DBA | ### Passez à l'instance de base de données cible | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Arrêtez les opérations d'écriture sur l'instance de base de données source. | Arrêtez les opérations d'écriture sur l'instance de base de données source afin que le temps d'arrêt de l'application puisse commencer. Vérifiez qu'AWS DMS a terminé la réplication des données du pipeline. Activez les déclencheurs et les clés étrangères sur l'instance de base de données cible. | DBA | | Mettre à jour les séquences de base | Si la base de données source contient des numéros de séquence, vérifiez et mettez à jour les séquences dans la base de données cible. | DBA | | Configurez le point final de l'application. | Configurez les connexions de vos applications pour utiliser les nouveaux points de terminaison de l'instance de base de données Amazon RDS. L'instance de base de données est désormais cryptée. | DBA, propriétaire de l'application | ## Ressources connexes + [Création d'une tâche AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) + [Surveillance des tâches de réplication à l'aide d'Amazon CloudWatch](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Monitoring.html#CHAP_Monitoring.CloudWatch) + [Surveillance des tâches AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Monitoring.html) + [Mise à jour de la clé de chiffrement Amazon RDS](https://aws.amazon.com/premiumsupport/knowledge-center/update-encryption-key-rds/) ## Informations supplémentaires Vérification du chiffrement de l'instance de base de données PostgreSQL source : ![\[La page Résumé de l'instance de base de données PostgreSQL source indique que le chiffrement n'est pas activé pour le stockage.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/820d17c0-0eed-4ed9-9f43-cbada081d924/images/d53d1dab-b5c2-452d-b823-ba3d6508ad15.png) Remarques supplémentaires concernant ce modèle : + Activez la réplication sur PostgreSQL en définissant `rds.logical_replication` le paramètre sur 1. **Remarque importante :** les emplacements de réplication conservent les fichiers WAL (Write Ahead Log) jusqu'à ce qu'ils soient consommés en externe, par exemple par `pg_recvlogical` des tâches d'extraction, de transformation et de chargement (ETL) ou par AWS DMS. Lorsque vous définissez la valeur du `rds.logical_replication` paramètre sur 1, AWS DMS définit les `max_connections` paramètres `wal_level``max_wal_senders`,`max_replication_slots`, et. Si des emplacements de réplication logiques sont présents mais qu'aucun consommateur n'est utilisé pour les fichiers WAL conservés par le slot de réplication, vous pouvez constater une augmentation de l'utilisation du disque du journal des transactions et une diminution constante de l'espace de stockage disponible. Pour plus d'informations et pour savoir comment résoudre ce problème, consultez l'article [Comment puis-je identifier la cause de l'erreur « Aucun espace restant sur l'appareil » ou « » DiskFull sur Amazon RDS for PostgreSQL ?](https://aws.amazon.com/premiumsupport/knowledge-center/diskfull-error-rds-postgresql/) dans le centre de connaissances AWS Support. + Les modifications de schéma que vous apportez à l'instance de base de données source après avoir créé le snapshot de base de données ne seront pas présentes sur l'instance de base de données cible. + Après avoir créé une instance de base de données chiffrée, vous ne pouvez pas modifier la clé KMS utilisée par cette instance de base de données. Assurez-vous de déterminer vos exigences en matière de clé KMS avant de créer votre instance de base de données chiffrée. + Vous devez désactiver les déclencheurs et les clés étrangères sur l'instance de base de données cible avant d'exécuter la tâche AWS DMS. Vous pouvez les réactiver une fois la tâche terminée. # Appliquer le balisage automatique des bases de données Amazon RDS au lancement *Susanne Kangnoh et l'architecte Mathur, Amazon Web Services* ## Résumé Amazon Relational Database Service (Amazon RDS) est un service Web qui facilite la configuration, l'exploitation et le dimensionnement d'une base de données relationnelle dans le cloud Amazon Web Services (AWS). Il fournit des capacités redimensionnables, à faible coût, pour les bases de données relationnelles classiques, et gère les tâches courantes d'administration de base de données. Vous pouvez utiliser le balisage pour classer vos ressources AWS de différentes manières. Le balisage des bases de données relationnelles est utile lorsque votre compte comporte de nombreuses ressources et que vous souhaitez identifier rapidement une ressource spécifique en fonction des balises. Vous pouvez utiliser les balises Amazon RDS pour ajouter des métadonnées personnalisées à vos instances de base de données RDS. Une balise se compose d'une clé et d'une valeur définies par l'utilisateur. Nous vous recommandons de créer un ensemble cohérent de balises pour répondre aux exigences de votre organisation. Ce modèle fournit un CloudFormation modèle AWS pour vous aider à surveiller et à étiqueter les instances de base de données RDS. Le modèle crée un événement Amazon CloudWatch Events qui surveille l'DBInstanceévénement AWS CloudTrail **Create**. (CloudTrail capture les appels d'API pour Amazon RDS sous forme d'événements.) Lorsqu'il détecte cet événement, il appelle une fonction AWS Lambda qui applique automatiquement les clés de balise et les valeurs que vous définissez. Le modèle envoie également une notification indiquant que l'instance a été balisée, à l'aide d'Amazon Simple Notification Service (Amazon SNS). ## Conditions préalables et limitations **Conditions préalables** + Un compte AWS actif. + Un bucket Amazon Simple Storage Service (Amazon S3) pour télécharger le code Lambda. + Adresse e-mail à laquelle vous souhaitez recevoir des notifications de marquage. **Limites** + La solution prend en charge la CloudTrail **création DBInstance** d'événements. Il ne crée pas de notifications pour d'autres événements. ## Architecture **Architecture du flux de travail** ![\[Workflow diagram showing Services AWS interaction for RDS instance creation and notification.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/5541bc1e-e00f-4b5a-94b7-bb1808b5591a/images/ec0bcf92-f986-4af3-bfe7-d2c5e04051c5.png) **Automatisation et mise à l'échelle** + Vous pouvez utiliser le CloudFormation modèle AWS à plusieurs reprises pour différents comptes et régions AWS. Vous ne devez exécuter le modèle qu'une seule fois dans chaque région ou compte. ## Outils **Services AWS** + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html) — AWS CloudTrail est un service AWS qui vous aide dans les domaines de la gouvernance, de la conformité et de l'audit opérationnel et des risques de votre compte AWS. Les actions entreprises par un utilisateur, un rôle ou un service AWS sont enregistrées sous forme d'événements dans CloudTrail. + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html) — Amazon CloudWatch Events fournit un flux quasi en temps réel d'événements système décrivant les modifications apportées aux ressources AWS. CloudWatch Events prend connaissance des changements opérationnels au fur et à mesure qu'ils se produisent et prend les mesures correctives nécessaires, en envoyant des messages pour répondre à l'environnement, en activant des fonctions, en apportant des modifications et en capturant des informations d'état. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) — AWS Lambda est un service de calcul qui prend en charge l'exécution de code sans qu'il soit nécessaire de configurer ou de gérer des serveurs. Lambda exécute le code uniquement lorsque cela est nécessaire et se met à l’échelle automatiquement, qu’il s’agisse de quelques requêtes par jour ou de milliers de requêtes par seconde. Vous payez uniquement le temps de calcul que vous utilisez. Vous n'exposez aucuns frais quand votre code n'est pas exécuté. + [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html) — Amazon Simple Storage Service (Amazon S3) est un service de stockage d'objets hautement évolutif qui peut être utilisé pour un large éventail de solutions de stockage, notamment les sites Web, les applications mobiles, les sauvegardes et les lacs de données. + [Amazon SNS —](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) Amazon Simple Notification Service (Amazon SNS) est un service Web qui permet aux applications, aux utilisateurs finaux et aux appareils d'envoyer et de recevoir instantanément des notifications depuis le cloud. **Code** Ce modèle inclut une pièce jointe contenant deux fichiers : + `index.zip`est un fichier compressé qui inclut le code Lambda pour ce modèle. + `rds.yaml`est un CloudFormation modèle qui déploie le code Lambda. Consultez la section *Epics* pour plus d'informations sur l'utilisation de ces fichiers. ## Épopées ### Déployer le code Lambda | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Téléchargez le code dans un compartiment S3. | Créez un nouveau compartiment S3 ou utilisez un compartiment S3 existant pour télécharger le `index.zip` fichier joint (code Lambda). Ce compartiment doit se trouver dans la même région AWS que les ressources (instances de base de données RDS) que vous souhaitez surveiller. | Architecte du cloud | | Déployez le CloudFormation modèle. | Ouvrez la console Cloudformation dans la même région AWS que le compartiment S3 et déployez le `rds.yaml` fichier fourni dans la pièce jointe. Dans l'épopée suivante, fournissez des valeurs pour les paramètres du modèle. | Architecte du cloud | ### Complétez les paramètres dans le CloudFormation modèle | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Indiquez le nom du compartiment S3. | Entrez le nom du compartiment S3 que vous avez créé ou sélectionné dans le premier épisode épique. Ce compartiment S3 contient le fichier .zip pour le code Lambda et doit se trouver dans la même région AWS que CloudFormation le modèle et les instances de base de données RDS que vous souhaitez surveiller. | Architecte du cloud | | Fournissez la clé S3. | Indiquez l'emplacement du fichier .zip de code Lambda dans votre compartiment S3, sans barres obliques (par exemple, ou). `index.zip` `controls/index.zip` | Architecte du cloud | | Indiquez une adresse e-mail. | Indiquez une adresse e-mail active à laquelle vous souhaitez recevoir des notifications de violation. | Architecte du cloud | | Spécifiez un niveau de journalisation. | Spécifiez le niveau de journalisation et la verbosité. `Info`désigne des messages d'information détaillés sur la progression de l'application et ne doit être utilisé que pour le débogage. `Error`désigne les événements d'erreur susceptibles de permettre à l'application de continuer à fonctionner. `Warning`désigne les situations potentiellement dangereuses. | Architecte du cloud | | Entrez les clés et les valeurs de balise pour vos instances de base de données RDS. | Entrez les clés de balise et les valeurs requises que vous souhaitez appliquer automatiquement à l'instance RDS. Pour plus d'informations, consultez la section [Marquage des ressources Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html) dans la documentation AWS. | Architecte du cloud | ### Confirmer l'abonnement. | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Confirmez l'abonnement par e-mail. | Lorsque le CloudFormation modèle est déployé avec succès, il envoie un e-mail d'abonnement à l'adresse e-mail que vous avez fournie. Pour recevoir des notifications lorsque vos instances sont étiquetées, vous devez confirmer cet abonnement par e-mail. | Architecte du cloud | ## Ressources connexes + [Création d'un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html) (documentation Amazon S3) + [Marquage des ressources Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html) (documentation Amazon Aurora) + [Chargement d'objets](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html) (documentation Amazon S3) + [Création d'une règle d' CloudWatch événements qui se déclenche lors d'un appel d'API AWS à l'aide d'AWS CloudTrail](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-CloudTrail-Rule.html) ( CloudWatch documentation Amazon) ## Pièces jointes [Pour accéder au contenu supplémentaire associé à ce document, décompressez le fichier suivant : attachment.zip](samples/p-attach/5541bc1e-e00f-4b5a-94b7-bb1808b5591a/attachments/attachment.zip) # Estimation du coût d'une table DynamoDB pour une capacité à la demande *Moinul Al-Mamun, Amazon Web Services* ## Résumé [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) est une base de données transactionnelle NoSQL qui fournit une latence à un chiffre en millisecondes, même à l'échelle du pétaoctet. Cette offre sans serveur Amazon Web Services (AWS) gagne en popularité en raison de ses performances et de son évolutivité constantes. Vous n'avez pas besoin de provisionner l'infrastructure sous-jacente. Votre table unique peut atteindre des pétaoctets. Avec le mode capacité à la demande, vous payez par demande pour les lectures et les écritures de données effectuées par votre application sur les tables. Les frais AWS sont basés sur le cumul des unités de demande de lecture (RRUs) et des unités de demande d'écriture (WRUs) par mois. DynamoDB surveille la taille de votre table en permanence tout au long du mois afin de déterminer vos frais de stockage. Il prend en charge la sauvegarde continue avec point-in-time-recovery (PITR). DynamoDB surveille la taille de vos tables compatibles PITR en permanence tout au long du mois afin de déterminer vos frais de sauvegarde. Pour estimer le coût DynamoDB d'un projet, il est important de calculer la quantité de RRU, de WRU et de stockage qui sera consommée aux différentes étapes du cycle de vie de votre produit. Pour une estimation approximative des coûts, vous pouvez utiliser le [calculateur de prix AWS](https://calculator.aws/#/createCalculator/DynamoDB), mais vous devez fournir un nombre approximatif de RRUs WRUs, et les exigences de stockage pour votre table. Il peut être difficile de les estimer au début du projet. Le calculateur de prix AWS ne prend pas en compte le taux de croissance des données ni la taille des éléments, ni le nombre de lectures et d'écritures pour la table de base et les index secondaires globaux (GSIs) séparément. Pour utiliser le calculateur de prix AWS, vous devez estimer tous ces aspects en supposant des chiffres approximatifs pour le WRU, le RRU et la taille du stockage afin d'obtenir votre estimation des coûts. Ce modèle fournit un mécanisme et un modèle Microsoft Excel réutilisable pour estimer les facteurs de coût de base de DynamoDB, tels que les coûts d'écriture, de lecture, de stockage, de sauvegarde et de restauration, pour le mode capacité à la demande. Il est plus détaillé que le calculateur de prix AWS, et il prend en compte le tableau de base et les GSIs exigences indépendamment. Il prend également en compte le taux de croissance mensuel des données par article et prévoit les coûts sur trois ans. ## Conditions préalables et limitations **Conditions préalables** + Connaissances de base de la conception de modèles de données DynamoDB et DynamoDB + [Connaissance de base de la tarification DynamoDB, de la WRU, de la RRU, du stockage, de la sauvegarde et de la restauration (pour plus d'informations, voir Tarification de la capacité à la demande)](https://aws.amazon.com/dynamodb/pricing/on-demand/) + Connaissance de vos données, de votre modèle de données et de la taille des éléments dans DynamoDB + Connaissance de DynamoDB GSIs **Limites** + Le modèle fournit un calcul approximatif, mais il ne convient pas à toutes les configurations. Pour obtenir une estimation plus précise, vous devez mesurer la taille individuelle de chaque article dans le tableau de base et GSIs. + Pour une estimation plus précise, vous devez prendre en compte le nombre prévu d'écritures (insertion, mise à jour et suppression) et de lectures pour chaque élément au cours d'un mois moyen. + Ce modèle permet d'estimer uniquement les coûts d'écriture, de lecture, de stockage, de sauvegarde et de restauration pour les prochaines années sur la base d'hypothèses de croissance des données fixes. ## Outils **Services AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) est un service de base de données NoSQL entièrement géré, offrant des performances rapides, prévisibles et évolutives. **Autres outils** + [AWS Pricing Calculator](https://calculator.aws/#/createCalculator/DynamoDB) est un outil de planification basé sur le Web que vous pouvez utiliser pour créer des estimations pour vos cas d'utilisation d'AWS. ## Bonnes pratiques Pour réduire les coûts, prenez en compte les meilleures pratiques de conception DynamoDB suivantes. + [Conception de clés de partition](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-partition-key-uniform-load.html) : utilisez une clé de partition à cardinalité élevée pour répartir la charge de manière uniforme. + [Modèle de conception de liste de contiguïté](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-adjacency-graphs.html) : utilisez ce modèle de conception pour la gestion one-to-many et many-to-many les relations. + [Index clairsemé — Utilisez un index](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-indexes-general-sparse-indexes.html) clairsemé pour votre. GSIs Lorsque vous créez un GSI, vous spécifiez une clé de partition et éventuellement une clé de tri. Seuls les éléments de la table de base contenant une clé de partition de GSI correspondante apparaissent dans l'index fragmenté. Cela permet de rester GSIs plus petit. + [Surcharge d'index](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-gsi-overloading.html) : utilisez le même GSI pour indexer différents types d'élément. + [Partitionnement d'écriture de GSI](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-indexes-gsi-sharding.html) : partitionnez judicieusement afin de distribuer les données entre les partitions pour des requêtes plus efficaces et plus rapides. + [Objets de grande taille](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-use-s3-too.html) : stockez uniquement les métadonnées dans la table, enregistrez le blob dans Amazon S3 et conservez la référence dans DynamoDB. Divisez les éléments volumineux en plusieurs éléments et indexez efficacement à l'aide des clés de tri. Pour d'autres bonnes pratiques de conception, veuillez consulter le [Guide du développeur](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html) Amazon DynamoDB. ## Épopées ### Extraire les informations relatives aux éléments de votre modèle de données DynamoDB | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Obtenez la taille de l'article. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Ingénieur de données | | Estimez le coût d'écriture. | Pour estimer le coût d'écriture en mode capacité à la demande, vous devez d'abord mesurer la quantité WRUs qui sera consommée en un mois. Pour cela, vous devez prendre en compte les facteurs suivants :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html)Pour plus d'informations, consultez la section *Informations supplémentaires*. | Ingénieur de données | | Estimez le coût de lecture. | Pour estimer le coût de lecture en mode à la demande, vous devez d'abord mesurer la quantité RRUs qui sera consommée en un mois. Pour cela, vous devez prendre en compte les facteurs suivants : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Ingénieur de données, développeur d'applications | | Estimez la taille et le coût du stockage. | Tout d'abord, estimez le besoin de stockage mensuel moyen en fonction de la taille de votre article indiquée dans le tableau. Calculez ensuite le coût du stockage en multipliant la taille du stockage par le prix par Go de stockage pour votre région AWS. Si vous avez déjà saisi des données pour estimer le coût d'écriture, il n'est pas nécessaire de les saisir à nouveau pour calculer la taille de stockage. Dans le cas contraire, pour estimer la taille du stockage, vous devez prendre en compte les facteurs suivants : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Ingénieur de données | ### Entrez les informations relatives à l'article et à l'objet dans le modèle Excel | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Téléchargez le modèle Excel depuis la section Pièces jointes et adaptez-le à votre tableau des cas d'utilisation. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Ingénieur de données | | Entrez les informations dans le modèle Excel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html)Le modèle comporte trois éléments, ou entités : informations, métadonnées et relations. Il y en a deux GSIs. Pour votre cas d'utilisation, si vous avez besoin de plus d'éléments, créez de nouvelles lignes. Si vous en avez besoin de plus GSIs, copiez un bloc GSI existant et collez-le pour créer autant de blocs GSI que nécessaire. Ajustez ensuite les calculs des colonnes SUM et TOTAL. | Ingénieur de données | ## Ressources connexes **Références** + [Tarification d'Amazon DynamoDB pour la capacité à la demande](https://aws.amazon.com/dynamodb/pricing/on-demand/) + [Calculateur de tarification AWS pour DynamoDB](https://calculator.aws/#/createCalculator/DynamoDB) + [Bonnes pratiques de conception et d'architecture avec DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html) + [Mise en route avec DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) **Guides et modèles** + [Modélisation de données avec Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-data-modeling/) + [Estimation des coûts de stockage pour une table Amazon DynamoDB](https://apg-library.amazonaws.com/content/9b74399d-9655-47ee-b9b3-de46b65bc4e3) ## Informations supplémentaires **Écrire un exemple de calcul des coûts** La conception du modèle de données DynamoDB indique trois éléments pour un produit et une taille moyenne de 4 Ko. Lorsque vous ajoutez un nouveau produit dans la table de base DynamoDB, il consomme le nombre d'éléments \$1 (taille de l'article/unité d'écriture de 1 Ko) = 3 \$1 (4/1) = 12 WRU. Dans cet exemple, pour écrire 1 Ko, le produit consomme 1 WRU. **Lire l'exemple de calcul des coûts** Pour obtenir l'estimation du RRU, considérez la moyenne du nombre de fois que chaque article sera lu par mois. Par exemple, l'élément d'information sera lu en moyenne 10 fois par mois, l'élément de métadonnées sera lu deux fois et l'élément de relation sera lu cinq fois. Dans le modèle d'exemple, le nombre total de RRU pour tous les composants = nombre de nouveaux composants créés chaque mois \$1 RRU par composant et par mois = 10 millions \$1 17 RRU = 170 millions de RRU par mois. Chaque mois, de nouveaux éléments (composants ou produits) seront ajoutés et le nombre total de produits augmentera au fil du temps. Ainsi, les exigences en matière de RRU augmenteront également au fil du temps. + Pour le premier mois de RRU, la consommation sera de 170 millions. + Pour le deuxième mois, la consommation de RRU sera de 2 \$1 170 millions = 340 millions. + Pour le troisième mois, la consommation de RRU sera de 3\$1 170 millions = 510 millions. Le graphique suivant montre la consommation mensuelle de RRU et les prévisions de coûts. ![\[La consommation de RRU augmente plus fortement que le coût.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/1797b48f-a183-4f25-811f-44921c3a48ee/images/3505bfc8-694d-4acc-8585-cd71258fa315.png) Notez que les prix indiqués dans le graphique ne sont fournis qu'à titre d'illustration. Pour créer des prévisions précises adaptées à votre cas d'utilisation, consultez la page de tarification d'AWS et utilisez ces prix dans la feuille Excel. **Exemples de calcul des coûts de stockage, de sauvegarde et de restauration** Le stockage, la sauvegarde et la restauration DynamoDB sont tous connectés les uns aux autres. La sauvegarde est directement liée au stockage, et la restauration est directement liée à la taille de la sauvegarde. À mesure que la taille de la table augmente, les coûts de stockage, de sauvegarde et de restauration correspondants augmentent proportionnellement. *Taille et coût du stockage* Le coût du stockage augmentera au fil du temps en fonction du taux de croissance de vos données. Supposons, par exemple, que la taille moyenne d'un composant ou d'un produit dans la table de base GSIs soit de 11 Ko et que 10 millions de nouveaux produits soient ajoutés chaque mois dans votre table de base de données. Dans ce cas, la taille de votre table DynamoDB augmentera (11 Ko x 10 millions) /1024/1024 = 105 Go par mois. Le premier mois, la taille de stockage de votre table sera de 105 Go, le deuxième mois, elle sera de 105 \$1 105 = 210 GBs, etc. + Le premier mois, le coût du stockage sera de 105 Go\$1 par Go pour votre région AWS. + Le deuxième mois, le coût du stockage sera de 210 Go\$1 par Go pour votre région. + Pour le troisième mois, le coût du stockage sera de 315 Go\$1 par Go pour votre région. Pour connaître la taille et le coût du stockage pour les trois prochaines années, consultez la section *Taille du stockage et prévisions*. *Coût de sauvegarde* Les coûts de sauvegarde augmenteront au fil du temps en fonction du taux de croissance de vos données. Lorsque vous activez la sauvegarde continue avec point-in-time-recovery (PITR), les frais de sauvegarde continue sont basés sur le nombre moyen de Go de stockage par mois. Au cours d'un mois civil, la taille moyenne des sauvegardes serait identique à la taille de stockage de votre table, bien que la taille réelle puisse être légèrement différente. Comme de nouveaux produits seront ajoutés chaque mois, la taille totale du stockage et la taille de sauvegarde augmenteront au fil du temps. Par exemple, le premier mois, la taille de sauvegarde moyenne de 105 Go pourrait passer à 210 Go le deuxième mois. + Le premier mois, le coût de sauvegarde sera de 105 Go par mois\$1, prix de sauvegarde continue par Go pour votre région AWS. + Pour le deuxième mois, le coût de sauvegarde sera de 210 Go par mois\$1 prix de sauvegarde continue par Go pour votre région. + Pour le troisième mois, le coût de sauvegarde sera de 315 Go par mois\$1 prix de sauvegarde continue par Go pour votre région. + et ainsi de suite Le coût de sauvegarde est inclus dans le graphique de la section *Taille du stockage et prévisions des coûts*. *Coûts de recouvrement* Lorsque vous effectuez une sauvegarde continue avec PITR activé, les frais d'opération de restauration sont basés sur la taille de la restauration. Chaque fois que vous effectuez une restauration, vous payez en fonction des gigaoctets de données restaurées. Si la taille de votre table est importante et que vous effectuez une restauration plusieurs fois par mois, cela sera coûteux. Pour estimer le coût de restauration, cet exemple suppose que vous effectuez une restauration PITR une fois par mois à la fin du mois. L'exemple utilise la taille de sauvegarde moyenne mensuelle comme taille des données de restauration pour le mois en question. Pour le premier mois, la taille de sauvegarde moyenne est de 105 Go, et pour la restauration à la fin du mois, la taille des données de restauration serait de 105 Go. Pour le deuxième mois, ce serait 210 GBs, et ainsi de suite. Le coût de restauration augmentera au fil du temps en fonction du taux de croissance de vos données. + Pendant le premier mois, le coût de restauration sera de 105 Go\$1 par Go pour votre région AWS. + Le deuxième mois, le coût de restauration sera de 210 Go\$1 le prix de restauration par Go pour votre région. + Pour le troisième mois, le coût de restauration sera de 315 Go\$1 par Go pour votre région. Pour plus d'informations, consultez l'onglet Stockage, sauvegarde et restauration du modèle Excel et le graphique de la section suivante. *Taille du stockage et prévisions des coûts* Dans le modèle, la taille de stockage facturable réelle est calculée en soustrayant le niveau gratuit de 25 Go par mois pour la classe de table Standard. Dans la feuille, vous trouverez un graphique de prévision ventilé en valeurs mensuelles. L'exemple de graphique suivant prévoit la taille de stockage mensuelle en Go, le coût de stockage facturable, le coût de sauvegarde à la demande et le coût de restauration pour les 36 prochains mois civils. Tous les frais sont en dollars américains. Le graphique montre clairement que les coûts de stockage, de sauvegarde et de restauration augmentent proportionnellement à l'augmentation de la taille du stockage. ![\[La taille du stockage dépasse trois mille alors que les coûts sont inférieurs à mille.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/1797b48f-a183-4f25-811f-44921c3a48ee/images/fd9f06d0-bc9c-4b4e-8cbd-3e527fe09e88.png) Notez que les prix utilisés dans le graphique sont fournis à titre d'illustration uniquement. Pour créer des prix précis adaptés à votre cas d'utilisation, consultez la page de tarification d'AWS et utilisez ces prix dans le modèle Excel. ## Pièces jointes [Pour accéder au contenu supplémentaire associé à ce document, décompressez le fichier suivant : attachment.zip](samples/p-attach/1797b48f-a183-4f25-811f-44921c3a48ee/attachments/attachment.zip) # Estimation des coûts de stockage pour une table Amazon DynamoDB *Moinul Al-Mamun, Amazon Web Services* ## Résumé Amazon DynamoDB est une base de données transactionnelle NoSQL qui fournit une latence à un chiffre en millisecondes, même à l'échelle du pétaoctet. Cette offre sans serveur populaire de AWS fournit des performances et une évolutivité constantes. Vous n'avez pas besoin de provisionner du stockage, et votre table unique peut atteindre des pétaoctets. DynamoDB surveille la taille de votre table en permanence tout au long du mois afin de déterminer vos frais de stockage. AWS vous facture ensuite la taille moyenne du stockage en gigaoctets. Plus votre table s'agrandit au fil du temps, plus vos coûts de stockage augmenteront. Pour calculer le coût de stockage, vous pouvez utiliser le [calculateur de AWS prix](https://calculator.aws/#/createCalculator/DynamoDB), mais vous devez indiquer la taille approximative de votre table, y compris les index secondaires globaux (GSIs), ce qui est très difficile à estimer au début du projet. De plus, le calculateur de AWS prix ne prend pas en compte le taux de croissance des données. Ce modèle fournit un mécanisme et un modèle Microsoft Excel réutilisable pour calculer la taille et le coût du stockage DynamoDB. Il prend en compte les exigences de stockage de la table de base et de la table GSIs indépendante. Il calcule la taille du stockage en tenant compte de la taille de vos éléments individuels et du taux de croissance des données au fil du temps. Pour obtenir une estimation, insérez deux informations dans le modèle : + La taille de chaque élément en kilo-octets pour la table de base et GSIs + Combien de nouveaux objets ou produits pourraient être ajoutés au tableau, en moyenne, par mois (par exemple, 10 millions) Le modèle génère un graphique de prévision du stockage et des coûts pour les trois prochaines années, comme le montre l'exemple suivant. ![\[La ligne inférieure pour les coûts augmente lentement et la ligne supérieure pour le stockage augmente plus rapidement.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/9b74399d-9655-47ee-b9b3-de46b65bc4e3/images/c0436252-cc42-4ea3-ac50-c0455aece39d.png) ## Conditions préalables et limitations **Conditions préalables** + Connaissance de base de DynamoDB, notamment du stockage et de la tarification DynamoDB + Connaissance de vos données, de votre modèle de données et de la taille des éléments dans DynamoDB + Connaissance des index secondaires globaux DynamoDB () GSIs **Limites** + Le modèle fournit un calcul approximatif, mais il ne convient pas à toutes les configurations. Pour obtenir une estimation plus précise, vous devez mesurer la taille individuelle de chaque article dans le tableau de base et GSIs. + Ce modèle permet d'estimer uniquement la taille et le coût du stockage pour les prochaines années sur la base d'hypothèses de croissance des données fixes. ## Outils **Services AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) est un service de base de données NoSQL entièrement géré, offrant des performances rapides, prévisibles et évolutives. **Autres outils** + AWS Le [calculateur de prix](https://docs.aws.amazon.com/pricing-calculator/latest/userguide/what-is-pricing-calculator.html) est un outil de planification en ligne que vous pouvez utiliser pour créer des estimations pour vos cas AWS d'utilisation. ## Épopées ### Extraire les informations relatives aux éléments de votre modèle de données DynamoDB | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Obtenez la taille de l'article. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Ingénieur de données | | Obtenez le nombre d'objets ajoutés en un mois. | Estimez le nombre de composants ou d'objets qui seront ajoutés à la table DynamoDB, en moyenne, en un mois. | Ingénieur de données | ### Entrez les informations relatives à l'article et à l'objet dans le modèle Excel | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Téléchargez et ajustez la feuille de calcul Excel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Ingénieur de données | | Entrez les informations dans le modèle Excel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Ingénieur de données | ## Ressources connexes + [Tarification de la capacité à la demande](https://aws.amazon.com/dynamodb/pricing/on-demand/) pour Amazon DynamoDB + [AWS Calculateur de prix pour DynamoDB](https://calculator.aws/#/createCalculator/DynamoDB) ## Informations supplémentaires Notez que le modèle ci-joint prévoit uniquement la taille et le coût du stockage pour la classe de table de stockage standard. Sur la base des prévisions relatives aux coûts de stockage et en tenant compte de la taille de chaque article et du taux de croissance du produit ou de l'objet, vous pouvez estimer les éléments suivants : + Coût d'exportation des données + Coûts de sauvegarde et de restauration + Exigences relatives au stockage des données. **Coût de stockage des données Amazon DynamoDB** DynamoDB surveille en permanence la taille de vos tables afin de déterminer vos frais de stockage. DynamoDB mesure la taille de vos données facturables en ajoutant la taille d’octet brute de vos données plus des frais de stockage par élément qui dépendent des fonctionnalités que vous avez activées. Pour plus d'informations, consultez le Guide du [développeur DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/CapacityUnitCalculations.html). Le prix du stockage des données dépend de la classe de votre table. Les 25 premiers Go stockés chaque mois sont gratuits si vous utilisez la classe de table DynamoDB Standard. Pour plus d'informations sur les coûts de stockage pour les classes de tables Standard et Standard-Infrequent Access selon les différentes classes Régions AWS, consultez la section [Tarification](https://aws.amazon.com/dynamodb/pricing/on-demand/) de la capacité à la demande. ## Pièces jointes [Pour accéder au contenu supplémentaire associé à ce document, décompressez le fichier suivant : attachment.zip](samples/p-attach/9b74399d-9655-47ee-b9b3-de46b65bc4e3/attachments/attachment.zip) # Estimez la taille du moteur Amazon RDS pour une base de données Oracle à l'aide des rapports AWR *Abhishek Verma et Eduardo Valentim, Amazon Web Services* ## Résumé Lorsque vous migrez une base de données Oracle vers Amazon Relational Database Service (Amazon RDS) ou Amazon Aurora, le calcul du processeur, de la mémoire et du I/O disque de la base de données cible est une exigence essentielle. Vous pouvez estimer la capacité requise de la base de données cible en analysant les rapports Oracle Automatic Workload Repository (AWR). Ce modèle explique comment utiliser les rapports AWR pour estimer ces valeurs. La base de données Oracle source peut être sur site ou hébergée sur une instance Amazon Elastic Compute Cloud (Amazon EC2), ou il peut s'agir d'une instance de base de données Amazon RDS for Oracle. La base de données cible peut être n'importe quelle base de données Amazon RDS ou Aurora. **Note** Les estimations de capacité seront plus précises si votre moteur de base de données cible est Oracle. Pour les autres bases de données Amazon RDS, la taille du moteur peut varier en raison des différences d'architecture de base de données. Nous vous recommandons d'exécuter le test de performance avant de migrer votre base de données Oracle. ## Conditions préalables et limitations **Conditions préalables** + Une licence Oracle Database Enterprise Edition et une licence Oracle Diagnostics Pack pour télécharger les rapports AWR. **Versions du produit** + Toutes les éditions d'Oracle Database pour les versions 11g (versions 11.2.0.3.v1 et ultérieures) et jusqu'à 12.2, et 18c,19c. + Ce modèle ne couvre pas les systèmes Oracle Engineered ou Oracle Cloud Infrastructure (OCI). ## Architecture **Pile technologique source** L’un des éléments suivants : + Une base de données Oracle sur site + Une base de données Oracle sur une EC2 instance + Une instance de base de données Amazon RDS pour Oracle **Pile technologique cible** + Toute base de données Amazon RDS ou Amazon Aurora **Architecture cible** Pour plus d'informations sur le processus de migration complet, consultez le modèle [Migrer une base de données Oracle vers Aurora PostgreSQL à l'aide d'AWS DMS et d'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). **Automatisation et mise à l'échelle** Si vous avez plusieurs bases de données Oracle à migrer et que vous souhaitez utiliser des indicateurs de performance supplémentaires, vous pouvez automatiser le processus en suivant les étapes décrites dans le billet de blog Ajustement de la [taille des instances Amazon RDS à grande échelle en fonction des indicateurs de performance Oracle](https://aws.amazon.com/blogs/database/right-sizing-amazon-rds-instances-at-scale-based-on-oracle-performance-metrics/). ## Outils + [Oracle Automatic Workload Repository (AWR)](https://docs.oracle.com/en-us/iaas/performance-hub/doc/awr-report-ui.html) est un référentiel intégré aux bases de données Oracle. Il collecte et stocke périodiquement les données relatives à l'activité du système et à la charge de travail, qui sont ensuite analysées par Automatic Database Diagnostic Monitor (ADDM). AWR prend régulièrement des instantanés des données de performance du système (par défaut, toutes les 60 minutes) et stocke les informations (par défaut, jusqu'à 8 jours). Vous pouvez utiliser les vues et les rapports AWR pour analyser ces données. ## Bonnes pratiques + Pour calculer les besoins en ressources de votre base de données cible, vous pouvez utiliser un seul rapport AWR, plusieurs rapports AWR ou des vues AWR dynamiques. Nous vous recommandons d'utiliser plusieurs rapports AWR pendant la période de pointe afin d'estimer les ressources nécessaires pour gérer ces pics de charge. En outre, les vues dynamiques fournissent davantage de points de données qui vous aident à calculer les besoins en ressources avec plus de précision. + Vous devez estimer les IOPS uniquement pour la base de données que vous prévoyez de migrer, et non pour les autres bases de données et processus qui utilisent le disque. + Pour calculer la quantité I/O utilisée par la base de données, n'utilisez pas les informations de la section Profil de charge du rapport AWR. Utilisez plutôt la section I/O Profil, si elle est disponible, ou passez directement à la section Statistiques d'activité de l'instance et examinez les valeurs totales des opérations physiques de lecture et d'écriture. + Lorsque vous estimez l'utilisation du processeur, nous vous recommandons d'utiliser la méthode des métriques de base de données plutôt que les statistiques du système d'exploitation (OS), car elle est basée sur le processeur utilisé uniquement par les bases de données. (Les statistiques du système d'exploitation incluent également l'utilisation du processeur par d'autres processus.) Vous devez également consulter les recommandations relatives au processeur dans le rapport ADDM afin d'améliorer les performances après la migration. + Tenez compte des limites de I/O débit (débit Amazon Elastic Block Store (Amazon EBS) et débit réseau) pour la taille spécifique de l'instance lorsque vous déterminez le type d'instance approprié. + Exécutez le test de performance avant la migration pour valider la cylindrée du moteur. ## Épopées ### Création d'un rapport AWR | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Activez le rapport AWR. | Pour activer le rapport, suivez les instructions de la [documentation Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/18/tgdba/gathering-database-statistics.html#GUID-26D359FA-F809-4444-907C-B5AFECD9AE29). | DBA | | Vérifiez la durée de conservation. | Pour vérifier la durée de conservation du rapport AWR, utilisez la requête suivante.
cc_idx:-2 country:Invalid
cc_idx:0 country:China
cc_idx:3 country:UK
cc_idx:5 country:USA
cc_idx:7 country:India
SQL> SELECT snap_interval,retention FROM dba_hist_wr_control;| DBA | | Générez le cliché. | Si l'intervalle entre les instantanés AWR n'est pas suffisamment précis pour capturer le pic de charge de travail, vous pouvez générer le rapport AWR manuellement. Pour générer l'instantané AWR manuel, utilisez la requête suivante.
SQL> EXEC dbms_workload_repository.create_snapshot;| DBA | | Vérifiez les instantanés récents. | Pour vérifier les instantanés AWR récents, utilisez la requête suivante.
SQL> SELECT snap_id, to_char(begin_interval_time,'dd/MON/yy hh24:mi') Begin_Interval,| DBA | ### Estimation des I/O besoins en disques | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Choisissez une méthode. | L'IOPS est la mesure standard des opérations d'entrée et de sortie par seconde sur un périphérique de stockage et inclut les opérations de lecture et d'écriture. Si vous migrez une base de données sur site vers AWS, vous devez déterminer le disque maximal I/O utilisé par la base de données. Vous pouvez utiliser les méthodes suivantes pour estimer le disque I/O de votre base de données cible :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Les étapes suivantes décrivent ces quatre méthodes. | DBA | | Option 1 : utilisez le profil de charge. | Le tableau suivant montre un exemple de la section Profil de charge du rapport AWR.Pour des informations plus précises, nous vous recommandons d'utiliser l'option 2 (profils d'E/S) ou l'option 3 (statistiques d'activité de l'instance) au lieu du profil de charge.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Sur la base de ces informations, vous pouvez calculer IOPs le débit comme suit :*IOPS = Demandes de lecture : \$1 I/O Demandes d'écriture I/O = 3 586,8 \$1 574,7 = 4134,5**Débit = lecture physique (blocs) \$1 écriture physique (blocs) = 13 575,1 \$1 3 467,3 = 17 042,4*La taille des blocs dans Oracle étant de 8 Ko, vous pouvez calculer le débit total comme suit :*Le débit total en Mo est de 17042,4 \$1 8 \$1 1024/1024/1024 = 133,2 Mo*N'utilisez pas le profil de charge pour estimer la taille de l'instance. Ce n'est pas aussi précis que les statistiques ou les I/O profils d'activité des instances. | DBA | | Option 2 : utiliser les statistiques d'activité de l'instance. | Si vous utilisez une version d'Oracle Database antérieure à 12c, vous pouvez utiliser la section Instance Activity Stats du rapport AWR pour estimer les IOPS et le débit. Le tableau suivant présente un exemple de cette section.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Sur la base de ces informations, vous pouvez calculer le total des IOPS et le débit comme suit :*Nombre total d'IOPS = 3 610,28 \$1 757,11 = 4 367**Mbits/s totaux = 114 482 426,26 \$1 36 165 631,84 = 150648058,1/1024/1024 = 143 Mbits/s* | DBA | | Option 3 : Utiliser I/O des profils. | Dans Oracle Database 12c, le rapport AWR inclut une section I/O Profils qui présente toutes les informations dans un seul tableau et fournit des données plus précises sur les performances de la base de données. Le tableau suivant présente un exemple de cette section.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Ce tableau fournit les valeurs suivantes pour le débit et le total des IOPS :*Débit = 143 Mbits/s (à partir de la cinquième ligne, intitulée Total, deuxième colonne)**IOPS = 4 367,4 (à partir de la première ligne, intitulée Total des demandes, deuxième colonne)* | DBA | | Option 4 : Utiliser les vues AWR. | Vous pouvez voir les mêmes informations d'IOPS et de débit en utilisant les vues AWR. Pour obtenir ces informations, utilisez la requête suivante :
to_char(end_interval_time,'dd/MON/yy hh24:mi') End_Interval
FROM dba_hist_snapshot
ORDER BY 1;
break on report| DBA | | | Par seconde | Par transaction | Par Exec | Par appel | | --- |--- |--- |--- |--- | | **Heure (s) de base de données :** | 26,6 | 0.2 | 0,00 | 0,02 | | **Processeur (s) de base de données :** | 18,0 | 0.1 | 0,00 | 0,01 | | **Processeur (s) d'arrière-plan :** | 0.2 | 0.0 | 0,00 | 0,00 | | **Taille de rétablissement (octets) :** | 2 458 539,9 | 17 097,5 | | | | **Lecture logique (blocs) :** | 3 371 931,5 | 23 449,6 | | | | **Bloquer les modifications :** | 21 643,5 | 150,5 | | | | **Lecture physique (blocs) :** | 13 575,1 | 94,4 | | | | **Écriture physique (blocs) :** | 3 467,3 | 24.1 | | | | **Lisez les demandes d'E/S :** | 3 586,8 | 24,9 | | | | **Rédigez des demandes d'E/S :** | 574,7 | 4.0 | | | | **Lire l'IO (Mo) :** | 106,1 | 0.7 | | | | **Écrire IO (Mo) :** | 27.1 | 0.2 | | | | **Lignes de numérisation par messagerie instantanée :** | 0.0 | 0.0 | | | | **Messagerie instantanée de lecture logique de session :** | | | | | | **Appels de l'utilisateur :** | 1 245,7 | 8,7 | | | | **Analyses (SQL) :** | 4 626,2 | 32,2 | | | | **Analyses approfondies (SQL) :** | 8,9 | 0.1 | | | | **Zone de travail SQL (Mo) :** | 824,9 | 5.7 | | | | **Connexions :** | 1,7 | 0.0 | | | | **Exécute (SQL) :** | 136 656,5 | 950,4 | | | | **Annulations :** | 22,9 | 0.2 | | | | **Transactions :** | 143,8 | | | | | Statistique | Total | par seconde | par Trans | | --- |--- |--- |--- | | **nombre total de demandes d'E/S en lecture physique** | 2 547 333 217 | 3 610,28 | 25,11 | | **nombre total d'octets de lecture physique** | 80 776 296 124 928 | 114 482 426,26 | 796 149,98 | | **nombre total de demandes d'E/S en écriture physique** | 534 198 208 | 757,11 | 5,27 | | **nombre total d'octets en écriture physique** | 25 517 678 849 024 | 36 165 631,84 | 251 508,18 | | | Lecture\$1écriture par seconde | Lecture par seconde | Écrire par seconde | | --- |--- |--- |--- | | **Nombre total de demandes :** | 4 367,4 | 3 610,3 | 757,1 | | **Demandes de base de données :** | 4 161,5 | 3 586,8 | 574,7 | | **Demandes optimisées :** | 0.0 | 0.0 | 0.0 | | **Demandes de rétablissement :** | 179,3 | 2,8 | 176,6 | | **Total (Mo) :** | 143,7 | 109,2 | 34,5 | | **Base de données (MB) :** | 133,1 | 106,1 | 27.1 | | **Total optimisé (Mo) :** | 0.0 | 0.0 | 0.0 | | **Rétablir (Mo) :** | 7.6 | 2.7 | 4,9 | | **Base de données (blocs) :** | 17 042,4 | 13 575,1 | 3 467,3 | | **Via le cache tampon (blocs) :** | 5 898,5 | 5 360,9 | 537,6 | | **Direct (blocs) :** | 11 143,9 | 8 214,2 | 2 929,7 | ### Estimation des besoins en CPU | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Choisissez une méthode. | Vous pouvez estimer le processeur requis pour la base de données cible de trois manières :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Si vous examinez les cœurs utilisés, nous vous recommandons d'utiliser la méthode des métriques de base de données plutôt que des statistiques du système d'exploitation, car elle est basée sur le processeur utilisé uniquement par les bases de données que vous envisagez de migrer. (Les statistiques du système d'exploitation incluent également l'utilisation du processeur par d'autres processus.) Vous devez également consulter les recommandations relatives au processeur dans le rapport ADDM afin d'améliorer les performances après la migration.Vous pouvez également estimer les besoins en fonction de la génération de processeurs. Si vous utilisez différentes générations de processeurs, vous pouvez estimer le processeur requis pour la base de données cible en suivant les instructions du livre blanc [Démystifier le nombre de v CPUs pour des performances de charge de travail optimales](https://d1.awsstatic.com/whitepapers/Demystifying_vCPUs.df200b766578b75009ad8d15c72e493d6408c68a.pdf). | DBA | | Option 1 : Estimer les besoins en fonction des noyaux disponibles. | Dans les rapports de l'AWR :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Vous pouvez estimer les noyaux disponibles de deux manières :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)**Pour estimer les cœurs disponibles à l'aide des commandes du système d'exploitation**Utilisez la commande suivante pour compter les cœurs du processeur.
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"|uniqUtilisez la commande suivante pour compter les sockets du processeur.
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 -uNous ne recommandons pas d'utiliser les commandes du système d'exploitation telles que **nmon** et **sar** pour extraire l'utilisation du processeur. Cela est dû au fait que ces calculs incluent l'utilisation du processeur par d'autres processus et peuvent ne pas refléter le processeur réel utilisé par la base de données.**Pour estimer les cœurs disponibles à l'aide du rapport AWR**Vous pouvez également déduire l'utilisation du processeur à partir de la première section du rapport AWR. Voici un extrait du rapport.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Dans cet exemple, le CPUs nombre est de 80, ce qui indique qu'ils sont logiques (virtuels) CPUs. Vous pouvez également constater que cette configuration comporte deux sockets, un processeur physique sur chaque socket (pour un total de deux processeurs physiques) et 40 cœurs pour chaque processeur physique ou socket. | DBA | | Option 2 : Estimez l'utilisation du processeur à l'aide des statistiques du système d'exploitation. | Vous pouvez vérifier les statistiques d'utilisation du processeur du système d'exploitation soit directement dans le système d'exploitation (à l'aide de **sar** ou d'un autre utilitaire du système d'exploitation hôte), soit en consultant les valeurs IDLE/ (IDLE\$1BUSY) de la section Statistiques du système d'exploitation du rapport AWR. Vous pouvez voir les secondes de processeur consommées directement depuis **v\$1osstat**. Les rapports AWR et Statspack présentent également ces données dans la section Statistiques du système d'exploitation.Si plusieurs bases de données se trouvent sur la même boîte, elles ont toutes les mêmes valeurs **v\$1osstat** pour BUSY\$1TIME.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)S'il n'y a aucun autre consommateur important de CPU dans le système, utilisez la formule suivante pour calculer le pourcentage d'utilisation du processeur :*Utilisation = Temps de charge/Temps total**Temps de pointe = exigences = V\$1OSSTAT.BUSY\$1TIME**C = Durée totale (occupé et inactif)**C = capacité = V\$1OSTAT.BUSY\$1TIME \$1 V\$1OSTAT.IDLE\$1TIME**Utilisation = BUSY\$1TIME/(BUSY\$1TIME \$1 IDLE\$1TIME)**= -1 305 569 937/(1 305 569 937 \$1 4 312 718 839)**= 23 % utilisés* | DBA | | Option 3 : Estimez l'utilisation du processeur à l'aide des métriques de base de données. | Si plusieurs bases de données sont en cours d'exécution dans le système, vous pouvez utiliser les métriques de base de données qui apparaissent au début du rapport.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Pour obtenir des mesures d'utilisation du processeur, utilisez cette formule :*Utilisation du processeur de la base de données (% de la puissance CPU disponible) = temps CPU/NUM\$1CPUS/temps écoulé*où l'utilisation du processeur est décrite par le *temps du processeur* et représente le temps passé sur le processeur, et non le temps d'attente du processeur. Ce calcul aboutit à :*= 312,625,40/11,759,64/80 = 33 % du processeur est utilisé**Nombre de cœurs (33 %) \$1 80 = 26,4 cœurs**Nombre total de cœurs = 26,4 \$1 (120 %) = 31,68 cœurs*Vous pouvez utiliser la plus élevée de ces deux valeurs pour calculer l'utilisation du processeur de l'instance de base de données Amazon RDS ou Aurora.Sur IBM AIX, l'utilisation calculée ne correspond pas aux valeurs du système d'exploitation ou de la base de données. Ces valeurs sont identiques sur les autres systèmes d'exploitation. | DBA | | DB Name | ID de base de données | Instance | Insérer un numéro | Heure de démarrage | Version | RAC | | --- |--- |--- |--- |--- |--- |--- | | XXXX |
physical id : 0
physical id : 1
call mysql.rds_set_configuration('binlog retention hours', XX)Confirmez le réglage en exécutant la commande suivante.call mysql.rds_show_configuration;Les bases de données compatibles MySQL gérées par AWS purgent les journaux binaires dès que possible. Par conséquent, la période de conservation doit être suffisamment longue pour garantir que les journaux ne sont pas purgés avant l'exécution de la tâche AWS DMS. Une valeur de 24 heures est généralement suffisante, mais elle doit être basée sur le temps nécessaire pour configurer la tâche AWS DMS dans la région DR. | DBA | ### Mettre à jour la tâche AWS DMS existante dans la région principale | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Enregistrez l'ARN de la tâche AWS DMS. | Utilisez l'Amazon Resource Name (ARN) pour obtenir le nom de la tâche AWS DMS pour une utilisation ultérieure. Pour récupérer l'ARN de la tâche AWS DMS, affichez la tâche dans la console ou exécutez la commande suivante.
aws dms describe-replication-tasksUn ARN ressemble à ce qui suit.
arn:aws:dms:us-east-1:Les caractères situés après le dernier deux-points correspondent au nom de la tâche utilisé lors d'une étape ultérieure. | Administrateur AWS | | Modifiez la tâche AWS DMS existante pour enregistrer le point de contrôle. | AWS DMS crée des points de contrôle contenant des informations afin que le moteur de réplication connaisse le point de reprise du flux de modifications. Pour enregistrer les informations relatives aux points de contrôle, effectuez les opérations suivantes dans la console :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html) | Administrateur AWS | | Validez les informations du point de contrôle. | À l'aide d'un client MySQL connecté au point de terminaison du rédacteur du cluster, interrogez la nouvelle table de métadonnées dans le cluster de base de données rapporteur pour vérifier qu'elle existe et qu'elle contient les informations sur l'état de réplication. Exécutez la commande suivante.:task:AN6HFFMPM246XOZVEUHCNSOVF7MQCLTOZUIRAMY
select * from awsdms_control.awsdms_txn_state;Le nom de la tâche issu de l'ARN doit se trouver dans ce tableau dans la `Task_Name` colonne. | DBA | ### Étendre les deux clusters Amazon Aurora à une région DR | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une infrastructure de base dans la région DR. | Créez les composants de base nécessaires à la création et à l'accès aux clusters Amazon Aurora :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html)Assurez-vous que la configuration des deux groupes de paramètres correspond à celle de la région principale. | Administrateur AWS | | Ajoutez la région DR aux deux clusters Amazon Aurora. | Ajoutez une région secondaire (la région DR) aux clusters Amazon Aurora principaux et déclarants. Pour plus d'informations, consultez [Ajouter une région AWS à une base de données mondiale Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html#aurora-global-database-attaching). | Administrateur AWS | ### Effectuer un basculement | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Arrêtez la tâche AWS DMS. | La tâche AWS DMS dans la région principale ne fonctionnera pas correctement après le basculement et doit être arrêtée pour éviter les erreurs. | Administrateur AWS | | Effectuez un basculement géré. | Effectuez un basculement géré du cluster de base de données principal vers la région DR. Pour obtenir des instructions, consultez la section [Réalisation de basculements planifiés gérés pour les bases de données mondiales Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-disaster-recovery.html#aurora-global-database-disaster-recovery.managed-failover). Une fois le basculement sur le cluster de base de données principal terminé, effectuez la même activité sur le cluster de bases de données rapporteur. | Administrateur AWS, DBA | | Chargez les données dans la base de données principale. | Insérez les données de test dans le nœud d'écriture de la base de données principale du cluster de bases de données DR. Ces données seront utilisées pour valider le bon fonctionnement de la réplication. | DBA | | Créez l'instance de réplication AWS DMS. | Pour créer l'instance de réplication AWS DMS dans la région DR, consultez [Création d'une instance de réplication](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.Creating.html). | Administrateur AWS, DBA | | Créez les points de terminaison source et cible AWS DMS. | Pour créer les points de terminaison source et cible AWS DMS dans la région DR, consultez [Création de points de terminaison source et cible](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Endpoints.Creating.html). La source doit pointer vers l'instance d'écriture du cluster de base de données principal. La cible doit pointer vers l'instance d'écriture du cluster de base de données de rapporteurs. | Administrateur AWS, DBA | | Obtenez le point de contrôle de réplication. | Pour obtenir le point de contrôle de réplication, utilisez un client MySQL pour interroger la table de métadonnées en exécutant la commande suivante sur le nœud d'écriture du cluster de base de données rapporteur dans la région DR.
select * from awsdms_control.awsdms_txn_state;Dans le tableau, recherchez la valeur task\$1name qui correspond à l'ARN de la tâche AWS DMS qui existe dans la région principale que vous avez obtenue lors du deuxième épisode épique. | DBA | | Créez une tâche AWS DMS. | À l'aide de la console, créez une tâche AWS DMS dans la région DR. Dans la tâche, spécifiez une méthode de migration consistant à **répliquer uniquement les modifications de données**. Pour plus d'informations, consultez la section [Création d'une tâche](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/fr_fr/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html)Définissez le paramètre **Démarrer la tâche de migration** d'AWS DMS **sur Automatiquement lors de la création**. | Administrateur AWS, DBA | | Enregistrez l'ARN de la tâche AWS DMS. | Utilisez l'ARN pour obtenir le nom de la tâche AWS DMS pour une utilisation ultérieure. Pour récupérer l'ARN de la tâche AWS DMS, exécutez la commande suivante.
aws dms describe-replication-tasks| Administrateur AWS, DBA | | Validez les données répliquées. | Interrogez le cluster de base de données rapporteur dans la région DR pour confirmer que les données de test que vous avez chargées dans le cluster de base de données principal ont été répliquées. | DBA | ### Effectuez un retour en arrière | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Arrêtez la tâche AWS DMS. | La tâche AWS DMS dans la région DR ne fonctionnera pas correctement après le failback et doit être arrêtée pour éviter les erreurs. | Administrateur AWS | | Effectuez un retour en arrière géré. | Replacez le cluster de base de données principal dans la région principale. Pour obtenir des instructions, consultez la section [Réalisation de basculements planifiés gérés pour les bases de données mondiales Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-disaster-recovery.html#aurora-global-database-disaster-recovery.managed-failover). Une fois le retour sur le cluster de base de données principal terminé, effectuez la même activité sur le cluster de base de données rapporteur. | Administrateur AWS, DBA | | Obtenez le point de contrôle de réplication. | Pour obtenir le point de contrôle de réplication, utilisez un client MySQL pour interroger la table de métadonnées en exécutant la commande suivante sur le nœud d'écriture du cluster de base de données rapporteur dans la région DR.
select * from awsdms_control.awsdms_txn_state;Dans le tableau, trouvez la `task_name` valeur correspondant à l'ARN de la tâche AWS DMS qui existe dans la région DR que vous avez obtenue lors de la quatrième épopée. | DBA | | Mettez à jour les points de terminaison source et cible d'AWS DMS. | Une fois les clusters de base de données défaillants, vérifiez les clusters de la région principale pour déterminer quels nœuds sont les instances d'écriture. Vérifiez ensuite que les points de terminaison source et cible AWS DMS existants dans la région principale pointent vers les instances du rédacteur. Si ce n'est pas le cas, mettez à jour les points de terminaison avec les noms DNS (Domain Name System) de l'instance du rédacteur. | Administrateur AWS | | Créez une tâche AWS DMS. | À l'aide de la console, créez une tâche AWS DMS dans la région principale. Dans la tâche, spécifiez une méthode de migration consistant à **répliquer uniquement les modifications de données**. Pour plus d'informations, consultez la section [Création d'une tâche](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/fr_fr/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html) | Administrateur AWS, DBA | | Enregistrez la tâche AWS DMS Amazon Resource Name (ARN). | Utilisez l'ARN pour obtenir le nom de la tâche AWS DMS pour une utilisation ultérieure. Pour récupérer l'ARN de la tâche AWS DMS, exécutez la commande suivante :
aws dms describe-replication-tasksLe nom de la tâche sera nécessaire lors de l'exécution d'un autre basculement géré ou lors d'un scénario de reprise après sinistre. | Administrateur AWS, DBA | | Supprimez les tâches AWS DMS. | Supprimez la tâche AWS DMS d'origine (actuellement arrêtée) dans la région principale et la tâche AWS DMS existante (actuellement arrêtée) dans la région secondaire. | Administrateur AWS | ## Ressources connexes + [Configuration de votre cluster de base de données Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraSettingUp.html) + [Utilisation de bases de données globales Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html) + [Utilisation d'Amazon Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraMySQL.html) + [Utilisation d'une instance de réplication AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.html) + [Utilisation des points de terminaison AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Endpoints.html) + [Utilisation des tâches AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.html) + [Qu'est-ce qu'AWS CloudFormation ?](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) ## Informations supplémentaires Les bases de données mondiales Amazon Aurora sont utilisées dans cet exemple pour la reprise après sinistre car elles fournissent un objectif de temps de restauration (RTO) effectif de 1 seconde et un objectif de point de reprise (RPO) inférieur à 1 minute, tous deux inférieurs aux solutions répliquées traditionnelles et idéaux pour les scénarios de reprise après sinistre. Les bases de données mondiales Amazon Aurora offrent de nombreux autres avantages, notamment les suivants : + Lectures globales avec latence locale — Les consommateurs du monde entier peuvent accéder aux informations d'une région locale, avec une latence locale. + Clusters de base de données Amazon Aurora secondaires évolutifs : les clusters secondaires peuvent être mis à l'échelle indépendamment, ce qui permet d'ajouter jusqu'à 16 répliques en lecture seule. + Réplication rapide des clusters de base de données Amazon Aurora principaux vers les clusters secondaires : la réplication a peu d'impact sur les performances du cluster principal. Elle se produit au niveau de la couche de stockage, avec des latences de réplication entre régions typiques de moins d'une seconde. Ce modèle utilise également AWS DMS pour la réplication. Les bases de données Amazon Aurora permettent de créer des répliques en lecture, ce qui peut simplifier le processus de réplication et la configuration de la reprise après sinistre. Cependant, AWS DMS est souvent utilisé pour effectuer une réplication lorsque des transformations de données sont requises ou lorsque la base de données cible nécessite des index supplémentaires que la base de données source ne possède pas. # Migrer les fonctions et procédures Oracle comportant plus de 100 arguments vers PostgreSQL *Srinivas Potlachervoo, Amazon Web Services* ## Résumé Ce modèle montre comment migrer les fonctions et procédures de base de données Oracle comportant plus de 100 arguments vers PostgreSQL. Par exemple, vous pouvez utiliser ce modèle pour migrer les fonctions et procédures Oracle vers l'un des services de base de données AWS compatibles avec PostgreSQL suivants : + Amazon Relational Database Service (Amazon RDS) pour PostgreSQL + Amazon Aurora PostgreSQL-Compatible Edition PostgreSQL ne prend pas en charge les fonctions ou les procédures comportant plus de 100 arguments. Pour contourner le problème, vous pouvez définir un nouveau type de données dont les champs de type correspondent aux arguments de la fonction source. Vous pouvez ensuite créer et exécuter une PL/pgSQL fonction qui utilise le type de données personnalisé comme argument. ## Conditions préalables et limitations **Conditions préalables** + Un compte AWS actif + Une instance de base de [données Oracle (DB) Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) + [Une instance de base de données [Amazon RDS pour PostgreSQL ou une instance de base de données compatible avec Aurora PostgreSQL](https://aws.amazon.com/getting-started/hands-on/create-connect-postgresql-db/)](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.AuroraPostgreSQL.html) **Versions du produit** + Instance de base de données Oracle Amazon RDS 10.2 et versions ultérieures + Instance de base de données Amazon RDS PostgreSQL versions 9.4 et ultérieures, ou instances de base de données compatibles Aurora PostgreSQL versions 9.4 et ultérieures + Oracle SQL Developer version 18 et versions ultérieures + pgAdmin version 4 et versions ultérieures ## Architecture **Pile technologique source** + Instance de base de données Oracle Amazon RDS 10.2 et versions ultérieures **Pile technologique cible** + Instance de base de données Amazon RDS PostgreSQL versions 9.4 et ultérieures, ou instances de base de données compatibles Aurora PostgreSQL versions 9.4 et ultérieures ## Outils **Services AWS** + [Amazon Relational Database Service (Amazon RDS) pour PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) vous aide à configurer, exploiter et dimensionner une base de données relationnelle PostgreSQL dans le cloud AWS. + [Amazon Aurora PostgreSQL Compatible Edition](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) est un moteur de base de données relationnelle entièrement géré et compatible ACID qui vous aide à configurer, exploiter et dimensionner les déploiements PostgreSQL. **Autres services** + [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) est un environnement de développement intégré qui simplifie le développement et la gestion des bases de données Oracle dans les déploiements traditionnels et basés sur le cloud. + [pgAdmin](https://www.pgadmin.org/) est un outil de gestion open source pour PostgreSQL. Il fournit une interface graphique qui vous permet de créer, de gérer et d'utiliser des objets de base de données. ## Bonnes pratiques Assurez-vous que le type de données que vous créez correspond aux champs de type inclus dans la fonction ou procédure Oracle source. ## Épopées ### Exécuter une fonction ou une procédure Oracle comportant plus de 100 arguments | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez ou identifiez une Oracle/PLSQL fonction ou une procédure existante comportant plus de 100 arguments. | Créez une Oracle/PLSQL fonction ou une procédure comportant plus de 100 arguments.-ou-Identifiez une Oracle/PLSQL fonction ou une procédure existante comportant plus de 100 arguments.Pour plus d'informations, consultez les sections [14.7 Instruction CREATE FUNCTION et 14.11 Instruction](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/lnpls/CREATE-FUNCTION-statement.html#GUID-B71BC5BD-B87C-4054-AAA5-213E856651F2) [CREATE PROCEDURE de la documentation](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/lnpls/CREATE-PROCEDURE-statement.html#GUID-5F84DB47-B5BE-4292-848F-756BF365EC54) de la base de données Oracle. | Connaissances d'Oracle/PLSQL | | Compilez la Oracle/PLSQL fonction ou la procédure. | Compilez la Oracle/PLSQL fonction ou la procédure.Pour plus d'informations, consultez la section [Compilation d'une fonction](https://docs.oracle.com/cd/E37097_01/doc.42/e35128/GUID-6B7B6F82-616D-4915-82BE-D4AE7F59CF37.htm#AEUTL165) dans la documentation de la base de données Oracle. | Connaissances d'Oracle/PLSQL | | Exécutez la Oracle/PLSQL fonction. | Exécutez la Oracle/PLSQL fonction ou la procédure. Enregistrez ensuite le résultat. | Connaissances d'Oracle/PLSQL | ### Définissez un nouveau type de données qui correspond aux arguments de la fonction ou de la procédure source | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Définissez un nouveau type de données dans PostgreSQL. | Définissez un nouveau type de données dans PostgreSQL qui inclut tous les mêmes champs que ceux qui apparaissent dans les arguments de la fonction ou de la procédure Oracle source.Pour plus d'informations, consultez [CREATE TYPE](https://www.postgresql.org/docs/current/sql-createtype.html) dans la documentation de PostgreSQL. | Connaissances de PostgreSQL PL/pgSQL | ### Créez une fonction PostgreSQL qui inclut le nouvel argument TYPE | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une fonction PostgreSQL qui inclut le nouveau type de données. | Créez une fonction PostgreSQL qui inclut le nouvel argument. `TYPE`Pour consulter un exemple de fonction, consultez la section **Informations supplémentaires** de ce modèle. | Connaissances de PostgreSQL PL/pgSQL | | Compilez la fonction PostgreSQL. | Compilez la fonction dans PostgreSQL. Si les nouveaux champs de type de données correspondent aux arguments de la fonction source ou de la procédure, la fonction se compile correctement. | Connaissances de PostgreSQL PL/pgSQL | | Exécutez la fonction PostgreSQL. | Exécutez la fonction PostgreSQL. | Connaissances de PostgreSQL PL/pgSQL | ## Résolution des problèmes | Problème | Solution | | --- | --- | | La fonction renvoie l'erreur suivante :**ERREUR : erreur de syntaxe à proximité de « »**
hdbnsutil -sr_enable --name=siteA| Administration de SAP Basis | | Enregistrez la base de données SAP HANA cible en tant que système secondaire. | Pour enregistrer la base de données SAP HANA cible en tant que système secondaire à utiliser comme source pour SAP HSR, choisissez la réplication **asynchrone**.
(sid)adm $> HDB stopVous pouvez également choisir l'`–online`option d'enregistrement. Dans ce cas, il n'est pas nécessaire d'arrêter et de démarrer la base de données SAP HANA. | Administration de SAP Basis | | Validez la synchronisation. | Sur la base de données SAP HANA source, vérifiez que tous les journaux sont appliqués au système cible (car il s'agit d'une réplication asynchrone).Pour vérifier la réplication, exécutez les commandes suivantes sur la source.
(sid)adm $> hdbnsutil -sr_register –name=siteB –remotehost=hdbhost /
--remoteInstance=00 –replicationMode=async –operationMode=logreplay
(sid)adm $> HDB start
(sid)adm $> cdpy| Administration de SAP Basis | | Arrêtez l'application SAP source et la base de données SAP HANA. | Pendant le passage à la migration, arrêtez le système source (l'application SAP et la base de données SAP HANA). | Administration de SAP Basis | | Effectuez une prise de contrôle sur la cible. | Pour effectuer une prise de contrôle sur la cible sur AWS, exécutez la commande`hdbnsutil -sr_takeover`. | Administration de SAP Basis | | Sur la base de données SAP HANA cible, désactivez la réplication. | Pour effacer les métadonnées de réplication, arrêtez la réplication sur le système cible en exécutant la commande`hdbnsutil -sr_disable`. Ceci est conforme à la note SAP 2693441 — Impossible de renommer un système SAP HANA en raison d'une erreur. | Administration de SAP Basis | | Sauvegardez la base de données SAP HANA cible. | Une fois le rachat réussi, nous vous recommandons d'effectuer une sauvegarde complète de la base de données SAP HANA. | Administration de SAP Basis | ### Revenir au nom d'hôte d'origine dans le système cible | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Rétablissez le nom d'hôte de la base de données SAP HANA cible à l'original. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-sap-hana-to-aws-using-sap-hsr-with-the-same-hostname.html)Vous pouvez valider d'autres options selon vos besoins. Veillez toutefois à ne pas confondre le changement de nom d'hôte avec un changement de SID (Note SAP 2598814 — hdblcm : échec du changement de nom du SID). | Administration de SAP Basis | | Ajustez hdbuserstore. | Adaptez les `hdbuserstore` détails pointant vers les `schema/user` détails de la source. Pour connaître les étapes détaillées, consultez la [documentation SAP](https://help.sap.com/viewer/b3ee5778bc2e4a089d3299b82ec762a7/2.0.02/en-US/ddbdd66b632d4fe7b3c2e0e6e341e222.html?q=hdbuserstore). Pour valider cette étape, exécutez la commande`R3trans -d`. Le résultat doit refléter une connexion réussie à la base de données SAP HANA. | Administration de SAP Basis | | Démarrez les connexions client. | Dans l'environnement cible, démarrez les serveurs d'applications SAP et les autres connexions client. | Administration de SAP Basis | ## Ressources connexes **Références SAP** Les références de documentation SAP sont fréquemment mises à jour par SAP. Pour rester à jour, consultez la note SAP 2407186 intitulée Guides pratiques et livres blancs pour la haute disponibilité de SAP HANA. *Remarques SAP supplémentaires* + 2550327 — Comment renommer un système SAP HANA + 1999880 — FAQ : réplication du système SAP HANA + 2078425 — Note de dépannage concernant l'outil de gestion du cycle de vie de la plateforme SAP HANA hdblcm + 2592227 — Modification du suffixe FQDN dans les systèmes HANA + 2048681 — Exécution de tâches d'administration de gestion du cycle de vie de la plateforme SAP HANA sur des systèmes à hôtes multiples sans informations d'identification SSH ou root *Documents SAP* + [Connexion réseau de réplication du système](https://help.sap.com/docs/SAP_HANA_PLATFORM/4e9b18c116aa42fc84c7dbfd02111aba/47190b425eb1433697b026ecd46ff5f9.html) + [Résolution du nom d'hôte pour la réplication du système](https://help.sap.com/viewer/eb3777d5495d46c5b2fa773206bbfb46/1.0.12/en-US/c0cba1cb2ba34ec89f45b48b2157ec7b.html) **AWS références** + [Migration de SAP HANA depuis d'autres plateformes vers AWS](https://docs.aws.amazon.com/sap/latest/sap-hana/migrating-hana-hana-to-aws.html) ## Informations supplémentaires Les modifications effectuées dans le `hdblcm` cadre de l'activité de changement de nom d'hôte sont consolidées dans le journal détaillé suivant. ![\[Code montrant les processus arrêtés sur l'hôte temporaire, démarrant sur hdbhost, et renommé du système de base de données SAP HANA.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/004781c1-96df-43dd-a52e-ed1db5bdf9ef/images/9e0c11ca-6555-484f-9639-107f60f725f5.png) # Migrez le groupe de disponibilité Microsoft SQL Server Always On à l'aide de AWS Application Migration Service *Sreenivas Nettem, Bharath Kumar Pammi Ramesh, Anantharaman Seshadri et Gireesh Sreekantan, Amazon Web Services* ## Résumé AWS Application Migration Service (AWS MGN) est un outil privilégié pour réhéberger les environnements existants dans le AWS Cloud, ce qui permet aux clients de s'éloigner des centres de données sur site. Ce modèle décrit le processus d'utilisation de AWS MGN pour migrer des clusters Windows avec des groupes de disponibilité Microsoft SQL Server Always On. ## Conditions préalables et limitations **Conditions préalables** + Un actif Compte AWS. + Un rôle Gestion des identités et des accès AWS (IAM) pour l'orchestration AWS MGN. + Accès aux serveurs de base de données source (groupe de disponibilité SQL Server Always On). + Active Directory dans une zone de AWS landing zone pour conserver les noms DNS. + Sous-réseau intermédiaire avec communication réseau fermée avec Active Directory. + Ciblez des sous-réseaux capables de communiquer avec Active Directory. + Deux adresses IP réservées pour le cluster Windows dans un sous-réseau cible (une dans chaque zone de disponibilité). + Deux adresses IP réservées pour l'écouteur SQL Always On dans un sous-réseau cible (une dans chaque zone de disponibilité). **Versions du produit** + Windows Server 2012 ou version ultérieure + SQL Server 2012 ou version ultérieure ## Architecture **Pile technologique source** Cluster Microsoft Windows (machine physique ou virtuelle sur site) Groupe de disponibilité Microsoft SQL Server Always On **Pile technologique cible** Instance Amazon EC2 Windows **Architecture cible** ![\[Architecture AWS pour la migration de SQL Server Always On Availability à l'aide d'AWS MGN.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/aa94040b-5ecf-42f9-90e3-929d0fa5e715/images/0b85c613-51df-475b-9598-3da3f9cd47c6.png) ## Outils *Services AWS* + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) fournit une capacité de calcul évolutive dans le AWS Cloud. Vous pouvez lancer autant de serveurs virtuels que vous le souhaitez et les augmenter ou les diminuer rapidement. + [AWS Application Migration Service](https://docs.aws.amazon.com/mgn/latest/ug/what-is-application-migration-service.html)vous permet de réhéberger (transférer et déplacer) des applications vers le site AWS Cloud sans modification et avec un minimum de temps d'arrêt. + [Gestion des identités et des accès AWS (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) vous aide à gérer en toute sécurité l'accès à vos AWS ressources en contrôlant qui est authentifié et autorisé à les utiliser. *Autres outils* + [Microsoft SQL Server Management Studio (SSMS)](https://learn.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms) est un outil de gestion de SQL Server, y compris l'accès, la configuration et l'administration des composants de SQL Server. ## Bonnes pratiques Pour AWS MGN, voir [Meilleures pratiques pour AWS Application Migration Service](https://docs.aws.amazon.com/mgn/latest/ug/best_practices_mgn.html). ## Épopées ### Préparez le compte cible | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Initialisez AWS MGN. | Initialisez AWS MGN dans la cible. Région AWS Cela crée les rôles et les politiques IAM requis. Pour plus d'informations, voir [Initialisation du service de migration d'applications avec la console.](https://docs.aws.amazon.com/mgn/latest/ug/mgn-initialize-console.html) | Administrateur du cloud | | Créez des modèles de réplication et de lancement. | Configurez les modèles de réplication et de lancement à utiliser avec AWS MGN. Pour plus d'informations, consultez [la section Configuration des modèles](https://docs.aws.amazon.com/mgn/latest/ug/mgn-initialization-templates.html) dans la AWS documentation. | Administrateur du cloud | | Autorisez les ports de communication. | Pour activer les communications réseau pour AWS MGN, autorisez le trafic sur les ports TCP 443 et 1500. Pour plus d'informations, consultez la section [Configuration réseau requise pour le service de migration d'applications](https://docs.aws.amazon.com/mgn/latest/ug/Network-Requirements.html) dans la AWS documentation. | Administrateur cloud, administrateur réseau | ### Préparer le serveur source | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Vérifiez les prérequis AWS MGN. | Vérifiez que les serveurs source répondent aux conditions requises pour l'installation de l'agent AWS MGN. Pour plus d'informations, consultez la section [Exigences d'installation](https://docs.aws.amazon.com/mgn/latest/ug/installation-requirements.html) dans la AWS documentation. | Ingénieur en migration | | Installez l'agent AWS MGN. | Installez l'agent AWS MGN sur les serveurs sources. Au cours de l'installation, choisissez l' Région AWS endroit où les serveurs seront migrés. Après l'installation, l'agent communique avec le service et lance la réplication. Pour plus d'informations, consultez la section [Installation de l'agent de AWS réplication sur les serveurs Windows](https://docs.aws.amazon.com/mgn/latest/ug/windows-agent.html). | Ingénieur en migration | | Vérifiez l'état du serveur source. | Dans la console AWS MGN, vérifiez l'état des serveurs sources. Les serveurs affichent « **Prêt pour les tests** » lorsque la réplication commence.Si vous rencontrez des erreurs, consultez la section [Résolution des erreurs de communication](https://docs.aws.amazon.com/mgn/latest/ug/Troubleshooting-Communication-Errors.html) dans la documentation AWS MGN. | Administrateur cloud, ingénieur en migration | | Optimisez les paramètres de réplication. | Les clusters SQL Always On utilisent une réplication I/O synchrone élevée entre le serveur principal et le serveur secondaire. Pour optimiser la réplication et éviter les retards, utilisez un [serveur de réplication dédié](https://docs.aws.amazon.com/mgn/latest/ug/replication-settings-template.html) pour chaque serveur SQL Always On.**Si la taille de la base de données est supérieure à 5 To, envisagez de choisir une instance de serveur de réplication de plus grande taille, telle que **m5.large**, au lieu de t3.small par défaut.** | Administrateur cloud, ingénieur en migration | | Mettre à jour le modèle de lancement. | Mettez à jour les [paramètres de lancement](https://docs.aws.amazon.com/mgn/latest/ug/launch-settings.html) et choisissez des sous-réseaux pour les serveurs SQL Always On. Les serveurs de cluster SQL Always On sont répartis sur différents serveurs AWS Zones de disponibilité pour une haute disponibilité. | Ingénieur en migration, responsable de la migration | | Mettez à jour les paramètres de lancement. | En fonction de votre taille et de vos exigences en matière de performances, mettez à jour le type d'instance et les input/output opérations par seconde (IOPS) dans les paramètres de lancement.(Facultatif) Choisissez une interface Elastic network existante dans les paramètres de lancement. | Ingénieur en migration, responsable de la migration | ### Test de transition | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Vérifiez les serveurs sources. | Dans la console AWS MGN, vérifiez que l'état du serveur source est **Prêt pour le test**. | Administrateur cloud, ingénieur en migration | | Lancez les instances de test. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | Administrateur cloud, ingénieur en migration | | Testez la connectivité et l'intégrité de la base de données. | Testez la connectivité et l'intégrité de la base de données des instances de test. Marquez ensuite les serveurs sources comme étant **prêts pour le passage dans** la console AWS MGN. | Administrateur cloud, ingénieur en migration | ### Tâches préalables à la migration | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Testez l'intégrité de la base de données. | Cela permet de garantir l'absence de problèmes d'intégrité de la base de données à la source avant la migration. Exécutez `DBCC CHECKDB` et spécifiez`WITH_PHYSICAL_ONLY`. L'exécution de cette vérification sans `WITH_PHYSICAL_ONLY` risque d'entraîner des problèmes de performances à la source. Pour préserver l'intégrité de la base de données, effectuez une vérification complète hebdomadaire de la base de données.Ces commandes vérifient l'intégrité logique et physique de la base de données en détectant les problèmes de corruption potentiels. La vérification vérifie la structure de la base de données, telle que les pages, les lignes, les index et les tables système. | Ingénieur de données, DBA | | Testez les connexions aux serveurs liés. | Testez les connexions entre tous les serveurs existants et documentez leur état. Cela permet de garantir que les serveurs liés fonctionnent comme prévu après la migration. | Ingénieur de données, DBA | | Vérifiez les sauvegardes. | Vérifiez l'intégrité des sauvegardes sources. | Ingénieur de données, DBA | ### AWS Découpe MGN | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Arrêtez le SQL Server et les services de cluster. | Arrêtez les services de cluster SQL Server et Microsoft sur tous les nœuds de cluster SQL. | DBA, ingénieur en migration | | Vérifiez les serveurs. | **Dans la console AWS MGN, vérifiez que l'état des serveurs sources est « **Prêt pour le passage » et que l'état de** réplication des données est « Sain ».** | Ingénieur en migration | | Lancez le cutover. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html)Pour plus d'informations, consultez la section [Lancement d'une instance de transition](https://docs.aws.amazon.com/mgn/latest/ug/launch-cutover-gs.html) dans la documentation AWS MGN. | Ingénieur en migration | | Testez les serveurs lancés. | Connectez-vous aux EC2 instances Amazon lancées et validez l'état du cluster. Vérifiez que les serveurs se trouvent dans les sous-réseaux appropriés, que la taille de l'instance et les paramètres d'IOPS sont corrects et que le serveur témoin est accessible. | DBA, ingénieur en migration | ### Tâches de base de données après le transfert | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Mettez à jour l'adresse IP du cluster. | Mettez à jour l'adresse IP du cluster Windows à l'aide des deux adresses IP réservées dans les sous-réseaux cibles. Pour plus d'informations, consultez [Modifier l'adresse IP d'une instance de cluster Failover](https://learn.microsoft.com/en-us/sql/sql-server/failover-clusters/windows/change-the-ip-address-of-a-failover-cluster-instance?view=sql-server-2016). | DBA, ingénieur en migration | | Mettez à jour l'écouteur IPs du groupe de disponibilité Always On. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | DBA, ingénieur en migration | | Vérifiez la connexion. | À l'aide de SSMS, connectez-vous à l'écouteur du groupe de disponibilité Always On et vérifiez que la connexion est réussie. | DBA, ingénieur en migration | | Vérifiez l'état du groupe de disponibilité Always On. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | DBA, ingénieur en migration | | Consultez le journal des erreurs. | Ouvrez le journal des erreurs et vérifiez les erreurs signalées pour l'instance de SQL Server. Assurez-vous que la restauration est terminée pour toutes les bases de données. | DBA, ingénieur en migration | | Testez les serveurs liés. | Testez la connectivité de tous les serveurs connectés. En cas de problème de connectivité, assurez-vous que le serveur et le port cibles sont accessibles. | DBA, ingénieur en migration | ### Finaliser le découpage | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Finalisez le découpage. | Après avoir validé les clusters SQL Always On cibles, [finalisez](https://docs.aws.amazon.com/mgn/latest/ug/launch-cutover-gs.html#revert-finalize-cutover-gs) le transfert via la AWS console MGN. Cela arrête la réplication des données depuis les serveurs sources et supprime les données du serveur de réplication. Il supprime également le serveur de réplication et ses ressources associées. | Administrateur cloud, ingénieur en migration | ## Résolution des problèmes | Problème | Solution | | --- | --- | | AWS Dépannage MGN | Pour connaître les problèmes courants et les solutions, consultez les sections [Dépannage](https://docs.aws.amazon.com/mgn/latest/ug/troubleshooting.html) et [FAQ](https://docs.aws.amazon.com/mgn/latest/ug/FAQ.html) de la documentation AWS MGN. | ## Ressources connexes *AWS resources* + [Option 1 Réhébergement - () 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'est-ce que c'est AWS Application Migration Service ?](https://docs.aws.amazon.com/mgn/latest/ug/what-is-application-migration-service.html) *Ressources SQL Server* + [Qu'est-ce que SQL Server Management Studio (SSMS) ?](https://learn.microsoft.com/en-us/ssms/sql-server-management-studio-ssms) ## Informations supplémentaires Pour connaître les exigences de sécurité standard relatives à la migration des charges de travail vers le AWS Cloud, consultez les [meilleures pratiques en matière de sécurité, d'identité et de conformité](https://aws.amazon.com/architecture/security-identity-compliance/) sur le AWS site Web. # Migrer SQL Server vers AWS à l'aide de groupes de disponibilité distribués *Praveen Marthala, Amazon Web Services* ## Résumé Les groupes de disponibilité Microsoft SQL Server Always On fournissent une solution de haute disponibilité (HA) et de reprise après sinistre (DR) pour SQL Server. Un groupe de disponibilité se compose d'un réplica principal qui accepte read/write le trafic et d'un maximum de huit répliques secondaires qui acceptent le trafic de lecture. Un groupe de disponibilité est configuré sur un cluster Windows Server Failover (WSFC) comportant au moins deux nœuds. Les groupes de disponibilité distribués Microsoft SQL Server Always On fournissent une solution pour configurer deux groupes de disponibilité distincts entre deux groupes indépendants WFSCs. Les groupes de disponibilité qui font partie du groupe de disponibilité distribué ne doivent pas nécessairement se trouver dans le même centre de données. L'un des groupes de disponibilité peut se trouver sur site, tandis que l'autre groupe de disponibilité peut se trouver sur le cloud Amazon Web Services (AWS) sur des instances Amazon Elastic Compute Cloud (Amazon EC2) d'un domaine différent. Ce modèle décrit les étapes d'utilisation d'un groupe de disponibilité distribué pour migrer des bases de données SQL Server locales faisant partie d'un groupe de disponibilité existant vers SQL Server avec des groupes de disponibilité configurés sur Amazon EC2. En suivant ce modèle, vous pouvez migrer les bases de données vers le cloud AWS avec un temps d'arrêt minimal lors de la transition. Les bases de données sont hautement disponibles sur AWS immédiatement après le passage. Vous pouvez également utiliser ce modèle pour faire passer le système d'exploitation sous-jacent sur site à AWS tout en conservant la même version de SQL Server. ## Conditions préalables et limitations **Conditions préalables** + Un compte AWS actif + AWS Direct Connect ou AWS Site-to-Site VPN + La même version de SQL Server installée sur site et sur les deux nœuds d'AWS **Versions du produit** + SQL Server version 2016 et versions ultérieures + SQL Server Enterprise Edition ## Architecture **Pile technologique source** + Base de données Microsoft SQL Server avec groupes de disponibilité Always On sur site **Pile technologique cible** + Base de données Microsoft SQL Server avec groupes de disponibilité Always On sur Amazon EC2 sur le cloud AWS **Architecture de migration** ![\[SQL Server avec réplication synchrone dans les groupes de disponibilité sur site et sur AWS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/6e229e30-9b11-4ccb-bccd-cbe6601139c0/images/79ee7911-d68f-4db7-9b94-113dcf09c28b.png) *Terminologie* + WSFC 1 — WSFC sur site + WSFC 2 — WSFC sur le cloud AWS + AG 1 — Premier groupe de disponibilité, qui se trouve dans WSFC 1 + AG 2 — Deuxième groupe de disponibilité, qui se trouve dans WSFC 2 + Réplique principale de SQL Server : nœud dans AG 1 considéré comme le principal global pour toutes les écritures + Redirecteur SQL Server : nœud dans AG 2 qui reçoit des données de manière asynchrone à partir de la réplique principale de SQL Server + Réplique secondaire de SQL Server : nœuds d'AG 1 ou AG 2 qui reçoivent des données de manière synchrone en provenance de la réplique principale ou du redirecteur ## Outils + [AWS Direct Connect](https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html) — AWS Direct Connect relie votre réseau interne à un site AWS Direct Connect via un câble Ethernet à fibre optique standard. Grâce à cette connexion, vous pouvez créer des *interfaces virtuelles* directement vers les services AWS publics, en contournant les fournisseurs de services Internet sur votre chemin réseau. + [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/concepts.html) — Amazon Elastic Compute Cloud (Amazon EC2) fournit une capacité de calcul évolutive dans le cloud AWS. Vous pouvez utiliser Amazon EC2 pour lancer autant ou aussi peu de serveurs virtuels que vous le souhaitez, et vous pouvez les étendre ou les intégrer. + [ Site-to-SiteVPN AWS — Le](https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html) Site-to-Site VPN AWS prend en charge la création d'un réseau privé site-to-site virtuel (VPN). Vous pouvez configurer le VPN pour transmettre le trafic entre les instances que vous lancez sur AWS et votre propre réseau distant. + [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) est un environnement intégré de gestion de l'infrastructure SQL Server. Il fournit une interface utilisateur et un groupe d'outils dotés d'éditeurs de script riches qui interagissent avec SQL Server. ## Épopées ### Configurer un deuxième groupe de disponibilité sur AWS | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un WSFC sur AWS. | Créez des EC2 instances WSFC 2 sur Amazon avec deux nœuds pour HA. Vous utiliserez ce cluster de basculement pour créer le deuxième groupe de disponibilité (AG 2) sur AWS. | Administrateur système, SysOps administrateur | | Créez le deuxième groupe de disponibilité sur WSFC 2. | À l'aide de SSMS, créez AG 2 sur deux nœuds dans WSFC 2. Le premier nœud de WSFC 2 fera office de redirecteur. Le deuxième nœud de WSFC 2 servira de réplique secondaire d'AG 2.À ce stade, aucune base de données n'est disponible dans AG 2. Il s'agit du point de départ pour configurer le groupe de disponibilité distribué. | DBA, Développeur | | Créez des bases de données sans option de restauration sur AG 2. | Sauvegardez les bases de données du groupe de disponibilité sur site (AG 1). Restaurez les bases de données à la fois sur le redirecteur et sur la réplique secondaire d'AG 2 sans option de restauration. Lors de la restauration des bases de données, spécifiez un emplacement avec suffisamment d'espace disque pour les fichiers de données de base de données et les fichiers journaux.À ce stade, les bases de données sont en état de restauration. Ils ne font pas partie de l'AG 2 ou du groupe de disponibilité distribuée, et ils ne se synchronisent pas. | DBA, Développeur | ### Configuration du groupe de disponibilité distribué | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez le groupe de disponibilité distribué sur AG 1. | Pour créer le groupe de disponibilité distribué sur AG 1, utilisez l'`DISTRIBUTED`option `CREATE AVAILABILITY GROUP` avec.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html) | DBA, Développeur | | Créez le groupe de disponibilité distribuée sur AG 2. | Pour créer le groupe de disponibilité distribué sur AG 2, utilisez-le `ALTER AVAILABILITY GROUP` avec l'`DISTRIBUTED`option.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html)Le groupe de disponibilité distribuée est créé entre AG 1 et AG 2.Les bases de données d'AG 2 ne sont pas encore configurées pour participer au flux de données d'AG 1 vers AG 2. | DBA, Développeur | | Ajoutez des bases de données au redirecteur et à la réplique secondaire sur AG 2. | Ajoutez les bases de données au groupe de disponibilité distribuée en utilisant l'`SET HADR``AVAILABILITY GROUP`option `ALTER DATABASE` à la fois dans le redirecteur et dans la réplique secondaire sur AG 2. Cela lance un flux de données asynchrone entre les bases de données sur AG 1 et AG 2. Le primaire global prend des écritures, envoie des données de manière synchrone à la réplique secondaire sur AG 1 et envoie des données de manière asynchrone au redirecteur sur AG 2. Le redirecteur sur AG 2 envoie des données de manière synchrone à la réplique secondaire sur AG 2. | DBA, Développeur | ### Surveillez le flux de données asynchrone entre AG 1 et AG 2 | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | DMVs Journaux d'utilisation et de SQL Server. | Surveillez l'état du flux de données entre deux groupes de disponibilité à l'aide de vues de gestion dynamiques (DMVs) et de journaux SQL Server. DMVs qui présentent un intérêt pour le suivi incluent `sys.dm_hadr_availability_replica_states` et`sys.dm_hadr_automatic_seeding`.Pour connaître l'état de la synchronisation du redirecteur, surveillez l'*état synchronisé* dans le journal SQL Server du redirecteur. | DBA, Développeur | ### Réaliser des activités de transition pour la migration finale | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Arrêtez tout le trafic vers le réplica principal. | Arrêtez le trafic entrant vers le réplica principal dans AG 1 afin qu'aucune activité d'écriture ne se produise sur les bases de données et que celles-ci soient prêtes pour la migration. | Propriétaire de l'application, développeur | | Modifiez le mode de disponibilité du groupe de disponibilité distribué sur AG 1. | Sur le réplica principal, définissez le mode de disponibilité du groupe de disponibilité distribué sur synchrone. Une fois que vous avez changé le mode de disponibilité en mode synchrone, les données sont envoyées de manière synchrone depuis la réplique principale dans AG 1 vers le redirecteur dans AG 2. | DBA, Développeur | | Vérifiez le LSNs dans les deux groupes de disponibilité. | Vérifiez les derniers numéros de séquence log (LSNs) dans AG 1 et AG 2. Aucune écriture n'ayant lieu dans le réplica principal d'AG 1, les données sont synchronisées et les derniers groupes LSNs de disponibilité doivent correspondre. | DBA, Développeur | | Mettez AG 1 à jour avec le rôle secondaire. | Lorsque vous mettez à jour AG 1 vers le rôle secondaire, AG 1 perd le rôle de réplique principal et n'accepte pas les écritures, et le flux de données entre deux groupes de disponibilité s'arrête. | DBA, Développeur | ### Basculer vers le deuxième groupe de disponibilité | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Basculez manuellement vers AG 2. | Sur le redirecteur d'AG 2, modifiez le groupe de disponibilité distribuée pour permettre la perte de données. Comme vous avez déjà vérifié et confirmé que les dernières données LSNs sur AG 1 et AG 2 correspondent, la perte de données n'est pas un problème.Lorsque vous autorisez la perte de données sur le transitaire dans AG 2, les rôles de AG 1 et AG 2 changent :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html) | DBA, Développeur | | Modifiez le mode de disponibilité du groupe de disponibilité distribué sur AG 2. | Sur la réplique principale dans AG 2, changez le mode de disponibilité en mode asynchrone.Cela fait passer le mouvement des données d'AG 2 à AG 1, de synchrone à asynchrone. Cette étape est nécessaire pour éviter le temps de latence du réseau entre AG 2 et AG 1, le cas échéant, et n'aura aucun impact sur les performances de la base de données. | DBA, Développeur | | Commencez à envoyer du trafic vers le nouveau réplica principal. | Mettez à jour la chaîne de connexion pour utiliser le point de terminaison URL de l'écouteur sur AG 2 pour envoyer du trafic aux bases de données.AG 2 accepte désormais les écritures et envoie des données au redirecteur dans AG 1, ainsi que l'envoi de données vers sa propre réplique secondaire dans AG 2. Les données se déplacent de manière asynchrone d'AG 2 à AG 1. | Propriétaire de l'application, développeur | ### Réaliser des activités après le passage au poste | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Supprimez le groupe de disponibilité distribuée sur AG 2. | Surveillez la migration pendant la durée prévue. Supprimez ensuite le groupe de disponibilité distribué sur AG 2 pour supprimer la configuration du groupe de disponibilité distribué entre AG 2 et AG 1. Cela supprime la configuration du groupe de disponibilité distribué et le flux de données entre AG 2 et AG 1 s'arrête. À ce stade, AG 2 est hautement disponible sur AWS, avec une réplique principale qui prend des écritures et une réplique secondaire dans le même groupe de disponibilité. | DBA, Développeur | | Mettez hors service les serveurs locaux. | Mettez hors service les serveurs locaux de WSFC 1 qui font partie d'AG 1. | Administrateur système, SysOps administrateur | ## Ressources connexes + [Groupes de disponibilité distribués](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-sql-server/distributed-groups.html) + [SQL Docs : groupes de disponibilité distribués](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/distributed-availability-groups?view=sql-server-ver15) + [SQL Docs : Groupes de disponibilité Always On : une solution de haute disponibilité et de reprise après sinistre](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/always-on-availability-groups-sql-server?view=sql-server-ver15) # Migrer une base de données relationnelle vers MongoDB Atlas sur AWS *Battulga Purevragchaa et Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Résumé Ce modèle décrit les étapes de migration d'une base de données relationnelle telle que SQL Server, MySQL ou PostgreSQL vers MongoDB Atlas dans le. AWS Cloud Il utilise [MongoDB Relational Migrator pour accélérer la migration](https://www.mongodb.com/products/relational-migrator) des données des bases de données relationnelles vers MongoDB Atlas. Le modèle accompagne le guide [Migrating to MongoDB Atlas AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) sur le site Web de Prescriptive AWS Guidance. Il fournit les étapes de mise en œuvre de l'un des scénarios de migration décrits dans ce guide. Pour d'autres scénarios de migration, consultez les modèles suivants sur le site Web des directives AWS prescriptives : + [Migrer un environnement MongoDB auto-hébergé vers MongoDB Atlas sur AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud.html) + [Diffusez des données depuis IBM Db2, SAP, Sybase et d'autres bases de données vers MongoDB Atlas sur AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/stream-data-from-ibm-db2-to-mongodb-atlas.html) Le modèle est destiné aux [partenaires et aux AWS utilisateurs d'AWS System Integrator (SI)](https://aws.amazon.com/managed-services/partners/). ## Conditions préalables et limitations **Conditions préalables** + Une base de données relationnelle source (base de données Oracle, SQL Server, PostgreSQL, SAP/Sybase MySQL, ASE, etc.) à migrer vers MongoDB Atlas. + Familiarité avec les bases de données relationnelles, MongoDB Atlas et. Services AWS Ce schéma explique certaines des étapes de migration à un niveau élevé. Des informations supplémentaires seront ajoutées dans les futures versions. **Versions du produit** + MongoDB version 5.0 ou ultérieure ## Architecture Le schéma suivant montre la migration d'une base de données du système de gestion de base de données relationnelle (RDBMS) vers MongoDB Atlas on. AWS ![\[Architecture pour la migration d'un RDBMS vers MongoDB Atlas sur AWS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/4e3ea0f1-21e8-4641-a9ee-732355f20baf/images/8eacf3ec-f480-4912-9002-6a50800fe9bf.png) Pour les architectures de référence de MongoDB Atlas qui prennent en charge différents scénarios d'utilisation, consultez la section [Migration vers MongoDB Atlas AWS sur](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) le site Web des directives prescriptives. AWS ## Outils + [MongoDB Atlas](https://www.mongodb.com/atlas) est une base de données en tant que service (DBaaS) entièrement gérée pour le déploiement et la gestion des bases de données MongoDB dans le cloud. + [MongoDB Relational Migrator](https://www.mongodb.com/products/relational-migrator) assure une transition fluide des données des bases de données relationnelles traditionnelles vers MongoDB. Il permet d'automatiser le processus de conversion et de transformer le modèle de données structuré des bases de données relationnelles dans le format de document flexible fourni par MongoDB. Le Relational Migrator préserve l'intégrité des données et les relations afin de simplifier la migration. Organisations peuvent tirer parti des avantages d'évolutivité, de performance et de polyvalence fournis par MongoDB tout en préservant la familiarité de leurs données existantes. ## Bonnes pratiques Pour connaître les meilleures pratiques relatives à l'utilisation de MongoDB sur AWS, consultez les articles publiés sur le blog du [AWS Partner Network](https://aws.amazon.com/blogs/apn/tag/mongodb-atlas/). ## Épopées ### Découverte et évaluation | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Déterminez les paramètres et la taille de la base de données relationnelle. | Estimez la taille de l'ensemble de travail en utilisant les recommandations du Relational Migrator et les informations provenant de l'`db.stats()`espace d'index total. Supposons qu'un pourcentage de votre espace de données soit fréquemment consulté. Cette tâche devrait prendre environ une semaine. Pour plus d'informations et des exemples concernant cette histoire et les autres de cette épopée, consultez la section [Ressources connexes](#migrate-relational-database-to-mongodb-atlas-resources). | Propriétaire de l'application, DBA | | Estimez les besoins en bande passante du réseau. | Pour estimer les besoins en bande passante de votre réseau, multipliez la taille moyenne des documents par le nombre de documents servis par seconde. Tenez compte du trafic maximal que chaque nœud de votre cluster pourra supporter comme base. Pour calculer les taux de transfert de données en aval de votre cluster vers les applications clientes, utilisez la somme du total des documents renvoyés sur une période donnée. Si vos applications lisent à partir de nœuds secondaires, divisez le nombre total de documents par le nombre de nœuds pouvant effectuer des opérations de lecture. Pour connaître la taille moyenne des documents d'une base de données, utilisez la `db.stats().avgObjSize` commande. Cette tâche prend généralement une journée. | DBA | | Sélectionnez le niveau Atlas. | Suivez les instructions de la [documentation MongoDB](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) pour sélectionner le niveau de cluster Atlas approprié. | DBA | | Planifiez le transfert. | Planifiez le transfert des applications. | DBA, propriétaire de l'application | ### Configurez un nouvel environnement MongoDB Atlas sur AWS | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un nouveau cluster MongoDB Atlas sur. AWS | Dans MongoDB Atlas, choisissez **Build a Cluster**. Dans la boîte de dialogue **Créer un nouveau cluster**, sélectionnez AWS comme fournisseur de cloud. | DBA | | Sélectionnez Régions AWS une configuration globale du cluster. | Sélectionnez dans la liste des options disponibles Régions AWS pour votre cluster Atlas. Configurez des clusters globaux si nécessaire. | DBA | | Sélectionnez le niveau du cluster. | Sélectionnez le niveau de cluster de votre choix. Le choix du niveau détermine des facteurs tels que la mémoire, le stockage et les spécifications d'IOPS. | DBA | | Configurez des paramètres de cluster supplémentaires. | Configurez des paramètres de cluster supplémentaires tels que la version de MongoDB, les options de sauvegarde et de chiffrement. Pour plus d'informations sur ces options, consultez la section [Ressources connexes](#migrate-relational-database-to-mongodb-atlas-resources). | DBA | ### Configuration de la sécurité et de la conformité | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Configurez la liste d'accès. | Pour vous connecter au cluster Atlas, vous devez ajouter une entrée à la liste d'accès du projet. Atlas TLS/SSL crypte les connexions au cloud privé virtuel (VPC) pour votre base de données. Pour configurer la liste d'accès au projet et pour plus d'informations sur les histoires de cette épopée, consultez la section [Ressources connexes](#migrate-relational-database-to-mongodb-atlas-resources). | DBA | | Authentifiez et autorisez les utilisateurs. | Vous devez créer et authentifier les utilisateurs de base de données qui accèderont aux clusters MongoDB Atlas. Pour accéder aux clusters d'un projet, les utilisateurs doivent appartenir à ce projet, et ils peuvent appartenir à plusieurs projets. | DBA | | Créez des rôles personnalisés. | (Facultatif) Atlas prend en charge la création de rôles personnalisés dans les cas où les autorisations utilisateur de la base de données Atlas intégrées ne couvrent pas l'ensemble des autorisations que vous souhaitez. | DBA | | Configurez le peering VPC. | (Facultatif) Atlas prend en charge le [peering VPC avec d'autres options](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html). VPCs AWS | Administrateur AWS | | Configurez un AWS PrivateLink point de terminaison. | (Facultatif) Vous pouvez configurer des points de terminaison privés AWS en utilisant AWS PrivateLink. Pour plus d'informations, consultez la [documentation Amazon VPC.](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html) | Administrateur AWS | | Activez l'authentification à deux facteurs. | (Facultatif) Atlas prend en charge l'authentification à deux facteurs (2FA) pour aider les utilisateurs à contrôler l'accès à leurs comptes Atlas. | Administrateur AWS | | Configurez l'authentification et l'autorisation des utilisateurs avec LDAP. | (Facultatif) Atlas prend en charge l'authentification et l'autorisation des utilisateurs avec le protocole LDAP (Lightweight Directory Access Protocol). | DBA | | Configurez un AWS accès unifié. | (Facultatif) Certaines fonctionnalités d'Atlas, notamment Atlas Data Lake et le chiffrement au repos à l'aide de la gestion des clés client, utilisent des rôles Gestion des identités et des accès AWS (IAM) pour l'authentification. | Administrateur AWS | | Configurez le chiffrement au repos à l'aide de AWS KMS. | (Facultatif) Atlas prend en charge l'utilisation de AWS Key Management Service (AWS KMS) pour chiffrer les moteurs de stockage et les sauvegardes des fournisseurs de cloud. | Administrateur AWS | | Configurez le chiffrement au niveau des champs côté client. | (Facultatif) Atlas prend en charge le chiffrement au niveau des champs côté client, y compris le chiffrement automatique des champs. | Administrateur AWS | ### Migration des données | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Ajoutez MongoDB Relational Migrator à la liste d'accès. | Ajoutez le Relational Migrator à la liste d'accès de votre base de données source. Cela permet de préparer l'environnement source à se connecter au cluster Atlas cible. | DBA | | Évaluez les objets de base de données relationnelle. | Lancez MongoDB Relational Migrator et connectez-vous à votre base de données relationnelle. Commencez l'évaluation. | DBA | | Acceptez les modèles de migration ou choisissez de les modifier en fonction des besoins de votre entreprise. | Acceptez les modèles de base de données recommandés par le Relational Migrator en fonction de l'évaluation initiale et des paramètres de performance, ou choisissez de les modifier en fonction des besoins de votre entreprise. | DBA | | Lancez votre ensemble de répliques cible dans MongoDB Atlas. | Lancez votre ensemble de répliques cible dans MongoDB Atlas. Dans Relational Migrator, choisissez **Je suis prêt à migrer**. | DBA | ### Configuration de l'intégration opérationnelle | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Connectez-vous au cluster MongoDB Atlas. | Assurez-vous que la connectivité au cluster MongoDB Atlas fonctionne comme prévu. | Propriétaire de l'application | | Interagissez avec les données du cluster. | Vérifiez les données du cluster. | DBA | | Surveillez vos clusters. | Vérifiez que vos clusters sont correctement configurés. | DBA | | Sauvegardez et restaurez les données du cluster. | Planifiez les sauvegardes à une cadence régulière pour les données du cluster. | DBA | ## Ressources connexes Tous les liens suivants, sauf indication contraire, renvoient à des pages Web de la documentation de MongoDB. **Guide de migration** + [Migration vers MongoDB Atlas AWS sur AWS (conseils prescriptifs](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/)) **Découverte et évaluation** + [Mémoire](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Exemple de dimensionnement à l'aide d'exemples de jeux de données Atlas](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Exemple de dimensionnement pour applications mobiles](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Trafic réseau](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Mise à l'échelle automatique du cluster](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Modèle de dimensionnement de l'Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Configuration de la sécurité et de la conformité** + [Configuration des entrées de liste d'accès IP](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Configuration des utilisateurs de base de données](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Configuration de l'accès à l'interface utilisateur d'Atlas](https://docs.atlas.mongodb.com/organizations-projects/) + [Configuration de rôles de base de données personnalisés](https://docs.atlas.mongodb.com/security-add-mongodb-roles) + [Configuration des utilisateurs de base de données](https://docs.atlas.mongodb.com/security-add-mongodb-users/#atlas-user-privileges) + [Configuration d'une connexion d'appairage réseau](https://docs.atlas.mongodb.com/security-vpc-peering/) + [En savoir plus sur les points de terminaison privés dans Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Gérez vos options d'authentification multifactorielle](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Configuration de l'authentification et de l'autorisation des utilisateurs avec LDAP](https://docs.atlas.mongodb.com/security-ldaps/) + [Lac de données Atlas](https://docs.mongodb.com/datalake/) + [Chiffrement au repos à l'aide de la gestion des clés client](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Méthodes pour assumer un rôle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (documentation IAM) + [Chiffrement au niveau des champs côté client](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Chiffrement automatique](https://docs.mongodb.com/manual/core/security-automatic-client-side-encryption) + [Contrôles de sécurité MongoDB Atlas](https://webassets.mongodb.com/_com_assets/cms/MongoDB_Atlas_Security_Controls-v7k3rbhi3p.pdf) + [Centre de confiance MongoDB](https://www.mongodb.com/cloud/trust) + [Configuration des fonctionnalités de sécurité pour les clusters](https://docs.atlas.mongodb.com/setup-cluster-security/) **Configuration d'un nouvel environnement MongoDB Atlas sur **AWS**** + [Fournisseurs de cloud et régions](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Gérer les clusters mondiaux](https://docs.atlas.mongodb.com/global-clusters/) + [Sélectionnez le niveau du cluster](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Configurer des paramètres supplémentaires](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Commencez avec Atlas](https://docs.atlas.mongodb.com/getting-started/) + [Configuration de l'accès à l'interface utilisateur d'Atlas](https://docs.atlas.mongodb.com/organizations-projects/) **Migration des données** + [Migrer ou importer des données](https://www.mongodb.com/docs/atlas/import/) **Clusters de surveillance** + [Surveillez vos clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) **Intégration des opérations** + [Se connecter à un cluster](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interagissez avec vos données](https://docs.atlas.mongodb.com/data-explorer/) + [Surveillez vos clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Sauvegarder, restaurer et archiver les données](https://docs.atlas.mongodb.com/backup-restore-cluster/) # Migrer un environnement MongoDB auto-hébergé vers MongoDB Atlas sur AWS *Battulga Purevragchaa et Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Résumé Ce modèle décrit les étapes de migration d'un environnement MongoDB autogéré (y compris MongoDB Community Server, Enterprise Server, Enterprise Advanced, mLab ou tout cluster MongoDB géré) vers MongoDB Atlas dans le. AWS Cloud Il utilise le [service de migration Atlas Live](https://www.mongodb.com/cloud/atlas/migrate) pour accélérer la migration des données de MongoDB vers MongoDB Atlas. Le modèle accompagne le guide [Migrating to MongoDB Atlas AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) sur le site Web de Prescriptive AWS Guidance. Il fournit les étapes de mise en œuvre de l'un des scénarios de migration décrits dans ce guide. Pour d'autres scénarios de migration, consultez les modèles suivants sur le site Web des directives AWS prescriptives : + [Migrer une base de données relationnelle vers MongoDB Atlas sur AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-relational-database-to-mongodb-atlas.html) + [Diffusez des données depuis IBM Db2, SAP, Sybase et d'autres bases de données vers MongoDB Atlas sur AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/stream-data-from-ibm-db2-to-mongodb-atlas.html) Le modèle est destiné aux [partenaires et aux AWS utilisateurs de AWS Systems Integrator (SI)](https://aws.amazon.com/managed-services/partners/). ## Conditions préalables et limitations **Conditions préalables** + Un environnement MongoDB Enterprise Advanced, Community Server ou autre environnement MongoDB autogéré à migrer vers MongoDB Atlas. + Connaissance de MongoDB, MongoDB Atlas et. Services AWS Ce schéma explique certaines des étapes de migration à un niveau élevé. Des informations supplémentaires seront ajoutées dans les futures versions. **Versions du produit** + MongoDB version 6.0.13 ou ultérieure ## Architecture Le schéma suivant montre le service de migration Atlas Live qui est utilisé pour migrer les données d'une base de données MongoDB Enterprise Advanced et d'une base de données communautaire MongoDB vers MongoDB Atlas on. AWS Utilisez ce service lorsque vous devez migrer des bases de données complexes et volumineuses vers MongoDB Atlas avec un temps d'arrêt minimal et une synchronisation continue des données. Ce modèle utilise le service de migration Atlas Live. ![\[Migration de données avec MongoDB Atlas Live Migration Service.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/52cdb923-64ff-4ee2-b129-93b9a139e24b/images/372134c4-ba47-4e48-bd0d-8b43017773b8.png) Le schéma suivant montre le service miroir MongoDB (`mongomirror`) que vous pouvez également utiliser pour migrer des données d'une base de données MongoDB Enterprise Advanced et d'une base de données MongoDB Community vers MongoDB Atlas via une connexion sécurisée. AWS [AWS PrivateLink](https://aws.amazon.com/privatelink/) `mongomirror`À utiliser pour la réplication continue des données entre MongoDB sur site et MongoDB Atlas. Cet outil est idéal pour la reprise après sinistre ou les migrations par étapes, mais il n'entre pas dans le cadre de ce modèle. ![\[Migration de données avec l'outil mongomirror.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/52cdb923-64ff-4ee2-b129-93b9a139e24b/images/53488a9b-2210-4b3d-b517-b618c1e0182c.png) Pour plus d'architectures de référence MongoDB Atlas prenant en charge différents scénarios d'utilisation, consultez la section [Migration vers MongoDB Atlas AWS sur](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) le site Web des directives prescriptives. AWS ## Outils + [MongoDB Atlas](https://www.mongodb.com/atlas) est une base de données en tant que service (DBaaS) entièrement gérée pour le déploiement et la gestion des bases de données MongoDB dans le cloud. + [Atlas Live Migration Service](https://www.mongodb.com/cloud/atlas/migrate) est un utilitaire gratuit MongoDB qui permet de migrer des bases de données vers Atlas. Ce service assure la synchronisation de la base de données source avec la base de données de destination jusqu'au transfert. Lorsque vous êtes prêt à effectuer la transition, vous arrêtez vos instances d'application, vous les pointez vers le cluster Atlas de destination et vous les redémarrez. Pour accéder à ce service, choisissez les **options de base** de données dans votre cluster MongoDB Atlas. + [mongomirror](https://www.mongodb.com/docs/atlas/import/mongomirror/) est un outil permettant de migrer manuellement les données d'un jeu de répliques MongoDB existant vers un jeu de répliques MongoDB Atlas. `mongomirror`ne vous oblige pas à arrêter votre jeu de répliques ou vos applications existants, n'importe pas de données d'utilisateur ou de rôle, ni ne copie la base de données de configuration. Vous pouvez le télécharger `mongomirror` depuis la documentation de [MongoDB.](https://www.mongodb.com/docs/atlas/import/mongomirror/#download-mongomirror) ## Bonnes pratiques Pour connaître les meilleures pratiques relatives à l'utilisation de MongoDB sur AWS, consultez les articles publiés sur le blog du [AWS Partner Network](https://aws.amazon.com/blogs/apn/tag/mongodb-atlas/). ## Épopées ### Découverte et évaluation | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Déterminez la taille du cluster. | Estimez la taille de l'ensemble de travail en utilisant les informations provenant de `db.stats()` pour l'espace d'index total. Supposons qu'un pourcentage de votre espace de données soit fréquemment consulté. Vous pouvez également estimer vos besoins en mémoire en vous basant sur vos propres hypothèses. Cette tâche devrait prendre environ une semaine. Pour plus d'informations et des exemples sur cette histoire et sur les autres histoires de cette épopée, consultez la section [Ressources connexes](#migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud-resources). | DBA, propriétaire de l'application | | Estimez les besoins en bande passante du réseau. | Pour estimer les besoins en bande passante de votre réseau, multipliez la taille moyenne des documents par le nombre de documents servis par seconde. Tenez compte du trafic maximal que chaque nœud de votre cluster pourra supporter comme base. Pour calculer les taux de transfert de données en aval de votre cluster vers les applications clientes, utilisez la somme du total des documents renvoyés sur une période donnée. Si vos applications lisent à partir de nœuds secondaires, divisez le nombre total de documents par le nombre de nœuds pouvant effectuer des opérations de lecture. Pour connaître la taille moyenne des documents d'une base de données, utilisez la `db.stats().avgObjSize` commande. Cette tâche prend généralement une journée. | DBA | | Sélectionnez le niveau Atlas. | Suivez les instructions de la [documentation MongoDB](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) pour sélectionner le niveau de cluster Atlas approprié. | DBA | | Planifiez le transfert. | Planifiez le transfert des applications. | DBA, propriétaire de l'application | ### Configuration d'un nouvel environnement MongoDB Atlas sur AWS | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un nouveau cluster MongoDB Atlas sur. AWS | Connectez-vous à Atlas et ouvrez la page **d'aperçu** de votre projet. Cliquez sur le bouton **Créer** pour créer un cluster. Pour obtenir plus d'informations, consultez [ la documentation MongoDB](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/). | DBA | | Sélectionnez Régions AWS une configuration globale du cluster. | Sélectionnez dans la liste des options disponibles Régions AWS pour votre cluster Atlas. Configurez des clusters globaux si nécessaire. Pour obtenir plus d'informations, consultez [ la documentation MongoDB](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/#select-your-preferred-region.). | DBA | | Sélectionnez le niveau du cluster. | Sélectionnez le niveau de cluster de votre choix. Le choix du niveau détermine des facteurs tels que la mémoire, le stockage et les spécifications d'IOPS. | DBA | | Configurez des paramètres de cluster supplémentaires. | Configurez des paramètres de cluster supplémentaires tels que la version de MongoDB, les options de sauvegarde et de chiffrement. Pour plus d'informations sur ces options, consultez la section [Ressources connexes](#migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud-resources). | DBA | ### Configuration de la sécurité et de la conformité | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Authentifiez et autorisez les utilisateurs. | Vous devez créer et authentifier les utilisateurs de base de données qui accèderont aux clusters MongoDB Atlas. Pour accéder aux clusters d'un projet, les utilisateurs doivent appartenir à ce projet, et ils peuvent appartenir à plusieurs projets. Atlas prend également en charge l'authentification basée sur Gestion des identités et des accès AWS (IAM). Pour obtenir plus d'informations, consultez [ la documentation MongoDB](https://www.mongodb.com/docs/atlas/security/aws-iam-authentication/#set-up-authentication-with-aws-iam). | DBA | | Créez des rôles personnalisés. | (Facultatif) Atlas prend en charge la création de rôles personnalisés dans les cas où les autorisations utilisateur de la base de données Atlas intégrées ne couvrent pas l'ensemble des autorisations que vous souhaitez. | DBA | | Configurez le peering VPC. | (Facultatif) Atlas prend en charge [le couplage entre un cloud privé virtuel (VPC) et un autre](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) cloud. VPCs AWS | Administrateur AWS | | Configurez un AWS PrivateLink point de terminaison. | (Facultatif) Vous pouvez configurer des points de terminaison privés AWS en utilisant AWS PrivateLink. Pour plus d'informations, consultez la [documentation Amazon VPC.](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html) | Administrateur AWS | | Activez l'authentification à deux facteurs. | (Facultatif) Atlas prend en charge l'authentification à deux facteurs (2FA) pour aider les utilisateurs à contrôler l'accès à leurs comptes Atlas. | Administrateur AWS | | Configurez l'authentification et l'autorisation des utilisateurs avec LDAP. | (Facultatif) Atlas prend en charge l'authentification et l'autorisation des utilisateurs avec le protocole LDAP (Lightweight Directory Access Protocol). | Administrateur AWS | | Configurez un AWS accès unifié. | (Facultatif) Certaines fonctionnalités d'Atlas, notamment Atlas Data Lake et le chiffrement au repos à l'aide de la gestion des clés client, utilisent des rôles IAM pour l'authentification. | Administrateur AWS | | Configurez le chiffrement au repos à l'aide de AWS KMS. | (Facultatif) Atlas prend en charge l'utilisation de AWS Key Management Service (AWS KMS) pour chiffrer les moteurs de stockage et les sauvegardes des fournisseurs de cloud. | Administrateur AWS | | Configurez le chiffrement au niveau des champs côté client. | (Facultatif) Atlas prend en charge le chiffrement au niveau des champs côté client, y compris le chiffrement automatique des champs. | Administrateur AWS | ### Migration des données | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Sélectionnez votre ensemble de répliques cible dans MongoDB Atlas. | Accédez au cluster Atlas de destination et cliquez sur le bouton représentant des points de suspension (...). Dans la liste des clusters, ce bouton apparaît sous le nom du cluster. Dans les détails du cluster, le bouton apparaît sur la droite, à côté des boutons **Connect** et **Configuration**. Pour obtenir plus d'informations, consultez [ la documentation MongoDB](https://www.mongodb.com/docs/atlas/import/c2c-pull-live-migration/#procedure). | DBA | | Ajoutez le service de migration Atlas Live à la liste d'accès. | Ajoutez le service de migration Atlas Live à la liste d'accès de votre cluster AWS source. Cela permet de préparer l'environnement source à se connecter au cluster Atlas cible. | DBA | | Effectuez la migration avec Atlas Live Migration Service. | Choisissez **Démarrer la migration**. Lorsque le bouton **Prepare to Cutover** devient vert, effectuez le découpage. Passez en revue les indicateurs de performance du cluster Atlas. Envisagez de mettre à jour la connexion à la base de données dans toutes les couches de l'application pour qu'elle pointe vers la nouvelle base de données. | DBA | ### Configuration de l'intégration opérationnelle | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Connectez-vous au cluster MongoDB Atlas. | Assurez-vous que la connectivité au cluster MongoDB Atlas fonctionne comme prévu. | Propriétaire de l'application | | Interagissez avec les données du cluster. | Testez les données du cluster. | DBA | | Surveillez vos clusters. | Vérifiez que vos clusters sont correctement configurés. | DBA | | Sauvegardez et restaurez les données du cluster. | Planifiez les sauvegardes à une cadence régulière pour les données du cluster. | DBA | ## Résolution des problèmes | Problème | Solution | | --- | --- | | Erreur : Impossible d'atteindre la source spécifiée | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud.html) | | Erreur : Impossible de résoudre le nom d'hôte | Aucune adresse IP n'a été trouvée pour le nom d'hôte indiqué. Vérifiez que le nom d'hôte indiqué est correct et accessible au public. | | Toute autre erreur | Si vous rencontrez d'autres erreurs, consultez la section [Troubleshoot Live Migration (Pull)](https://www.mongodb.com/docs/atlas/import/live-import-troubleshooting/) dans la documentation de MongoDB. | ## Ressources connexes Tous les liens suivants, sauf indication contraire, renvoient à des pages Web de la documentation de MongoDB. **Guide de migration** + [Migration vers MongoDB Atlas AWS sur AWS (conseils prescriptifs](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/)) **Migration d'anciennes versions** + [Migration des anciennes versions de MongoDB](https://www.mongodb.com/docs/atlas/legacy-migration/) **Découverte et évaluation** + [Mémoire](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Exemple de dimensionnement avec des exemples de jeux de données Atlas](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Exemple de dimensionnement pour applications mobiles](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Trafic réseau](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Mise à l'échelle automatique du cluster](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Modèle de dimensionnement de l'Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Configuration de la sécurité et de la conformité** + [Configuration des entrées de liste d'accès IP](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Configuration des utilisateurs de base de données](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Configuration de l'accès à l'interface utilisateur d'Atlas](https://docs.atlas.mongodb.com/organizations-projects/) + [Configuration de rôles de base de données personnalisés](https://docs.atlas.mongodb.com/security-add-mongodb-roles) + [Configuration des utilisateurs de base de données](https://docs.atlas.mongodb.com/security-add-mongodb-users/#atlas-user-privileges) + [Configuration d'une connexion d'appairage réseau](https://docs.atlas.mongodb.com/security-vpc-peering/) + [En savoir plus sur les points de terminaison privés dans Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Gérez vos options d'authentification multifactorielle](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Configuration de l'authentification et de l'autorisation des utilisateurs avec LDAP](https://docs.atlas.mongodb.com/security-ldaps/) + [Lac de données Atlas](https://docs.mongodb.com/datalake/) + [Chiffrement au repos à l'aide de la gestion des clés client](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Méthodes pour assumer un rôle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (documentation IAM) + [Chiffrement au niveau des champs côté client](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Chiffrement automatique](https://docs.mongodb.com/manual/core/security-automatic-client-side-encryption) + [Contrôles de sécurité MongoDB Atlas](https://webassets.mongodb.com/_com_assets/cms/MongoDB_Atlas_Security_Controls-v7k3rbhi3p.pdf) + [Centre de confiance MongoDB](https://www.mongodb.com/cloud/trust) + [Configuration des fonctionnalités de sécurité pour les clusters](https://docs.atlas.mongodb.com/setup-cluster-security/) **Configuration d'un nouvel environnement MongoDB Atlas sur **AWS**** + [Fournisseurs de cloud et régions](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Gérer les clusters mondiaux](https://docs.atlas.mongodb.com/global-clusters/) + [Sélectionnez le niveau du cluster](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Configurer des paramètres supplémentaires](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Commencez avec Atlas](https://docs.atlas.mongodb.com/getting-started/) + [Configuration de l'accès à l'interface utilisateur d'Atlas](https://docs.atlas.mongodb.com/organizations-projects/) **Migration des données** + [Migrer ou importer des données](https://www.mongodb.com/docs/atlas/import/) **Clusters de surveillance** + [Surveillez vos clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) **Intégration des opérations** + [Se connecter à un cluster](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interagissez avec vos données](https://docs.atlas.mongodb.com/data-explorer/) + [Surveillez vos clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Sauvegarder, restaurer et archiver les données](https://docs.atlas.mongodb.com/backup-restore-cluster/) **Entrainement** + [Migration en direct avec MongoDB Atlas](https://learn.mongodb.com/courses/live-migration-with-mongodb-atlas) ## Informations supplémentaires Pour plus d'informations, consultez les rubriques suivantes dans la documentation de MongoDB : + Pour déplacer des données vers une instance sans serveur, [utilisez Compass pour exporter et importer des données, ou migrez des données](https://www.mongodb.com/docs/compass/current/import-export/) à l'aide d'outils autogérés. Pour en savoir plus, consultez la section [Limitations relatives aux instances sans serveur](https://www.mongodb.com/docs/atlas/reference/serverless-instance-limitations/). + Pour charger des données dans un nouveau cluster dans Atlas, voir [Charger des données dans Atlas.](https://www.mongodb.com/docs/atlas/sample-data/#std-label-sample-data) + Pour créer une copie de votre cluster à des fins de test, consultez la section [Méthodes de sauvegarde pour un déploiement autogéré](https://www.mongodb.com/docs/manual/core/backups/). + Si l'application que vous souhaitez migrer nécessite une disponibilité quasi continue, contactez le [support](https://www.mongodb.com/docs/atlas/support/#std-label-request-support) MongoDB et faites-lui part de vos besoins en termes de disponibilité et de configuration du cluster. + Pour plus d'informations, consultez la section [Migrer ou importer des données](https://www.mongodb.com/docs/atlas/import/). # Migrer une base de données Oracle vers Amazon DynamoDB à l'aide d'AWS DMS *Rambabu Karnena, Amazon Web Services* ## Résumé Ce modèle explique les étapes de migration d'une base de données Oracle vers [Amazon](https://aws.amazon.com/dynamodb/) DynamoDB à l'aide d'AWS Database Migration Service [(](https://aws.amazon.com/dms/)AWS DMS). Il couvre trois types de bases de données sources : + Bases de données Oracle sur site + Bases de données Oracle sur Amazon Elastic Compute Cloud ([Amazon EC2](https://aws.amazon.com/ec2/)) + Amazon Relational Database Service ([Amazon](https://aws.amazon.com/rds/) RDS) pour les instances de base de données Oracle Dans cette preuve de concept, ce modèle met l'accent sur la migration depuis une instance de base de données Amazon RDS pour Oracle. ## Conditions préalables et limitations **Conditions préalables** + Un compte AWS actif + Une application se connectant à une base de données Amazon RDS for Oracle + Une table créée dans la base de données source Amazon RDS for Oracle avec une clé primaire et des exemples de données **Limites** + Les objets de base de données Oracle, tels que les procédures, les fonctions, les packages et les déclencheurs, ne sont pas pris en compte pour la migration car Amazon DynamoDB ne prend pas en charge ces objets de base de données. **Versions du produit** + Ce modèle s'applique à toutes les éditions et versions des bases de données Oracle prises en charge par AWS DMS. Pour plus d'informations, consultez les sections Utilisation d'une [base de données Oracle comme source pour AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html) et Utilisation d'[une base de données Amazon DynamoDB comme cible](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.DynamoDB.html) pour AWS DMS. Nous vous recommandons d'utiliser les dernières versions d'AWS DMS pour bénéficier du support le plus complet en termes de versions et de fonctionnalités. ## Architecture **Pile technologique source** + Instances de bases de données Amazon RDS for Oracle, Oracle sur EC2 Amazon ou bases de données Oracle sur site **Pile technologique cible** + Amazon DynamoDB **Architecture de migration de données AWS** ![\[Les données sont transférées d'Oracle DB vers AWS DMS puis Amazon DynamoDB.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/463fc7d4-ec8d-473b-8c7f-1df31800ee03/images/180e7340-3887-455d-a591-b5850e22770a.png) ## Outils + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) vous aide à migrer des magasins de données vers le cloud AWS ou entre des combinaisons de configurations cloud et sur site. + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) est un service de base de données NoSQL entièrement géré, offrant des performances rapides, prévisibles et évolutives. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) vous aide à configurer, exploiter et dimensionner une base de données relationnelle dans le cloud AWS. Ce modèle utilise Amazon RDS for Oracle. ## Épopées ### Planifier la migration | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un VPC. | Dans votre compte AWS, créez un cloud privé virtuel (VPC) et un sous-réseau privé. | Administrateur de systèmes | | Créez des groupes de sécurité et des listes de contrôle d'accès au réseau. | Pour plus d'informations, consultez la [documentation AWS](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html). | Administrateur de systèmes | | Configurez et démarrez l'instance de base de données Amazon RDS for Oracle. | Pour plus d'informations, consultez la [documentation AWS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html). | DBA, administrateur système | ### Migration des données | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un rôle IAM pour accéder à DynamoDB. | Dans la console AWS Identity and Access Management (IAM), créez le rôle, attachez la politique `AmazonDynamoDBFullAccess to it` et sélectionnez AWS DMS comme service. | Administrateur de systèmes | | Créez une instance de réplication AWS DMS pour la migration. | L'instance de réplication doit se trouver dans la même zone de disponibilité et le même VPC que la base de données source. | Administrateur de systèmes | | Créez des points de terminaison source et cible dans AWS DMS. | Pour créer le point de terminaison de la base de données source, deux options s'offrent à vous :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.html)Pour créer le point de terminaison de base de données cible, choisissez le rôle Amazon Resource Name (ARN) dans la tâche précédente pour accéder à DynamoDB. | Administrateur de systèmes | | Créez une tâche AWS DMS pour charger les tables de base de données Oracle source dans DynamoDB. | Choisissez les noms des points de terminaison source et de destination ainsi que l'instance de réplication à partir des étapes précédentes. Le type peut être à pleine charge. Choisissez le schéma Oracle et spécifiez **%** pour sélectionner toutes les tables. | Administrateur de systèmes | | Validez les tables dans DynamoDB. | Pour afficher les résultats de la migration, choisissez **Tables** dans le volet de navigation de gauche de la console DynamoDB. | DBA | ### Migrer l'application | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Modifiez le code de l'application. | Pour vous connecter à DynamoDB et récupérer des données depuis DynamoDB, mettez à jour le code de l'application. | Propriétaire de l'application, DBA, administrateur système | ### Découper | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Changez les clients de l'application pour qu'ils utilisent DynamoDB. | | DBA, propriétaire de l'application, administrateur système | ### Fermez le projet | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Arrêtez les ressources AWS. | Par exemple, l'arrêt de l'instance Amazon RDS pour Oracle, DynamoDB et de l'instance de réplication AWS DMS. | DBA, administrateur système | | Collectez des statistiques. | Les indicateurs incluent le temps de migration, les pourcentages de travail manuel et de travail effectué par l'outil, ainsi que les économies de coûts. | DBA, propriétaire de l'application, administrateur système | ## Ressources connexes + [AWS Database Migration Service et Amazon DynamoDB : ce que vous devez savoir (article de blog](https://aws.amazon.com/blogs/database/aws-database-migration-service-and-amazon-dynamodb-what-you-need-to-know/)) + [Utilisation d'une base de données Oracle comme source pour AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html) + [Utilisation d'une base de données Amazon DynamoDB comme cible pour AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.DynamoDB.html) + [Bonnes pratiques pour la migration d'un SGBDR vers Amazon DynamoDB (livre blanc)](https://docs.aws.amazon.com/whitepapers/latest/best-practices-for-migrating-from-rdbms-to-dynamodb/welcome.html) # Migrez d'Oracle 8i ou 9i vers Amazon RDS for Oracle à l'aide d'AWS DMS SharePlex *Ramu Jagini, Amazon Web Services* ## Résumé Ce modèle décrit comment migrer une base de données Oracle 8i ou 9i sur site vers une base de données Amazon Relational Database Service (Amazon RDS) pour Oracle. Vous pouvez utiliser ce modèle pour terminer votre migration en réduisant les temps d'arrêt en utilisant Quest SharePlex pour la réplication synchrone. Vous devez utiliser une instance de base de données Oracle intermédiaire pour votre migration car AWS Database Migration Service (AWS DMS) ne prend pas en charge Oracle 8i ou 9i en tant qu'environnement source. Vous pouvez utiliser la version [SharePlex 7.6.3 pour effectuer](https://www.quest.com/community/shareplex/f/forum/20700/where-can-download-7-6-3-or-support-9i-shareplex) une réplication à partir de versions de base de données Oracle précédentes vers des versions ultérieures de base de données Oracle. L'instance de base de données Oracle intermédiaire est compatible en tant que cible pour la version SharePlex 7.6.3 et prise en charge en tant que source pour AWS DMS ou les versions plus récentes de. SharePlex Cette prise en charge permet la réplication ultérieure des données vers l'environnement cible Amazon RDS for Oracle. Sachez que plusieurs types de données et fonctionnalités obsolètes peuvent avoir un impact sur la migration d'Oracle 8i ou 9i vers la dernière version d'Oracle Database. Pour atténuer cet impact, ce modèle utilise Oracle 11.2.0.4 comme version de base de données intermédiaire afin d'optimiser le code du schéma avant la migration vers l'environnement cible Amazon RDS for Oracle. ## Conditions préalables et limitations **Conditions préalables** + Un compte AWS actif + Une base de données Oracle 8i ou 9i source dans un environnement sur site + [Oracle Database 12c version 2](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/index.html) (12CR2) pour le staging sur Amazon Elastic Compute Cloud (Amazon EC2) + Quest SharePlex 7.6.3 (version commerciale) **Limites** + [Limites de RDS pour Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Oracle.Concepts.limitations.html) **Versions du produit** + Oracle 8i ou 9i pour la base de données source + Oracle 12 CR2 pour la base de données intermédiaire (doit correspondre à la version Amazon RDS for Oracle) + Oracle 12 CR2 ou version ultérieure pour la base de données cible (Amazon RDS for Oracle) ## Architecture **Pile technologique source** + Base de données Oracle 8i ou 9i + SharePlex **Pile technologique cible** + Amazon RDS for Oracle **Architecture de migration** Le schéma suivant montre comment migrer une base de données Oracle 8i ou 9i d'un environnement sur site vers une instance de base de données Amazon RDS for Oracle dans le cloud AWS. ![\[Flux de travail pour la migration d'une base de données Oracle sur site vers Amazon RDS sur AWS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/6e07d586-fd74-4f3d-8e81-79dd55c445c3/images/36e1a5ff-908b-4cb7-96f7-997eb105f1d6.png) Le schéma suivant illustre le flux de travail suivant : 1. Activez la base de données source Oracle avec le mode journal d'archivage, la journalisation forcée et la journalisation supplémentaire. 1. Restaurez la base de données intermédiaire Oracle à partir de la base de données source Oracle en utilisant Recovery Manager (RMAN) point-in-time Recovery et [FLASHBACK\$1SCN](https://docs.oracle.com/database/121/SUTIL/GUID-D408B112-1A81-4F68-BEFF-7403A9588DDB.htm#SUTIL849). 1. Configurez SharePlex pour lire les journaux de journalisation à partir de la base de données source Oracle en utilisant `FLASHBACK_SCN` (utilisé dans RMAN). 1. Lancez SharePlex la réplication pour synchroniser les données de la base de données source Oracle vers la base de données intermédiaire Oracle. 1. Restaurez la base de données cible Amazon RDS for Oracle en utilisant EXPDP et IMPDP avec. `FLASHBACK_SCN` 1. Configurez AWS DMS et ses tâches sources en tant que base de données intermédiaire Oracle et Amazon RDS for Oracle en tant que base de données cible `FLASHBACK_SCN` en utilisant (utilisé dans EXPDP). 1. Lancez des tâches AWS DMS pour synchroniser les données de la base de données intermédiaire Oracle avec la base de données cible Oracle. ## Outils + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) vous aide à configurer, exploiter et dimensionner une base de données relationnelle dans le cloud AWS. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) vous aide à migrer des magasins de données vers le cloud AWS ou entre des combinaisons de configurations cloud et sur site. + [ SharePlexQuest](https://support.quest.com/shareplex/11.0/technical-documents) est un outil de réplication de Oracle-to-Oracle données permettant de déplacer des données avec un minimum de temps d'arrêt et sans perte de données. + [Recovery Manager (RMAN)](https://docs.oracle.com/cd/E11882_01/backup.112/e10642/rcmquick.htm) est un client de base de données Oracle qui effectue des tâches de sauvegarde et de restauration sur vos bases de données. Il simplifie considérablement la sauvegarde, la restauration et la restauration des fichiers de base de données. + [Data Pump Export](https://docs.oracle.com/cd/E11882_01/server.112/e22490/dp_export.htm#SUTIL823) vous permet de télécharger des données et des métadonnées dans un ensemble de fichiers du système d'exploitation appelé ensemble de fichiers de vidage. L'ensemble de fichiers de vidage ne peut être importé que par l'utilitaire [Data Pump Import](https://docs.oracle.com/cd/E11882_01/server.112/e22490/dp_import.htm#SUTIL300) ou le package [DBMS\$1DATAPUMP](https://docs.oracle.com/database/121/ARPLS/d_datpmp.htm#ARPLS356). ## Épopées ### Configuration SharePlex et base de données de préparation Oracle sur Amazon EC2 | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une EC2 instance. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html) | Administration d'Oracle | | Préparez la base de données de préparation. | Préparez la base de données intermédiaire Oracle pour la restauration en tant que mise à niveau sur Oracle 12 CR2 en utilisant la sauvegarde RMAN depuis l'environnement source de base de données Oracle 8i ou 9i.Pour plus d'informations, consultez le guide de [l'utilisateur d'Oracle 9i Recovery Manager et le guide de](https://docs.oracle.com/cd/B10500_01/server.920/a96566/toc.htm) [l'utilisateur de Database Backup and Recovery](https://docs.oracle.com/database/121/BRADV/rcmcomre.htm#BRADV8005) dans la documentation Oracle. | Administration d'Oracle | | Configurez SharePlex. | Configurez la SharePlex source en tant que base de données Oracle 8i ou 9i sur site, et configurez la cible en tant que base de données intermédiaire Oracle 12 CR2 hébergée sur Amazon. EC2 | SharePlex, administration d'Oracle | ### Configurez Amazon RDS for Oracle comme environnement cible | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une instance de base de données Oracle. | Créez une base de données Amazon RDS for Oracle, puis connectez Oracle CR2 12 à la base de données.Pour plus d'informations, consultez [Création d'une instance de base de données Oracle et connexion à une base de données sur une instance de base de données Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.Oracle.html) dans la documentation Amazon RDS. | DBA | | Restaurez Amazon RDS for Oracle à partir de la base de données intermédiaire. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html)Pour plus d'informations, consultez la section [54 DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/21/arpls/DBMS_DATAPUMP.html#GUID-AEA7ED80-DB4A-4A70-B199-592287206348) dans la documentation Oracle. | DBA | ### Configuration d'AWS DMS | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez des points de terminaison pour les bases de données. | Créez un point de terminaison source pour la base de données intermédiaire Oracle et un point de terminaison cible pour la base de données Amazon RDS for Oracle.Pour plus d'informations, consultez [Comment créer des points de terminaison source ou cible à l'aide d'AWS DMS](https://aws.amazon.com/premiumsupport/knowledge-center/create-source-target-endpoints-aws-dms/) ? dans le centre de connaissances AWS. | DBA | | Créez une instance de réplication. | Utilisez AWS DMS pour lancer une instance de réplication de la base de données intermédiaire Oracle vers la base de données Amazon RDS for Oracle.Pour plus d'informations, consultez [Comment créer une instance de réplication AWS DMS](https://aws.amazon.com/premiumsupport/knowledge-center/create-aws-dms-replication-instance/) ? dans le centre de connaissances AWS. | DBA | | Créez et lancez des tâches de réplication. | Créez des tâches de réplication AWS DMS pour la capture des données de modification (CDC) `FLASHBACK_SCN` à l'aide de from EXPDP (puisque le chargement complet a déjà été effectué via EXPDP).Pour plus d'informations, consultez [la section Création d'une tâche](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) dans la documentation AWS DMS. | DBA | ### Passez à Amazon RDS for Oracle | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Arrêtez la charge de travail de l'application. | Arrêtez les serveurs d'applications et leurs applications pendant la période de transition planifiée. | Développeur d'applications, DBA | | Validez la synchronisation de la base de données intermédiaire Oracle locale avec l' EC2 instance. | Vérifiez que tous les messages relatifs aux tâches de réplication ont été publiés depuis l'instance de SharePlex réplication vers la base de données intermédiaire Oracle sur Amazon en EC2 effectuant quelques changements de journal sur la base de données source locale.Pour plus d'informations, reportez-vous à la section [6.4.2 Changer de fichier journal](https://docs.oracle.com/database/121/ADMQS/GUID-E30B4C65-2AC7-4A44-A58C-D3C121EB152F.htm#ADMQS12075) dans la documentation Oracle. | DBA | | Validez la synchronisation de la base de données intermédiaire Oracle avec la base de données Amazon RDS for Oracle. | Vérifiez que toutes vos tâches AWS DMS ne présentent aucun décalage ni aucune erreur, puis vérifiez l'état de validation des tâches. | DBA | | Arrêtez la réplication SharePlex d'Amazon RDS. | Si les réplications SharePlex et AWS DMS ne présentent aucune erreur, arrêtez les deux réplications. | DBA | | Remappez l'application sur Amazon RDS. | Partagez les détails du point de terminaison Amazon RDS for Oracle avec le serveur d'applications et ses applications, puis démarrez l'application pour reprendre les activités commerciales. | Développeur d'applications, DBA | ### Testez l'environnement cible d'AWS | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Testez l'environnement de base de données intermédiaire Oracle sur AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html) | SharePlex, administration d'Oracle | | Testez l'environnement Amazon RDS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html)Pour plus d'informations, consultez [Amazon RDS pour](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) Oracle dans la documentation Amazon RDS. | Administration d'Oracle | ## Ressources connexes + [Migrez en toute confiance](https://aws.amazon.com/cloud-migration/) + [Amazon EC2](https://aws.amazon.com/ec2/) + [Amazon RDS for Oracle](https://aws.amazon.com/rds/oracle/) + [AWS Database Migration Service](https://aws.amazon.com/dms/) + [Débogage de vos migrations AWS DMS : que faire en cas de problème (partie 1)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-1/) + [Débogage de vos migrations AWS DMS : que faire en cas de problème (partie 2)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-2/) + [Débogage de vos migrations AWS DMS : que faire en cas de problème ? (Partie 3)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-3/) + [SharePlex pour la réplication de bases de données](https://aws.amazon.com/marketplace/pp/B07943W4MJ) + [SharePlex: réplication de base de données pour tous les environnements](https://www.youtube.com/watch?v=ygS_ouUaNus) # Migrer une base de données MySQL sur site vers Amazon EC2 *Lorenzo Mota, Amazon Web Services* ## Résumé Ce modèle fournit des conseils pour la migration d'une base de données MySQL sur site vers une base de données MySQL sur une instance Amazon Elastic Compute Cloud (Amazon EC2). Le modèle décrit l'utilisation de AWS Database Migration Service (AWS DMS) ou d'outils MySQL natifs tels que **mysqldump** pour la migration. Il se concentre sur la migration complète de la base de données vers une instance de base de données MySQL. Le modèle est principalement destiné aux architectes DBAs et aux architectes de solutions. Il peut être utilisé dans le cadre de petits ou de grands projets, lors d'une phase de test ou de migration finale. Nous vous recommandons d'exécuter au moins un cycle de test avant d'utiliser ce modèle dans un environnement de production. ## Conditions préalables et limitations **Conditions préalables** + Un compte AWS actif + Une base de données source MySQL dans un centre de données sur site **Versions du produit** + MySQL version 5.5 et versions ultérieures + [Un système d'exploitation cible pris en charge par Amazon EC2 ; voir Amazon EC2 FAQs](https://aws.amazon.com/ec2/faqs/) ## Architecture **Pile technologique source** + Une base de données MySQL sur site **Pile technologique cible** + Une instance de base de données MySQL sur Amazon EC2 **Méthodes de migration de données AWS** + AWS DMS + [Des outils MySQL natifs tels que [mysqldump](https://dev.mysql.com/doc/refman/en/mysqldump.html) ou des outils tiers tels que Percona XtraBackup](https://www.percona.com/mysql/software/percona-xtrabackup) **Architecture cible** Le schéma suivant illustre la mise en œuvre cible d'Amazon EC2 après le basculement. ![\[Une instance de base de données MySQL sur Amazon EC2 avec réplication vers une instance de base de données MySQL de secours.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/34cab6f9-9107-4c3b-98ec-a6d7fa9f298a.png) **Architecture de migration de données AWS** *À l'aide d'AWS DMS :* Le schéma suivant illustre le flux de travail de migration des données basé sur l'envoi AWS DMS de modifications complètes et incrémentielles à la base de données MySQL cible jusqu'au passage. La connexion réseau depuis le réseau local vers AWS dépend des exigences du client SQL et n'entre pas dans le cadre de ce modèle. ![\[Utilisation d'AWS DMS pour envoyer des données à une base de données MySQL cible sur Amazon EC2.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/c906c45d-fac5-4bb9-b8c8-55e2f9f05fd8.png) *À l'aide d'autres outils MySQL :* Le schéma suivant illustre le flux de travail de migration des données basé sur l'utilisation des outils MySQL pour générer des fichiers de vidage d'exportation à partir de la base de données locale. Ces fichiers sont déplacés vers Amazon Simple Storage Service (Amazon S3) et importés dans la base de données MySQL cible avant le transfert. La connexion réseau depuis le réseau local vers AWS dépend des exigences du client SQL et n'entre pas dans le cadre de ce modèle. ![\[Utilisation d'outils MySQL natifs pour envoyer des données à une base de données MySQL cible sur Amazon EC2.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/18e88877-7879-4a99-b985-25c56bf7c35f.png) Remarques : + En fonction des considérations relatives aux temps d'arrêt et de la taille de la base de données pour le transfert final, vous pouvez utiliser AWS DMS un autre outil de capture des données de modification (CDC) pour minimiser le temps de transition. Lorsque vous utilisez un outil CDC tel que AWS DMS, vous pouvez migrer vers la base de données cible en quelques minutes. + Une stratégie hors ligne avec **mysqldump** peut suffire si la taille de la base de données et la latence du réseau permettent une courte période de migration. (Nous vous recommandons d'effectuer des tests pour obtenir une durée approximative.) + En général, une stratégie du CDC AWS DMS nécessite plus de surveillance et de complexité qu'une option hors ligne. ## Outils **AWS services** + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) prend en charge plusieurs bases de données sources et cibles. Pour plus d'informations sur les bases de données source et cible MySQL prises en charge par AWS DMS, consultez les [sections Utilisation d'une base de données compatible MySQL comme source pour AWS DMS et Utilisation d'](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.MySQL.html)[une base de données compatible MySQL](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.MySQL.html) comme cible pour. AWS DMS Si votre base de données source n'est pas prise en charge par AWS DMS, vous devez choisir une autre méthode pour migrer vos données. **Autres outils** + [mysqldump](https://dev.mysql.com/doc/refman/8.0/en/mysqldump.html) est un utilitaire MySQL qui crée un fichier dump à partir d'une base de données MySQL à des fins de sauvegarde ou de migration. + [Percona XtraBackup](https://www.percona.com/mysql/software/percona-xtrabackup) est un utilitaire open source permettant d'effectuer des sauvegardes non bloquantes sur des bases de données MySQL. ## Épopées ### Planifier la migration | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Validez les versions de base de données. | Validez les versions des bases de données source et cible. Pour plus d'informations sur les versions de MySQL prises en charge par AWS DMS, consultez la section [Sources AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.Sources.html) et [cibles](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.Targets.html) de la AWS DMS documentation. AWS DMS | DBA | | Identifiez le système d'exploitation cible. | Déterminez la version du système d'exploitation cible. Pour obtenir la liste des systèmes d'exploitation cibles pris en charge par Amazon EC2, consultez Amazon [EC2. FAQs](https://aws.amazon.com/ec2/faqs/) | DBA, administrateur système | | Identifiez les exigences matérielles. | Déterminez la configuration matérielle requise pour l'[instance de serveur cible](https://aws.amazon.com/rds/instance-types/) en fonction de la liste de compatibilité MySQL et des exigences en matière de capacité. | DBA, administrateur système | | Identifiez les besoins en matière de stockage. | Déterminez le type et la capacité de stockage de la base de données cible. | DBA, administrateur système | | Identifiez les exigences du réseau. | Déterminez les exigences du réseau telles que la latence et la bande passante. | DBA, administrateur système | | Choisissez le type d'instance cible. | Choisissez le [type d'instance cible](https://aws.amazon.com/rds/instance-types/) en fonction de la capacité, des fonctionnalités de stockage et des fonctionnalités réseau. | DBA, administrateur système | | Identifiez les exigences en matière de sécurité. | Déterminez les exigences de sécurité d'accès au réseau ou à l'hôte pour les bases de données source et cible. | DBA, administrateur système | | Identifiez les utilisateurs. | Déterminez la liste des utilisateurs du système d'exploitation pour l'installation du logiciel MySQL. Pour plus d’informations, consultez [la documentation MySQL](https://dev.mysql.com/doc/mysql-security-excerpt/en/access-control.html). | DBA, administrateur système | | Déterminez une stratégie de sauvegarde. | | DBA | | Déterminez les exigences de disponibilité. | | DBA | | Identifiez la stratégie de migration ou de transition des applications. | | DBA, administrateur système | ### Configuration de l'infrastructure | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un cloud privé virtuel (VPC) et des sous-réseaux. | Configurez les tables de routage, la passerelle Internet, les passerelles NAT et les sous-réseaux. Pour plus d'informations, consultez les [options de configuration VPC](https://docs.aws.amazon.com/vpc/latest/userguide/create-vpc-options.html) dans la documentation Amazon VPC. | Administrateur de systèmes | | Créez des groupes de sécurité et des listes de contrôle d'accès au réseau (ACLs). | Configurez les ports (la valeur par défaut pour MySQL est 3306) et les plages CIDR ou spécifiques IPs en fonction de vos besoins. | Administrateur de systèmes | | Configurez et démarrez une instance EC2. | Pour obtenir des instructions, consultez la section [Lancer une instance EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/LaunchingAndUsingInstances.html) dans la documentation Amazon EC2. | Administrateur de systèmes | ### Installez le logiciel MySQL | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez des utilisateurs et des groupes. | Créez les utilisateurs et les groupes du système d'exploitation qui ont besoin d'accéder au serveur et à la base de données. Pour de plus amples informations, veuillez consulter [Contrôle d'accès et gestion des comptes](https://dev.mysql.com/doc/refman/en/access-control.html) dans la documentation MySQL. | DBA, administrateur système | | Téléchargez MySQL. | Téléchargez le logiciel MySQL. Pour les instructions et les fichiers binaires, consultez la section [Installation de MySQL](https://dev.mysql.com/doc/refman/en/installing.html) dans la documentation MySQL. | DBA, administrateur système | | Installez MySQL sur l'instance EC2 et configurez le serveur. | Connectez-vous à votre instance EC2 et installez le logiciel MySQL. Pour plus d'informations, consultez [Connect to your EC2 instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect.html) dans la documentation Amazon EC2. | DBA, administrateur système | ### Migrer les données — option 1 | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Migrez les données avec MySQL natif ou des outils tiers. | Cette option utilise des outils MySQL natifs ou des outils tiers pour migrer les objets et les données de base de données. Pour obtenir des instructions, consultez la documentation de [mysqldump](https://dev.mysql.com/doc/refman/en/mysqldump.html) ou de [Percona XtraBackup](https://docs.percona.com/percona-xtrabackup/2.4/index.html) (pour la migration physique). Pour plus d'informations sur l'utilisation de ces outils, consultez le billet de AWS blog [Options de migration pour MySQL vers Amazon RDS for MySQL ou Amazon Aurora MySQL](https://aws.amazon.com/blogs/database/migration-options-for-mysql-to-amazon-rds-for-mysql-or-amazon-aurora-mysql/). | DBA | ### Migrer les données — option 2 | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Migrez les données avec AWS DMS. | Pour plus d'informations, consultez la section [Vue de haut niveau AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.HighLevelView.html) de la AWS DMS documentation. | DBA | ### Préparez-vous pour le découpage | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Recueillez le nombre d'objets. | Recueillez le nombre d'objets à partir de la base de données source et des nouvelles bases de données cibles. Corrigez les éventuelles anomalies dans la base de données cible. | DBA | | Vérifiez les dépendances. | Vérifiez que les dépendances (liens) vers et depuis d'autres bases de données sont toujours valides et fonctionnent correctement. | DBA | | Tester. | S'il s'agit d'un cycle de test, effectuez des tests de requêtes, collectez des métriques et corrigez les éventuels problèmes. | DBA | ### Découper | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Déplacez les clients. | Basculez les clients de l'application vers la nouvelle infrastructure. | DBA, propriétaire de l'application, administrateur système | | Fournir un soutien. | Fournir une assistance lors des tests fonctionnels des applications. | DBA | ### Fermez le projet | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Arrêtez les ressources. | Arrêtez l'instance AWS DMS de réplication et les autres AWS ressources temporaires. | DBA, administrateur système | | Révision et documents de projet. | Passez en revue et validez les documents du projet. | DBA, propriétaire de l'application, administrateur système | | Collectez des métriques. | Collectez des indicateurs tels que le temps de migration, le pourcentage de modifications manuelles par rapport aux modifications assistées par des outils et les économies de coûts. | DBA, propriétaire de l'application, administrateur système | | Clôturez le projet. | Clôturez le projet de migration et faites part de vos commentaires. | DBA, propriétaire de l'application, administrateur système | | Mise hors service de la base de données source. | Mettez hors service la base de données MySQL locale. | DBA, administrateur système | ## Ressources connexes **Références** + [Documentation Amazon EC2](https://docs.aws.amazon.com/ec2/) + [AWS DMS documentation](https://docs.aws.amazon.com/dms/) + [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/) + [AWS DMS Step-by-Step Procédures pas à pas](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) **Tutoriels et vidéos** + [Commencer avec AWS DMS](https://aws.amazon.com/dms/getting-started/) + [Présentation d'Amazon EC2 — Elastic Cloud Server & Hosting avec AWS(vidéo](https://www.youtube.com/watch?v=TsRBftzZsQo)) # Surveillez Amazon Aurora pour détecter les instances sans chiffrement *Mansi Suratwala, Amazon Web Services* ## Résumé Ce modèle fournit un CloudFormation modèle Amazon Web Services (AWS) que vous pouvez déployer pour configurer des notifications automatiques lorsqu'une instance Amazon Aurora est créée sans que le chiffrement soit activé. Aurora est un moteur de base de données relationnelle entièrement géré compatible avec MySQL et PostgreSQL. Avec certaines charges de travail, Aurora peut offrir un débit jusqu’à cinq fois supérieur à celui de MySQL et jusqu’à trois fois supérieur à celui de PostgreSQL sans qu’il soit nécessaire de modifier la plupart de vos applications existantes. Le CloudFormation modèle crée un événement Amazon CloudWatch Events et une fonction AWS Lambda. L'événement utilise AWS CloudTrail pour surveiller la création d'une instance Aurora ou la restauration ponctuelle d'une instance existante. L'événement Cloudwatch Events lance la fonction Lambda, qui vérifie si le chiffrement est activé. Si le chiffrement n'est pas activé, la fonction Lambda envoie une notification Amazon Simple Notification Service (Amazon SNS) vous informant de la violation. ## Conditions préalables et limitations **Prérequis****** + Un compte AWS actif **Limites** + Ce contrôle de service fonctionne uniquement avec les instances Amazon Aurora. Il ne prend pas en charge les autres instances Amazon Relational Database Service (Amazon RDS). + Le CloudFormation modèle doit être déployé pour `CreateDBInstance`**** et `RestoreDBClusterToPointInTim` **e** uniquement. **Versions du produit** + Versions de PostgreSQL prises en charge dans Amazon Aurora + Versions de MySQL prises en charge dans Amazon Aurora ## Architecture **Pile technologique cible** + Amazon Aurora + AWS CloudTrail + Amazon CloudWatch + AWS Lambda + Amazon Simple Storage Service (Amazon S3) + Amazon SNS **Architecture cible** ![\[Aurora se lance sans appel de chiffrement, sans CloudWatch événements CloudTrail, sans Lambda et sans message SNS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/de1528b8-a5a4-4c66-8ab3-7d9863572cbc/images/7dcab41a-d805-4bb0-99d1-1dcef37c4e55.png) **Automatisation et mise à l'échelle** Vous pouvez utiliser le CloudFormation modèle plusieurs fois pour différentes régions et différents comptes. Vous ne devez l'exécuter qu'une seule fois dans chaque région ou compte. ## Outils **Outils** + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) — Amazon Aurora est un moteur de base de données relationnelle entièrement géré compatible avec MySQL et PostgreSQL. + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html) — AWS vous CloudTrail aide à gérer la gouvernance, la conformité, ainsi que l'audit opérationnel et des risques de votre compte AWS. Les actions entreprises par un utilisateur, un rôle ou un service AWS sont enregistrées sous forme d'événements dans CloudTrail. + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html) — Amazon CloudWatch Events fournit un near-real-time flux d'événements système décrivant les modifications apportées aux ressources AWS. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) — AWS Lambda est un service de calcul qui prend en charge l'exécution de code sans provisionner ni gérer de serveurs. Lambda exécute le code uniquement lorsque cela est nécessaire et se met à l’échelle automatiquement, qu’il s’agisse de quelques requêtes par jour ou de milliers de requêtes par seconde. + [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/gsg/GetStartedWithS3.html) — Amazon Simple Storage Service (Amazon S3) est un service de stockage d'objets hautement évolutif que vous pouvez utiliser pour un large éventail de solutions de stockage, notamment les sites Web, les applications mobiles, les sauvegardes et les lacs de données. + [Amazon SNS —](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) Amazon Simple Notification Service (Amazon SNS) est un service géré qui fournit des messages via Lambda, HTTP, e-mail, notifications push mobiles et messages texte (SMS) mobiles. **Code** Un fichier .zip du projet est disponible en pièce jointe. ## Épopées ### Créez le compartiment S3 pour le script Lambda | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Définissez le compartiment S3. | Ouvrez la console Amazon S3 et choisissez ou créez un compartiment S3. Ce compartiment S3 hébergera le fichier .zip du code Lambda. Votre compartiment S3 doit se trouver dans la même région qu'Aurora. Le nom du compartiment S3 ne peut pas contenir de barres obliques en tête. | Architecte du cloud | ### Téléchargez le code Lambda dans le compartiment S3 | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Téléchargez le code Lambda. | Téléchargez le fichier .zip de code Lambda fourni dans la section *Pièces jointes* dans le compartiment S3 que vous avez défini. | Architecte du cloud | ### Déployer le CloudFormation modèle | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Déployez le CloudFormation modèle. | Sur la CloudFormation console, déployez le `RDS_Aurora_Encryption_At_Rest.yml` CloudFormation modèle fourni en pièce jointe à ce modèle. Dans l'épopée suivante, fournissez des valeurs pour les paramètres du modèle. | Architecte du cloud | ### Complétez les paramètres dans le CloudFormation modèle | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Indiquez le nom du compartiment S3. | Entrez le nom du compartiment S3 que vous avez créé ou choisi dans le premier épisode épique. | Architecte du cloud | | Fournissez la clé S3. | Indiquez l'emplacement du fichier .zip de code Lambda dans votre compartiment S3, sans barres obliques (par exemple,). `
(sidadm $> python systemReplicationStatus.py
sudo yum install -y awslogs| AWS en général | | Modifiez les fichiers de configuration de l'agent. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | AWS en général | | Démarrez l' CloudWatch agent. | Pour démarrer l'agent, utilisez la commande suivante.
$ sudo service awslogsd startAprès avoir démarré l'agent, vous pouvez consulter le groupe de journaux dans la CloudWatch console. Le flux du journal contiendra le contenu du fichier. | AWS en général | ### Étape 6. Création de filtres métriques pour le groupe de journaux | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez des filtres métriques pour les mots clés ABEND et STOPPED. | Lorsque vous créez des filtres métriques pour le groupe de journaux, chaque fois que les filtres sont identifiés dans le journal des erreurs, celui-ci déclenche une alarme et envoie une notification par e-mail en fonction de la configuration Amazon SNS.Pour créer des filtres métriques :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | CloudWatch | ### Étape 7. Configurer Amazon SNS | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une rubrique SNS. | Au cours de cette étape, vous configurez Amazon SNS pour créer des alarmes pour les filtres métriques.Pour créer une rubrique SNS :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | Amazon SNS | | Créez un abonnement. | Pour créer un abonnement à la rubrique :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html)Amazon SNS ouvre votre navigateur web et affiche une confirmation d'abonnement avec votre ID d'abonnement. | Amazon SNS | ### Étape 8. Créez une alarme pour envoyer des notifications pour les filtres métriques | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une alarme pour la rubrique SNS. | Pour créer une alarme basée sur un filtre métrique de groupe de logs :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html)Après ces étapes, chaque fois que ces modèles sont détectés dans le fichier journal des GoldenGate erreurs (`ggserr.log`) que vous surveillez, vous recevez une notification par e-mail. | CloudWatch | ## Résolution des problèmes | Problème | Solution | | --- | --- | | Le flux du journal des GoldenGate erreurs n'est pas acheminé vers CloudWatch. | Vérifiez le `/etc/awslogs/awslogs.conf` fichier pour vérifier le nom du fichier, le nom du groupe de journaux et le date/time format. Vous devez spécifier le date/time pour qu'il corresponde au format de date dans`ggserror.log`. Dans le cas contraire, le flux de log ne sera pas acheminé vers CloudWatch. | ## Ressources connexes + [ CloudWatch Documentation Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) + [Collecte de métriques et de journaux avec l' CloudWatch agent](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) + [Documentation Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) # Replateformage d'Oracle Database Enterprise Edition vers l'édition Standard 2 sur Amazon RDS for Oracle *Lanre (Lan-Ray) showummi et Tarun Chawla, Amazon Web Services* ## Résumé Oracle Database Enterprise Edition (EE) est un choix populaire pour exécuter des applications dans de nombreuses entreprises. Dans certains cas, toutefois, les applications n'utilisent que peu ou pas de fonctionnalités d'Oracle Database EE, de sorte qu'il n'est pas justifié d'engager des coûts de licence énormes. Vous pouvez réaliser des économies en rétrogradant ces bases de données vers Oracle Database Standard Edition 2 (SE2) lorsque vous migrez vers Amazon RDS. Ce modèle décrit comment rétrograder d'Oracle Database EE à Oracle Database SE2 lors d'une migration sur site vers [Amazon RDS](https://aws.amazon.com/rds/oracle/) for Oracle. Les étapes présentées dans ce modèle s'appliquent également si votre base de données EE Oracle est déjà exécutée sur Amazon RDS ou sur une instance [Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) (Amazon EC2). Pour plus d'informations, consultez le guide AWS Prescriptive Guidance sur la façon d'[évaluer la rétrogradation des bases de données Oracle vers l'édition Standard](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/welcome.html) 2 sur AWS. ## Conditions préalables et limitations **Conditions préalables** + Un compte AWS actif + Oracle Database Enterprise Edition + Outil client, tel qu'[Oracle SQL Developer](https://www.oracle.com/database/sqldeveloper/) ou SQL\$1Plus, permettant de se connecter à une base de données Oracle et d'exécuter des commandes SQL sur celle-ci + Utilisateur de la base de données pour effectuer l'évaluation ; par exemple, l'un des éléments suivants : + Utilisateur disposant de [privilèges](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Source.Oracle.html#CHAP_Source.Oracle.Permissions) suffisants pour exécuter l'évaluation [AWS Schema Conversion Tool (AWS SCT)](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html) + Utilisateur disposant de privilèges suffisants pour exécuter des requêtes SQL sur les tables du dictionnaire de base de données Oracle + Utilisateur de base de données pour effectuer la migration de base de données ; par exemple, l'un des éléments suivants : + Utilisateur disposant de [privilèges](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html#CHAP_Source.Oracle.Self-Managed) suffisants pour exécuter [AWS Database Migration Service (AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)) + Utilisateur disposant de [privilèges suffisants pour effectuer l'exportation et l'importation d'Oracle Data Pump](https://docs.oracle.com/database/121/SUTIL/GUID-8B6975D3-3BEC-4584-B416-280125EEC57E.htm#SUTIL807) + Utilisateur disposant de [privilèges suffisants pour exécuter Oracle GoldenGate](https://docs.oracle.com/goldengate/1212/gg-winux/GIORA/user_assignment.htm#GIORA546) **Limites** + Amazon RDS for Oracle dispose d'une taille de base de données maximale. Pour plus d’informations, consultez [Stockage d’instance de base de données Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Storage.html). **Versions du produit** La logique générale décrite dans ce document s'applique aux versions d'Oracle 9i et ultérieures. Pour connaître les versions prises en charge des bases de données autogérées et Amazon RDS for Oracle, consultez la documentation [AWS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html) DMS. Pour identifier l'utilisation des fonctionnalités dans les cas où AWS SCT n'est pas pris en charge, exécutez des requêtes SQL sur la base de données source. Pour effectuer une migration depuis des versions antérieures d'Oracle dans lesquelles AWS DMS et Oracle Data Pump ne sont pas pris en charge, utilisez les [utilitaires Oracle Export and Import](https://docs.oracle.com/cd/B19306_01/server.102/b14215/exp_imp.htm). Pour obtenir la liste actuelle des versions et éditions prises en charge, consultez [Oracle sur Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) dans la documentation AWS. Pour plus de détails sur la tarification et les classes d'instances prises en charge, veuillez consulter [Tarification d'Amazon RDS for Oracle](https://aws.amazon.com/rds/oracle/pricing/). ## Architecture **Pile technologique source** + Oracle Database Enterprise Edition s'exécutant sur site ou sur Amazon EC2 **Cibler la pile technologique à l'aide d'outils Oracle natifs** + Amazon RDS pour Oracle exécutant une base de données Oracle SE2 ![\[Processus en trois étapes pour la migration d'une base de données Oracle sur site vers Amazon RDS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/a1b28050-9bab-4de6-b2a9-b97b3e5070bd/images/bf765c5b-4b12-4a8c-b27c-c5e0bd605dd1.png) 1. Exportez les données à l'aide d'Oracle Data Pump. 1. Copiez les fichiers de vidage sur Amazon RDS via un lien de base de données. 1. Importez des fichiers de vidage sur Amazon RDS à l'aide d'Oracle Data Pump. **Cibler la pile technologique à l'aide d'AWS DMS** + Amazon RDS pour Oracle exécutant une base de données Oracle SE2 + AWS DMS ![\[Processus en quatre étapes pour la migration d'une base de données Oracle sur site vers Amazon RDS à l'aide d'AWS DMS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/a1b28050-9bab-4de6-b2a9-b97b3e5070bd/images/fef4eced-1acb-4303-baaa-5c1c29650935.png) 1. Exportez les données à l'aide d'Oracle Data Pump avec FLASHBACK\$1SCN. 1. Copiez les fichiers de vidage sur Amazon RDS via un lien de base de données. 1. Importez des fichiers de vidage sur Amazon RDS à l'aide d'Oracle Data Pump. 1. Utilisez la [capture des données de modification (CDC)](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Task.CDC.html) d'AWS DMS. ## Outils **Services AWS** + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) vous aide à migrer des magasins de données vers le cloud AWS ou entre des combinaisons de configurations cloud et sur site. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) vous aide à configurer, exploiter et dimensionner une base de données relationnelle dans le cloud AWS. Ce modèle utilise Amazon RDS for Oracle. + [AWS SCT****](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html) fournit une interface utilisateur basée sur un projet pour évaluer, convertir et copier automatiquement le schéma de base de données de votre base de données Oracle source dans un format compatible avec Amazon RDS for Oracle. AWS SCT vous permet d'analyser les économies potentielles qui peuvent être réalisées en modifiant le type de licence d'Oracle pour passer de l'édition Enterprise à l'édition Standard. La section **Évaluation des licences et support cloud** du rapport AWS SCT fournit des informations détaillées sur les fonctionnalités Oracle utilisées afin que vous puissiez prendre une décision éclairée lors de la migration vers Amazon RDS for Oracle. **Autres outils** + Les utilitaires natifs d'importation et d'exportation Oracle prennent en charge le transfert des données Oracle vers et depuis les bases de données Oracle. Oracle propose deux types d'utilitaires d'importation et d'exportation de bases de données : [Original Export and Import](https://docs.oracle.com/cd/B19306_01/server.102/b14215/exp_imp.htm) (pour les versions antérieures) et [Oracle Data Pump Export and Import](https://docs.oracle.com/cd/B19306_01/server.102/b14215/part_dp.htm#CEGJCCHC) (disponible dans Oracle Database 10g versions 1 et ultérieures). + [Oracle GoldenGate](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.OracleGoldenGate.html) propose des fonctionnalités de réplication en temps réel qui vous permettent de synchroniser votre base de données cible après un chargement initial. Cette option permet de réduire les temps d'arrêt des applications lors de la mise en service. ## Épopées ### Réaliser une évaluation préalable à la migration | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Validez les exigences de base de données pour vos applications. | Assurez-vous que vos applications sont certifiées pour fonctionner sur Oracle Database SE2. Renseignez-vous directement auprès du fournisseur du logiciel, du développeur ou de la documentation de l'application. | Développeur d'applications, DBA, propriétaire de l'application | | Étudiez l'utilisation des fonctionnalités EE directement dans la base de données. | Pour déterminer l'utilisation des fonctionnalités EE, effectuez l'une des opérations suivantes :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.html) | Propriétaire de l'application, DBA, développeur d'applications | | Identifier l'utilisation des fonctionnalités EE pour les activités opérationnelles. | Les administrateurs de bases de données ou d'applications s'appuient parfois sur des fonctionnalités d'EE uniquement pour leurs activités opérationnelles. Les exemples courants incluent les activités de maintenance en ligne (reconstruction d'index, déplacement de tables) et l'utilisation du parallélisme par des tâches par lots.Ces dépendances peuvent être atténuées en modifiant vos opérations dans la mesure du possible. Identifiez l'utilisation de ces fonctionnalités et prenez une décision basée sur les coûts par rapport aux avantages.Utilisez le tableau de [comparaison entre Oracle Database EE et les SE2 fonctionnalités](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/compare-features.html) comme guide pour identifier les fonctionnalités disponibles dans Oracle Database SE2. | Développeur d'applications, DBA, propriétaire de l'application | | Passez en revue les modèles de charge de travail de la base de données EE Oracle. | Oracle Database limite SE2 automatiquement l'utilisation à un maximum de 16 threads CPU à tout moment.Si votre base de données Oracle EE est autorisée à utiliser le pack de diagnostic Oracle, utilisez l'outil Automatic Workload Repository (AWR), ou les vues DBA\$1HIST\$1\$1, pour analyser les modèles de charge de travail de la base de données afin de déterminer si la limite maximale de 16 threads CPU aura un impact négatif sur les niveaux de service en cas de rétrogradation vers. SE2Assurez-vous que votre évaluation couvre les périodes de pointe, telles que le traitement en fin de journée, de mois ou d'année. | Propriétaire de l'application, DBA, développeur d'applications | ### Préparer l'infrastructure cible sur AWS | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Déployez et configurez l'infrastructure réseau. | Créez un [cloud privé virtuel (VPC) ainsi que des sous-réseaux, des [groupes de sécurité](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) et](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html) des listes de contrôle [d'accès réseau](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html). | Administrateur AWS, architecte cloud, administrateur réseau, DevOps ingénieur | | Approvisionnez la base de données Amazon RDS for SE2 Oracle. | Provisionnez la base de données [Amazon RDS for](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.Oracle.html) SE2 Oracle cible afin de répondre aux exigences de performance, de disponibilité et de sécurité de vos applications. Nous recommandons une configuration multi-AZ pour les charges de travail de production. Toutefois, pour améliorer les performances de migration, vous pouvez différer l'[activation de Multi-AZ](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/create-multi-az-db-cluster.html) jusqu'à la fin de la migration des données. | Administrateur cloud, architecte cloud, DBA, DevOps ingénieur, administrateur AWS | | Personnalisez l'environnement Amazon RDS. | Configurez [des paramètres](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) et [options](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithOptionGroups.html) personnalisés et activez une [surveillance](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/MonitoringOverview.html) supplémentaire. Pour plus d'informations, consultez la section [Meilleures pratiques pour la migration vers Amazon RDS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html) for Oracle. | Administrateur AWS, administrateur système AWS, administrateur cloud, DBA, architecte cloud | ### Effectuer les tests de migration, de fonctionnement à sec et d'application | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Migrez les données (essai à sec). | Migrez les données de la base de données Oracle EE source vers l'instance de base de données Amazon RDS for SE2 Oracle en utilisant l'approche la mieux adaptée à votre environnement spécifique. Sélectionnez une stratégie de migration en fonction de facteurs tels que la taille, la complexité et la période d'indisponibilité disponible. Utilisez l'une ou plusieurs des options suivantes :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.html) | DBA | | Validez la base de données cible. | Effectuez la validation après la migration du stockage de la base de données et des objets de code. Consultez les journaux de migration et corrigez les problèmes identifiés. Pour plus d'informations, consultez le guide [Migration des bases de données Oracle vers le cloud AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html#post-import). | DBA | | Testez les applications. | Les administrateurs d'applications et de bases de données doivent effectuer des tests fonctionnels, de performance et opérationnels, le cas échéant. Pour plus d'informations, consultez la section [Meilleures pratiques pour la migration vers Amazon RDS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html#test-migration) for Oracle.Enfin, obtenez l'approbation des résultats des tests par les parties prenantes. | Développeur d'applications, propriétaire de l'application, DBA, ingénieur de migration, responsable de la migration | ### Découper | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Actualisez les données depuis Oracle Database EE. | Sélectionnez une approche d'actualisation des données en fonction des exigences de disponibilité des applications. Pour plus d'informations, consultez les méthodes de migration dans la section [Stratégies de migration des bases de données Oracle vers AWS](https://docs.aws.amazon.com/whitepapers/latest/strategies-migrating-oracle-db-to-aws/data-migration-methods.html).Par exemple, vous pouvez atteindre un temps d'arrêt quasi nul en utilisant des outils tels qu'Oracle GoldenGate ou AWS DMS avec réplication continue. Si la période d'indisponibilité le permet, vous pouvez effectuer le transfert final des données à l'aide de méthodes hors ligne telles que les utilitaires Oracle Data Pump ou Original Export-Import. | Propriétaire de l'application, responsable du transfert, administrateur de base de données, ingénieur de migration, responsable de la migration | | Pointez les applications vers l'instance de base de données cible. | Mettez à jour les paramètres de connexion dans les applications et les autres clients pour qu'ils pointent vers la base de données Amazon RDS for SE2 Oracle. | Développeur d'applications, propriétaire de l'application, ingénieur de migration, responsable de la migration, responsable du transfert | | Effectuez des activités après la migration. | Effectuez des tâches après la migration des données, telles que l'activation de la technologie multi-AZ, la validation des données et d'autres vérifications. | DBA, ingénieur en migration | | Effectuez une surveillance après le passage. | Utilisez des outils tels qu'[Amazon CloudWatch](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/monitoring-cloudwatch.html) et Amazon [RDS Performance Insights](https://aws.amazon.com/rds/performance-insights/) pour surveiller la base de données Amazon RDS for SE2 Oracle. | Développeur d'applications, propriétaire de l'application, administrateur AWS, DBA, ingénieur de migration | ## Ressources connexes **Recommandations AWS** + [Migration de bases de données Oracle vers le cloud AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/welcome.html) (guide) + [Évaluer la rétrogradation des bases de données Oracle vers l'édition Standard 2 sur AWS (guide](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/welcome.html)) + [Migrer une base de données Oracle sur site vers Amazon RDS for](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) Oracle (modèle) + [Migrate an on-premises Oracle database to Amazon RDS for Oracle using 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) (modèle) **Billets de blogs** + [Migration de bases de données Oracle avec des interruptions de service quasi nulles à l'aide d'AWS DMS](https://aws.amazon.com/blogs/database/migrating-oracle-databases-with-near-zero-downtime-using-aws-dms/) + [Analyse de la gestion des performances dans Oracle SE à l'aide d'Amazon RDS for Oracle](https://aws.amazon.com/blogs/database/analyzing-performance-management-in-oracle-se-using-amazon-rds-for-oracle/) + [Gestion de votre plan SQL dans Oracle SE avec Amazon RDS for Oracle](https://aws.amazon.com/blogs/database/managing-your-sql-plan-in-oracle-se-with-amazon-rds-for-oracle/) + [Implémentation du partitionnement des tables dans Oracle Standard Edition : partie 1](https://aws.amazon.com/blogs/database/implementing-table-partitioning-in-oracle-standard-edition-part-1/) # Répliquez des bases de données mainframe sur AWS à l'aide de Precisely Connect *Lucio Pereira, Sayantan Giri et Balaji Mohan, Amazon Web Services* ## Résumé Ce modèle décrit les étapes à suivre pour répliquer les données des bases de données mainframe vers les magasins de données Amazon en temps quasi réel à l'aide de Precisely Connect. Il met en œuvre une architecture basée sur les événements avec Amazon Managed Streaming for Apache Kafka (Amazon MSK) et des connecteurs de base de données personnalisés dans le cloud afin d'améliorer l'évolutivité, la résilience et les performances. Precisely Connect est un outil de réplication qui capture les données des systèmes mainframe existants et les intègre dans des environnements cloud. Les données sont répliquées des mainframes vers AWS par le biais de la capture des données de modification (CDC) en utilisant des flux de messages en temps quasi réel avec des pipelines de données hétérogènes à faible latence et à haut débit. Ce modèle couvre également une stratégie de reprise après sinistre pour des pipelines de données résilients avec réplication des données multirégions et routage sur incident. ## Conditions préalables et limitations **Conditions préalables** + Une base de données mainframe existante, par exemple IBM DB2, IBM Information Management System (IMS) ou Virtual Storage Access Method (VSAM), que vous souhaitez répliquer dans le cloud AWS + Un [compte AWS](https://aws.amazon.com/account/) actif + [AWS Direct Connect](https://aws.amazon.com/directconnect/) ou [réseau privé virtuel AWS (AWS VPN](https://aws.amazon.com/vpn/)) entre votre environnement d'entreprise et AWS + Un [cloud privé virtuel](https://aws.amazon.com/vpc/) avec un sous-réseau accessible par votre ancienne plateforme ## Architecture **Pile technologique source** Un environnement mainframe qui inclut au moins l'une des bases de données suivantes : + Base de données IBM IMS + Base de DB2 données IBM + fichiers VSAM **Pile technologique cible** + Amazon MSK + Amazon Elastic Kubernetes Service (Amazon EKS) et Amazon EKS Anywhere + Docker + Une base de données relationnelle ou NoSQL AWS telle que la suivante : + Amazon DynamoDB + Amazon Relational Database Service (Amazon RDS) pour Oracle, Amazon RDS pour PostgreSQL ou Amazon Aurora + Amazon ElastiCache pour Redis + Amazon Keyspaces (pour Apache Cassandra) **Architecture cible** *Réplication des données du mainframe vers des bases de données AWS* Le schéma suivant illustre la réplication des données du mainframe vers une base de données AWS telle que DynamoDB, Amazon RDS, Amazon ou Amazon Keyspaces ElastiCache. La réplication s'effectue en temps quasi réel à l'aide de Precisely Capture et Publisher dans votre environnement mainframe sur site, de Precisely Dispatcher sur Amazon EKS Anywhere dans votre environnement distribué sur site, et de Precisely Apply Engine et des connecteurs de base de données dans le cloud AWS. ![\[Réplication des données du mainframe vers des bases de données AWS\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/777dd7da-48ed-4510-b8fa-9041be042671.png) Le schéma suivant illustre le flux de travail suivant : 1. Precisely Capture extrait les données du mainframe à partir des journaux du CDC et les conserve dans un stockage transitoire interne. 1. Precisely Publisher écoute les modifications apportées au stockage interne des données et envoie les enregistrements CDC à Precisely Dispatcher via une TCP/IP connexion. 1. Precisely Dispatcher reçoit les enregistrements CDC de Publisher et les envoie à Amazon MSK. Dispatcher crée des clés Kafka en fonction de la configuration utilisateur et de plusieurs tâches de travail pour envoyer des données en parallèle. Dispatcher envoie un accusé de réception à Publisher lorsque les enregistrements ont été stockés dans Amazon MSK. 1. Amazon MSK détient les dossiers du CDC dans l'environnement cloud. La taille de partition des sujets dépend des exigences de débit de votre système de traitement des transactions (TPS). La clé Kafka est obligatoire pour toute transformation ultérieure et pour la commande de transactions. 1. Le moteur Precisely Apply écoute les enregistrements CDC d'Amazon MSK et transforme les données (par exemple, en filtrant ou en mappant) en fonction des exigences de la base de données cible. Vous pouvez ajouter une logique personnalisée aux scripts Precisely SQD. (SQD est le langage propriétaire de Precisely.) Le moteur Precisely Apply transforme chaque enregistrement CDC au format Apache Avro ou JSON et le distribue à différents sujets en fonction de vos besoins. 1. Les rubriques Kafka cibles contiennent des enregistrements CDC dans plusieurs rubriques en fonction de la base de données cible, et Kafka facilite l'ordre des transactions en fonction de la clé Kafka définie. Les clés de partition s'alignent sur les partitions correspondantes pour permettre un processus séquentiel. 1. Les connecteurs de base de données (applications Java personnalisées) écoutent les enregistrements CDC d'Amazon MSK et les stockent dans la base de données cible. 1. Vous pouvez sélectionner une base de données cible en fonction de vos besoins. Ce modèle prend en charge les bases de données NoSQL et relationnelles. *Reprise après sinistre* La continuité des activités est essentielle au succès de votre entreprise. Le cloud AWS fournit des fonctionnalités de haute disponibilité (HA) et de reprise après sinistre (DR), et prend en charge les plans de reprise et de secours de votre organisation. Ce modèle suit une stratégie de reprise après active/passive sinistre et fournit des conseils de haut niveau pour la mise en œuvre d'une stratégie de reprise après sinistre qui répond à vos exigences en matière de RTO et de RPO. Le schéma suivant illustre le flux de travail DR. ![\[Flux de travail de reprise après sinistre pour la réplication des données du mainframe sur AWS\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/9cccba7a-7a25-411e-829f-7cd5a7a20ab4.png) Le diagramme décrit les éléments suivants : 1. Un basculement semi-automatique est nécessaire en cas de panne dans la région 1 d'AWS. En cas de panne dans la région 1, le système doit initier les modifications de routage pour connecter Precisely Dispatcher à la région 2. 1. Amazon MSK réplique les données par le biais de la mise en miroir entre les régions. C'est pourquoi, lors du basculement, le cluster Amazon MSK de la région 2 doit être promu en tant que principal leader. 1. Le moteur Precisely Apply et les connecteurs de base de données sont des applications sans état qui peuvent fonctionner dans n'importe quelle région. 1. La synchronisation des bases de données dépend de la base de données cible. Par exemple, DynamoDB peut utiliser des tables globales ElastiCache et des banques de données globales. *Traitement à faible latence et haut débit via des connecteurs de base de données* Les connecteurs de base de données sont des composants essentiels de ce modèle. Les connecteurs suivent une approche basée sur les écouteurs pour collecter les données d'Amazon MSK et envoyer des transactions à la base de données via un traitement à haut débit et à faible latence pour les applications critiques (niveaux 0 et 1). Le schéma suivant illustre ce processus. ![\[Utilisation de connecteurs de base de données pour répliquer les données du mainframe sur AWS\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/79479634-becb-4212-bbfc-1a3b17ae1bed.png) Ce modèle permet le développement d'une application personnalisée consommant un seul thread grâce à un moteur de traitement multithread. 1. Le thread principal du connecteur consomme les enregistrements CDC d'Amazon MSK et les envoie au pool de threads pour traitement. 1. Les threads du pool de threads traitent les enregistrements CDC et les envoient à la base de données cible. 1. Si tous les threads sont occupés, les enregistrements CDC sont conservés par la file d'attente des threads. 1. Le thread principal attend que tous les enregistrements soient effacés de la file d'attente des threads et valide les offsets dans Amazon MSK. 1. Les threads enfants gèrent les défaillances. En cas d'échec pendant le traitement, les messages d'échec sont envoyés à la rubrique DLQ (file d'attente de lettres mortes). 1. Les threads enfants initient les mises à jour conditionnelles (voir [Expressions de condition](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html) dans la documentation DynamoDB), en fonction de l'horodatage du mainframe, afin d'éviter toute duplication ou mise à jour dans la base de données. out-of-order Pour plus d'informations sur la mise en œuvre d'une application client Kafka dotée de fonctionnalités multithreading, consultez le billet de blog intitulé [Multi-Threaded Message Consumption with the Apache Kafka Consumer sur le](https://www.confluent.io/blog/kafka-consumer-multi-threaded-messaging/) site Web de Confluent. ## Outils **Services AWS** + [Amazon Managed Streaming for Apache Kafka (Amazon MSK)](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html) est un service entièrement géré qui vous permet de créer et d'exécuter des applications utilisant Apache Kafka pour traiter les données de streaming. + [Amazon Elastic Kubernetes Service (Amazon](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) EKS) vous aide à exécuter Kubernetes sur AWS sans avoir à installer ou à gérer votre propre plan de contrôle ou vos propres nœuds Kubernetes. + [Amazon EKS Anywhere](https://anywhere.eks.amazonaws.com/docs/) vous aide à déployer, utiliser et gérer des clusters Kubernetes exécutés dans vos propres centres de données. + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) est un service de base de données NoSQL entièrement géré, offrant des performances rapides, prévisibles et évolutives. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) vous aide à configurer, exploiter et dimensionner une base de données relationnelle dans le cloud AWS. + [Amazon](https://docs.aws.amazon.com/elasticache/) vous ElastiCache aide à configurer, gérer et faire évoluer des environnements de cache en mémoire distribués dans le cloud AWS. + [Amazon Keyspaces (pour Apache Cassandra)](https://docs.aws.amazon.com/keyspaces/latest/devguide/what-is-keyspaces.html) est un service de base de données géré qui vous aide à migrer, exécuter et dimensionner vos charges de travail Cassandra dans le cloud AWS. **Autres outils** + [Precisely Connect](https://www.precisely.com/product/precisely-connect/connect) intègre les données des systèmes mainframe existants tels que les ensembles de données VSAM ou les bases de données mainframe IBM dans des plateformes cloud et de données de nouvelle génération. ## Bonnes pratiques + Trouvez la meilleure combinaison de partitions Kafka et de connecteurs multithread pour un équilibre optimal entre performances et coûts. Plusieurs instances de Precisely Capture et Dispatcher peuvent augmenter les coûts en raison de la consommation plus élevée de MIPS (millions d'instructions par seconde). + Évitez d'ajouter une logique de manipulation et de transformation des données aux connecteurs de base de données. Pour ce faire, utilisez le moteur Precisely Apply, qui fournit les temps de traitement en microsecondes. + Créez des appels périodiques de demande ou de vérification de l'état de la base de données (*pulsations cardiaques*) dans les connecteurs de base de données afin de réchauffer fréquemment la connexion et de réduire le temps de latence. + Implémentez une logique de validation du pool de threads pour comprendre les tâches en attente dans la file d'attente des threads et attendez que tous les threads soient terminés avant le prochain sondage Kafka. Cela permet d'éviter la perte de données en cas de panne d'un nœud, d'un conteneur ou d'un processus. + Exposez les mesures de latence via les points de terminaison de santé afin d'améliorer les capacités d'observabilité grâce à des tableaux de bord et à des mécanismes de suivi. ## Épopées ### Préparation de l'environnement source (sur site) | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Configurez le processus du mainframe (batch ou utilitaire en ligne) pour démarrer le processus CDC à partir des bases de données du mainframe. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Ingénieur mainframe | | Activez les flux de journaux de la base de données mainframe. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Spécialiste des bases de données mainframe | | Utilisez le composant Capture pour capturer les enregistrements CDC. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Ingénieur mainframe, Precisely Connect SME | | Configurez le composant Publisher pour écouter le composant Capture. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Ingénieur mainframe, Precisely Connect SME | | Provisionnez Amazon EKS Anywhere dans l'environnement distribué sur site. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingénieur | | Déployez et configurez le composant Dispatcher dans l'environnement distribué pour publier les rubriques dans le cloud AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingénieur, Precisely Connect PME | ### Préparation de l'environnement cible (AWS) | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Provisionnez un cluster Amazon EKS dans la région AWS désignée. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingénieur, administrateur réseau | | Provisionnez un cluster MSK et configurez les rubriques Kafka applicables. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingénieur, administrateur réseau | | Configurez le composant Apply Engine pour écouter les sujets Kafka répliqués. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Precisely Connect PME | | Provisionnez des instances de base de données dans le cloud AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Ingénieur de données, DevOps ingénieur | | Configurez et déployez des connecteurs de base de données pour écouter les rubriques publiées par le moteur Apply. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Développeur d'applications, Architecte cloud, Ingénieur de données | ### Configurez la continuité des activités et la reprise après sinistre | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Définissez des objectifs de reprise après sinistre pour vos applications professionnelles. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Architecte cloud, ingénieur des données, propriétaire de l'application | | Concevez des stratégies de reprise après sinistre basées sur un RTO/RPO défini. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Architecte cloud, ingénieur de données | | Provisionnez des clusters et des configurations de reprise après sinistre. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps ingénieur, administrateur réseau, architecte cloud | | Testez le pipeline du CDC pour la reprise après sinistre. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Propriétaire de l'application, ingénieur de données, architecte cloud | ## Ressources connexes **Ressources AWS** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) + [Expressions de condition avec 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 et Amazon Aurora](https://docs.aws.amazon.com/rds/index.html) + [Amazon VPC](https://docs.aws.amazon.com/vpc/index.html) **Ressources Precisely Connect** + [Présentation de Precisely Connect](https://www.precisely.com/product/precisely-connect/connect) + [Changez la capture de données avec Precisely Connect](https://help.precisely.com/r/Connect-CDC-SQData/4.1/en-US/Connect-CDC-SQData-Installation/Connect-CDC-SQData-Architecture) **Ressources de Confluent** + [Consommation de messages multithread avec Apache Kafka Consumer](https://www.confluent.io/blog/kafka-consumer-multi-threaded-messaging/) # Planifiez des tâches pour Amazon RDS for PostgreSQL et Aurora PostgreSQL à l'aide de Lambda et Secrets Manager *Yaser Raja, Amazon Web Services* ## Résumé Pour les bases de données locales et les bases de données hébergées sur des instances Amazon Elastic Compute Cloud (Amazon EC2), les administrateurs de base de données utilisent souvent l'utilitaire **cron** pour planifier les tâches. Par exemple, une tâche d'extraction de données ou une tâche de purge de données peuvent être facilement planifiées à l'aide de **cron**. Pour ces tâches, les informations d'identification de base de données sont généralement codées en dur ou stockées dans un fichier de propriétés. **Toutefois, lorsque vous migrez vers Amazon Relational Database Service (Amazon RDS) ou Amazon Aurora PostgreSQL Compatible Edition, vous ne pouvez plus vous connecter à l'instance hôte pour planifier des tâches cron.** Ce modèle décrit comment utiliser AWS Lambda et planifier des tâches pour AWS Secrets Manager les bases de données compatibles Amazon RDS for PostgreSQL et Aurora PostgreSQL après la migration. ## Conditions préalables et limitations **Conditions préalables** + Un actif Compte AWS + Une base de données compatible avec Amazon RDS for PostgreSQL ou Aurora PostgreSQL **Limites** + Une tâche doit être terminée dans les 15 minutes, ce qui correspond au délai d'expiration de la fonction Lambda. Pour les autres limites, consultez la [AWS Lambda documentation](https://docs.aws.amazon.com/lambda/latest/dg/limits.html). + Le code du job doit être écrit dans un [langage compatible avec Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). ## Architecture **Pile technologique source** Cette pile contient des jobs écrits dans des langages tels que Bash, Python et Java. Les informations d'identification de la base de données sont stockées dans le fichier de propriétés et la tâche est planifiée à l'aide de Linux **cron**. **Pile technologique cible** Cette pile possède une fonction Lambda qui utilise les informations d'identification stockées dans Secrets Manager pour se connecter à la base de données et effectuer l'activité. La fonction Lambda est lancée à l'intervalle planifié à l'aide d'Amazon CloudWatch Events. **Architecture cible** ![\[CloudWatch événement démarrant une fonction Lambda qui planifie des tâches pour l'instance de base de données RDS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/8e0d1c90-0599-4909-a800-26a89b87f686/images/61f9ca34-9157-4565-96ba-5234d389ac2a.png) ## Outils + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html) fournit un flux en temps quasi réel d'événements système décrivant les modifications apportées aux AWS ressources. À l'aide de règles simples que vous pouvez configurer rapidement, vous pouvez associer des événements et les acheminer vers une ou plusieurs fonctions ou flux cibles. CloudWatch Events prend conscience des changements opérationnels au fur et à mesure qu'ils se produisent. Il répond à ces changements opérationnels et prend les mesures correctives nécessaires, en envoyant des messages pour répondre à l'environnement, en activant des fonctions, en apportant des modifications et en capturant des informations d'état. Vous pouvez également utiliser les CloudWatch événements pour planifier des actions automatisées qui se déclenchent automatiquement à certains moments à l'aide d'**expressions cron** ou **rate**. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) est un service informatique qui vous permet d’exécuter un code sans demander la mise en service ou la gestion des serveurs. Lambda exécute le code uniquement lorsque cela est nécessaire et se met à l’échelle automatiquement, qu’il s’agisse de quelques requêtes par jour ou de milliers de requêtes par seconde. Vous ne payez que pour le temps de calcul que vous consommez ; aucun frais n'est facturé lorsque votre code n'est pas en cours d'exécution. Avec Lambda, vous pouvez exécuter du code pour pratiquement n'importe quel type d'application ou de service principal sans aucune administration. Lambda exécute votre code sur une infrastructure informatique à haute disponibilité et gère toutes les ressources de calcul, y compris la maintenance des serveurs et des systèmes d'exploitation, le provisionnement des capacités et le dimensionnement automatique, la surveillance du code et la journalisation. Il vous suffit de fournir votre code dans l'un des [langages pris en charge par 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)vous aide à protéger les secrets d'accès à vos applications, services et ressources informatiques. Vous pouvez facilement faire pivoter, gérer et récupérer les informations d'identification de base de données, les clés d'API et d'autres secrets tout au long de leur cycle de vie. Les utilisateurs et les applications récupèrent les secrets en appelant Secrets Manager APIs, ce qui élimine le besoin de coder en dur les informations sensibles en texte brut. Secrets Manager propose une rotation secrète avec intégration intégrée à Amazon RDS, Amazon Redshift et Amazon DocumentDB. Le service est extensible à d'autres types de secrets, notamment les clés d'API et les OAuth jetons. Secrets Manager vous permet de contrôler l'accès aux secrets à l'aide d'autorisations détaillées et d'auditer la rotation des secrets de manière centralisée pour les ressources dans les AWS Cloud services tiers et sur site. ## Épopées ### Stocker les informations d'identification de la base de données dans Secrets Manager | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un utilisateur de base de données pour la fonction Lambda. | Il est recommandé d'utiliser des utilisateurs de base de données distincts pour les différentes parties de votre application. S'il existe déjà un utilisateur de base de données distinct pour vos tâches cron, utilisez-le. Dans le cas contraire, créez un nouvel utilisateur de base de données. Pour plus d'informations, consultez [la section Gestion des utilisateurs et des rôles PostgreSQL](https://aws.amazon.com/blogs/database/managing-postgresql-users-and-roles/)AWS (article de blog). | DBA | | Stockez les informations d'identification de la base de données sous forme de secret dans Secrets Manager. | Suivez les instructions de la section [Création d'un secret de base](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_database_secret.html) de données (documentation Secrets Manager). | DBA, DevOps | ### Créez le code de la fonction Lambda | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Choisissez un langage de programmation pris en charge par Lambda. | Pour obtenir la liste des langages pris en charge, consultez les environnements d'[exécution Lambda (documentation](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html) Lambda). | Developer | | Écrivez la logique pour récupérer les informations d'identification de la base de données depuis Secrets Manager. | Pour un exemple de code, voir [Comment fournir en toute sécurité des informations d'identification de base de données aux fonctions Lambda en utilisant AWS Secrets Manager](https://aws.amazon.com/blogs/security/how-to-securely-provide-database-credentials-to-lambda-functions-by-using-aws-secrets-manager/) (article de AWS blog). | Developer | | Écrivez la logique pour exécuter l'activité de base de données planifiée. | Migrez votre code existant pour la tâche de planification que vous utilisez sur site vers la fonction Lambda. Pour plus d'informations, consultez [Déploiement de fonctions Lambda (documentation](https://docs.aws.amazon.com/lambda/latest/dg/lambda-deploy-functions.html) Lambda). | Developer | ### Déployez le code et créez la fonction Lambda | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez le package de déploiement de la fonction Lambda. | Ce paquet contient le code et ses dépendances. Pour plus d'informations, consultez [Packages de déploiement](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) (documentation Lambda). | Developer | | Créez la fonction Lambda. | Dans la console Lambda, choisissez **Create function**, entrez un nom de fonction, choisissez l'environnement d'exécution, puis choisissez **Create** function. | DevOps | | Charger un package de déploiement | Choisissez la fonction Lambda que vous avez créée pour ouvrir sa configuration. Vous pouvez écrire votre code directement dans la section du code ou télécharger votre package de déploiement. Pour télécharger votre package, accédez à la section **Code de fonction**, choisissez le **type d'entrée de code** pour télécharger un fichier .zip, puis sélectionnez le package. | DevOps | | Configurez la fonction Lambda selon vos besoins. | Par exemple, vous pouvez définir le paramètre **Timeout sur** la durée prévue pour votre fonction Lambda. Pour plus d'informations, consultez [Configuration des options de fonction](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-common.html) (documentation Lambda). | DevOps | | Définissez les autorisations pour le rôle de fonction Lambda afin d'accéder à Secrets Manager. | Pour obtenir des instructions, consultez la section [Utiliser des secrets dans AWS Lambda les fonctions](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets_lambda.html) (documentation Secrets Manager). | DevOps | | Testez la fonction Lambda. | Lancez la fonction Lambda manuellement pour vous assurer qu'elle fonctionne comme prévu. | DevOps | ### Planifiez la fonction Lambda à l'aide d'Events CloudWatch | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une règle pour exécuter votre fonction Lambda selon une planification. | Planifiez la fonction Lambda à l'aide CloudWatch d'Events. Pour obtenir des instructions, voir [Planifier des fonctions Lambda à l'aide d' CloudWatch événements](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/RunLambdaSchedule.html) (didacticiel sur CloudWatch les événements). | DevOps | ## Ressources connexes + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) + [Commencer à utiliser Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) + [Création d'une règle d' CloudWatch événements qui déclenche un événement](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-Rule.html) + [AWS Lambda Restrictions](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) + [Interrogez votre AWS base de données depuis votre application sans serveur](https://aws.amazon.com/blogs/database/query-your-aws-database-from-your-serverless-application/) (article de blog) # Envoyer des notifications pour une instance de base de données Amazon RDS for SQL Server à l'aide d'un serveur SMTP sur site et de Database Mail *Nishad Mankar, Amazon Web Services* ## Résumé [Database Mail](https://learn.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail?view=sql-server-ver16) (documentation Microsoft) envoie des messages électroniques, tels que des notifications ou des alertes, à partir d'une base de données Microsoft SQL Server à l'aide d'un serveur SMTP (Simple Mail Transfer Protocol). La documentation Amazon Relational Database Service (Amazon RDS) pour Microsoft SQL Server fournit des instructions pour utiliser Amazon Simple Email Service (Amazon SES) comme serveur SMTP pour le courrier de base de données. Pour plus d’informations, consultez [Utilisation de Database Mail sur Amazon RDS for SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html). Comme configuration alternative, ce modèle explique comment configurer Database Mail pour envoyer des e-mails depuis une instance de base de données (DB) Amazon RDS for SQL Server en utilisant un serveur SMTP sur site comme serveur de messagerie. ## Conditions préalables et limitations **Conditions préalables** + Un compte AWS actif + Une instance de base de données Amazon RDS exécutant une édition Standard ou Enterprise de SQL Server + Adresse IP ou nom d'hôte du serveur SMTP local + [Règle de groupe de sécurité](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html#working-with-security-group-rules) entrant qui autorise les connexions à l'instance de base de données Amazon RDS for SQL Server à partir de l'adresse IP du serveur SMTP + Une connexion, telle qu'une connexion [AWS Direct Connect](https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html), entre votre réseau sur site et le cloud privé virtuel (VPC) qui contient l'instance de base de données Amazon RDS **Limites** + Les éditions Express de SQL Server ne sont pas prises en charge. + Pour plus d'informations sur les limitations, consultez la section [Limitations relatives](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html#SQLServer.Concepts.General.FeatureSupport.Limits) à *l'utilisation de Database Mail sur Amazon RDS for SQL Server* dans la documentation Amazon RDS. **Versions du produit** + Éditions Standard et Enterprise des [versions de SQL Server prises en charge par RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html#SQLServer.Concepts.General.VersionSupport) ## Architecture **Pile technologique cible** + Instance de base de données Amazon RDS for SQL Server + Règle de transfert Amazon Route 53 + Messagerie de base de données + Serveur SMTP sur site + Microsoft SQL Server Management Studio (SSMS) **Architecture cible** L'image suivante montre l'architecture cible pour ce modèle. Lorsqu'un événement ou une action déclenche une notification ou une alerte concernant l'instance de base de données, Amazon RDS for SQL Server utilise Database Mail pour envoyer une notification par e-mail. Database Mail utilise le serveur SMTP local pour envoyer le courrier électronique. ![\[Amazon RDS for SQL Server utilise un serveur SMTP sur site pour envoyer des notifications par e-mail aux utilisateurs.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/e5599724-43cf-4fe1-8c5a-8fca1a424993/images/47efb12f-3505-4a60-ac43-194a176e71c8.png) ## Outils **Services AWS** + [Amazon Relational Database Service (Amazon RDS) pour Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html) vous aide à configurer, exploiter et dimensionner une base de données relationnelle SQL Server dans le cloud AWS. + [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) est un service Web DNS hautement disponible et évolutif. **Autres outils** + [Database Mail](https://learn.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail) est un outil qui envoie des messages électroniques, tels que des notifications et des alertes, depuis le moteur de base de données SQL Server aux utilisateurs. + [Microsoft SQL Server Management Studio (SSMS)](https://docs.microsoft.com/en-us/sql/ssms/sql-server-management-studio-ssms) est un outil de gestion de SQL Server, y compris l'accès, la configuration et l'administration des composants de SQL Server. Dans ce modèle, vous utilisez SSMS pour exécuter les commandes SQL afin de configurer Database Mail sur une instance de base de données Amazon RDS for SQL Server. ## Épopées ### Activez la connectivité réseau avec le serveur SMTP local | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Supprimez Multi-AZ de l'instance de base de données RDS. | Si vous utilisez une instance de base de données RDS multizone, convertissez-la en instance mono-AZ. Lorsque vous aurez terminé de configurer Database Mail, vous reconvertirez l'instance de base de données en déploiement multi-AZ. La configuration Database Mail fonctionne alors à la fois dans les nœuds principal et secondaire. Pour obtenir des instructions, consultez la section [Suppression de Multi-AZ d'une instance de base de données Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerMultiAZ.html#USER_SQLServerMultiAZ.Removing). | DBA | | Créez une liste d'autorisations pour le point de terminaison ou l'adresse IP Amazon RDS sur le serveur SMTP local. | Le serveur SMTP se trouve en dehors du réseau AWS. Sur le serveur SMTP local, créez une liste d'autorisation qui permet au serveur de communiquer avec le point de terminaison sortant ou l'adresse IP de l'instance Amazon RDS ou de l'instance Amazon Elastic Compute Cloud (Amazon EC2) hébergée sur Amazon RDS. Cette procédure varie d'une organisation à l'autre. Pour plus d'informations sur le point de terminaison de l'instance de base de données, consultez [Trouver le point de terminaison et le numéro de port de l'instance](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html#sqlserver-endpoint) de base de données. | DBA | | Supprimez les restrictions du port 25. | Par défaut, AWS limite le port 25 aux EC2 instances. Pour supprimer la restriction du port 25, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/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/fr_fr/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 général | | Ajoutez une règle Route 53 pour résoudre les requêtes DNS pour le serveur SMTP. | Utilisez Route 53 pour résoudre les requêtes DNS entre vos ressources AWS et le serveur SMTP sur site. Vous devez créer une règle qui transfère les requêtes DNS au domaine du serveur SMTP, telle que`example.com`. Pour obtenir des instructions, consultez [la section Création de règles de transfert](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-rules-managing.html#resolver-rules-managing-creating-rules) dans la documentation de Route 53. | Administrateur réseau | ### Configurer Database Mail sur l'instance de base de données Amazon RDS for SQL Server | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Activez Database Mail. | Créez un groupe de paramètres pour Database Mail, définissez le `database mail xps` paramètre sur`1`, puis associez le groupe de paramètres Database Mail à l'instance de base de données RDS cible. Pour obtenir des instructions, consultez la section [Enabling Database Mail](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html#SQLServer.DBMail.Enable) dans la documentation Amazon RDS. Ne passez pas à la section *Configuration du courrier de base* de données dans ces instructions. La configuration du serveur SMTP sur site est différente de celle d'Amazon SES. | DBA | | Connectez-vous à l’instance de base de données. | Depuis un hôte Bastion, utilisez Microsoft SQL Server Management Studio (SSMS) pour vous connecter à l'instance de base de données Amazon RDS for SQL Server. Pour obtenir des instructions, voir [Connexion à une instance de base de données exécutant le moteur de base de données Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html). Si vous rencontrez des erreurs, consultez les références de résolution des problèmes de connexion dans la section [Ressources associées](#send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail-resources). | DBA | | Créez le profil. | Dans SSMS, entrez l'instruction SQL suivante pour créer le profil de messagerie de base de données. Remplacez les valeurs suivantes :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/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)Pour plus d'informations sur cette procédure stockée et ses arguments, consultez [sysmail\$1add\$1profile\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profile-sp-transact-sql) dans la documentation Microsoft.
EXECUTE msdb.dbo.sysmail_add_profile_sp| DBA | | Ajoutez des directeurs au profil. | Entrez l'instruction SQL suivante pour ajouter des entités publiques ou privées au profil Database Mail. Un *principal* est une entité qui peut demander des ressources SQL Server. Remplacez les valeurs suivantes :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/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)Pour plus d'informations sur cette procédure stockée et ses arguments, consultez [sysmail\$1add\$1principalprofile\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-principalprofile-sp-transact-sql) dans la documentation Microsoft.
@profile_name = 'SQL Alerts profile',
@description = 'Profile used for sending outgoing notifications using OM SMTP Server.';
EXECUTE msdb.dbo.sysmail_add_principalprofile_sp| DBA | | Créez le compte. | Entrez l'instruction SQL suivante pour créer le compte Database Mail. Remplacez les valeurs suivantes :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/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)Pour plus d'informations sur cette procédure stockée et ses arguments, consultez [sysmail\$1add\$1account\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-account-sp-transact-sql) dans la documentation Microsoft.
@profile_name = 'SQL Alerts profile',
@principal_name = 'public',
@is_default = 1 ;
EXECUTE msdb.dbo.sysmail_add_account_sp| DBA | | Ajoutez le compte au profil. | Entrez l'instruction SQL suivante pour ajouter le compte Database Mail au profil Database Mail. Remplacez les valeurs suivantes :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/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)Pour plus d'informations sur cette procédure stockée et ses arguments, consultez [sysmail\$1add\$1profileaccount\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profileaccount-sp-transact-sql) dans la documentation Microsoft.
@account_name = 'SQL Alerts account',
@description = 'Database Mail account for sending outgoing notifications.',
@email_address = 'xyz@example.com',
@display_name = 'xyz@example.com',
@mailserver_name = 'test_smtp.example.com',
@port = 25,
@enable_ssl = 1,
@username = 'SMTP-username',
@password = 'SMTP-password';
EXECUTE msdb.dbo.sysmail_add_profileaccount_sp| DBA | | (Facultatif) Ajoutez Multi-AZ à l'instance de base de données RDS. | Si vous souhaitez ajouter le mode multi-AZ avec mise en miroir de base de données (DBM) ou les groupes de disponibilité Always On (AGs), consultez les instructions de la section [Ajout du mode multi-AZ à une instance de base de données Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerMultiAZ.html#USER_SQLServerMultiAZ.Adding). | DBA | ## Ressources connexes + [Utilisation de Database Mail sur Amazon RDS for SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html) (documentation Amazon RDS) + [Utilisation des pièces jointes](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html#SQLServer.DBMail.MAZ) (documentation Amazon RDS) + [Résolution des problèmes de connexion à votre instance de base de données SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html#USER_ConnectToMicrosoftSQLServerInstance.Troubleshooting) (documentation Amazon RDS) + [Impossible de se connecter à l'instance de base de données Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Troubleshooting.html#CHAP_Troubleshooting.Connecting) (documentation Amazon RDS) # Configuration de la reprise après sinistre pour SAP sur IBM Db2 on AWS *Ambarish Satarkar et Debasis Sahoo, Amazon Web Services* ## Résumé Ce modèle décrit les étapes à suivre pour configurer un système de reprise après sinistre (DR) pour les charges de travail SAP avec IBM Db2 comme plate-forme de base de données, exécuté sur le cloud Amazon Web Services (AWS). L'objectif est de fournir une solution peu coûteuse pour assurer la continuité des activités en cas de panne. Le motif utilise l'[approche de la veilleuse](https://aws.amazon.com/blogs/architecture/disaster-recovery-dr-architecture-on-aws-part-iii-pilot-light-and-warm-standby/). En implémentant Pilot Light DR sur AWS, vous pouvez réduire les temps d'arrêt et maintenir la continuité des activités. L'approche pilote met l'accent sur la mise en place d'un environnement de reprise après sinistre minimal dans AWS, comprenant un système SAP et une base de données DB2 de secours, synchronisé avec l'environnement de production. Cette solution est évolutive. Vous pouvez l'étendre à un environnement de reprise après sinistre à grande échelle selon vos besoins. ## Conditions préalables et limitations **Conditions préalables** + Une instance SAP exécutée sur une instance Amazon Elastic Compute Cloud (Amazon EC2) + Une base de données IBM Db2 + Système d'exploitation pris en charge par la matrice de disponibilité des produits SAP (PAM) + Différents noms d'hôte de base de données physiques pour les hôtes de base de données de production et de secours + Un compartiment Amazon Simple Storage Service (Amazon S3) dans chaque région AWS [avec la réplication entre régions (CRR](https://docs.aws.amazon.com/AmazonS3/latest/userguide/replication.html)) activée **Versions du produit** + IBM Db2 Database version 11.5.7 ou ultérieure ## Architecture **Pile technologique cible** + Amazon EC2 + Amazon Simple Storage Service (Amazon S3) + Amazon Virtual Private Cloud (peering VPC) + Amazon Route 53 + IBM Db2 High Availability Disaster Recovery (HADR) **Architecture cible** Cette architecture met en œuvre une solution de reprise après sinistre pour les charges de travail SAP avec Db2 comme plate-forme de base de données. La base de données de production est déployée dans la région AWS 1 et une base de données de secours est déployée dans une deuxième région. La base de données de secours est appelée système DR. La base de données DB2 prend en charge plusieurs bases de données de secours (jusqu'à trois). Il utilise Db2 HADR pour configurer la base de données DR et automatiser l'envoi des journaux entre les bases de données de production et de secours. En cas de sinistre rendant la région 1 indisponible, la base de données de secours de la région DR prend le rôle de base de données de production. Les serveurs d'applications SAP peuvent être créés à l'avance ou à l'aide d'[AWS Elastic Disaster Recovery](https://aws.amazon.com/disaster-recovery/) ou d'une Amazon Machine Image (AMI) pour répondre aux exigences relatives aux objectifs de temps de restauration (RTO). Ce modèle utilise une AMI. Db2 HADR implémente une configuration de veille de production, dans laquelle la production agit en tant que serveur principal et où tous les utilisateurs y sont connectés. Toutes les transactions sont écrites dans des fichiers journaux, qui sont transférés vers le serveur de secours à l'aide du protocole TCP/IP. Le serveur de secours met à jour sa base de données locale en reportant les enregistrements du journal transférés, ce qui permet de garantir sa synchronisation avec le serveur de production. Le peering VPC est utilisé pour que les instances de la région de production et de la région DR puissent communiquer entre elles. Amazon Route 53 dirige les utilisateurs finaux vers des applications Internet. ![\[DB2 sur AWS avec réplication entre régions\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/06edfa4c-0827-4d05-95cf-2d2651e74323/images/e77c1e4e-36f3-4af4-89d0-8eec72348f0a.png) 1. [Créez une AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html#creating-an-ami) du serveur d'applications dans la région 1 et [copiez-la](https://repost.aws/knowledge-center/copy-ami-region) dans la région 2. Utilisez l'AMI pour lancer des serveurs dans la région 2 en cas de sinistre. 1. Configurez la réplication Db2 HADR entre la base de données de production (dans la région 1) et la base de données de secours (dans la région 2). 1. Modifiez le type d' EC2 instance pour qu'il corresponde à l'instance de production en cas de sinistre. 1. Dans la région 1, `LOGARCHMETH1` est défini sur`db2remote: S3 path`. 1. Dans la région 2, `LOGARCHMETH1` est défini sur`db2remote: S3 path`. 1. La réplication entre régions est effectuée entre les compartiments S3. ## Outils **Services AWS** + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/ec2/) fournit une capacité de calcul évolutive dans le cloud AWS. Vous pouvez lancer autant de serveurs virtuels que vous le souhaitez et les augmenter ou les diminuer rapidement. + [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) est un service Web DNS hautement disponible et évolutif. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) est un service de stockage d'objets basé sur le cloud qui vous permet de stocker, de protéger et de récupérer n'importe quel volume de données. + [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) vous aide à lancer des ressources AWS dans un réseau virtuel que vous avez défini. Ce réseau virtuel ressemble à un réseau traditionnel que vous exploiteriez dans votre propre centre de données, avec les avantages liés à l'utilisation de l'infrastructure évolutive d'AWS. Ce modèle utilise le [peering VPC.](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-peering.html) ## Bonnes pratiques + Le réseau joue un rôle clé dans le choix du mode de réplication HADR. Pour la reprise après sinistre dans les régions AWS, nous vous recommandons d'utiliser le mode DB2 HADR ASYNC ou SUPERASYNC. + Pour plus d'informations sur les modes de réplication pour Db2 HADR, consultez la documentation [IBM](https://ibm.github.io/db2-hadr-wiki/hadrSyncMode.html#Description_of_the_Modes). + Vous pouvez utiliser la console de gestion AWS ou l'interface de ligne de commande AWS (AWS CLI) [pour créer une nouvelle AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html#creating-an-ami) de votre système SAP existant. Vous pouvez ensuite utiliser l'AMI pour récupérer votre système SAP existant ou pour créer un clone. + [AWS Systems Manager Automation](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-automation.html) peut vous aider à effectuer les tâches courantes de maintenance et de déploiement des EC2 instances et des autres ressources AWS. + AWS fournit plusieurs services natifs pour surveiller et gérer votre infrastructure et vos applications sur AWS. Des services tels qu'Amazon CloudWatch et AWS CloudTrail peuvent être utilisés pour surveiller votre infrastructure sous-jacente et vos opérations d'API, respectivement. Pour plus de détails, consultez [SAP on AWS — IBM Db2 HADR with](https://docs.aws.amazon.com/sap/latest/sap-AnyDB/sap-ibm-pacemaker.html) Pacemaker. ## Épopées ### Préparez l'environnement | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Vérifiez le système et les journaux. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrateur AWS, administrateur SAP Basis | ### Configuration des serveurs et de la réplication | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez le SAP et les serveurs de base de données. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html)L'état en attente de report est défini par défaut une fois la sauvegarde complète restaurée. L'état en attente de report indique que la base de données est en cours de restauration et que certaines modifications devront peut-être être appliquées. Pour plus d'informations, consultez la [documentation IBM](https://www.ibm.com/docs/en/db2/11.5?topic=commands-rollforward-database). | Administrateur SAP Basis | | Vérifiez la configuration. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrateur AWS, administrateur SAP Basis | | Configurez la réplication de la base de données de production vers la base de données DR (en utilisant le mode ASYNC). | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrateur SAP Basis | ### Tester les tâches de reprise après sinistre | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Planifiez les interruptions de production pour le test de reprise après sinistre. | Assurez-vous de planifier les interruptions de service requises dans l'environnement de production pour tester le scénario de reprise après sinistre. | Administrateur SAP Basis | | Créez un utilisateur de test. | Créez un utilisateur de test (ou toute modification de test) qui peut être validé sur l'hôte DR pour confirmer la réplication du journal après le basculement de DR. | Administrateur SAP Basis | | Sur la console, arrêtez les EC2 instances de production. | Un arrêt indécent est initié au cours de cette étape pour imiter un scénario de catastrophe. | Administrateur système AWS | | Augmentez la taille de l' EC2 instance DR en fonction des exigences. | Sur la EC2 console, modifiez le type d'instance dans la région DR.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrateur SAP Basis | | Initiez le rachat. | À partir du système DR (`host2`), lancez le processus de prise de contrôle et affichez la base de données DR en tant que base de données principale.
@profile_name = 'SQL Alerts profile',
@account_name = 'SQL Alerts account',
@sequence_number = 1;
db2 takeover hadr on databaseVous pouvez éventuellement définir les paramètres suivants pour ajuster automatiquement l'allocation de mémoire de la base de données en fonction du type d'instance. La `INSTANCE_MEMORY` valeur peut être décidée en fonction de la portion de mémoire dédiée à allouer à la base de données Db2.by force
db2 update db cfg forVérifiez la modification à l'aide des commandes suivantes.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| Administrateur SAP Basis | | Lancez le serveur d'applications pour SAP dans la région DR. | À l'aide de l'AMI que vous avez créée pour le système de production, [lancez un nouveau serveur d'applications supplémentaire](https://aws.amazon.com/premiumsupport/knowledge-center/launch-instance-custom-ami/) dans la région DR. | Administrateur SAP Basis | | Effectuez la validation avant de démarrer l'application SAP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrateur AWS, administrateur SAP Basis | | Démarrez l'application SAP sur le système DR. | Démarrez l'application SAP sur le système DR en utilisant `| grep -i MEMORY
db2 get db cfg for| grep -i self_tuning_mem
sapconrol -nr XX -function StartService| Administrateur SAP Basis | | Effectuez la validation SAP. | Ceci est effectué sous forme de test DR pour fournir des preuves ou pour vérifier le succès de la réplication des données dans la région DR. | Ingénieur de test | ### Réaliser des tâches de reprise après sinistre | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Démarrez le SAP de production et les serveurs de base de données. | Sur la console, démarrez les EC2 instances qui hébergent SAP et la base de données dans le système de production. | Administrateur SAP Basis | | Démarrez la base de données de production et configurez HADR. | Connectez-vous au système de production (`host1`) et vérifiez que la base de données est en mode de restauration à l'aide de la commande suivante.
sapconrol -nr XX -function StartSystem
sapconrol -nr YY -function StartService
sapconrol -nr YY -function StartSystem
db2startVérifiez que le statut HADR est`connected`. L'état de réplication doit être`peer`.
db2 start HADR on db P3V as standby
db2 connect to
db2pd -dSi la base de données n'est pas incohérente `connected` et n'est pas en `peer` état, une sauvegarde et une restauration peuvent être nécessaires pour synchroniser la base de données avec la base de données actuellement active (`host2`dans la région DR). `host1` Dans ce cas, restaurez la sauvegarde de base de données de la base de données de la région `host2` DR vers la base de données de la région `host1` de production. | Administrateur SAP Basis | | Replacez la base de données dans la région de production. | Dans un business-as-usual scénario normal, cette étape est exécutée lors d'un arrêt planifié. Les applications exécutées sur le système DR sont arrêtées et la base de données est renvoyée dans la région de production (région 1) pour reprendre les opérations depuis la région de production.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrateur SAP Basis | | Effectuez la validation avant de démarrer l'application SAP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrateur AWS, administrateur SAP Basis | | Démarrez l'application SAP. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | Administrateur SAP Basis | ## Résolution des problèmes | Problème | Solution | | --- | --- | | Fichiers journaux et commandes clés pour résoudre les problèmes liés au HADR | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | | Note SAP pour la résolution des problèmes HADR sur Db2 UDB | Reportez-vous à la [note SAP 1154013 - DB6 : Problèmes de base de données dans l'environnement HADR](https://service.sap.com/sap/support/notes/1154013). (Vous avez besoin des informations d'identification du portail SAP pour accéder à cette note.) | ## Ressources connexes + [Approches de reprise après sinistre pour les bases de données DB2 sur AWS](https://aws.amazon.com/blogs/architecture/disaster-recovery-approaches-for-db2-databases-on-aws/) (article de blog) + [SAP on AWS — IBM DB2 HADR avec stimulateur cardiaque](https://docs.aws.amazon.com/sap/latest/sap-AnyDB/sap-ibm-pacemaker.html) + [Procédure étape par étape pour configurer la réplication HADR entre les bases de données DB2 ](https://www.ibm.com/support/pages/step-step-procedure-set-hadr-replication-between-db2-databases) + [Wiki DHR DB2](https://ibm.github.io/db2-hadr-wiki/index.html) ## Informations supplémentaires À l'aide de ce modèle, vous pouvez configurer un système de reprise après sinistre pour un système SAP exécuté sur la base de données DB2. En cas de sinistre, l'entreprise doit être en mesure de poursuivre ses activités dans les limites de vos objectifs de temps de reprise (RTO) et de point de reprise (RPO) définis : + Le **RTO** est le délai maximum acceptable entre l'interruption du service et le rétablissement du service. Elle détermine ce qui est considéré comme étant un créneau de temps acceptable d’indisponibilité du service. + Le **RPO** est la durée maximale acceptable depuis le dernier point de récupération des données. Il détermine ce qui est considéré comme étant une perte de données acceptable entre le dernier point de reprise et l’interruption du service. Pour en FAQs savoir plus sur le HADR, consultez la [note SAP \$11612105 - DB6 : FAQ sur Db2 High Availability Disaster Recovery (HADR](https://launchpad.support.sap.com/#/notes/1612105)). (Vous avez besoin des informations d'identification du portail SAP pour accéder à cette note.) # Configurer un CI/CD pipeline pour la migration de base de données à l'aide de Terraform *Dr. Rahul Sharad Gaikwad, Ashish Bhatt, Aniket Dekate, Ruchika Modi, Tamilselvan P, Nadeem Rahaman, Aarti Rajput et Naveen Suthar, Amazon Web Services* ## Résumé Ce modèle consiste à établir un pipeline d'intégration et de déploiement continus (CI/CD) pour gérer les migrations de bases de données de manière fiable et automatisée. Il couvre le processus de mise en service de l'infrastructure nécessaire, de migration des données et de personnalisation des modifications de schéma à l'aide de Terraform, un outil d'infrastructure en tant que code (IaC). Plus précisément, le modèle met en place un CI/CD pipeline pour migrer une base de données Microsoft SQL Server sur site vers Amazon Relational Database Service (Amazon RDS) sur. AWS Vous pouvez également utiliser ce modèle pour migrer une base de données SQL Server située sur une machine virtuelle (VM) ou dans un autre environnement cloud vers Amazon RDS. Ce modèle permet de relever les défis suivants liés à la gestion et au déploiement de bases de données : + Les déploiements manuels de bases de données prennent du temps, sont sujets aux erreurs et manquent de cohérence entre les environnements. + La coordination du provisionnement de l'infrastructure, des migrations de données et des modifications de schéma peut s'avérer complexe et difficile à gérer. + Garantir l'intégrité des données et minimiser les temps d'arrêt lors des mises à jour des bases de données est crucial pour les systèmes de production. Ce modèle offre les avantages suivants : + Rationalise le processus de mise à jour et de déploiement des modifications de base de données en mettant en œuvre un CI/CD pipeline pour les migrations de bases de données. Cela réduit le risque d'erreurs, garantit la cohérence entre les environnements et minimise les temps d'arrêt. + Contribue à améliorer la fiabilité, l'efficacité et la collaboration. Permet d'accélérer la mise sur le marché et de réduire les temps d'arrêt lors des mises à jour des bases de données. + Vous aide à adopter DevOps des pratiques modernes de gestion de base de données, ce qui améliore l'agilité, la fiabilité et l'efficacité de vos processus de livraison de logiciels. ## Conditions préalables et limitations **Conditions préalables** + Un actif Compte AWS + [Terraform 0.12 ou version ultérieure installé sur votre machine locale (pour les instructions, consultez la documentation Terraform)](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli) + Terraform AWS Provider version 3.0.0 ou ultérieure à partir de HashiCorp (voir le [GitHub référentiel](https://github.com/hashicorp/terraform-provider-aws) de ce fournisseur) + Politique du moindre privilège Gestion des identités et des accès AWS (IAM) (voir le billet de blog [Techniques de rédaction des politiques IAM du moindre privilège](https://aws.amazon.com/blogs/security/techniques-for-writing-least-privilege-iam-policies/)) ## Architecture Ce modèle implémente l'architecture suivante, qui fournit l'infrastructure complète pour le processus de migration de base de données. ![\[Architecture de pipeline CI/CD pour la migration d'une base de données SQL Server sur site vers Amazon RDS sur AWS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/87845d9f-8e6e-4c51-b9ee-9e7833671d05/images/a1e95458-419a-4de9-85ef-b17d8340700a.png) Dans cette architecture : + La base de données source est une base de données SQL Server installée sur site, sur une machine virtuelle (VM) ou hébergée par un autre fournisseur de cloud. Le schéma suppose que la base de données source se trouve dans un centre de données local. + Le centre de données sur site est connecté via un VPN ou une AWS Direct Connect connexion. AWS Cela garantit des communications sécurisées entre la base de données source et l' AWS infrastructure. + La base de données cible est une base de données Amazon RDS hébergée dans le cloud privé virtuel (VPC) à l'aide d'un AWS pipeline de provisionnement de base de données. + AWS Database Migration Service (AWS DMS) réplique votre base de données locale vers. AWS Il est utilisé pour configurer la réplication de la base de données source vers la base de données cible. Le schéma suivant montre l'infrastructure configurée à différents niveaux du processus de migration de base de données, qui implique le provisionnement, la AWS DMS configuration et la validation. ![\[Détails du pipeline CI/CD concernant le processus de migration depuis le site vers AWS.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/87845d9f-8e6e-4c51-b9ee-9e7833671d05/images/3aca17e5-6fd7-4317-b578-ab5e485c6efb.png) Dans le cadre de ce processus : + Le pipeline de validation valide toutes les vérifications. Le pipeline intégré passe à l'étape suivante lorsque toutes les validations nécessaires sont terminées. + Le pipeline de provisionnement de base de données comprend différentes AWS CodeBuild étapes qui exécutent des actions Terraform sur le code Terraform fourni pour la base de données. Lorsque ces étapes sont terminées, il déploie les ressources dans la cible Compte AWS. + Le AWS DMS pipeline comprend différentes CodeBuild étapes qui effectuent des tests, puis fournissent l' AWS DMS infrastructure pour effectuer la migration à l'aide d'IaC. ## Outils **Services AWS et outils** + [AWS CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html)est un service d'intégration continue entièrement géré qui compile le code source, exécute des tests et produit des ready-to-deploy progiciels. + [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)est un service de livraison continue entièrement géré qui vous aide à automatiser vos pipelines de publication pour des mises à jour rapides et fiables des applications et de l'infrastructure. + [Amazon Relational Database Service (Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)) vous aide à configurer, exploiter et dimensionner une base de données relationnelle dans le. AWS Cloud + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) est un service de stockage d'objets qui offre évolutivité, disponibilité des données, sécurité et performances. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) vous aide à migrer les banques de données vers AWS Cloud ou entre des combinaisons de configurations cloud et sur site. **Autres services** + [Terraform](https://www.terraform.io/) est un outil IaC HashiCorp qui vous aide à créer et à gérer des ressources sur site et dans le cloud. **Référentiel de code** Le code de ce modèle est disponible dans le [ DevOps framework de migration de GitHub base de données à l'aide du référentiel d'exemples Terraform](https://github.com/aws-samples/aws-terraform-db-migration-framework-samples). ## Bonnes pratiques + Mettez en œuvre des tests automatisés pour la migration de votre base de données afin de vérifier l'exactitude des modifications de schéma et l'intégrité des données. Cela inclut les tests unitaires, les tests d'intégration et les end-to-end tests. + Mettez en œuvre une stratégie de sauvegarde et de restauration robuste pour vos bases de données, en particulier avant la migration. Cela garantit l'intégrité des données et fournit une option de secours en cas de panne. + Mettez en œuvre une stratégie de restauration robuste pour annuler les modifications apportées à la base de données en cas de défaillance ou de problème lors de la migration. Cela peut impliquer de revenir à un état de base de données antérieur ou de rétablir des scripts de migration individuels. + Configurez des mécanismes de surveillance et de journalisation pour suivre la progression et l'état des migrations de bases de données. Cela vous permet d'identifier et de résoudre rapidement les problèmes. ## Épopées ### Configurez votre poste de travail local | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Installez et configurez Git sur votre poste de travail local. | Installez et configurez Git sur votre poste de travail local en suivant les instructions de la [documentation Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git). | DevOps ingénieur | | Créez un dossier de projet et ajoutez les fichiers du GitHub référentiel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps ingénieur | ### Provisionner l'architecture cible | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Mettez à jour les paramètres requis. | Le `ssm-parameters.sh` fichier enregistre tous les AWS Systems Manager paramètres requis. Vous pouvez configurer ces paramètres avec les valeurs personnalisées de votre projet.Dans le `setup/db-ssm-params` dossier de votre station de travail locale, ouvrez le `ssm-parameters.sh` fichier et définissez ces paramètres avant d'exécuter le CI/CD pipeline. | DevOps ingénieur | | Initialisez la configuration Terraform. | Dans le `db-cicd-integration` dossier, entrez la commande suivante pour initialiser votre répertoire de travail contenant les fichiers de configuration Terraform :-hadr
terraform init| DevOps ingénieur | | Prévisualisez le plan Terraform. | Pour créer un plan Terraform, entrez la commande suivante :
terraform plan -var-file="terraform.sample"Terraform évalue les fichiers de configuration pour déterminer l'état cible des ressources déclarées. Il compare ensuite l'état cible à l'état actuel et crée un plan. | DevOps ingénieur | | Vérifiez le plan. | Passez en revue le plan et confirmez qu'il configure l'architecture requise dans votre cible Compte AWS. | DevOps ingénieur | | Déployez la solution. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps ingénieur | ### Vérification du déploiement | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Validez le déploiement. | Vérifiez l'état du `db-cicd-integration` pipeline pour confirmer que la migration de la base de données est terminée.1. Connectez-vous à la [AWS CodePipeline console AWS Management Console, puis ouvrez-la](https://console.aws.amazon.com/codesuite/codepipeline/home).2. Dans le volet de navigation, sélectionnez **Pipelines**.3. Choisissez le `db-cicd-integration` pipeline.4. Vérifiez que l'exécution du pipeline s'est terminée avec succès. | DevOps ingénieur | ### Nettoyer l'infrastructure après utilisation | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Nettoyez l'infrastructure. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps ingénieur | ## Ressources connexes **AWS documentation** + [Commencer à utiliser un produit Terraform](https://docs.aws.amazon.com/servicecatalog/latest/adminguide/getstarted-Terraform.html) **Documentation Terraform** + [Installation de Terraform](https://learn.hashicorp.com/tutorials/terraform/install-cli) + [Configuration du backend Terraform](https://developer.hashicorp.com/terraform/language/backend) + [Documentation du fournisseur Terraform AWS](https://registry.terraform.io/providers/hashicorp/aws/latest/docs) # Configurer un cluster de basculement Microsoft SQL Server sur Amazon à EC2 l'aide FSx de Windows File Server *Sweta Krishna et Ramesh Babu Donti, Amazon Web Services* ## Résumé L'édition Microsoft SQL Server Standard avec une instance de cluster de basculement (FCI) peut constituer une alternative plus rentable à SQL Server Enterprise. La configuration de SQL FCI nécessite un stockage de fichiers partagé entre les nœuds, et [Amazon FSx pour Windows File Server](https://aws.amazon.com/fsx/windows/) fournit un stockage entièrement géré qui se réplique automatiquement de manière synchrone entre les zones de disponibilité. Amazon FSx réduit les coûts de stockage en utilisant la déduplication des données intégrée pour les partages de fichiers à usage général, ce qui élimine le besoin de gérer des solutions tierces. Amazon prend FSx également en charge les solutions suivantes : + Payez uniquement pour ce que vous utilisez, sans frais initiaux ni engagements. + Configurez FCI manuellement en FSx tant que stockage partagé. + À utiliser FSx comme témoin de partage de fichiers pour votre cluster SQL. + Amazon FSx pour Windows File Server prend en charge Server Message Block (SMB) 3.0 pour les partages de fichiers disponibles en permanence, ce qui le rend adapté aux déploiements SQL Server FCI. ## Conditions préalables et limitations **Conditions préalables** + Actif [Compte AWS](https://aws.amazon.com/account/). + Autorisations pour créer et gérer les ressources Amazon Virtual Private Cloud (Amazon VPC), l'instance Amazon Elastic Compute Cloud (Amazon EC2), les groupes de sécurité et les rôles Gestion des identités et des accès AWS (IAM). + AWS Managed Microsoft AD ou votre propre Active Directory sur site. + Un utilisateur de domaine Active Directory disposant des [autorisations nécessaires](https://learn.microsoft.com/en-us/windows-server/failover-clustering/configure-failover-cluster-accounts) pour configurer un cluster de basculement. + Règles de groupe de sécurité pour les [ports SQL Server FCI et Microsoft Active Directory](https://docs.aws.amazon.com/whitepapers/latest/access-workspaces-with-access-cards/ip-address-and-port-requirements.html) pour une connectivité hybride sécurisée. + [Compte de service](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) dans Active Directory pour SQL Server configuré avec les autorisations appropriées sur les nœuds SQL. + Serveur de fichiers Amazon FSx pour Windows dans un cluster de basculement. + Binaires d'installation de SQL Server. **Limites** + Certains Services AWS ne sont pas disponibles du tout Régions AWS. Pour connaître la disponibilité par région, voir [Services AWS par région](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Pour des points de terminaison spécifiques, consultez la [page Points de terminaison et quotas du service](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html), puis choisissez le lien vers le service. **Versions du produit** + Amazon EC2 pour Windows Server 2012 R2 ou version ultérieure + Amazon FSx pour Windows File Server avec toutes les versions actuelles de Windows Server + Amazon FSx pour NetApp ONTAP comme alternative au stockage partagé + SQL Server 2012/2016/2019/2022 ## Architecture **Pile technologique** + Amazon EC2 + Serveur FSx de fichiers Amazon pour Windows + Amazon VPC + AWS Directory Service + AWS Systems Manager + IAM **Architecture cible** Le schéma suivant montre l'architecture de haut niveau de Microsoft SQL Server FCI sur Amazon à EC2 l'aide d'Amazon FSx pour Windows File Server. ![\[Schéma d'architecture pour Microsoft Server FCI sur Amazon EC2 à l'aide d'Amazon FSx pour Windows File Server.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/208bf64a-8fef-4019-944a-723372450885/images/ba0c9169-9536-41c3-ae8e-7264dcc3e1ad.png) **Infrastructure réseau** + Amazon VPC fournit un conteneur réseau qui couvre trois zones de disponibilité. + Les sous-réseaux privés fournissent des sous-réseaux isolés dans chaque zone de disponibilité pour le déploiement des ressources. **couche de calcul** + Amazon EC2 contient un nœud de cluster SQL Server 1, déployé dans la zone de disponibilité 1 dans le cadre du Windows Server Failover Cluster (WSFC). + Amazon EC2 contient un nœud de cluster SQL Server 2, déployé dans la zone de disponibilité 2 dans le cadre du WSFC. + Le cluster WSFC connecte les deux nœuds SQL Server pour permettre le basculement. **Couche de stockage pour Amazon FSx pour Windows File Server** ** FSx Déploiement multi-AZ (couvrant les zones de disponibilité 1 et 2)** + Un système de FSx fichiers principal de la zone de disponibilité 1 héberge les données et les fichiers journaux SQL Server actifs. + Un système de FSx fichiers secondaire situé dans la zone de disponibilité 2 fournit une fonctionnalité de basculement automatique. + Un partage de fichiers SMB partagé (\$1 \$1 fsx.domain \$1 sqlshare), accessible par les deux nœuds du cluster pour les bases de données SQL Server. ** FSx Déploiement mono-AZ (en AZ3)** + Le témoin du serveur de FSx fichiers Amazon dans la zone de disponibilité 3 sert de témoin du quorum du cluster. + Le témoin de partage de fichiers (`\\fsx.domain\witness`) maintient le quorum du cluster et empêche les scénarios de split-brain. **Services d'annuaire** + AWS Managed Microsoft AD fournit l'authentification Windows et les services de domaine nécessaires au fonctionnement du cluster. **Fonctionnalités de haute disponibilité** + Les composants multi-AZ garantissent une tolérance aux pannes dans toutes les zones de disponibilité. + FSx le serveur de fichiers de secours assure un basculement automatique en cas de défaillance du serveur principal. + Le témoin de partage de fichiers assure la gestion du quorum du cluster dans la zone de disponibilité 3 afin de garantir le bon fonctionnement du cluster en cas de panne. + Le domaine est intégré AWS Managed Microsoft AD pour une authentification Windows fluide. ## Outils **Services AWS** + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) fournit une capacité de calcul évolutive dans le AWS Cloud. Vous pouvez lancer autant de serveurs virtuels que vous le souhaitez et les augmenter ou les diminuer rapidement. + [Amazon FSx](https://docs.aws.amazon.com/fsx/?id=docs_gateway) fournit des systèmes de fichiers qui prennent en charge les protocoles de connectivité standard du secteur et offrent une disponibilité et une réplication élevées sur l'ensemble Régions AWS de ces protocoles. + [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) vous aide à lancer AWS des ressources dans un réseau virtuel que vous avez défini. Ce réseau virtuel ressemble à un réseau traditionnel que vous pourriez exécuter dans votre propre centre de données et présente l'avantage d'utiliser l'infrastructure évolutive d' AWS. + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)permet à vos charges de travail et à vos AWS ressources sensibles aux annuaires d'utiliser Microsoft Active Directory dans le. AWS Cloud + [Gestion des identités et des accès AWS (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) vous aide à gérer en toute sécurité l'accès à vos AWS ressources en contrôlant qui est authentifié et autorisé à les utiliser. + [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html)vous aide à gérer vos applications et votre infrastructure exécutées dans le AWS Cloud. Il simplifie la gestion des applications et des ressources, réduit le délai de détection et de résolution des problèmes opérationnels et vous aide à gérer vos AWS ressources en toute sécurité à grande échelle. ## Bonnes pratiques + Placez les instances de base de données dans des sous-réseaux privés afin de les empêcher d'être accessibles au public depuis Internet tout en leur permettant de se connecter Services AWS et d'effectuer des mises à jour. + Pour connaître les meilleures pratiques générales, consultez la section [Meilleures pratiques pour le déploiement de Microsoft SQL Server sur Amazon EC2](https://docs.aws.amazon.com/prescriptive-guidance/latest/sql-server-ec2-best-practices/welcome.html). + À utiliser PowerShell pour administrer votre serveur de fichiers Amazon FSx pour Windows, consultez la section [Administration FSx des systèmes de fichiers Windows](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/administering-file-systems.html). ## Épopées ### Création et configuration de EC2 nœuds Amazon pour SQL Server | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Ajoutez des noms et des tags. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Choisissez une AMI Windows. | Choisissez une Amazon Machine Image (AMI) pour Windows qui répond aux exigences de SQL Server. | DBA | | Sélectionnez un type d’instance. | Sélectionnez un type d' EC2 instance Amazon qui répond à vos besoins. | DBA | | Utilisez une paire de clés. | Vous pouvez utiliser une paire de clés pour vous connecter en toute sécurité à votre instance. Assurez-vous d'avoir accès à la paire de clés sélectionnée avant de lancer l'instance. | DBA | | Configurer les paramètres réseau. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Configurez les paramètres réseau avancés. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Configurez le stockage. | Configurez le stockage total requis et choisissez le type de stockage requis. | DBA | | Configurez les détails avancés et lancez l'instance. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Créez le nœud 2. | Répétez ces étapes pour créer et configurer le nœud 2. | DBA | ### Installation et configuration d'un cluster de basculement Windows Server sur les nœuds 1 et 2 | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Connectez-vous au nœud 1. | Connectez-vous à l' EC2 instance Amazon Windows en tant qu'administrateur. | DBA | | Installez les fonctionnalités FCI sur le nœud 1. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/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/fr_fr/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Connectez-vous au nœud 2. | Connectez-vous à l' EC2 instance Amazon Windows en tant qu'administrateur. | DBA | | Installez les fonctionnalités FCI sur le nœud 2. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/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/fr_fr/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Ajoutez des nœuds au cluster. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Mettez le cluster en ligne. | Pour mettre le cluster en ligne, mettez à jour les adresses IP statiques des deux nœuds :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Validez le cluster. | Accédez au **gestionnaire de cluster Failover** et vérifiez que les ressources principales du cluster sont en ligne. | DBA | ### Installation de SQL Server sur les nœuds 1 et 2 | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Connectez-vous au serveur. | Connectez-vous à l' EC2 instance Amazon en tant qu'administrateur. | DBA | | Montez les fichiers binaires SQL. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | | | Ajoutez le nœud 2 au cluster de basculement. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | ### Configurer le témoin de partage de FSx fichiers Amazon | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Configurez les paramètres du quorum. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Récupérez les détails du DNS. | Dans la FSx console Amazon, choisissez **Managed AD**, puis **Attach**. Le DNS doit avoir le format suivant : `\\example.example.net\share` | DBA | | Configurez le témoin de partage de fichiers. | Choisissez le **chemin de partage de FSx fichiers Amazon**, puis **Terminer**. | DBA | ## Ressources connexes **AWS resources** + [Serveur de fichiers Amazon FSx pour Windows](https://www.youtube.com/watch?v=IMDWTIShlyI) (vidéo) + [Présentation approfondie d'Amazon FSx pour Windows File Server](https://www.youtube.com/watch?v=_x_Geur93oc) (vidéo) + [Comment déployer un cluster de basculement SQL Server avec Amazon EBS Multi-Attach sur 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 article de blog) + [Simplifiez vos déploiements de haute disponibilité de Microsoft SQL Server à l'aide d'Amazon FSx pour Windows File Server](https://aws.amazon.com/blogs/storage/simplify-your-microsoft-sql-server-high-availability-deployments-using-amazon-fsx-for-windows-file-server/) (article de AWS blog) + [Déploiements de haute disponibilité de SQL Server à l'aide d'Amazon FSx pour NetApp ONTAP](https://aws.amazon.com/blogs/modernizing-with-aws/sql-server-high-availability-amazon-fsx-for-netapp-ontap/) (AWS article de blog) + [Utilisation FSx d'un serveur de fichiers Windows avec Microsoft SQL Server](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/sql-server.html) + [Qu'est-ce que c'est FSx pour le serveur de fichiers Windows ?](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) **Autres ressources** + [Création d'un cluster de basculement](https://learn.microsoft.com/en-us/windows-server/failover-clustering/create-failover-cluster?pivots=windows-admin-center) ## Informations supplémentaires **Configuration du témoin de partage de fichiers** Assurez-vous d'être connecté au système de fichiers depuis les deux nœuds en ajoutant des règles dans le groupe de FSx sécurité Amazon qui autorisent les connexions entrantes. Le port SMB doit être autorisé. Par exemple, si le nom DNS est`\\example.example.com\share`, utilisez`\\example.example.com\share`. Utilisez la même valeur pour le témoin de partage de fichiers dans le cluster de disponibilité Always On. Procédez comme suit pour configurer le témoin de partage de fichiers : 1. Utilisez le protocole RDP pour vous connecter à votre EC2 instance Amazon. 1. Accédez au **gestionnaire de clusters Failover**. 1. Ouvrez le menu contextuel (clic droit) et choisissez **Autres actions**. 1. Choisissez **Configurer les paramètres de quorum du cluster**. 1. Choisissez **Suivant**. 1. Sélectionnez **Configuration du quorum** et configurez un témoin de partage de fichiers. 1. Entrez le nom DNS. 1. Passez en revue le résumé, puis choisissez **Terminer**. Le témoin de partage de fichiers doit être en ligne dans la section des ressources de **base du cluster**. # Configuration d'une HA/DR architecture pour Oracle E-Business Suite sur Amazon RDS Custom avec une base de données de secours active *Simon Cunningham, Jaydeep Nandy et Nitin Saxena, Amazon Web Services* ## Résumé Ce modèle décrit comment vous pouvez concevoir votre solution Oracle E-Business sur Amazon Relational Database Service (Amazon RDS) Custom pour la haute disponibilité (HA) et la reprise après sinistre (DR) en configurant une base de données de répliques en lecture personnalisée Amazon RDS dans une autre zone de disponibilité Amazon Web Services (AWS) et en la convertissant en base de données de secours active. La création de la réplique de lecture personnalisée Amazon RDS est entièrement automatisée via l'AWS Management Console. Ce modèle ne décrit pas les étapes à suivre pour ajouter des niveaux d'application supplémentaires et des systèmes de fichiers partagés, qui peuvent également faire partie d'une HA/DR architecture. *Pour plus d'informations sur ces sujets, consultez les notes de support Oracle suivantes : 1375769.1, 1375670.1 et 1383621.1 (section 5, Options de clonage avancées).* (L'accès nécessite un compte [Oracle Support](https://support.oracle.com/portal/).) Pour migrer le système E-Business Suite vers une architecture mono-AZ à niveau unique sur Amazon Web Services (AWS), consultez le modèle [Migrer Oracle E-Business Suite vers Amazon](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html) RDS Custom. Oracle E-Business Suite est une solution de planification des ressources d'entreprise (ERP) permettant d'automatiser les processus à l'échelle de l'entreprise tels que les finances, les ressources humaines, les chaînes d'approvisionnement et la fabrication. Il possède une architecture à trois niveaux : client, application et base de données. Auparavant, vous deviez exécuter votre base de données E-Business Suite sur une [instance Amazon Elastic Compute Cloud EC2 (Amazon) autogérée,](https://aws.amazon.com/ec2/) mais vous pouvez désormais bénéficier d'[Amazon RDS](https://aws.amazon.com/rds/custom/) Custom. ## Conditions préalables et limitations **Conditions préalables** + Une installation existante de E-Business Suite sur Amazon RDS Custom ; voir le modèle [Migrer Oracle E-Business Suite vers Amazon](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html) RDS Custom + Si vous souhaitez remplacer la réplique en lecture seule et l'utiliser pour transférer les rapports au serveur de secours, une [licence de base de données Oracle Active Data Guard](https://www.oracle.com/corporate/pricing/) (voir la liste des prix *commerciaux d'Oracle Technology*) **Limites** + Limitations et configurations non prises en charge pour les [bases de données Oracle sur Amazon RDS Custom](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.limits) + Limitations associées aux [répliques de lecture Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html#custom-rr.limitations) **Versions du produit** Pour les versions de base de données Oracle et les classes d'instances prises en charge par Amazon RDS Custom, consultez [Exigences et limites relatives à Amazon RDS Custom pour](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html) Oracle. ## Architecture Le schéma suivant illustre une architecture représentative de la suite E-Business sur AWS qui inclut plusieurs zones de disponibilité et niveaux d'application dans une active/passive configuration. La base de données utilise une instance de base de données Amazon RDS Custom et une réplique de lecture Amazon RDS Custom. La réplique en lecture utilise Active Data Guard pour se répliquer vers une autre zone de disponibilité. Vous pouvez également utiliser la réplique de lecture pour décharger le trafic de lecture sur la base de données principale et à des fins de création de rapports. ![\[Architecture multi-AZ pour Oracle E-Business Suite sur AWS\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/a17947e8-56b1-4d92-91df-096c02ff4c19/images/ffdaa2d4-123b-44a0-8d52-b1352a4eee44.png) Pour plus d'informations, consultez la section [Travailler avec des répliques de lecture pour Amazon RDS Custom pour Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html) dans la documentation Amazon RDS. La réplique de lecture personnalisée Amazon RDS est créée par défaut telle qu'elle est montée. [Toutefois, si vous souhaitez décharger certaines de vos charges de travail en lecture seule vers la base de données de secours afin de réduire la charge sur votre base de données principale, vous pouvez modifier manuellement le mode des répliques montées en lecture seule en suivant les étapes de la section Epics.](#set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database-epics) Un cas d'utilisation typique consiste à exécuter vos rapports à partir de la base de données de secours. Le passage en lecture seule nécessite une licence de base de données de secours active. Lorsque vous créez une réplique en lecture sur AWS, le système utilise le courtier Oracle Data Guard en guise de couverture. Cette configuration est automatiquement générée et configurée en mode Performances maximales comme suit : ``` 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) ``` ## Outils **Services AWS** + [Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/working-with-custom-oracle.html) est un service de base de données géré pour les applications existantes, personnalisées et packagées qui nécessitent un accès au système d'exploitation et à l'environnement de base de données sous-jacents. Il automatise les tâches et les opérations d'administration des bases de données tout en vous permettant, en tant qu'administrateur de base de données, d'accéder à votre environnement de base de données et de votre système d'exploitation et de les personnaliser. **Autres outils** + Oracle Data Guard est un outil qui vous aide à créer et à gérer des bases de données de secours Oracle. Ce modèle utilise Oracle Data Guard pour configurer une base de données de secours active sur Amazon RDS Custom. ## Épopées ### Création d'un réplica en lecture | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez une réplique en lecture de l'instance de base de données personnalisée Amazon RDS. | Pour créer une réplique en lecture, suivez les instructions de la [documentation Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReadRepl.html#USER_ReadRepl.Create) et utilisez l'instance de base de données personnalisée Amazon RDS que vous avez créée (voir la section [Conditions préalables](#set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database-prereqs)) comme base de données source.Par défaut, la réplique de lecture personnalisée Amazon RDS est créée en tant que support physique et est à l'état monté. Cela est intentionnel pour garantir la conformité avec la licence Oracle Active Data Guard. Suivez les étapes suivantes pour convertir la réplique en lecture seule en mode lecture seule. | DBA | ### Remplacez le réplica en lecture seule par un mode veille actif en lecture seule | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Connectez-vous à la réplique de lecture personnalisée Amazon RDS. | Utilisez les commandes suivantes pour convertir votre base de données de secours physique en base de données de secours active. Ces commandes nécessitent une licence Oracle Active Standby. Pour obtenir une licence, contactez votre représentant Oracle.
$ sudo su - rdsdb| DBA | | Démarrez la restauration multimédia avec l'application du journal en temps réel. | Pour activer la fonctionnalité d'application du journal en temps réel, utilisez les commandes suivantes. Ils convertissent et valident la base de données de secours (réplique en lecture) en tant que base de données de secours active, afin que vous puissiez vous connecter et exécuter des requêtes en lecture seule.
-bash-4.2$ sql
SQL> select process,status,sequence# from v$managed_standby;
PROCESS STATUS SEQUENCE#
--------- ------------ ----------
ARCH CLOSING 3956
ARCH CONNECTED 0
ARCH CLOSING 3955
ARCH CLOSING 3957
RFS IDLE 0
RFS IDLE 3958
MRP0 APPLYING_LOG 3958
SQL> select name, database_role, open_mode from v$database;
NAME DATABASE_ROLE OPEN_MODE
--------- ---------------- --------------------
VIS PHYSICAL STANDBY MOUNTED
SQL> alter database recover managed standby database cancel;
Database altered.
Open the standby database
SQL> alter database open;
Database altered.
SQL> select name, database_role, open_mode from v$database;
NAME DATABASE_ROLE OPEN_MODE
--------- ---------------- --------------------
VIS PHYSICAL STANDBY READ ONLY
SQL> alter database recover managed standby database using current logfile disconnect from session;| DBA | | Vérifiez l'état de la base de données. | Pour vérifier l'état de la base de données, utilisez la commande suivante.
Database altered
SQL> select name, database_role, open_mode from v$database;| DBA | | Cochez le mode Rétablir l'application. | Pour activer le mode Redo Apply, utilisez la commande suivante.
NAME DATABASE_ROLE OPEN_MODE
--------- ---------------- --------------------
VIS PHYSICAL STANDBY READ ONLY WITH APPLY
SQL> select process,status,sequence# from v$managed_standby;| DBA | ## Ressources connexes + [Migrer la suite Oracle E-Business vers Amazon RDS Custom](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html) (AWS Prescriptive Guidance) + [Utilisation d'Amazon RDS Custom](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-custom.html) (documentation Amazon RDS) + [Utilisation de répliques de lecture pour Amazon RDS Custom pour Oracle (documentation](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html) Amazon RDS) + [Amazon RDS Custom pour Oracle — Nouvelles fonctionnalités de contrôle dans l'environnement de base de données](https://aws.amazon.com/blogs/aws/amazon-rds-custom-for-oracle-new-control-capabilities-in-database-environment/) (blog d'actualités AWS) + [Migration d'Oracle E-Business Suite sur AWS (livre blanc AWS](https://d1.awsstatic.com/whitepapers/migrate-oracle-e-business-suite.pdf)) + [Architecture de la suite Oracle E-Business sur AWS](https://docs.aws.amazon.com/whitepapers/latest/overview-oracle-e-business-suite/oracle-e-business-suite-architecture-on-aws.html) (livre blanc AWS) # Diffusez des données depuis IBM Db2, SAP, Sybase et d'autres bases de données vers MongoDB Atlas sur AWS *Battulga Purevragchaa et Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Résumé Ce modèle décrit les étapes de migration des données depuis IBM Db2 et d'autres bases de données telles que les bases de données mainframe et Sybase vers MongoDB Atlas sur le. AWS Cloud Il permet [AWS Glue](https://aws.amazon.com/glue/)d'accélérer la migration des données vers MongoDB Atlas. Le modèle accompagne le guide [Migrating to MongoDB Atlas AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) sur le site Web de Prescriptive AWS Guidance. Il fournit les étapes de mise en œuvre de l'un des scénarios de migration décrits dans ce guide. Pour d'autres scénarios de migration, consultez les modèles suivants sur le site Web des directives AWS prescriptives : + [Migrer un environnement MongoDB auto-hébergé vers MongoDB Atlas sur AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud.html) + [Migrer des bases de données relationnelles vers MongoDB Atlas sur AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-relational-database-to-mongodb-atlas.html) Le modèle est destiné aux [partenaires et aux AWS utilisateurs de AWS Managed Services](https://aws.amazon.com/managed-services/partners/). ## Conditions préalables et limitations **Conditions préalables** + Une base de données source telle que SAP, Sybase, IBM Db2, etc. à migrer vers MongoDB Atlas. + Connaissance des bases de données telles que SAP, Sybase, IBM Db2, MongoDB Atlas et. Services AWS **Versions du produit** + MongoDB version 5.0 ou ultérieure. ## Architecture Le schéma suivant illustre le chargement de données par lots et le streaming de données à l'aide AWS Glue Studio d'Amazon Kinesis Data Streams et de MongoDB Atlas. Cette architecture de référence permet AWS Glue Studio de créer des pipelines d'extraction, de transformation et de chargement (ETL) afin de migrer les données vers MongoDB Atlas. An AWS Glue crawler s'intègre à MongoDB Atlas pour faciliter la gouvernance des données. Les données peuvent être portées par lots ou diffusées vers MongoDB Atlas à l'aide d'Amazon Kinesis Data Streams. **Chargement de données par lots** ![\[Migration des données vers MongoDB Atlas en mode batch.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/805a376f-35f4-44cc-b4b0-8bf4d95c1e5d/images/68d87202-95ba-4e2a-9b3b-27dd6db6165e.png) Pour plus d'informations sur la migration des données par lots, consultez le billet de AWS blog [Composez vos tâches ETL pour MongoDB Atlas with](https://aws.amazon.com/blogs/big-data/compose-your-etl-jobs-for-mongodb-atlas-with-aws-glue/). AWS Glue **Streaming de données** ![\[Migration des données vers MongoDB Atlas en mode streaming de données.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/805a376f-35f4-44cc-b4b0-8bf4d95c1e5d/images/b007a116-f463-418f-9721-647d80177e3b.png) Pour les architectures de référence de MongoDB Atlas qui prennent en charge différents scénarios d'utilisation, consultez la section [Migration vers MongoDB Atlas AWS sur](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) le site Web des directives prescriptives. AWS ## Outils ● [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html)est un service ETL entièrement géré. Il vous aide à classer, nettoyer, enrichir et déplacer les données de manière fiable entre les magasins de données et les flux de données. ● [Amazon Kinesis Data](https://aws.amazon.com/kinesis/data-streams/) Streams vous aide à collecter et à traiter de grands flux d'enregistrements de données en temps réel. ● [MongoDB Atlas](https://www.mongodb.com/atlas) est une base de données en tant que service (DBaaS) entièrement gérée pour le déploiement et la gestion des bases de données MongoDB dans le cloud. ## Bonnes pratiques Pour les directives, consultez [le Guide des meilleures pratiques pour MongoDB](https://github.com/mongodb-partners/mongodb_atlas_as_aws_bedrock_knowledge_base/blob/main/data/MongoDB_Best_Practices_Guide.pdf) dans le référentiel MongoDB. GitHub ## Épopées ### Découverte et évaluation | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Déterminez la taille du cluster. | Estimez la taille de l'ensemble de travail en utilisant les informations provenant de `db.stats()` pour l'espace d'index total. Supposons qu'un pourcentage de votre espace de données soit fréquemment consulté. Vous pouvez également estimer vos besoins en mémoire en fonction de vos hypothèses. Cette tâche devrait prendre environ une semaine. Pour plus d'informations et des exemples concernant cette histoire et les autres de cette épopée, consultez les liens dans la section [Ressources connexes](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | MongoDB DBA, architecte d'applications | | Estimez les besoins en bande passante du réseau. | Pour estimer les besoins en bande passante de votre réseau, multipliez la taille moyenne des documents par le nombre de documents servis par seconde. Tenez compte du trafic maximal que chaque nœud de votre cluster pourra supporter comme base. Pour calculer les taux de transfert de données en aval de votre cluster vers les applications clientes, utilisez la somme du total des documents renvoyés sur une période donnée. Si vos applications lisent à partir de nœuds secondaires, divisez le nombre total de documents par le nombre de nœuds pouvant effectuer des opérations de lecture. Pour connaître la taille moyenne des documents d'une base de données, utilisez la `db.stats().avgObjSize` commande. Cette tâche prend généralement une journée. | Base de données MongoDB | | Sélectionnez le niveau Atlas. | Suivez les instructions de la [documentation MongoDB](https://www.mongodb.com/docs/atlas/manage-clusters/) pour sélectionner le niveau de cluster Atlas approprié. | Base de données MongoDB | | Planifiez le transfert. | Planifiez le transfert des applications. | MongoDB DBA, architecte d'applications | ### Configuration d'un nouvel environnement MongoDB Atlas sur AWS | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un nouveau cluster MongoDB Atlas sur. AWS | Dans MongoDB Atlas, choisissez **Build a Cluster**, puis sélectionnez en AWS tant que fournisseur de cloud. | Base de données MongoDB | | Sélectionnez Régions AWS une configuration globale du cluster. | Sélectionnez dans la liste des options disponibles Régions AWS pour votre cluster Atlas. Configurez des clusters globaux si nécessaire. | Base de données MongoDB | | Sélectionnez le niveau du cluster. | Sélectionnez le niveau de cluster de votre choix. Le choix du niveau détermine des facteurs tels que la mémoire, le stockage et les spécifications d'IOPS. | Base de données MongoDB | | Configurez des paramètres de cluster supplémentaires. | Configurez des paramètres de cluster supplémentaires tels que la version de MongoDB, les options de sauvegarde et de chiffrement. Pour plus d'informations sur ces options, consultez la section [Ressources connexes](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | Base de données MongoDB | ### Configuration de la sécurité et de la conformité | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Configurez la liste d'accès. | Pour vous connecter au cluster Atlas, vous devez ajouter une entrée à la [liste d'accès du projet](https://www.mongodb.com/docs/atlas/setup-cluster-security/#configure-security-features-for-clusters). Atlas utilise Transport Layer Security (TLS) /Secure Sockets Layer (SSL) pour chiffrer les connexions au cloud privé virtuel (VPC) de votre base de données. Pour configurer la liste d'accès au projet et pour plus d'informations sur les histoires de cette épopée, consultez les liens dans la section [Ressources connexes](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | Base de données MongoDB | | Authentifiez et autorisez les utilisateurs. | Vous devez créer et authentifier les utilisateurs de base de données qui accèderont aux clusters MongoDB Atlas. Pour accéder aux clusters d'un projet, les utilisateurs doivent appartenir à ce projet, et ils peuvent appartenir à plusieurs projets. Vous pouvez également activer l'autorisation avec Gestion des identités et des accès AWS (IAM). Pour plus d'informations, consultez [Configurer l'authentification avec IAM](https://www.mongodb.com/docs/atlas/security/aws-iam-authentication/#set-up-authentication-with-aws-iam) dans la documentation de MongoDB. | Base de données MongoDB | | Créez des rôles personnalisés. | (Facultatif) Atlas prend en charge la création de [rôles personnalisés](https://www.mongodb.com/docs/atlas/reference/custom-role-actions/) si les privilèges utilisateur de la base de données Atlas intégrés ne couvrent pas l'ensemble de privilèges souhaité. | Base de données MongoDB | | Configurez le peering VPC. | (Facultatif) Atlas prend en charge le [peering VPC avec d'autres AWS](https://www.mongodb.com/docs/atlas/security-vpc-peering/#set-up-a-network-peering-connection). VPCs | Base de données MongoDB | | Configurez un AWS PrivateLink point de terminaison. | (Facultatif) Vous pouvez configurer des points de terminaison privés AWS en utilisant [AWS PrivateLink](https://www.mongodb.com/docs/atlas/security-private-endpoint/). | Base de données MongoDB | | Activez l'authentification à deux facteurs. | (Facultatif) Atlas prend en charge l'authentification à deux facteurs (2FA) pour aider les utilisateurs à contrôler l'accès à leurs comptes Atlas. | Base de données MongoDB | | Configurez l'authentification et l'autorisation des utilisateurs avec LDAP. | (Facultatif) Atlas prend en charge l'authentification et l'autorisation des utilisateurs avec le protocole LDAP (Lightweight Directory Access Protocol). | Base de données MongoDB | | Configurez un AWS accès unifié. | (Facultatif) Certaines fonctionnalités d'Atlas, notamment Atlas Data Lake et le chiffrement au repos à l'aide de la gestion des clés client, utilisent des rôles IAM pour l'authentification. | Base de données MongoDB | | Configurez le chiffrement au repos en utilisant AWS KMS. | (Facultatif) Atlas prend en charge l'utilisation de AWS Key Management Service (AWS KMS) pour chiffrer les moteurs de stockage et les sauvegardes des fournisseurs de cloud. | Base de données MongoDB | | Configurez CSFLE. | (Facultatif) Atlas prend en charge le [chiffrement au niveau des champs côté client (CSFLE), y compris le chiffrement](https://www.mongodb.com/docs/upcoming/core/csfle/#client-side-field-level-encryption) automatique des champs. | Base de données MongoDB | ### Migration des données | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Lancez votre ensemble de répliques cible dans MongoDB Atlas. | Lancez votre ensemble de répliques cible dans MongoDB Atlas. Dans Atlas Live Migration Service, choisissez **Je suis prêt à migrer**. | Base de données MongoDB | | Établissez la connexion AWS Glue avec MongoDB Atlas. | Utilisez an AWS Glue crawler pour vous connecter AWS Glue à MongoDB Atlas (base de données cible). Cette étape permet de préparer l'environnement cible pour la migration. Pour plus d’informations, consultez la [documentation AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-connections.html). | Base de données MongoDB | | Établissez la connexion AWS Glue avec la base de données source ou le flux source. | Cela permet de préparer l'environnement cible pour la migration. | Base de données MongoDB | | Configurez la transformation des données. | Configurez la logique de transformation pour migrer les données de l'ancien schéma structuré vers le schéma flexible de MongoDB. | Base de données MongoDB | | Migrez les données. | Planifiez la migration dans AWS Glue Studio. | Base de données MongoDB | ### Configuration de l'intégration opérationnelle | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Connectez-vous au cluster. | Connectez-vous au cluster MongoDB Atlas. | Développeur d’applications | | Interagissez avec les données. | Interagissez avec les données du cluster. | Développeur d’applications | | Surveillez les clusters. | Surveillez vos clusters MongoDB Atlas. | Base de données MongoDB | | Sauvegardez et restaurez les données. | Sauvegardez et restaurez les données du cluster. | Base de données MongoDB | ## Résolution des problèmes | Problème | Solution | | --- | --- | | Si vous rencontrez des problèmes | Consultez la section [Résolution des problèmes](https://github.com/mongodb/mongodbatlas-cloudformation-resources/tree/master#troubleshooting) dans le référentiel MongoDB Atlas CloudFormation Resources. | ## Ressources connexes Tous les liens suivants, sauf indication contraire, renvoient à des pages Web de la documentation de MongoDB. **Guide de migration** + [Migration vers MongoDB Atlas AWS sur AWS (conseils prescriptifs](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/)) **Découverte et évaluation** + [Mémoire](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Exemple de dimensionnement à l'aide d'exemples de jeux de données Atlas](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Exemple de dimensionnement pour applications mobiles](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Trafic réseau](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Mise à l'échelle automatique du cluster](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Modèle de dimensionnement de l'Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Configuration de la sécurité et de la conformité** + [Configuration des entrées de liste d'accès IP](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Configuration des utilisateurs de base de données](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Configuration de l'accès à l'interface utilisateur d'Atlas](https://docs.atlas.mongodb.com/organizations-projects/) + [Configuration de rôles de base de données personnalisés](https://docs.atlas.mongodb.com/security-add-mongodb-roles) + [Configuration des utilisateurs de base de données](https://docs.atlas.mongodb.com/security-add-mongodb-users/#atlas-user-privileges) + [Configuration d'une connexion d'appairage réseau](https://docs.atlas.mongodb.com/security-vpc-peering/) + [En savoir plus sur les points de terminaison privés dans Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Gérez vos options d'authentification multifactorielle](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Configuration de l'authentification et de l'autorisation des utilisateurs avec LDAP](https://docs.atlas.mongodb.com/security-ldaps/) + [Lac de données Atlas](https://docs.mongodb.com/datalake/) + [Chiffrement au repos à l'aide de la gestion des clés client](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Méthodes pour assumer un rôle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (documentation IAM) + [Chiffrement au niveau des champs côté client](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Chiffrement automatique](https://docs.mongodb.com/manual/core/security-automatic-client-side-encryption) + [Contrôles de sécurité MongoDB Atlas](https://webassets.mongodb.com/_com_assets/cms/MongoDB_Atlas_Security_Controls-v7k3rbhi3p.pdf) + [Centre de gestion de la confidentialité MongoDB](https://www.mongodb.com/cloud/trust) + [Configuration des fonctionnalités de sécurité pour les clusters](https://docs.atlas.mongodb.com/setup-cluster-security/) **Configuration d'un nouvel environnement MongoDB Atlas sur **AWS**** + [Fournisseurs de cloud et régions](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Gérer les clusters mondiaux](https://docs.atlas.mongodb.com/global-clusters/) + [Sélectionnez le niveau du cluster](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Configurer des paramètres supplémentaires](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Commencez avec Atlas](https://docs.atlas.mongodb.com/getting-started/) + [Configuration de l'accès à l'interface utilisateur d'Atlas](https://docs.atlas.mongodb.com/organizations-projects/) **Migration des données** + [Migrer ou importer des données](https://www.mongodb.com/docs/atlas/import/) **Clusters de surveillance** + [Surveillez vos clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) **Intégration des opérations** + [Se connecter à un cluster](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interagissez avec vos données](https://docs.atlas.mongodb.com/data-explorer/) + [Surveillez vos clusters](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Sauvegarder, restaurer et archiver des données](https://docs.atlas.mongodb.com/backup-restore-cluster/) **GitHub référentiel** + [Diffusez des données vers MongoDB Atlas à l'aide de AWS Glue](https://github.com/mongodb-partners/Stream_Data_into_MongoDB_AWS_Glue?tab=readme-ov-file#troubleshooting) # Rôles de transition pour une PeopleSoft application Oracle sur Amazon RDS Custom for Oracle *sampath kathirvel, Amazon Web Services* ## Résumé Pour exécuter la solution de planification des ressources PeopleSoft d'entreprise (ERP) [Oracle](https://www.oracle.com/applications/peoplesoft/) sur Amazon Web Services (AWS), vous pouvez utiliser [Amazon Relational Database Service (Amazon RDS) ou Amazon RDS](https://aws.amazon.com/rds/) [Custom pour Oracle, qui prend en charge les applications existantes, personnalisées](https://aws.amazon.com/rds/custom/) et packagées qui nécessitent un accès au système d'exploitation (SE) et à l'environnement de base de données sous-jacents. Pour connaître les principaux facteurs à prendre en compte lors de la planification d'une migration, consultez les [stratégies de migration des bases de données Oracle](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/strategies.html) dans AWS Prescriptive Guidance. Ce modèle se concentre sur les étapes à suivre pour effectuer un passage à Oracle Data Guard, ou une transition de rôle, pour une base de données d' PeopleSoft application exécutée sur Amazon RDS Custom en tant que base de données principale avec une base de données répliquée en lecture. Le modèle inclut des étapes pour configurer le [basculement rapide (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). Au cours de ce processus, les bases de données de la configuration Oracle Data Guard continuent de fonctionner dans leurs nouveaux rôles. Les cas d'utilisation typiques du passage à Oracle Data Guard sont les exercices de reprise après sinistre (DR), les activités de maintenance planifiée sur les bases de données et les patchs [roulants Standby-First](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) Patch Apply. Pour plus d'informations, consultez le billet de blog [Réduire le temps d'arrêt de l'application de correctifs aux bases de données dans 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/) ## Conditions préalables et limitations **Prérequis** + Réalisation de l'opération [personnalisée Ajouter HA à Oracle PeopleSoft sur Amazon RDS à l'aide d'un modèle de réplication de lecture](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/add-ha-to-oracle-peoplesoft-on-amazon-rds-custom-by-using-a-read-replica.html). **Limites** + Limitations et configurations non prises en charge pour [RDS Custom](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.limits) pour Oracle + Limitations associées aux [répliques de lecture Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html#custom-rr.limitations) **Versions du produit** + Pour les versions de base de données Oracle prises en charge par Amazon RDS Custom, consultez [RDS Custom pour](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) Oracle. + Pour les classes d'instance de base de données Oracle prises en charge par Amazon RDS Custom, consultez la section [Support des classes d'instance de base de données pour RDS Custom pour](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.instances) Oracle. ## Architecture **Pile technologique** + Amazon RDS Custom for Oracle **Architecture cible** Le schéma suivant montre une instance de base de données Amazon RDS Custom et une réplique de lecture Amazon RDS Custom. Oracle Data Guard assure la transition des rôles lors du basculement pour DR. ![\[Passage d'Oracle Data Guard à une instance de base de données personnalisée RDS principale avec une base de données répliquée en lecture.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/da3b011c-1668-4de4-9079-0982888a74b4/images/4e2a2f3b-b5bd-44b7-9b5a-13a663ee3be6.png) Pour une architecture représentative utilisant Oracle PeopleSoft sur AWS, voir [Configurer une PeopleSoft architecture hautement disponible sur AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/set-up-a-highly-available-peoplesoft-architecture-on-aws.html). ## Outils **Services AWS** + [Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/working-with-custom-oracle.html) est un service de base de données géré pour les applications existantes, personnalisées et packagées qui nécessitent un accès au système d'exploitation et à l'environnement de base de données sous-jacents. + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) vous aide à remplacer les informations d'identification codées en dur dans votre code, y compris les mots de passe, par un appel d'API à Secrets Manager pour récupérer le secret par programmation. Dans ce modèle, vous pouvez récupérer les mots de passe des utilisateurs de base de données depuis Secrets Manager pour `RDS_DATAGUARD` lesquels le nom du secret est indiqué`do-not-delete-rds-custom-+<
PROCESS STATUS SEQUENCE#
--------- ------------ ----------
ARCH CLOSING 3956
ARCH CONNECTED 0
ARCH CLOSING 3955
ARCH CLOSING 3957
RFS IDLE 0
RFS IDLE 3958
MRP0 APPLYING_LOG 3958
SQL> select open_mode from v$database;
OPEN_MODE
--------------------
READ ONLY WITH APPLY
-bash-4.2$ dgmgrl RDS_DATAGUARD@RDS_CUSTOM_ORCL_A**CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Mon Nov 28 20:55:50 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "ORCL_A"
Connected as SYSDG.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 59 seconds ago)
DGMGRL>
CDB-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_A| DBA | | Vérifiez le rôle de l'instance. | Ouvrez la console de gestion AWS et accédez à la console Amazon RDS. Dans la section **Réplication** de la base de données, sous l'onglet **Connectivité et sécurité**, vérifiez le rôle de l'instance principale et de la réplique.Le rôle principal doit correspondre à la base de données principale Oracle Data Guard, et le rôle de réplique doit correspondre à la base de données de secours physique Oracle Data Guard. | Administrateur cloud, DBA | | Effectuez le changement. | Pour effectuer le basculement, connectez-vous `DGMGRL` depuis le nœud principal.**Non CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 18 06:13:07 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_A"
Connected as SYSDG.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 52 seconds ago)
DGMGRL>
DGMGRL> switchover to orcl_d;**CDB**
Performing switchover NOW, please wait...
Operation requires a connection to database "orcl_d"
Connecting ...
Connected to "ORCL_D"
Connected as SYSDG.
New primary database "orcl_d" is opening...
Operation requires start up of instance "ORCL" on database "orcl_a"
Starting instance "ORCL"...
Connected to an idle instance.
ORACLE instance started.
Connected to "ORCL_A"
Database mounted.
Database opened.
Connected to "ORCL_A"
Switchover succeeded, new primary is "orcl_d"
DGMGRL>
DGMGRL> switchover to rdscdb_b| DBA | | Vérifiez la connexion Oracle Data Guard. | Après le basculement, vérifiez la connexion Oracle Data Guard entre le nœud principal et. `DGMGRL`**Non CDB**
Performing switchover NOW, please wait...
New primary database "rdscdb_b" is opening...
Operation requires start up of instance "RDSCDB" on database "rdscdb_a"
Starting instance "RDSCDB"...
Connected to an idle instance.
ORACLE instance started.
Connected to "RDSCDB_A"
Database mounted.
Database opened.
Connected to "RDSCDB_A"
Switchover succeeded, new primary is "rdscdb_b"
DGMGRL> show configuration;**CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_d - Primary database
orcl_a - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 60 seconds ago)
DGMGRL>
DGMGRL> show configuration lag;
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_d - Primary database
orcl_a - Physical standby database
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 44 seconds ago)
DGMGRL>
DGMGRL> show configuration| DBA | | Vérifiez le rôle de l'instance sur la console Amazon RDS. | Après avoir effectué le changement de rôle, la console Amazon RDS affiche les nouveaux rôles dans la section **Réplication** de l'onglet **Connectivité et sécurité** sous **Bases** de données. La mise à jour de **l'état de réplication** de vide à **Réplication peut prendre quelques minutes.** | DBA | ### Configurer FSFO | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Réinitialisez le basculement. | Replacez le basculement sur le nœud principal. | DBA | | Installez et démarrez l'observateur. | Un processus d'observation est un composant `DGMGRL` client qui s'exécute généralement sur une machine différente de celle des bases de données principale et de secours. L'installation d'ORACLE HOME pour l'observateur peut être une installation Oracle Client Administrator, ou vous pouvez installer Oracle Database Enterprise Edition ou Personal Edition. Pour plus d'informations sur l'installation de l'observateur pour la version de votre base de données, reportez-vous à la section [Installation et démarrage de l'observateur](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). Pour configurer la haute disponibilité pour le processus d'observation, vous pouvez effectuer les opérations suivantes :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/transition-roles-for-an-oracle-peoplesoft-application-on-amazon-rds-custom-for-oracle.html)Pour Oracle 12c version 2 et versions ultérieures, vous pouvez déployer jusqu'à trois observateurs. L'un des observateurs est l'observateur principal et les autres sont des observateurs suppléants. En cas de défaillance de l'observateur principal, l'un des observateurs suppléants prend le rôle principal. | DBA | | Connectez-vous à DGMGRL depuis l'hôte observateur. | L'hôte observateur est configuré avec des `tnsnames.ora` entrées pour la connectivité à la base de données principale et de secours. Vous pouvez activer FSFO avec le mode de protection des performances maximales tant que la perte de données se situe dans les limites de la [FastStartFailoverLagLimit](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/oracle-data-guard-broker-properties.html)configuration (valeur en secondes). Cependant, vous devez utiliser le mode de protection de disponibilité maximale pour atteindre zéro perte de données (RPO=0).**Non CDB**
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_b - Primary database
rdscdb_a - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 52 seconds ago)
DGMGRL>
DGMGRL> show configuration lag
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_b - Primary database
rdscdb_a - Physical standby database
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 53 seconds ago)
DGMGRL>
DGMGRL> show configuration;**CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 58 seconds ago)
DGMGRL> show configuration lag
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 5 seconds ago)
DGMGRL>
-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_A| DBA | | Modifiez la base de données de secours pour qu'elle soit la cible du basculement. | Connectez-vous depuis le nœud principal ou le nœud observateur à une base de données de secours. (Bien que votre configuration puisse comporter plusieurs bases de données de secours, vous ne devez vous connecter qu'à une seule pour le moment.)**Non CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 18 06:55:09 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_A"
Connected as SYSDG.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 18 seconds ago)
DGMGRL>
DGMGRL> edit database orcl_a set property FastStartFailoverTarget='orcl_d';**CDB**
Property "faststartfailovertarget" updated
DGMGRL> edit database orcl_d set property FastStartFailoverTarget='orcl_a';
Property "faststartfailovertarget" updated
DGMGRL> show database orcl_a FastStartFailoverTarget;
FastStartFailoverTarget = 'orcl_d'
DGMGRL> show database orcl_d FastStartFailoverTarget;
FastStartFailoverTarget = 'orcl_a'
DGMGRL>
DGMGRL> edit database orcl_a set property FastStartFailoverTarget='rdscdb_b';| DBA | | Configurez FastStartFailoverThreshold pour la connexion à DGMGRL. | La valeur par défaut est de 30 secondes dans Oracle 19c et la valeur minimale est de 6 secondes. Une valeur inférieure peut potentiellement raccourcir l'objectif de temps de restauration (RTO) lors du basculement. Une valeur plus élevée permet de réduire le risque d'erreurs transitoires inutiles liées au basculement sur la base de données principale.Le framework d'automatisation RDS Custom for Oracle surveille l'état de la base de données et effectue des actions correctives toutes les quelques secondes. Par conséquent, nous vous recommandons FastStartFailoverThreshold de définir une valeur supérieure à 10 secondes. L'exemple suivant configure la valeur de seuil à 35 secondes.**Sans CBD ou CDB**
Object "orcl_a" was not found
DGMGRL> edit database rdscdb_a set property FastStartFailoverTarget='rdscdb_b';
Property "faststartfailovertarget" updated
DGMGRL> edit database rdscdb_b set property FastStartFailoverTarget='rdscdb_a';
Property "faststartfailovertarget" updated
DGMGRL> show database rdscdb_a FastStartFailoverTarget;
FastStartFailoverTarget = 'rdscdb_b'
DGMGRL> show database rdscdb_b FastStartFailoverTarget;
FastStartFailoverTarget = 'rdscdb_a'
DGMGRL>
DGMGRL> edit configuration set property FastStartFailoverThreshold=35;| DBA | | Activez FSFO en vous connectant à DGMGRL depuis le nœud principal ou le nœud observateur. | Si la base de données [Flashback](https://docs.oracle.com/en/database/oracle/oracle-database/19/rcmrf/FLASHBACK-DATABASE.html#GUID-584AC79A-40C5-45CA-8C63-DED3BE3A4511) n'est pas activée, le message d'avertissement `ORA-16827` s'affiche. La base de données flashback facultative permet de rétablir automatiquement les bases de données principales défaillantes à un moment donné avant le basculement si la propriété 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)configuration est définie sur `TRUE` (valeur par défaut).**Non CDB**
Property "faststartfailoverthreshold" updated
DGMGRL> show configuration FastStartFailoverThreshold;
FastStartFailoverThreshold = '35'
DGMGRL>
DGMGRL> enable fast_start failover;**CDB**
Warning: ORA-16827: Flashback Database is disabled
Enabled in Zero Data Loss Mode.
DGMGRL>
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
Warning: ORA-16819: fast-start failover observer not started
orcl_d - (*) Physical standby database
Warning: ORA-16819: fast-start failover observer not started
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
WARNING (status updated 29 seconds ago)
DGMGRL>
DGMGRL> enable fast_start failover;| DBA | | Démarrez l'observateur pour la surveillance du FSFO et vérifiez l'état. | Vous pouvez démarrer l'observateur avant ou après avoir activé FSFO. Si FSFO est déjà activé, l'observateur commence immédiatement à surveiller l'état et les connexions aux bases de données de secours principales et cibles. Si le FSFO n'est pas activé, l'observateur ne commence à surveiller qu'une fois le FSFO activé.Lorsque vous démarrez l'observateur, la configuration de base de données principale s'affiche sans aucun message d'erreur, comme en témoigne la `show configuration` commande précédente.**Non CDB**
Warning: ORA-16827: Flashback Database is disabled
Enabled in Zero Data Loss Mode.
DGMGRL> show configuration;
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
Warning: ORA-16819: fast-start failover observer not started
rdscdb_b - (*) Physical standby database
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
WARNING (status updated 11 seconds ago)
DGMGRL>
DGMGRL> start observer;**CDB**
[W000 2022-12-01T06:16:51.271+00:00] FSFO target standby is orcl_d
Observer 'ip-10-0-1-89' started
[W000 2022-12-01T06:16:51.352+00:00] Observer trace level is set to USER
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - (*) Physical standby database
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
SUCCESS (status updated 56 seconds ago)
DGMGRL>
DGMGRL> show observer
Configuration - rds_dg
Primary: orcl_a
Active Target: orcl_d
Observer "ip-10-0-1-89" - Master
Host Name: ip-10-0-1-89
Last Ping to Primary: 1 second ago
Last Ping to Target: 1 second ago
DGMGRL>
DGMGRL> start observer;| DBA | | Vérifiez le basculement. | Dans ce scénario, un test de basculement peut être effectué en arrêtant manuellement l' EC2 instance principale. Avant d'arrêter l' EC2 instance, utilisez la `tail` commande pour surveiller le fichier journal de l'observateur en fonction de votre configuration. `DGMGRL`À utiliser pour se connecter à la base de données de secours `orcl_d` avec l'utilisateur `RDS_DATAGUARD` et vérifier l'état d'Oracle Data Guard. Cela devrait indiquer qu'il s'`orcl_d`agit de la nouvelle base de données principale.Dans ce scénario de test de basculement, `orcl_d` se trouve la base de données non CDB.Avant le basculement, la base de données Flashback a été activée. `orcl_a` Une fois que l'ancienne base de données principale est remise en ligne et redémarre en `MOUNT` état, l'observateur la rétablit dans une nouvelle base de données de secours. La base de données rétablie fait office de cible FSFO pour la nouvelle base de données principale. Vous pouvez vérifier les détails dans les journaux des observateurs.
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 configurationL'exemple suivant montre un exemple de sortie en`observer.log`.
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_d - Primary database
Warning: ORA-16824: multiple warnings, including fast-start failover-related warnings, detected for the database
orcl_a - (*) Physical standby database (disabled)
ORA-16661: the standby database needs to be reinstated
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
WARNING (status updated 25 seconds ago)
DGMGRL>
$ tail -f /tmp/observer.log| DBA | ### Configuration de la connectivité entre l'application Oracle Peoplesoft et la base de données | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez et démarrez le service dans la base de données principale. | Vous pouvez éviter de modifier la configuration de l'application lors d'une transition de rôle en utilisant une entrée TNS qui contient à la fois les points de terminaison de base de données principaux et de secours dans la configuration. Vous pouvez définir deux services de base de données basés sur des rôles pour prendre en charge à la fois les charges de travail read/write et les charges de travail en lecture seule. Dans l'exemple suivant, le read/write service `orcl_rw` est actif sur la base de données principale. `orcl_ro`est le service en lecture seule et est actif sur la base de données de secours qui a été ouverte en mode lecture seule.
Unable to connect to database using rds_custom_orcl_a
[W000 2023-01-18T07:50:32.589+00:00] Primary database cannot be reached.
[W000 2023-01-18T07:50:32.589+00:00] Fast-Start Failover threshold has expired.
[W000 2023-01-18T07:50:32.590+00:00] Try to connect to the standby.
[W000 2023-01-18T07:50:32.590+00:00] Making a last connection attempt to primary database before proceeding with Fast-Start Failover.
[W000 2023-01-18T07:50:32.591+00:00] Check if the standby is ready for failover.
[S002 2023-01-18T07:50:32.591+00:00] Fast-Start Failover started...
2023-01-18T07:50:32.591+00:00
Initiating Fast-Start Failover to database "orcl_d"...
[S002 2023-01-18T07:50:32.592+00:00] Initiating Fast-start Failover.
Performing failover NOW, please wait...
Failover succeeded, new primary is "orcl_d"
2023-01-18T07:55:32.101+00:00
[S002 2023-01-18T07:55:32.591+00:00] Fast-Start Failover finished...
[W000 2023-01-18T07:55:32.591+00:00] Failover succeeded. Restart pinging.
[W000 2023-01-18T07:55:32.603+00:00] Primary database has changed to orcl_d.
[W000 2023-01-18T07:55:33.618+00:00] Try to connect to the primary.
[W000 2023-01-18T07:55:33.622+00:00] Try to connect to the primary rds_custom_orcl_d.
[W000 2023-01-18T07:55:33.634+00:00] The standby orcl_a needs to be reinstated
[W000 2023-01-18T07:55:33.654+00:00] Try to connect to the new standby orcl_a.
[W000 2023-01-18T07:55:33.654+00:00] Connection to the primary restored!
[W000 2023-01-18T07:55:35.654+00:00] Disconnecting from database rds_custom_orcl_d.
[W000 2023-01-18T07:55:57.701+00:00] Try to connect to the new standby orcl_a.
ORA-12170: TNS:Connect timeout occurred
SQL> select name,open_mode from v$database;| DBA | | Démarrez le service dans la base de données de secours. | Pour démarrer le service dans la base de données de secours en lecture seule, utilisez le code suivant.
NAME OPEN_MODE
--------- --------------------
ORCL READ WRITE
SQL> exec dbms_service.create_service('orcl_rw','orcl_rw');
PL/SQL procedure successfully completed.
SQL> exec dbms_service.create_service('orcl_ro','orcl_ro');
PL/SQL procedure successfully completed.
SQL> exec dbms_service.start_service('orcl_rw');
PL/SQL procedure successfully completed.
SQL>
SQL> select name,open_mode from v$database;| DBA | | Automatisez le démarrage du service lorsque la base de données principale est redémarrée. | Pour démarrer automatiquement le service dans la base de données principale lors de son redémarrage, utilisez le code suivant.
NAME OPEN_MODE
--------- --------------------
ORCL READ ONLY WITH APPLY
SQL> exec dbms_service.start_service('orcl_ro');
PL/SQL procedure successfully completed.
SQL>
SQL> CREATE OR REPLACE TRIGGER TrgDgServices after startup on database| DBA | | Configurez une connexion entre les bases de données read/write et les bases de données en lecture seule. | Vous pouvez utiliser l'exemple de configuration d'application suivant pour la connexion read/write et la connexion en lecture seule.
DECLARE
db_role VARCHAR(30);
db_open_mode VARCHAR(30);
BEGIN
SELECT DATABASE_ROLE, OPEN_MODE INTO db_role, db_open_mode FROM V$DATABASE;
IF db_role = 'PRIMARY' THEN
DBMS_SERV 2 ICE.START_SERVICE('orcl_rw');
END IF;
IF db_role = 'PHYSICAL STANDBY' AND db_open_mode LIKE 'READ ONLY%' THEN
DBMS_SERVICE.START_SERVICE('orcl_ro');
END IF;
END;
/
Trigger created.
SQL>
ORCL_RW = (DESCRIPTION =| DBA | ## Ressources connexes + [Activer la haute disponibilité avec Data Guard sur Amazon RDS Custom pour Oracle](https://d1.awsstatic.com/whitepapers/enabling-high-availability-with-data-guard-on-amazon-rds-custom-for-oracle.pdf) (Guide technique AWS) + [Configuration d'Amazon RDS en tant que PeopleSoft base de données Oracle](https://d1.awsstatic.com/whitepapers/configuring-amazon-rds-as-peoplesoft-database.pdf) (livre blanc AWS) + [Guide Oracle Data Guard Broker](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/index.html) (documentation de référence Oracle) + [Concepts et administration de Data Guard](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/index.html) (documentation de référence Oracle) + [Exigences de configuration du FAN et du FCF spécifiques à 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) (documentation de référence Oracle) # Déchargez les données d'un cluster Amazon Redshift entre différents comptes vers Amazon S3 *Andrew Kamel, Amazon Web Services* ## Résumé Lorsque vous testez des applications, il est utile de disposer de données de production dans votre environnement de test. L'utilisation des données de production peut vous donner une évaluation plus précise de l'application que vous développez. Ce modèle extrait les données d'un cluster Amazon Redshift dans un environnement de production vers un bucket Amazon Simple Storage Service (Amazon S3) dans un environnement de développement sur Amazon Web Services ().AWS Le modèle décrit les étapes de configuration des comptes DEV et PROD, notamment les suivantes : + Ressources requises + Gestion des identités et des accès AWS Rôles (IAM) + Ajustements réseau apportés aux sous-réseaux, aux groupes de sécurité et au cloud privé virtuel (VPC) pour prendre en charge la connexion Amazon Redshift + Exemple de AWS Lambda fonction avec un environnement d'exécution Python pour tester l'architecture Pour accorder l'accès au cluster Amazon Redshift, le modèle permet de stocker les AWS Secrets Manager informations d'identification pertinentes. L'avantage est de disposer de toutes les informations nécessaires pour se connecter directement au cluster Amazon Redshift sans avoir besoin de savoir où se trouve le cluster Amazon Redshift. De plus, vous pouvez [contrôler l'utilisation du secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/monitoring.html). Le secret enregistré dans Secrets Manager inclut l'hôte du cluster Amazon Redshift, le nom de la base de données, le port et les informations d'identification pertinentes. Pour plus d'informations sur les considérations de sécurité liées à l'utilisation de ce modèle, consultez la section [Bonnes pratiques](#unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3-best-practices). ## Conditions préalables et limitations **Conditions préalables** + Un [cluster Amazon Redshift exécuté](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html) dans le compte PROD + Un [bucket S3 créé](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) dans le compte DEV + [Peering VPC](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html) [entre les comptes DEV et PROD, avec tables de routage ajustées en conséquence](https://docs.aws.amazon.com/vpc/latest/peering/vpc-peering-routing.html) + [Noms d'hôte DNS et résolution DNS activés](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html) pour les deux versions peered VPCs **Limites** + En fonction de la quantité de données que vous souhaitez interroger, le délai d'expiration de la fonction Lambda peut être dépassé. Si votre exécution prend plus de temps que le délai maximum Lambda (15 minutes), utilisez une approche asynchrone pour votre code Lambda. L'exemple de code de ce modèle utilise la bibliothèque [psycopg2](https://github.com/psycopg/psycopg2) pour Python, qui ne prend actuellement pas en charge le traitement asynchrone. + Certains Services AWS ne sont pas disponibles du tout Régions AWS. Pour connaître la disponibilité par région, voir [Services AWS par région](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Pour des points de terminaison spécifiques, consultez la page [Points de terminaison et quotas du service](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html), puis choisissez le lien vers le service. ## Architecture Le schéma suivant montre l'architecture cible, avec les comptes DEV et PROD. ![\[Le VPC Lambda dans le compte DEV et le VPC Amazon Redshift dans le compte PROD.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/fa4d01df-483d-4454-9711-b391ebbe4629.png) Le schéma suivant illustre le flux de travail suivant : 1. La fonction Lambda du compte DEV assume le rôle IAM requis pour accéder aux informations d'identification Amazon Redshift dans Secrets Manager dans le compte PROD. La fonction Lambda récupère ensuite le secret du cluster Amazon Redshift. 1. La fonction Lambda du compte DEV utilise les informations pour se connecter au cluster Amazon Redshift dans le compte PROD via le peered. VPCs La fonction Lambda envoie ensuite une commande de déchargement pour interroger le cluster Amazon Redshift dans le compte PROD. 1. Le cluster Amazon Redshift du compte PROD assume le rôle IAM approprié pour accéder au compartiment S3 du compte DEV. Le cluster Amazon Redshift décharge les données demandées dans le compartiment S3 du compte DEV. **Interrogation de données depuis Amazon Redshift** Le schéma suivant montre les rôles utilisés pour récupérer les informations d'identification Amazon Redshift et se connecter au cluster Amazon Redshift. Le flux de travail est lancé par la fonction Lambda. ![\[Le processus en trois étapes pour assumer des rôles sur plusieurs comptes.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/ab25b72c-773c-4d58-9012-4a3755c181ff.png) Le schéma suivant illustre le flux de travail suivant : 1. Le compte `CrossAccount-SM-Read-Role` in the DEV suppose le compte `SM-Read-Role` in the PROD. 1. Le `SM-Read-Role` rôle utilise la politique ci-jointe pour récupérer le secret auprès de Secrets Manager. 1. Les informations d'identification sont utilisées pour accéder au cluster Amazon Redshift. **Chargement de données vers Amazon S3** Le schéma suivant montre le processus de lecture-écriture entre comptes permettant d'extraire des données et de les télécharger sur Amazon S3. Le flux de travail est lancé par la fonction Lambda. Le modèle [enchaîne les rôles IAM dans Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html#authorizing-redshift-service-chaining-roles). La commande de déchargement qui provient du cluster Amazon Redshift suppose `CrossAccount-S3-Write-Role` le, puis suppose le. `S3-Write-Role` Ce chaînage de rôles permet à Amazon Redshift d'accéder à Amazon S3. ![\[Les rôles qui obtiennent des informations d'identification, accèdent à Amazon Redshift et chargent des données vers Amazon S3.\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/d2982fc6-1d12-4f9d-9493-a99ce691d693.png) Le flux de travail comprend les étapes suivantes : 1. Le compte `CrossAccount-SM-Read-Role` in the DEV suppose le compte `SM-Read-Role` in the PROD. 1. `SM-Read-Role`récupère les informations d'identification Amazon Redshift auprès de Secrets Manager. 1. La fonction Lambda se connecte au cluster Amazon Redshift et envoie une requête. 1. Le cluster Amazon Redshift suppose que. `CrossAccount-S3-Write-Role` 1. Cela `CrossAccount-S3-Write-Role` suppose que c'est `S3-Write-Role` dans le compte DEV. 1. Les résultats de la requête sont déchargés dans le compartiment S3 du compte DEV. ## Outils **Services AWS** + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) vous aide à créer et à contrôler des clés cryptographiques afin de protéger vos données. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) est un service de calcul qui vous aide à exécuter du code sans avoir à allouer ni à gérer des serveurs. Il exécute votre code uniquement lorsque cela est nécessaire et évolue automatiquement, de sorte que vous ne payez que pour le temps de calcul que vous utilisez. + [Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html) est un service d'entrepôt de données géré à l'échelle du pétaoctet dans le cloud AWS. + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) vous aide à remplacer les informations d'identification codées en dur dans votre code, y compris les mots de passe, par un appel d'API à Secrets Manager pour récupérer le secret par programmation. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) est un service de stockage d'objets basé sur le cloud qui vous permet de stocker, de protéger et de récupérer n'importe quel volume de données. **Référentiel de code** Le code de ce modèle est disponible dans le dépôt GitHub [unload-redshift-to-s3-python](https://github.com/aws-samples/unload-redshift-to-s3-python/). ## Bonnes pratiques **Avertissement de sécurité** Avant de mettre en œuvre cette solution, tenez compte des recommandations de sécurité importantes suivantes : + N'oubliez pas que la connexion des comptes de développement et de production peut augmenter la portée et réduire le niveau de sécurité global. Nous recommandons de ne déployer cette solution que temporairement, en extrayant la portion de données requise, puis en détruisant immédiatement les ressources déployées. Pour détruire les ressources, vous devez supprimer la fonction Lambda, supprimer tous les rôles et politiques IAM créés pour cette solution et révoquer tout accès réseau accordé entre les comptes. + Consultez vos équipes de sécurité et de conformité avant de copier des données depuis des environnements de production vers des environnements de développement. Les informations personnelles identifiables (PII), les informations de santé protégées (PHI) et les autres données confidentielles ou réglementées ne doivent généralement pas être copiées de cette manière. Copiez uniquement les informations non confidentielles accessibles au public (par exemple, les données boursières publiques provenant d'une interface de boutique). Envisagez de tokeniser ou d'anonymiser les données, ou de générer des données de test synthétiques, au lieu d'utiliser des données de production dans la mesure du possible. L'un des [principes de AWS sécurité](https://docs.aws.amazon.com/en_us/wellarchitected/2022-03-31/framework/sec-design.html) consiste à tenir les gens à l'écart des données. En d'autres termes, les développeurs ne doivent pas effectuer d'opérations dans le compte de production. + Limitez l'accès à la fonction Lambda dans le compte de développement, car elle peut lire les données du cluster Amazon Redshift dans l'environnement de production. + Pour éviter de perturber l'environnement de production, appliquez les recommandations suivantes : + Utilisez un compte de développement dédié distinct pour les activités de test et de développement. + Mettez en œuvre des contrôles d'accès réseau stricts et limitez le trafic entre les comptes au strict nécessaire. + Surveillez et auditez l'accès à l'environnement de production et aux sources de données. + Mettez en œuvre des contrôles d'accès basés sur le principe du moindre privilège pour toutes les ressources et tous les services concernés. + Passez régulièrement en revue et alternez les informations d'identification, telles que AWS Secrets Manager les secrets et les clés d'accès aux rôles IAM. + Reportez-vous à la documentation de sécurité suivante pour les services utilisés dans cet article : + [AWS Lambda sécurité](https://docs.aws.amazon.com/lambda/latest/dg/lambda-security.html) + [Sécurité d'Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/iam-redshift-user-mgmt.html) + [Sécurité d'Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/security.html) + [AWS Secrets Manager sécurité](https://docs.aws.amazon.com/secretsmanager/latest/userguide/security.html) + [Bonnes pratiques de sécurité IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) La sécurité est une priorité absolue lors de l'accès aux données et aux ressources de production. Suivez toujours les meilleures pratiques, mettez en œuvre des contrôles d'accès fondés sur le moindre privilège et révisez et mettez à jour régulièrement vos mesures de sécurité. ## Épopées ### Interrogez des données depuis Amazon Redshift | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un secret pour le cluster Amazon Redshift. | Pour créer le secret du cluster Amazon Redshift, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingénieur | | Créez un rôle pour accéder à Secrets Manager. | Pour créer le rôle, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingénieur | ### Chargement de données vers Amazon S3 | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Créez un rôle pour accéder au compartiment S3. | Pour créer le rôle permettant d'accéder au compartiment S3, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingénieur | | Créez le rôle Amazon Redshift. | Pour créer le rôle Amazon Redshift, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingénieur | ### Déployez la fonction Lambda. | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Déployez la fonction Lambda. | Pour déployer une fonction Lambda dans le VPC homologue, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingénieur | ### Testez l'architecture | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Importez les ressources requises. | Pour importer les ressources requises, exécutez les commandes suivantes :
(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| Développeur d’applications | | Exécutez la fonction de gestion Lambda. | La fonction Lambda utilise AWS Security Token Service (AWS STS) pour l'accès entre comptes et la gestion des informations d'identification temporaires. La fonction utilise l'opération d' AssumeRole API pour assumer temporairement les autorisations du rôle `sm_read_role` IAM.Pour exécuter la fonction Lambda, utilisez l'exemple de code suivant :
import boto3
import psycopg2
import base64
from botocore.exceptions import ClientError
def lambda_handler(event, context):| Développeur d’applications | | Découvrez le secret. | Pour obtenir le secret Amazon Redshift, utilisez l'exemple de code suivant :
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):| Développeur d’applications | | Exécutez la commande de déchargement. | Pour décharger les données dans le compartiment S3, utilisez l'exemple de code suivant.
# 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):| Développeur d’applications | ### Nettoyage | Sous-tâche | Description | Compétences requises | | --- | --- | --- | | Supprimez la fonction Lambda. | Pour éviter d'encourir des coûts imprévus, supprimez les ressources et la connexion entre les comptes DEV et PROD.Pour supprimer la fonction Lambda, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingénieur | | Supprimez les rôles et les politiques IAM. | Supprimez les rôles et politiques IAM des comptes DEV et PROD.Dans le compte DEV, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html)Dans le compte PROD, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingénieur | | Supprimez le secret dans Secrets Manager. | Pour supprimer le secret, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingénieur | | Supprimez les règles de peering et de groupe de sécurité des VPC. | Pour supprimer les règles de peering et de groupe de sécurité VPC, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingénieur | | Supprimez les données du compartiment S3. | Pour supprimer les données d'Amazon S3, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingénieur | | Nettoyez AWS KMS les clés. | Si vous avez créé des AWS KMS clés personnalisées pour le chiffrement, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingénieur | | Vérifiez et supprimez les CloudWatch journaux Amazon. | Pour supprimer les CloudWatch journaux, procédez comme suit :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps ingénieur | ## Ressources connexes + [ CloudWatch Documentation Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) + [Documentation IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) + [Documentation Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) + [Documentation Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html) + [Documentation Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) + [AWS Secrets Manager documentation](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) + [AWS principes de sécurité](https://docs.aws.amazon.com/en_us/wellarchitected/2022-03-31/framework/sec-design.html) ## Informations supplémentaires Après avoir déchargé les données d'Amazon Redshift vers Amazon S3, vous pouvez les analyser à l'aide d'Amazon Athena. [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/getting-started.html) est un service de requêtes de données volumineuses qui s'avère utile lorsque vous devez accéder à de gros volumes de données. Vous pouvez utiliser Athena sans avoir à approvisionner des serveurs ou des bases de données. Athena prend en charge les requêtes complexes et vous pouvez l'exécuter sur différents objets. Comme c'est le cas pour la plupart des autres Services AWS, le principal avantage d'Athena est qu'elle offre une grande flexibilité dans la façon dont vous exécutez les requêtes sans complexité supplémentaire. Lorsque vous utilisez Athena, vous pouvez interroger différents types de données, tels que CSV et JSON, dans Amazon S3 sans modifier le type de données. Vous pouvez interroger des données provenant de différentes sources, y compris extérieures AWS. Athena réduit la complexité car vous n'avez pas à gérer de serveurs. Athena lit les données directement depuis Amazon S3 sans les charger ni les modifier avant que vous n'exécutiez la requête. # Modèles de migration de base de données par charge de travail **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) + [Open source](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** + [Migrer une base de données DB2 d'Amazon EC2 vers Aurora compatible avec MySQL à l'aide d'AWS DMS](migrate-a-db2-database-from-amazon-ec2-to-aurora-mysql-compatible-by-using-aws-dms.md) + [Migrez Db2 for LUW vers Amazon EC2 en utilisant l'expédition des journaux pour réduire les temps d'arrêt](migrate-db2-for-luw-to-amazon-ec2-by-using-log-shipping-to-reduce-outage-time.md) + [Migrez Db2 for LUW vers Amazon EC2 avec une reprise après sinistre à haute disponibilité](migrate-db2-for-luw-to-amazon-ec2-with-high-availability-disaster-recovery.md) + [Migrez d'IBM Db2 sur Amazon vers une version compatible avec Aurora PostgreSQL EC2 à l'aide d'AWS DMS et d'AWS SCT](migrate-from-ibm-db2-on-amazon-ec2-to-aurora-postgresql-compatible-using-aws-dms-and-aws-sct.md) + [Migrer d'un serveur WebSphere d'applications IBM vers Apache Tomcat sur Amazon EC2](migrate-from-ibm-websphere-application-server-to-apache-tomcat-on-amazon-ec2.md) + [Diffusez des données depuis IBM Db2, SAP, Sybase et d'autres bases de données vers MongoDB Atlas sur AWS](stream-data-from-ibm-db2-to-mongodb-atlas.md) # Microsoft **Topics** + [Accélérez la découverte et la migration des charges de travail Microsoft vers AWS](accelerate-the-discovery-and-migration-of-microsoft-workloads-to-aws.md) + [Accédez aux tables Microsoft SQL Server locales depuis Microsoft SQL Server sur Amazon à EC2 l'aide de serveurs liés](access-on-premises-microsoft-sql-server-tables-from-microsoft-sql-server-on-amazon-ec2-using-linked-servers.md) + [Évaluez les performances des requêtes pour la migration des bases de données SQL Server vers MongoDB Atlas sur AWS](assess-query-performance-for-migrating-sql-server-databases-to-mongodb-atlas-on-aws.md) + [Automatisez les tâches de base de données dans l'édition SQL Server Express exécutée sur Amazon à EC2 l'aide AWS Lambda d'un planificateur de tâches](automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.md) + [Modifier les applications Python et Perl pour prendre en charge la migration de bases de données de Microsoft SQL Server vers Amazon Aurora PostgreSQL Compatible Edition](change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.md) + [Configurer le routage en lecture seule dans un groupe de disponibilité Always On dans SQL Server sur AWS](configure-read-only-routing-in-an-always-on-availability-group-in-sql-server-on-aws.md) + [Configurez l'authentification Windows pour Amazon RDS pour Microsoft SQL Server à l'aide de AWS Managed Microsoft AD](configure-windows-authentication-for-amazon-rds-using-microsoft-ad.md) + [Création de CloudFormation modèles AWS pour les tâches AWS DMS à l'aide de Microsoft Excel et Python](create-aws-cloudformation-templates-for-aws-dms-tasks-using-microsoft-excel-and-python.md) + [Déployez des instances de cluster de basculement SQL Server sur Amazon EC2 et Amazon à l'aide FSx de Terraform](deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.md) + [Exporter une base de données Microsoft SQL Server vers Amazon S3 à l'aide d'AWS DMS](export-a-microsoft-sql-server-database-to-amazon-s3-by-using-aws-dms.md) + [Exportez les tables Amazon RDS for SQL Server vers un compartiment S3 à l'aide d'AWS DMS](export-amazon-rds-for-sql-server-tables-to-an-s3-bucket-by-using-aws-dms.md) + [SHA1 Implémenter le hachage des données personnelles lors de la migration de SQL Server vers PostgreSQL](implement-sha1-hashing-for-pii-data-when-migrating-from-sql-server-to-postgresql.md) + [Ingérez et migrez des instances EC2 Windows vers un compte AWS Managed Services](ingest-and-migrate-ec2-windows-instances-into-an-aws-managed-services-account.md) + [Configurer un cluster de basculement Microsoft SQL Server sur Amazon à EC2 l'aide FSx de Windows File Server](microsoft-sql-failover-cluster-on-amazon-ec2.md) + [Migrer une file d'attente de messagerie de Microsoft Azure Service Bus vers Amazon SQS](migrate-a-messaging-queue-from-microsoft-azure-service-bus-to-amazon-sqs.md) + [Migrer une base de données Microsoft SQL Server d'Amazon EC2 vers Amazon DocumentDB à l'aide d'AWS DMS](migrate-a-microsoft-sql-server-database-from-amazon-ec2-to-amazon-documentdb-by-using-aws-dms.md) + [Migrer une base de données Microsoft SQL Server vers Aurora MySQL à l'aide d'AWS DMS et d'AWS SCT](migrate-a-microsoft-sql-server-database-to-aurora-mysql-by-using-aws-dms-and-aws-sct.md) + [Migrer une application .NET de Microsoft Azure App Service vers AWS Elastic Beanstalk](migrate-a-net-application-from-microsoft-azure-app-service-to-aws-elastic-beanstalk.md) + [Migrer une base de données Microsoft SQL Server sur site vers Amazon EC2](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-ec2.md) + [Migrer une base de données Microsoft SQL Server locale vers Amazon RDS for SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server.md) + [Migrer une base de données Microsoft SQL Server locale vers Amazon RDS for SQL Server à l'aide de serveurs liés](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-linked-servers.md) + [Migrer une base de données Microsoft SQL Server locale vers Amazon RDS for SQL Server à l'aide de méthodes de sauvegarde et de restauration natives](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-native-backup-and-restore-methods.md) + [Migrer une base de données Microsoft SQL Server sur site vers Amazon Redshift à l'aide d'AWS DMS](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-dms.md) + [Migrer une base de données Microsoft SQL Server sur site vers Amazon Redshift à l'aide des agents d'extraction de données AWS SCT](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.md) + [Migrer une base de données Microsoft SQL Server sur site vers Microsoft SQL Server sur Amazon EC2 exécutant Linux](migrate-an-on-premises-microsoft-sql-server-database-to-microsoft-sql-server-on-amazon-ec2-running-linux.md) + [Migrez les données de Microsoft Azure Blob vers Amazon S3 à l'aide de Rclone](migrate-data-from-microsoft-azure-blob-to-amazon-s3-by-using-rclone.md) + [Migrez les applications hébergées EC2 par IIS vers Amazon à l'aide de appcmd.exe](migrate-iis-hosted-applications-to-amazon-ec2-by-using-appcmd.md) + [Migrez le groupe de disponibilité Microsoft SQL Server Always On à l'aide de AWS Application Migration Service](migrate-microsoft-sql-server-always-on-group-using-mgn.md) + [Migrer une base de données Microsoft SQL Server sur site vers Amazon à EC2 l'aide du service de migration d'applications](migrate-microsoft-sql-server-to-amazon-ec2-using-aws-mgn.md) + [Migrer une base de données relationnelle vers MongoDB Atlas sur AWS](migrate-relational-database-to-mongodb-atlas.md) + [Migrer SQL Server vers AWS à l'aide de groupes de disponibilité distribués](migrate-sql-server-to-aws-using-distributed-availability-groups.md) + [Migrer les certificats SSL Windows vers un Application Load Balancer à l'aide d'ACM](migrate-windows-ssl-certificates-to-an-application-load-balancer-using-acm.md) + [Réhébergez les charges de travail sur site dans le cloud AWS : liste de contrôle pour la migration](rehost-on-premises-workloads-in-the-aws-cloud-migration-checklist.md) + [Résoudre les erreurs de connexion après la migration de Microsoft SQL Server vers le cloud AWS](resolve-connection-errors-after-migrating-microsoft-sql-server-to-the-aws-cloud.md) + [Envoyer des notifications pour une instance de base de données Amazon RDS for SQL Server à l'aide d'un serveur SMTP sur site et de Database Mail](send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.md) + [Configurer un CI/CD pipeline pour la migration de base de données à l'aide de Terraform](set-up-ci-cd-pipeline-for-db-migration-with-terraform.md) + [Configurez une infrastructure multi-AZ pour un SQL Server Always On FCI à l'aide d'Amazon FSx](set-up-multi-az-infrastructure-for-a-sql-server-always-on-fci-by-using-amazon-fsx.md) # N/A **Topics** + [Créez un processus d'approbation pour les demandes de pare-feu lors d'une migration de réhébergement vers AWS](create-an-approval-process-for-firewall-requests-during-a-rehost-migration-to-aws.md) + [Chiffrer une instance de base de données Amazon RDS pour PostgreSQL existante](encrypt-an-existing-amazon-rds-for-postgresql-db-instance.md) + [Estimation des coûts de stockage pour une table Amazon DynamoDB](estimate-storage-costs-for-an-amazon-dynamodb-table.md) + [Mettre en œuvre la reprise après sinistre entre régions avec AWS DMS et Amazon Aurora](implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.md) # Open source **Topics** + [Générez automatiquement un modèle PynamoDB et des fonctions CRUD pour Amazon DynamoDB à l'aide d'une application Python](automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.md) + [Connectez-vous en utilisant un tunnel SSH dans pgAdmin](connect-by-using-an-ssh-tunnel-in-pgadmin.md) + [Création d'utilisateurs et de rôles d'application dans Aurora PostgreSQL compatible](create-application-users-and-roles-in-aurora-postgresql-compatible.md) + [Activer les connexions chiffrées pour les instances de base de données PostgreSQL dans Amazon RDS](enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.md) + [Migrer Amazon RDS for Oracle vers Amazon RDS for PostgreSQL avec et en utilisant et 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) + [Migrer une base de données MariaDB sur site vers Amazon RDS for MariaDB à l'aide d'outils natifs](migrate-an-on-premises-mariadb-database-to-amazon-rds-for-mariadb-using-native-tools.md) + [Migrer une base de données MySQL sur site vers Amazon EC2](migrate-an-on-premises-mysql-database-to-amazon-ec2.md) + [Migrer une base de données MySQL sur site vers Amazon RDS for MySQL](migrate-an-on-premises-mysql-database-to-amazon-rds-for-mysql.md) + [Migrer une base de données MySQL sur site vers Aurora MySQL](migrate-an-on-premises-mysql-database-to-aurora-mysql.md) + [Migrer une base de données PostgreSQL locale vers Aurora PostgreSQL](migrate-an-on-premises-postgresql-database-to-aurora-postgresql.md) + [Migrer une base de données Couchbase Server vers Amazon EC2](migrate-couchbase-server-ec2.md) + [Migrez d'IBM WebSphere Application Server vers Apache Tomcat sur Amazon EC2 avec Auto Scaling](migrate-from-ibm-websphere-application-server-to-apache-tomcat-on-amazon-ec2-with-auto-scaling.md) + [Migrez d'Oracle 8i ou 9i vers Amazon RDS for Oracle à l'aide d'AWS DMS SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.md) + [Migrez de PostgreSQL sur EC2 Amazon vers Amazon RDS pour PostgreSQL à l'aide de pglogical](migrate-from-postgresql-on-amazon-ec2-to-amazon-rds-for-postgresql-using-pglogical.md) + [Migrez des applications Java sur site vers AWS à l'aide d'AWS App2Container](migrate-on-premises-java-applications-to-aws-using-aws-app2container.md) + [Migrez des bases de données MySQL sur site vers Aurora MySQL à l'aide de Percona, XtraBackup Amazon EFS et Amazon S3](migrate-on-premises-mysql-databases-to-aurora-mysql-using-percona-xtrabackup-amazon-efs-and-amazon-s3.md) + [Migrer des tables externes Oracle vers des tables compatibles avec Amazon Aurora PostgreSQL](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md) + [Migrer les fonctions et procédures Oracle comportant plus de 100 arguments vers PostgreSQL](migrate-oracle-functions-and-procedures-that-have-more-than-100-arguments-to-postgresql.md) + [Migrer les charges de travail Redis vers Redis Enterprise Cloud sur AWS](migrate-redis-workloads-to-redis-enterprise-cloud-on-aws.md) + [Surveillez Amazon Aurora pour détecter les instances sans chiffrement](monitor-amazon-aurora-for-instances-without-encryption.md) + [Redémarrez automatiquement l'agent de réplication AWS sans le désactiver SELinux après le redémarrage d'un serveur source RHEL](restart-the-aws-replication-agent-automatically-without-disabling-selinux-after-rebooting-a-rhel-source-server.md) + [Planifiez des tâches pour Amazon RDS for PostgreSQL et Aurora PostgreSQL à l'aide de Lambda et Secrets Manager](schedule-jobs-for-amazon-rds-for-postgresql-and-aurora-postgresql-by-using-lambda-and-secrets-manager.md) + [Transportez des bases de données PostgreSQL entre deux instances de base de données Amazon RDS à l'aide de pg\$1transport](transport-postgresql-databases-between-two-amazon-rds-db-instances-using-pg-transport.md) + [Déchargez les données d'un cluster Amazon Redshift entre différents comptes vers Amazon S3](unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.md) # Oracle **Topics** + [Ajoutez HA à Oracle PeopleSoft sur Amazon RDS Custom à l'aide d'une réplique en lecture](add-ha-to-oracle-peoplesoft-on-amazon-rds-custom-by-using-a-read-replica.md) + [Convertir les requêtes Oracle JSON en base de données PostgreSQL SQL SQL SQL](convert-json-oracle-queries-into-postgresql-database-sql.md) + [Convertir VARCHAR2 (1) type de données pour Oracle en type de données booléen pour Amazon Aurora PostgreSQL](convert-varchar2-1-data-type-for-oracle-to-boolean-data-type-for-amazon-aurora-postgresql.md) + [Émulez Oracle DR à l'aide d'une base de données globale Aurora compatible avec PostgreSQL](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md) + [Émulez des baies PL/SQL associatives Oracle dans Amazon Aurora PostgreSQL et Amazon RDS for PostgreSQL](emulate-oracle-plsql-associative-arrays-in-aurora-and-rds-postgresql.md) + [Estimez la taille du moteur Amazon RDS pour une base de données Oracle à l'aide des rapports AWR](estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.md) + [Gérer les blocs anonymes dans les instructions Dynamic SQL dans Aurora PostgreSQL](handle-anonymous-blocks-in-dynamic-sql-statements-in-aurora-postgresql.md) + [Migrez progressivement d'Amazon RDS for Oracle vers Amazon RDS for PostgreSQL à l'aide d'Oracle SQL Developer et d'AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md) + [Chargez des fichiers BLOB dans TEXT en utilisant le codage de fichiers compatible avec Aurora PostgreSQL](load-blob-files-into-text-by-using-file-encoding-in-aurora-postgresql-compatible.md) + [Migrez Amazon RDS for Oracle vers Amazon RDS for PostgreSQL en mode SSL à l'aide d'AWS DMS](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-in-ssl-mode-by-using-aws-dms.md) + [Migrer une base de données Amazon RDS for Oracle vers Compte AWS une autre Région AWS et AWS DMS l'utiliser pour une réplication continue](migrate-an-amazon-rds-for-oracle-database-to-another-aws-account-and-aws-region-using-aws-dms-for-ongoing-replication.md) + [Migrer une base de données Oracle sur site vers Amazon à l'aide EC2 d'Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-ec2-by-using-oracle-data-pump.md) + [Migrer une base de données Oracle sur site vers Amazon OpenSearch Service à l'aide de Logstash](migrate-an-on-premises-oracle-database-to-amazon-opensearch-service-using-logstash.md) + [Migrer une base de données Oracle sur site vers Amazon RDS for MySQL à l'aide d'AWS DMS et d'AWS SCT](migrate-an-on-premises-oracle-database-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migrer une base de données Oracle sur site vers Amazon RDS for Oracle](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle.md) + [Migrez une base de données Oracle sur site vers Amazon RDS for Oracle en utilisant directement Oracle Data Pump Import via un lien de base de données](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-by-using-direct-oracle-data-pump-import-over-a-database-link.md) + [Migrer une base de données Oracle sur site vers Amazon RDS for Oracle à l'aide d'Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-using-oracle-data-pump.md) + [Migrer une base de données Oracle sur site vers Amazon RDS for PostgreSQL à l'aide d'un assistant Oracle et d'AWS DMS](migrate-an-on-premises-oracle-database-to-amazon-rds-for-postgresql-by-using-an-oracle-bystander-and-aws-dms.md) + [Migrer une base de données Oracle sur site vers Oracle sur Amazon EC2](migrate-an-on-premises-oracle-database-to-oracle-on-amazon-ec2.md) + [Migrer une base de données Oracle d'Amazon EC2 vers Amazon RDS for MariaDB à l'aide d'AWS DMS et d'AWS SCT](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-mariadb-using-aws-dms-and-aws-sct.md) + [Migrer une base de données Oracle d'Amazon EC2 vers Amazon RDS for Oracle à l'aide d'AWS DMS](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-oracle-using-aws-dms.md) + [Migrer une base de données Oracle vers Amazon DynamoDB à l'aide d'AWS DMS](migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.md) + [Migrer une base de données Oracle vers Amazon RDS for Oracle à l'aide d'adaptateurs de GoldenGate fichiers plats Oracle](migrate-an-oracle-database-to-amazon-rds-for-oracle-by-using-oracle-goldengate-flat-file-adapters.md) + [Migrer une base de données Oracle vers Amazon Redshift à l'aide d'AWS DMS et d'AWS SCT](migrate-an-oracle-database-to-amazon-redshift-using-aws-dms-and-aws-sct.md) + [Migrer une base de données Oracle vers Aurora PostgreSQL à l'aide d'AWS DMS et d'AWS SCT](migrate-an-oracle-database-to-aurora-postgresql-using-aws-dms-and-aws-sct.md) + [Migrer une EnterpriseOne base de données Oracle JD Edwards vers AWS à l'aide d'Oracle Data Pump et d'AWS DMS](migrate-an-oracle-jd-edwards-enterpriseone-database-to-aws-by-using-oracle-data-pump-and-aws-dms.md) + [Migrer une table partitionnée Oracle vers PostgreSQL à l'aide d'AWS DMS](migrate-an-oracle-partitioned-table-to-postgresql-by-using-aws-dms.md) + [Migrer une PeopleSoft base de données Oracle vers AWS à l'aide d'AWS DMS](migrate-an-oracle-peoplesoft-database-to-aws-by-using-aws-dms.md) + [Migrer les données d'une base de données Oracle sur site vers Aurora PostgreSQL](migrate-data-from-an-on-premises-oracle-database-to-aurora-postgresql.md) + [Migrer d'Amazon RDS for Oracle vers Amazon RDS for MySQL](migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-mysql.md) + [Migrez d'Oracle 8i ou 9i vers Amazon RDS for PostgreSQL à l'aide de vues matérialisées et d'AWS DMS](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-materialized-views-and-aws-dms.md) + [Migrez d'Oracle 8i ou 9i vers Amazon RDS for PostgreSQL à l'aide d'AWS DMS SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-shareplex-and-aws-dms.md) + [Migrer d'une base de données Oracle vers Amazon RDS for PostgreSQL à l'aide d'Oracle GoldenGate](migrate-from-oracle-database-to-amazon-rds-for-postgresql-by-using-oracle-goldengate.md) + [Migrez d'Oracle sur Amazon EC2 vers Amazon RDS for MySQL à l'aide d'AWS DMS et d'AWS SCT](migrate-from-oracle-on-amazon-ec2-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migrer d'Oracle WebLogic vers Apache Tomcat (ToMee) sur Amazon ECS](migrate-from-oracle-weblogic-to-apache-tomcat-tomee-on-amazon-ecs.md) + [Migrer les index basés sur les fonctions d'Oracle vers PostgreSQL](migrate-function-based-indexes-from-oracle-to-postgresql.md) + [Migrer les applications existantes d'Oracle Pro\$1C vers ECPG](migrate-legacy-applications-from-oracle-pro-c-to-ecpg.md) + [Migrer les valeurs Oracle CLOB vers des lignes individuelles dans PostgreSQL sur AWS](migrate-oracle-clob-values-to-individual-rows-in-postgresql-on-aws.md) + [Migrer les codes d'erreur de la base de données Oracle vers une base de données compatible avec Amazon Aurora PostgreSQL](migrate-oracle-database-error-codes-to-an-amazon-aurora-postgresql-compatible-database.md) + [Migrer les fonctions natives d'Oracle vers PostgreSQL à l'aide d'extensions](migrate-oracle-native-functions-to-postgresql-using-extensions.md) + [Migrer Oracle PeopleSoft vers Amazon RDS Custom](migrate-oracle-peoplesoft-to-amazon-rds-custom.md) + [Migrer la fonctionnalité Oracle ROWID vers PostgreSQL sur AWS](migrate-oracle-rowid-functionality-to-postgresql-on-aws.md) + [Migrer les packages pragma Oracle SERIALLY\$1REUSERABLE vers PostgreSQL](migrate-oracle-serially-reusable-pragma-packages-into-postgresql.md) + [Migrer les colonnes générées virtuellement d'Oracle vers PostgreSQL](migrate-virtual-generated-columns-from-oracle-to-postgresql.md) + [Surveillez GoldenGate les journaux Oracle à l'aide d'Amazon CloudWatch](monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.md) + [Analyser les dépendances des objets pour les migrations partielles de bases de données d'Oracle vers PostgreSQL](multilevel-object-analysis-for-database-migration-from-oracle-to-postgresql.md) + [Replateformage d'Oracle Database Enterprise Edition vers l'édition Standard 2 sur Amazon RDS for Oracle](replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.md) + [Configuration d'une HA/DR architecture pour Oracle E-Business Suite sur Amazon RDS Custom avec une base de données de secours active](set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database.md) + [Configuration de la fonctionnalité Oracle UTL\$1FILE sur Aurora compatible avec PostgreSQL](set-up-oracle-utl_file-functionality-on-aurora-postgresql-compatible.md) + [Rôles de transition pour une PeopleSoft application Oracle sur Amazon RDS Custom for Oracle](transition-roles-for-an-oracle-peoplesoft-application-on-amazon-rds-custom-for-oracle.md) + [Valider les objets de base de données après la migration d'Oracle vers Amazon Aurora PostgreSQL](validate-database-objects-after-migrating-from-oracle-to-amazon-aurora-postgresql.md) # SAP **Topics** + [Sauvegardez automatiquement les bases de données SAP HANA à l'aide de Systems Manager et EventBridge](automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.md) + [Migrez de SAP ASE vers Amazon RDS for SQL Server à l'aide d'AWS DMS](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md) + [Migrez SAP ASE sur Amazon EC2 vers une version compatible avec Amazon Aurora PostgreSQL à l'aide d'AWS SCT et d'AWS DMS](migrate-sap-ase-on-amazon-ec2-to-amazon-aurora-postgresql-compatible-using-aws-sct-and-aws-dms.md) + [Migrez SAP HANA vers AWS à l'aide de SAP HSR avec le même nom d'hôte](migrate-sap-hana-to-aws-using-sap-hsr-with-the-same-hostname.md) + [Configuration de la reprise après sinistre pour SAP sur IBM Db2 on AWS](set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.md) # Plus de modèles **Topics** + [Accédez à une base de données Amazon Neptune depuis un conteneur Amazon EKS](access-amazon-neptune-database-from-amazon-eks-container.md) + [Accédez aux tables Amazon DynamoDB, interrogez-les et joignez-les à l'aide d'Athena](access-query-and-join-amazon-dynamodb-tables-using-athena.md) + [Autoriser EC2 les instances à accéder en écriture aux compartiments S3 dans les comptes AMS](allow-ec2-instances-write-access-to-s3-buckets-in-ams-accounts.md) + [Analysez et visualisez des données JSON imbriquées avec Amazon Athena et Amazon Quick Sight](analyze-and-visualize-nested-json-data-with-amazon-athena-and-amazon-quicksight.md) + [Automatisez les sauvegardes pour les instances de base de données Amazon RDS for PostgreSQL à l'aide d'AWS Batch](automate-backups-for-amazon-rds-for-postgresql-db-instances-by-using-aws-batch.md) + [Archivez automatiquement les éléments sur Amazon S3 à l'aide de DynamoDB TTL](automatically-archive-items-to-amazon-s3-using-dynamodb-ttl.md) + [Corriger automatiquement les instances et clusters de base de données Amazon RDS non chiffrés](automatically-remediate-unencrypted-amazon-rds-db-instances-and-clusters.md) + [Arrêtez et démarrez automatiquement une instance de base de données Amazon RDS à l'aide de AWS Systems Manager Maintenance Windows](automatically-stop-and-start-an-amazon-rds-db-instance-using-aws-systems-manager-maintenance-windows.md) + [Créez une zone AWS d'atterrissage qui inclut MongoDB Atlas](build-aws-landing-zone-that-includes-mongodb-atlas.md) + [Créez des programmes COBOL DB2 en utilisant et AWS Mainframe Modernization AWS CodeBuild](build-cobol-db2-programs-mainframe-modernization-codebuild.md) + [Créez un maillage de données d'entreprise avec Amazon DataZone AWS CDK, et AWS CloudFormation](build-enterprise-data-mesh-amazon-data-zone.md) + [Modifier les applications Python et Perl pour prendre en charge la migration de bases de données de Microsoft SQL Server vers Amazon Aurora PostgreSQL Compatible Edition](change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.md) + [Convertissez et décompressez les données EBCDIC en ASCII sur AWS à l'aide de Python](convert-and-unpack-ebcdic-data-to-ascii-on-aws-by-using-python.md) + [Convertir la fonctionnalité temporelle Teradata NORMALIZE en Amazon Redshift SQL](convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql.md) + [Convertir la fonctionnalité Teradata RESET WHEN en Amazon Redshift SQL](convert-the-teradata-reset-when-feature-to-amazon-redshift-sql.md) + [Convertir VARCHAR2 (1) type de données pour Oracle en type de données booléen pour Amazon Aurora PostgreSQL](convert-varchar2-1-data-type-for-oracle-to-boolean-data-type-for-amazon-aurora-postgresql.md) + [Création d'utilisateurs et de rôles d'application dans Aurora PostgreSQL compatible](create-application-users-and-roles-in-aurora-postgresql-compatible.md) + [Création de CloudFormation modèles AWS pour les tâches AWS DMS à l'aide de Microsoft Excel et Python](create-aws-cloudformation-templates-for-aws-dms-tasks-using-microsoft-excel-and-python.md) + [Fournissez des enregistrements DynamoDB à Amazon S3 à l'aide de Kinesis Data Streams et Firehose avec AWS CDK](deliver-dynamodb-records-to-amazon-s3-using-kinesis-data-streams-and-amazon-data-firehose-with-aws-cdk.md) + [Déployez un cluster Cassandra sur Amazon EC2 avec une statique privée IPs pour éviter le rééquilibrage](deploy-a-cassandra-cluster-on-amazon-ec2-with-private-static-ips-to-avoid-rebalancing.md) + [Déployez un cluster CockroachDB dans Amazon EKS à l'aide de Terraform](deploy-cockroachdb-on-eks-using-terraform.md) + [Développez des assistants avancés basés sur l'IA générative basés sur le chat en utilisant RAG et des instructions ReAct](develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.md) + [Émulez Oracle DR à l'aide d'une base de données globale Aurora compatible avec PostgreSQL](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md) + [Activez l'archivage des DB2 journaux directement sur Amazon S3 dans une base de données IBM Db2](enable-db2-logarchive-directly-to-amazon-s3-in-ibm-db2-database.md) + [Activez le chiffrement transparent des données dans Amazon RDS for SQL Server](enable-transparent-data-encryption-in-amazon-rds-for-sql-server.md) + [Exporter une base de données Microsoft SQL Server vers Amazon S3 à l'aide d'AWS DMS](export-a-microsoft-sql-server-database-to-amazon-s3-by-using-aws-dms.md) + [SHA1 Implémenter le hachage des données personnelles lors de la migration de SQL Server vers PostgreSQL](implement-sha1-hashing-for-pii-data-when-migrating-from-sql-server-to-postgresql.md) + [Migrez progressivement d'Amazon RDS for Oracle vers Amazon RDS for PostgreSQL à l'aide d'Oracle SQL Developer et d'AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md) + [Chargez des fichiers BLOB dans TEXT en utilisant le codage de fichiers compatible avec Aurora PostgreSQL](load-blob-files-into-text-by-using-file-encoding-in-aurora-postgresql-compatible.md) + [Gérez les informations d'identification à l'aide d'AWS Secrets Manager](manage-credentials-using-aws-secrets-manager.md) + [Migrer une base de données DB2 d'Amazon EC2 vers Aurora compatible avec MySQL à l'aide d'AWS DMS](migrate-a-db2-database-from-amazon-ec2-to-aurora-mysql-compatible-by-using-aws-dms.md) + [Migrer une base de données Microsoft SQL Server d'Amazon EC2 vers Amazon DocumentDB à l'aide d'AWS DMS](migrate-a-microsoft-sql-server-database-from-amazon-ec2-to-amazon-documentdb-by-using-aws-dms.md) + [Migrer une base de données Microsoft SQL Server vers Aurora MySQL à l'aide d'AWS DMS et d'AWS SCT](migrate-a-microsoft-sql-server-database-to-aurora-mysql-by-using-aws-dms-and-aws-sct.md) + [Migrez Amazon RDS for Oracle vers Amazon RDS for PostgreSQL en mode SSL à l'aide d'AWS DMS](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-in-ssl-mode-by-using-aws-dms.md) + [Migrer Amazon RDS for Oracle vers Amazon RDS for PostgreSQL avec et en utilisant et 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) + [Migrer une instance de base de données Amazon RDS vers un autre VPC ou un autre compte](migrate-an-amazon-rds-db-instance-to-another-vpc-or-account.md) + [Migrer une base de données Amazon RDS for Oracle vers Compte AWS une autre Région AWS et AWS DMS l'utiliser pour une réplication continue](migrate-an-amazon-rds-for-oracle-database-to-another-aws-account-and-aws-region-using-aws-dms-for-ongoing-replication.md) + [Migrer un cluster Amazon Redshift vers une région AWS en Chine](migrate-an-amazon-redshift-cluster-to-an-aws-region-in-china.md) + [Migrer une base de données MariaDB sur site vers Amazon RDS for MariaDB à l'aide d'outils natifs](migrate-an-on-premises-mariadb-database-to-amazon-rds-for-mariadb-using-native-tools.md) + [Migrer une base de données Microsoft SQL Server sur site vers Amazon EC2](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-ec2.md) + [Migrer une base de données Microsoft SQL Server locale vers Amazon RDS for SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server.md) + [Migrer une base de données Microsoft SQL Server locale vers Amazon RDS for SQL Server à l'aide de serveurs liés](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-linked-servers.md) + [Migrer une base de données Microsoft SQL Server locale vers Amazon RDS for SQL Server à l'aide de méthodes de sauvegarde et de restauration natives](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-native-backup-and-restore-methods.md) + [Migrer une base de données Microsoft SQL Server sur site vers Amazon Redshift à l'aide d'AWS DMS](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-dms.md) + [Migrer une base de données Microsoft SQL Server sur site vers Amazon Redshift à l'aide des agents d'extraction de données AWS SCT](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.md) + [Migrer une base de données Microsoft SQL Server sur site vers Microsoft SQL Server sur Amazon EC2 exécutant Linux](migrate-an-on-premises-microsoft-sql-server-database-to-microsoft-sql-server-on-amazon-ec2-running-linux.md) + [Migrer une base de données MySQL sur site vers Amazon RDS for MySQL](migrate-an-on-premises-mysql-database-to-amazon-rds-for-mysql.md) + [Migrer une base de données MySQL sur site vers Aurora MySQL](migrate-an-on-premises-mysql-database-to-aurora-mysql.md) + [Migrer une base de données Oracle sur site vers Amazon à l'aide EC2 d'Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-ec2-by-using-oracle-data-pump.md) + [Migrer une base de données Oracle sur site vers Amazon OpenSearch Service à l'aide de Logstash](migrate-an-on-premises-oracle-database-to-amazon-opensearch-service-using-logstash.md) + [Migrer une base de données Oracle sur site vers Amazon RDS for MySQL à l'aide d'AWS DMS et d'AWS SCT](migrate-an-on-premises-oracle-database-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migrer une base de données Oracle sur site vers Amazon RDS for Oracle](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle.md) + [Migrez une base de données Oracle sur site vers Amazon RDS for Oracle en utilisant directement Oracle Data Pump Import via un lien de base de données](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-by-using-direct-oracle-data-pump-import-over-a-database-link.md) + [Migrer une base de données Oracle sur site vers Amazon RDS for Oracle à l'aide d'Oracle Data Pump](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-using-oracle-data-pump.md) + [Migrer une base de données Oracle sur site vers Amazon RDS for PostgreSQL à l'aide d'un assistant Oracle et d'AWS DMS](migrate-an-on-premises-oracle-database-to-amazon-rds-for-postgresql-by-using-an-oracle-bystander-and-aws-dms.md) + [Migrer une base de données Oracle sur site vers Oracle sur Amazon EC2](migrate-an-on-premises-oracle-database-to-oracle-on-amazon-ec2.md) + [Migrer une base de données PostgreSQL locale vers Aurora PostgreSQL](migrate-an-on-premises-postgresql-database-to-aurora-postgresql.md) + [Migrer une base de données ThoughtSpot Falçon sur site vers Amazon Redshift](migrate-an-on-premises-thoughtspot-falcon-database-to-amazon-redshift.md) + [Migrer une base de données Oracle d'Amazon EC2 vers Amazon RDS for MariaDB à l'aide d'AWS DMS et d'AWS SCT](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-mariadb-using-aws-dms-and-aws-sct.md) + [Migrer une base de données Oracle d'Amazon EC2 vers Amazon RDS for Oracle à l'aide d'AWS DMS](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-oracle-using-aws-dms.md) + [Migrer une base de données Oracle vers Amazon RDS for Oracle à l'aide d'adaptateurs de GoldenGate fichiers plats Oracle](migrate-an-oracle-database-to-amazon-rds-for-oracle-by-using-oracle-goldengate-flat-file-adapters.md) + [Migrer une base de données Oracle vers Amazon Redshift à l'aide d'AWS DMS et d'AWS SCT](migrate-an-oracle-database-to-amazon-redshift-using-aws-dms-and-aws-sct.md) + [Migrer une base de données Oracle vers Aurora PostgreSQL à l'aide d'AWS DMS et d'AWS SCT](migrate-an-oracle-database-to-aurora-postgresql-using-aws-dms-and-aws-sct.md) + [Migrer une EnterpriseOne base de données Oracle JD Edwards vers AWS à l'aide d'Oracle Data Pump et d'AWS DMS](migrate-an-oracle-jd-edwards-enterpriseone-database-to-aws-by-using-oracle-data-pump-and-aws-dms.md) + [Migrer une table partitionnée Oracle vers PostgreSQL à l'aide d'AWS DMS](migrate-an-oracle-partitioned-table-to-postgresql-by-using-aws-dms.md) + [Migrer une PeopleSoft base de données Oracle vers AWS à l'aide d'AWS DMS](migrate-an-oracle-peoplesoft-database-to-aws-by-using-aws-dms.md) + [Migrer une base de données Couchbase Server vers Amazon EC2](migrate-couchbase-server-ec2.md) + [Migrer les données d'une base de données Oracle sur site vers Aurora PostgreSQL](migrate-data-from-an-on-premises-oracle-database-to-aurora-postgresql.md) + [Migrez les données vers le AWS Cloud en utilisant Starburst](migrate-data-to-the-aws-cloud-by-using-starburst.md) + [Migrez Db2 for LUW vers Amazon EC2 en utilisant l'expédition des journaux pour réduire les temps d'arrêt](migrate-db2-for-luw-to-amazon-ec2-by-using-log-shipping-to-reduce-outage-time.md) + [Migrez Db2 for LUW vers Amazon EC2 avec une reprise après sinistre à haute disponibilité](migrate-db2-for-luw-to-amazon-ec2-with-high-availability-disaster-recovery.md) + [Migrer d'Amazon RDS for Oracle vers Amazon RDS for MySQL](migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-mysql.md) + [Migrer du serveur Couchbase vers Couchbase Capella sur AWS](migrate-from-couchbase-server-to-couchbase-capella-on-aws.md) + [Migrez d'IBM Db2 sur Amazon vers une version compatible avec Aurora PostgreSQL EC2 à l'aide d'AWS DMS et d'AWS SCT](migrate-from-ibm-db2-on-amazon-ec2-to-aurora-postgresql-compatible-using-aws-dms-and-aws-sct.md) + [Migrez d'Oracle 8i ou 9i vers Amazon RDS for PostgreSQL à l'aide de vues matérialisées et d'AWS DMS](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-materialized-views-and-aws-dms.md) + [Migrez d'Oracle 8i ou 9i vers Amazon RDS for PostgreSQL à l'aide d'AWS DMS SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-shareplex-and-aws-dms.md) + [Migrer d'une base de données Oracle vers Amazon RDS for PostgreSQL à l'aide d'Oracle GoldenGate](migrate-from-oracle-database-to-amazon-rds-for-postgresql-by-using-oracle-goldengate.md) + [Migrez d'Oracle sur Amazon EC2 vers Amazon RDS for MySQL à l'aide d'AWS DMS et d'AWS SCT](migrate-from-oracle-on-amazon-ec2-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migrez de PostgreSQL sur EC2 Amazon vers Amazon RDS pour PostgreSQL à l'aide de pglogical](migrate-from-postgresql-on-amazon-ec2-to-amazon-rds-for-postgresql-using-pglogical.md) + [Migrez de SAP ASE vers Amazon RDS for SQL Server à l'aide d'AWS DMS](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md) + [Migrer les index basés sur les fonctions d'Oracle vers PostgreSQL](migrate-function-based-indexes-from-oracle-to-postgresql.md) + [Migrer les applications existantes d'Oracle Pro\$1C vers ECPG](migrate-legacy-applications-from-oracle-pro-c-to-ecpg.md) + [Migrer une base de données Microsoft SQL Server sur site vers Amazon à EC2 l'aide du service de migration d'applications](migrate-microsoft-sql-server-to-amazon-ec2-using-aws-mgn.md) + [Migrez les charges de travail Cloudera sur site vers Cloudera Data Platform sur AWS](migrate-on-premises-cloudera-workloads-to-cloudera-data-platform-on-aws.md) + [Migrez des bases de données MySQL sur site vers Aurora MySQL à l'aide de Percona, XtraBackup Amazon EFS et Amazon S3](migrate-on-premises-mysql-databases-to-aurora-mysql-using-percona-xtrabackup-amazon-efs-and-amazon-s3.md) + [Migrer Oracle Business Intelligence 12c vers le cloud AWS à partir de serveurs sur site](migrate-oracle-business-intelligence-12c-to-the-aws-cloud-from-on-premises-servers.md) + [Migrer les valeurs Oracle CLOB vers des lignes individuelles dans PostgreSQL sur AWS](migrate-oracle-clob-values-to-individual-rows-in-postgresql-on-aws.md) + [Migrer les codes d'erreur de la base de données Oracle vers une base de données compatible avec Amazon Aurora PostgreSQL](migrate-oracle-database-error-codes-to-an-amazon-aurora-postgresql-compatible-database.md) + [Migrer des tables externes Oracle vers des tables compatibles avec Amazon Aurora PostgreSQL](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md) + [Migrer les fonctions natives d'Oracle vers PostgreSQL à l'aide d'extensions](migrate-oracle-native-functions-to-postgresql-using-extensions.md) + [Migrer Oracle PeopleSoft vers Amazon RDS Custom](migrate-oracle-peoplesoft-to-amazon-rds-custom.md) + [Migrer la fonctionnalité Oracle ROWID vers PostgreSQL sur AWS](migrate-oracle-rowid-functionality-to-postgresql-on-aws.md) + [Migrer les packages pragma Oracle SERIALLY\$1REUSERABLE vers PostgreSQL](migrate-oracle-serially-reusable-pragma-packages-into-postgresql.md) + [Migrez SAP ASE sur Amazon EC2 vers une version compatible avec Amazon Aurora PostgreSQL à l'aide d'AWS SCT et d'AWS DMS](migrate-sap-ase-on-amazon-ec2-to-amazon-aurora-postgresql-compatible-using-aws-sct-and-aws-dms.md) + [Migrer les colonnes générées virtuellement d'Oracle vers PostgreSQL](migrate-virtual-generated-columns-from-oracle-to-postgresql.md) + [Configurez un espace de données minimum viable pour partager les données entre les organisations](minimum-viable-data-space-share-data-organizations.md) + [Surveillez les ElastiCache clusters Amazon pour le chiffrement au repos](monitor-amazon-elasticache-clusters-for-at-rest-encryption.md) + [Interrogez les tables Amazon DynamoDB avec SQL à l'aide d'Amazon Athena](query-amazon-dynamodb-tables-sql-amazon-athena.md) + [Sécurisez et rationalisez l'accès des utilisateurs dans une base de données de fédération DB2 sur AWS en utilisant des contextes fiables](secure-and-streamline-user-access-in-a-db2-federation-database-on-aws-by-using-trusted-contexts.md) + [Configuration d'une PeopleSoft architecture à haute disponibilité sur AWS](set-up-a-highly-available-peoplesoft-architecture-on-aws.md) + [Configuration de la fonctionnalité Oracle UTL\$1FILE sur Aurora compatible avec PostgreSQL](set-up-oracle-utl_file-functionality-on-aurora-postgresql-compatible.md) + [Simplifiez les déploiements de PostgreSQL sur Amazon EKS à l'aide de PGO](streamline-postgresql-deployments-amazon-eks-pgo.md) + [Transférez des z/OS données Db2 à grande échelle vers Amazon S3 dans des fichiers CSV](transfer-large-scale-db2-z-os-data-to-amazon-s3-in-csv-files.md) + [Transportez des bases de données PostgreSQL entre deux instances de base de données Amazon RDS à l'aide de pg\$1transport](transport-postgresql-databases-between-two-amazon-rds-db-instances-using-pg-transport.md) + [Valider les objets de base de données après la migration d'Oracle vers 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()