Comment vérifier le délai de réplication dans PostgreSQL?
je voudrais mesurer le temps entre insérer des données dans la table maître et la table esclave en utilisant la réplication en continu dans PostgreSQL 9.3. Pour cela je crée la table test_time avec 2 champs id(numéro de série), t(texte). Après cela ajouté un déclencheur:
cur_time:=to_char(current_timestamp, 'HH12:MI:SS:MS:US');
update test_time set t=cur_time where id=new.id;
mais l'heure est la même dans les deux tableaux. Comment puis-je mesurer les temps de retard
6 réponses
Vous pouvez obtenir le retard octets à partir de le maître côté assez facilement à l'aide de pg_xlog_location_diff pour comparer le maître pg_current_xlog_insert_locationreplay_location pour que backend pg_stat_replication entrée.
Cela ne fonctionne que lorsqu'il est exécuté sur le maître. Vous ne pouvez pas le faire à partir de la réplique parce que la réplique n'a aucune idée de la longueur d'avance du maître.
de plus, cela ne vous indiquera pas le décalage dans secondes. Dans les versions PostgreSQL actuelles (au moins 9.4) il n'y a pas timestamp associé à un enregistrement commit ou WAL. Il n'y a donc aucun moyen de savoir depuis combien de temps une LSN (position xlog) donnée existait.
la seule façon d'obtenir le décalage de réplique en quelques secondes sur une version PostgreSQL courante est d'avoir un processus externe commit un update à une table d'horodatage dédiée périodiquement. Ainsi vous pouvez comparer current_timestamp sur la réplique de l'horodatage de l'entrée la plus récente dans le tableau visible sur le réplica pour voir comment loin, la réplique est derrière. Cela crée d'autres Trafic WAL qui devra alors être conservé dans votre Wal archivé pour PITR (PgBarman ou autre), vous devez donc équilibrer l'utilisation accrue de données avec la granularité de détection de décalage dont vous avez besoin.
PostgreSQL 9.5 peut ajouter des marqueurs temporels de propagation qui vous permettront, espérons-le, de savoir depuis combien de temps une propagation donnée s'est produite et, par conséquent, jusqu'à quel point une réplique est en retard dans les secondes d'une horloge murale.
Alf162 a mentionné une bonne solution dans les commentaires à la réponse de Craig Ringer; donc je l'ajoute pour clarifier.
PostgreSQL a une fonction administrative pg_last_xact_replay_timestamp () qui renvoie l'horodatage de la dernière transaction rejouée pendant la récupération. C'est à ce moment que le dossier de commit ou d'abandon de la transaction a été généré sur le primaire.
alors cette requête select now()-pg_last_xact_replay_timestamp() as replication_lag sur un esclave retournera une durée représentant différence de temps entre l'horloge courante et l'horodatage du dernier enregistrement WAL appliqué à partir du flux de réplication.
notez que si le master ne reçoit pas de nouvelles mutations, il n'y aura pas d'enregistrements WAL à diffuser et le décalage calculé de cette façon va croître sans être en fait un signal de retards dans la réplication. Si le master est soumis à une mutation plus ou moins continue, il diffusera en continu WALs et la requête ci-dessus est une bonne approximation du délai de les changements sur le maître à se matérialiser sur l'esclave. La précision sera évidemment affectée par la rigueur de la synchronisation des horloges système sur les deux hôtes.
si votre base de données a écrit fréquemment, alors la requête ci-dessous est une approximation proche pour obtenir le décalage de l'esclave
select now() - pg_last_xact_replay_timestamp() AS replication_delay;
ci-dessous est une requête plus précise pour calculer le décalage de réplication pour les bases de données avec très peu d'Écritures. Si le maître n'envoie pas d'écriture à l'esclave, alors pg_last_xact_replay_timestamp() peut être constant et donc ne pas déterminer avec précision le décalage de l'esclave en utilisant la requête ci-dessus.
SELECT CASE WHEN pg_last_xlog_receive_location() =
pg_last_xlog_replay_location() THEN 0 ELSE EXTRACT (EPOCH FROM now() -
pg_last_xact_replay_timestamp()) END AS log_delay;
version légèrement différente de la réponse correcte:
postgres=# SELECT
pg_last_xlog_receive_location() receive,
pg_last_xlog_replay_location() replay,
(
extract(epoch FROM now()) -
extract(epoch FROM pg_last_xact_replay_timestamp())
)::int lag;
receive | replay | lag
------------+------------+-------
1/AB861728 | 1/AB861728 | 2027
le décalage n'est important que lorsque "receive" n'est pas égal à "replay". exécuter la requête sur l'esclave
en tant que de 10 de presse:
https://www.postgresql.org/docs/10/static/monitoring-stats.html#pg-stat-replication-view
write_lagintervalle temps écoulé entre le rinçage du WAL récent localement et la réception de la notification que ce serveur de veille a écrit (mais pas encore le rouge ou appliquée). Ceci peut être utilisé pour évaluer le délai que le niveau de remote_write synchronous_commit a encouru lors de la perpétration d' si ce serveur a été configuré comme un synchrones veille.
flush_lagintervalle temps écoulé entre le rinçage du WAL récent localement et la réception de la notification que ce serveur de veille a écrit et le rouge (mais pas encore appliqué). Ceci peut être utilisé pour mesurer le retard que synchronous_commit niveau remote_flush engagés en commettant si ce serveur a été configuré en tant que synchrone veille.
replay_lagintervalle temps écoulé entre le rinçage du WAL récent localement et la réception de la notification que ce serveur de veille a écrit, de rincer et de l'appliquer. Cela peut être utilisé pour évaluer le retard que le niveau synchrone_commit remote_apply encouru lors de l'engagement si ce serveur a été configuré en veille synchrone.
(mise en forme de la mine)
hélas, les nouvelles colonnes ne semblent convenir qu'à une réplication synchrone (sinon le maître ne connaîtrait pas exactement le lag) ainsi le Chack de retard de réplication asynchrone semble rester now()-pg_last_xact_replay_timestamp()...
sur master, vous pouvez faire select * from pg_stat_replication;
cela vous donnera:
| sent_lsn | write_lsn | flush_lsn | replay_lsn
-+-------------+-------------+-------------+-------------
| 8D/2DA48000 | 8D/2DA48000 | 8D/2DA48000 | 89/56A0D500
ceux-ci peuvent vous dire où votre décalages sont. comme vous pouvez le voir dans cet exemple, la relecture de l'esclave qui est derrière.