Wie überprüfen Sie die Replikation Verzögerung in PostgreSQL?

Ich würde gerne um die Zeit zu Messen zwischen dem einfügen von Daten in die master-Tabelle und dem slave-Tabelle, die mithilfe von streaming-Replikation in PostgreSQL 9.3. Dafür habe ich die create table - test_time mit 2 Feldern id(Seriennummer), t(text). Nach dass Hinzugefügt-trigger:

cur_time:=to_char(current_timestamp, 'HH12:MI:SS:MS:US'); update test_time set t=cur_time where id=new.id;

Aber die Zeit ist die gleiche in beiden Tabellen.
Wie kann ich Messen, delay-Zeit

InformationsquelleAutor der Frage Alf162 | 2015-02-04

postgresql replication

13

Können Sie die Verzögerung in bytes von der master-Seite ganz einfach mit pg_xlog_location_diff zu vergleichen, die Meister pg_current_xlog_insert_location mit der replay_location für das backend ist pg_stat_replication Eintrag.

Dies funktioniert nur, wenn die Ausführung auf dem master. Man kann es nicht aus der Replik, weil der replica hat keine Ahnung, wie weit Voraus der master ist.

Zusätzlich werde Ihnen nicht sagen, der lag in Sekunden. In der aktuellen (Stand 9.4 mindestens) PostgreSQL-Versionen gibt es keine timestamp-verbunden mit einem commit oder einem WAL aufnehmen. Also gibt es keine Möglichkeit zu sagen, wie lange eine bestimmte LSN (xlog-position) war.

Der einzige Weg, um die Replik Verzögerung in Sekunden auf einem aktuellen PostgreSQL-version ist eine externe Prozess der Begehung einer update auf einem dedizierten timestamp-Tabelle in regelmäßigen Abständen. So können Sie vergleichen current_timestamp auf die Replik auf die Zeitstempel der letzten Eintrag in der Tabelle sichtbar, auf die Replik zu sehen, wie weit die Replik ist hinter. Dies schafft zusätzliche WAL-Verkehr, die haben dann gehalten werden, die in Ihrer archivierte WAL für PITR (PgBarman oder was auch immer), so sollten Sie Gleichgewicht die erhöhte Verwendung der Daten mit der Granularität der lag-Erkennung, die Sie benötigen.

PostgreSQL 9.5 hinzufügen kann, commit-Zeitstempel, der hoffentlich lassen Sie Sie herausfinden, wie lange vor einem bestimmten commit passiert ist und deshalb, wie weit eine Replik ist hinter in Wand-Uhr Sekunden.

InformationsquelleAutor der Antwort Craig Ringer
15

Alf162 erwähnt, eine gute Lösung in die Kommentare zu Craig Ringer-Antwort; also ich bin das hinzufügen dieser zu klären.

PostgreSQL hat eine administrative Funktion pg_last_xact_replay_timestamp() gibt den Zeitstempel der letzten Transaktion, die während der Wiederherstellung wiedergegeben. Dies ist die Zeit, zu der die commit-oder die abort-WAL-record für diese Transaktion generiert wurde, auf dem primären.

Also diese Abfrage select now()-pg_last_xact_replay_timestamp() as replication_lag auf einem slave zurück Dauer repräsentieren den Unterschied in der Zeit zwischen dem aktuellen Takt und den Zeitstempel des letzten WAL-Datensatz angewendet, von der Replikations-stream.

Beachten Sie, dass wenn der master nicht empfangen neue Mutationen gibt, gibt es kein WAL Einträge zu stream und die Verzögerung berechnet, der auf diese Weise wachsen, ohne tatsächlich ein signal von Verzögerungen bei der Replikation. Wenn der Meister unter mehr oder weniger kontinuierlicher mutation, es wird kontinuierlich streaming-WALs und die oben erwähnte Abfrage ist eine feine Annäherung der Zeitverzögerung für die änderungen auf dem master zu materialisieren, auf dem slave. Die Genauigkeit wird natürlich beeinflusst durch, wie streng synchronisiert die Systemuhren auf den beiden hosts sind.

InformationsquelleAutor der Antwort dbenhur
5

Wenn Ihre Datenbank Häufig schreibt, dann die folgenden Abfrage ist eine gute Annäherung, um die slave-lag
```
select now() - pg_last_xact_replay_timestamp() AS replication_delay;
```
Unten ist eine genauere Abfrage für die Berechnung der Verzögerungen bei der Replizierung für Datenbanken mit sehr wenig schreibt. Wenn der master nicht herabgesandt, alle schreiben an den slave, dann pg_last_xact_replay_timestamp() kann konstant sein und daher möglicherweise nicht genau zu bestimmen, die Sklavin lag mit der obigen Abfrage.
```
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;
```
InformationsquelleAutor der Antwort Ramanan

etwas andere version von die richtige Antwort:

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

die lag ist nur wichtig, wenn "empfangen" nicht gleich "replay". führen Sie die Abfrage auf die slave -

InformationsquelleAutor der Antwort shurikk

3

als 10 release:

https://www.postgresql.org/docs/10/static/monitoring-stats.html#pg-stat-replication-view

write_lag Intervall Zeitspanne zwischen Spülung jüngsten WAL-lokal und Erhalt der Benachrichtigung, dass dieser standby-server hat
es geschrieben (aber noch nicht gespült oder angewandte). Dies kann verwendet werden, um
Messen die Verzögerung, die synchronous_commit Ebene remote_write entstanden
während der Begehung, wenn dieser server wurde so konfiguriert, dass als synchron
standby.

flush_lag Intervall Zeitspanne zwischen Spülung jüngsten WAL-lokal und Erhalt der Benachrichtigung, dass dieser standby-server hat
geschrieben und spülte es (aber noch nicht angewendet). Dies kann verwendet werden, um
Messen die Verzögerung, die synchronous_commit Ebene remote_flush entstanden
während der Begehung, wenn dieser server wurde so konfiguriert, dass als synchron
standby.

replay_lag Intervall Zeitspanne zwischen Spülung jüngsten WAL-lokal und Erhalt der Benachrichtigung, dass dieser standby-server hat
geschrieben, gespült und angewendet. Dies kann verwendet werden, um zu Messen die Verzögerung
dass synchronous_commit Ebene remote_apply entstanden während der Begehung
wenn dieser server wurde so konfiguriert, wie ein synchronen standby.

(Formatierung von mir)

Ach neue Spalten scheinen, um den Anzug nur für die synchrone Replikation (sonst Meister würde nicht wissen, die genaue Verzögerung), also asynchrone Replikation Verzögerung chack scheinen zu bleiben now()-pg_last_xact_replay_timestamp()...

InformationsquelleAutor der Antwort Vao Tsun
0

auf master, die Sie tun können select * from pg_stat_replication;

dies wird Ihnen:
```
|  sent_lsn   |  write_lsn  |  flush_lsn  | replay_lsn  

-+-------------+-------------+-------------+-------------

 | 8D/2DA48000 | 8D/2DA48000 | 8D/2DA48000 | 89/56A0D500 
```
diejenigen, die Ihnen sagen kann, wo deine offsets sind.
wie Sie sehen können aus diesem Beispiel, wird die Wiedergabe auf dem slave hinter.

InformationsquelleAutor der Antwort linehrr

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.