Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Utilisation de pgactive pour prendre en charge la réplication active-active

L'pgactiveextension utilise la réplication active-active pour prendre en charge et coordonner les opérations d'écriture sur plusieurs bases de données RDS SQL Postgre. Amazon RDS pour Postgre SQL prend en charge l'pgactiveextension sur les versions suivantes :

Initialisation de la capacité d'extension pgactive

Pour initialiser la fonctionnalité d'pgactiveextension sur votre RDS SQL instance de base de données Postgre, définissez la valeur du rds.enable_pgactive paramètre sur, 1 puis créez l'extension dans la base de données. Les paramètres rds.logical_replication et track_commit_timestamp sont alors automatiquement activés et la valeur de wal_level est définie sur logical.

Vous devez disposer d'autorisations en tant que rôle rds_superuser pour effectuer ces tâches.

Vous pouvez utiliser le AWS Management Console ou le AWS CLI pour créer les éléments requis RDS pour les SQL instances de base de données Postgre. Les étapes suivantes supposent que votre SQL instance de base de données RDS for Postgre est associée à un groupe de paramètres de base de données personnalisé. Pour obtenir des informations sur la création d'un groupe de paramètres de base de données personnalisé, consultez Groupes de paramètres pour Amazon RDS.

Configuration de la réplication active-active pour le pour les instances de base de données Postgre SQL

La procédure suivante explique comment démarrer une réplication active-active entre deux pour des instances de base de données Postgre exécutant Postgre SQL SQL 15.4 ou une version ultérieure dans la même région. Pour exécuter l'exemple de haute disponibilité multirégionale, vous devez déployer les SQL instances Amazon RDS for Postgre dans deux régions différentes et configurer VPC Peering. Pour plus d'informations, voir VPCpeering.

Ces étapes supposent que l'SQLinstance de base de données RDS for Postgre a été configurée avec l'pgactiveextension. Pour de plus amples informations, veuillez consulter Initialisation de la capacité d'extension pgactive.

Gestion des conflits de la réplication active-active

L'extension pgactive fonctionne par base de données et non par cluster. Chaque instance de base de données qui utilise pgactive est une instance indépendante et peut accepter les modifications de données de n'importe quelle source. Lorsqu'une modification est envoyée à une instance de base de données, Postgre la SQL valide localement, puis l'utilise pgactive pour répliquer la modification de manière asynchrone sur d'autres instances de base de données. Lorsque deux SQL instances de base de données Postgre mettent à jour le même enregistrement à peu près au même moment, un conflit peut survenir.

L'extension pgactive propose des mécanismes de détection et de résolution automatique des conflits. Il suit l'horodatage du moment où la transaction a été validée sur les deux instances de base de données et applique automatiquement la modification avec l'horodatage le plus récent. L'extension pgactive journalise également la survenance d'un conflit dans la table pgactive.pgactive_conflict_history.

Ils pgactive.pgactive_conflict_history vont continuer de croître. Vous souhaiterez peut-être définir une politique de purge. Cela peut être fait en supprimant régulièrement certains enregistrements ou en définissant un schéma de partitionnement pour cette relation (puis en détachant, supprimant, tronquant les partitions qui vous intéressent). Pour mettre en œuvre régulièrement la politique de purge, l'une des options consiste à utiliser l'pg_cronextension. Consultez les informations suivantes concernant un exemple de table d'pg_cronhistorique, Planification de la maintenance avec l'extension Postgre SQL pg_cron.

Gestion des séquences dans une réplication active-active

Une SQL instance RDS de base de données Postgre dotée de l'pgactiveextension utilise deux mécanismes de séquence différents pour générer des valeurs uniques.

Séquences globales

Pour utiliser une séquence globale, créez une séquence locale avec l'instruction CREATE SEQUENCE. Utilisez pgactive.pgactive_snowflake_id_nextval(seqname) plutôt que usingnextval(seqname) pour obtenir la prochaine valeur unique de la séquence.

L'exemple suivant crée une séquence globale :

postgres=> CREATE TABLE gstest (
      id bigint primary key,
      parrot text
    );

postgres=>CREATE SEQUENCE gstest_id_seq OWNED BY gstest.id;

postgres=> ALTER TABLE gstest \
      ALTER COLUMN id SET DEFAULT \
      pgactive.pgactive_snowflake_id_nextval('gstest_id_seq');

Séquences partitionnées

Dans les séquences partitionnées ou fractionnées, une SQL séquence Postgre normale est utilisée sur chaque nœud. Chaque séquence s'incrémente de la même valeur et débute à des décalages différents. Par exemple, avec un pas de 100, le nœud 1 génère la séquence 101, 201, 301, etc. et le nœud 2 génère la séquence 102, 202, 302, etc. Ce mécanisme fonctionne bien même si les nœuds ne peuvent pas communiquer pendant de longues périodes. Cependant, il impose au concepteur de spécifier un nombre maximal de nœuds au moment d'établir le schéma et nécessite une configuration par nœud. Les erreurs peuvent facilement engendrer un chevauchement de séquences.

Il est relativement simple de configurer cette approche avec pgactive en créant la séquence souhaitée sur un nœud comme suit :

CREATE TABLE some_table (generated_value bigint primary key);

postgres=> CREATE SEQUENCE some_seq INCREMENT 100 OWNED BY some_table.generated_value;

postgres=> ALTER TABLE some_table ALTER COLUMN generated_value SET DEFAULT nextval('some_seq');
    

Appelez ensuite setval sur chaque nœud pour donner une valeur de départ de décalage différente comme suit.

postgres=>
-- On node 1
SELECT setval('some_seq', 1);

-- On node 2
SELECT setval('some_seq', 2);     

Référence des paramètres de l'extension pgactive

Vous pouvez utiliser la requête suivante pour afficher tous les paramètres associés à l'extension pgactive.

postgres=> SELECT * FROM pg_settings WHERE name LIKE 'pgactive.%';

Mesurer le délai de réplication entre les membres actifs

Vous pouvez utiliser la requête suivante pour visualiser le délai de réplication entre les pgactive membres. Exécutez cette requête sur chaque pgactive nœud pour obtenir une vue d'ensemble complète.

      postgres=# SELECT *, (last_applied_xact_at - last_applied_xact_committs) AS lag FROM pgactive.pgactive_node_slots;
-{ RECORD 1 ]----------------+----------------------------------------------------------------- 
node_name                    | node2-app
slot_name                    | pgactive_5_7332551165694385385_0_5__
slot_restart_lsn             | 0/1A898A8
slot_confirmed_lsn           | 0/1A898E0
walsender_active             | t
walsender_pid                | 69022
sent_lsn                     | 0/1A898E0 
write_lsn                    | 0/1A898E0
flush_lsn                    | 0/1A898E0  
replay_lsn                   | 0/1A898E0
last_sent_xact_id            | 746
last_sent_xact_committs      | 2024-02-06 18:04:22.430376+00
last_sent_xact_at            | 2024-02-06 18:04:22.431359+00
last_applied_xact_id         | 746
last_applied_xact_committs   | 2024-02-06 18:04:22.430376+00
last_applied_xact_at         | 2024-02-06 18:04:52.452465+00
lag                          | 00:00:30.022089

Limitations liées à l'extension pgactive