Planen der Wartung mit der PostgreSQL-Erweiterung pg_cron - Amazon Relational Database Service
Einrichten der pg_con-ErweiterungGewähren von Berechtigungen zur Verwendung von pg_cron für DatenbankbenutzerPlanen von pg_cron-AufträgenReferenz für die pg_cron-Erweiterung

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Planen der Wartung mit der PostgreSQL-Erweiterung pg_cron

Sie können die PostgreSQL-Erweiterung pg_cron verwenden, um Wartungsbefehle innerhalb einer PostgreSQL-Datenbank zu planen. Weitere Informationen zu der Erweiterung finden Sie unter Was ist pg_cron? in der pg_cron-Dokumentation.

Die Erweiterung pg_cron wird von RDS-PostgreSQL-Engine-Versionen 12.5 und höher unterstützt.

Weitere Informationen zur Verwendung von pg_cron finden Sie unter Planen von Aufträgen mit pg_cron auf RDS für PostgreSQL oder Ihren Datenbanken der mit Aurora PostgreSQL kompatiblen Edition.

Einrichten der pg_con-Erweiterung

Richten Sie die Erweiterung pg_cron wie folgt ein:

  1. Ändern Sie die benutzerdefinierte Parametergruppe, die mit Ihrer PostgreSQL-DB-Instance verknüpft ist, indem Sie pg_cron dem Parameterwert shared_preload_libraries hinzufügen.

    • Wenn Ihre DB-Instance von RDS für PostgreSQL den Parameter rds.allowed_extensions verwendet, um Erweiterungen, die installiert werden können, explizit aufzulisten, müssen Sie die Erweiterung pg_cron in die Liste aufnehmen. Nur bestimmte Versionen von RDS für PostgreSQL unterstützen den Parameter rds.allowed_extensions. Standardmäßig sind alle verfügbaren Erweiterungen zulässig. Weitere Informationen finden Sie unter Einschränkung der Installation von Postgre-Erweiterungen SQL.

    Starten Sie die PostgreSQL-DB-Instance neu, damit die Änderungen an der Parametergruppe in Kraft treten. Weitere Informationen zum Arbeiten mit Parametergruppen finden Sie unter Ändern von Parametern in einer DB-Parametergruppe in Amazon RDS.

  2. Nachdem die PostgreSQL-DB-Instance neu gestartet wurde, führen Sie den folgenden Befehl mit einem Konto aus, das über rds_superuser-Berechtigungen verfügt. Wenn Sie beispielsweise beim Erstellen Ihrer RDS-for-PostgreSQL-DB-Instance die Standardeinstellungen verwendet haben, verbinden Sie sich als Benutzer postgres und erstellen Sie die Erweiterung. 

    CREATE EXTENSION pg_cron;

    Der Scheduler pg_cron ist in der standardmäßigen PostgreSQL-Datenbank mit dem Namen postgres festgelegt. Die Objekte pg_cron werden in dieser postgres-Datenbank erstellt und alle Planungsaktionen werden in dieser Datenbank ausgeführt.

  3. Sie können die Standardeinstellungen verwenden oder Aufgaben für die Ausführung in anderen Datenbanken innerhalb Ihrer PostgreSQL-DB-Instance planen. Informationen zum Planen von Aufgaben für andere Datenbanken innerhalb Ihrer PostgreSQL-DB-Instance finden Sie im Beispiel unter Planen einer Cron-Aufgabe für eine andere als die Standard-Datenbank.

Gewähren von Berechtigungen zur Verwendung von pg_cron für Datenbankbenutzer

Zum Installieren der Erweiterung pg_cron sind rds_superuser-Berechtigungen erforderlich. Berechtigungen zur Verwendung von pg_cron können anderen Datenbankbenutzern (von einem Mitglied der Gruppe/Rolle rds_superuser) gewährt werden, damit diese ihre eigenen Aufträge planen können. Wir empfehlen Ihnen, dem cron-Schema Berechtigungen nur nach Bedarf, wenn es die Abläufe in Ihrer Produktionsumgebung verbessert, zu gewähren.

Führen Sie den folgenden Befehl aus, um einem Datenbankbenutzer Berechtigungen im cron-Schema zu erteilen:

postgres=> GRANT USAGE ON SCHEMA cron TO db-user;

Damit wird die db-user-Berechtigung für den Zugriff auf das cron-Schema gwährt, um cron-Aufträge für die Objekte zu planen, für die sie Zugriffsberechtigungen haben. Wenn der Datenbankbenutzer keine Berechtigungen hat, schlägt der Auftrag fehl, nachdem die Fehlermeldung in der postgresql.log-Datei angezeigt wurde, wie nachfolgend dargestellt:

2020-12-08 16:41:00 UTC::@:[30647]:ERROR: permission denied for table table-name
2020-12-08 16:41:00 UTC::@:[27071]:LOG: background worker "pg_cron" (PID 30647) exited with exit code 1

Mit anderen Worten, stellen Sie sicher, dass Datenbankbenutzer, denen Berechtigungen für das cron Schema gewährt werden, auch über Berechtigungen für die Objekte (Tabellen, Schemata usw.) verfügen, die sie planen möchten.

Die Details des Cron-Auftrags und dessen Erfolg oder Misserfolg werden ebenfalls in der cron.job_run_details Tabelle erfasst. Weitere Informationen finden Sie unter Tabellen zum Planen von Jobs und zur Erfassung des Status .

Planen von pg_cron-Aufträgen

Die folgenden Abschnitte zeigen, wie Sie verschiedene Verwaltungsaufgaben mit pg_cron-Aufträgen planen können.

Anmerkung

Wenn Sie pg_cron-Aufträge erstellen, überprüfen Sie, dass die Einstellung max_worker_processes größer ist als die Anzahl von cron.max_running_jobs. Ein pg_cron-Auftrag schlägt fehl, wenn keine Hintergrund-Workerprozesse ausgeführt werden. Die Standardanzahl von pg_cron-Aufträgen ist 5. Weitere Informationen finden Sie unter Parameter für die Verwaltung der pg_cron-Erweiterung.

Bereinigen von Tabellen

Autovacuum übernimmt die Entfernung für die meisten Fälle Möglicherweise möchten Sie jedoch eine Bereinigung für eine bestimmte Tabelle zu einem Zeitpunkt Ihrer Wahl planen.

Weitere Informationen finden Sie auch unter, Arbeiten mit dem SQL Postgre-Autovakuum auf Amazon RDS für Postgre SQL.

Es folgt ein Beispiel für die Verwendung der Funktion cron.schedule zum Einrichten eines Auftrags, der jeden Tag um 22:00 Uhr (GMT) VACUUM FREEZE auf eine bestimmte Tabelle anwenden soll.

SELECT cron.schedule('manual vacuum', '0 22 * * *', 'VACUUM FREEZE pgbench_accounts');
 schedule
----------
1
(1 row)

Nachdem das vorangehende Beispiel ausgeführt wurde, können Sie den Verlauf in der cron.job_run_details-Tabelle wie folgt überprüfen.

postgres=> SELECT * FROM cron.job_run_details;
jobid  | runid | job_pid | database | username | command                        | status    | return_message | start_time                    | end_time
-------+-------+---------+----------+----------+--------------------------------+-----------+----------------+-------------------------------+-------------------------------
 1     | 1     | 3395    | postgres | adminuser| vacuum freeze pgbench_accounts | succeeded | VACUUM         | 2020-12-04 21:10:00.050386+00 | 2020-12-04 21:10:00.072028+00
(1 row)

Im Folgenden finden Sie eine Abfrage der cron.job_run_details Tabelle, um die fehlgeschlagenen Aufträge anzuzeigen.

postgres=> SELECT * FROM cron.job_run_details WHERE status = 'failed';
jobid | runid | job_pid | database | username | command                       | status | return_message                                   | start_time                    | end_time
------+-------+---------+----------+----------+-------------------------------+--------+--------------------------------------------------+-------------------------------+------------------------------
 5    | 4     | 30339   | postgres | adminuser| vacuum freeze pgbench_account | failed | ERROR: relation "pgbench_account" does not exist | 2020-12-04 21:48:00.015145+00 | 2020-12-04 21:48:00.029567+00
(1 row)

Weitere Informationen finden Sie unter Tabellen zum Planen von Jobs und zur Erfassung des Status .

Löschen der Verlaufstabelle pg_cron

Die cron.job_run_details-Tabelle enthält einen Verlauf von Cron-Aufgaben, die im Laufe der Zeit sehr groß werden können. Wir empfehlen Ihnen, eine Aufgabe zu planen, die diese Tabelle bereinigt. Beispielsweise kann es für die Fehlerbehebung ausreichen, die Eingaben einer Woche beizubehalten.

Im folgenden Beispiel wird die cron.schedule-Funktion verwendet, um eine Aufgabe zu planen, die jeden Tag um Mitternacht ausgeführt wird, um die cron.job_run_details-Tabelle zu bereinigen. Die Aufgabe behält nur die letzten sieben Tage. Verwenden Sie Ihr rds_superuser-Konto, um die Aufgabe wie folgt zu planen.

SELECT cron.schedule('0 0 * * *', $$DELETE 
    FROM cron.job_run_details 
    WHERE end_time < now() - interval '7 days'$$);

Weitere Informationen finden Sie unter Tabellen zum Planen von Jobs und zur Erfassung des Status .

Protokollieren von Fehlern nur in der Datei postgresql.log

Wenn Sie verhindern möchten, dass in die cron.job_run_details-Tabelle geschrieben wird, ändern Sie die mit der PostgreSQL-DB-Instance verknüpfte Parametergruppe und deaktivieren Sie den Parameter cron.log_run. Es werden keine Schreibvorgänge der pg_cron-Erweiterung in die Tabelle mehr durchgeführt und nur noch Fehler in der postgresql.log-Datei erfasst. Weitere Informationen finden Sie unter Ändern von Parametern in einer DB-Parametergruppe in Amazon RDS.

Verwenden Sie den folgenden Befehl, um den Wert des cron.log_run-Parameters zu überprüfen.

postgres=> SHOW cron.log_run;

Weitere Informationen finden Sie unter Parameter für die Verwaltung der pg_cron-Erweiterung.

Planen einer Cron-Aufgabe für eine andere als die Standard-Datenbank

Die Metadaten für pg_cron werden alle in der PostgreSQL-Standarddatenbank mit dem Namen postgres gespeichert. Da Hintergrund-Worker für die Ausführung der Maintenance-Cron-Aufgaben verwendet werden, können Sie eine Aufgabe in jeder Ihrer Datenbanken innerhalb der PostgreSQL-DB-Instance planen.

  1. Planen Sie die Aufgabe in der Cron-Datenbank wie gewohnt mit cron.schedule.

    postgres=> SELECT cron.schedule('database1 manual vacuum', '29 03 * * *', 'vacuum freeze test_table');

  2. Aktualisieren Sie als Benutzer mit der rds_superuser-Rolle die Datenbankspalte für die soeben erstellte Aufgabe, damit sie in einer anderen Datenbank innerhalb Ihrer PostgreSQL-DB-Instance ausgeführt wird.

    postgres=> UPDATE cron.job SET database = 'database1' WHERE jobid = 106;

  3. Überprüfen Sie dies, indem Sie die cron.job-Tabelle abfragen.

    postgres=> SELECT * FROM cron.job;
jobid | schedule    | command                        | nodename  | nodeport | database | username  | active | jobname
------+-------------+--------------------------------+-----------+----------+----------+-----------+--------+-------------------------
106   | 29 03 * * * | vacuum freeze test_table       | localhost | 8192     | database1| adminuser | t      | database1 manual vacuum
  1   | 59 23 * * * | vacuum freeze pgbench_accounts | localhost | 8192     | postgres | adminuser | t      | manual vacuum
(2 rows)
Anmerkung

In einigen Fällen können Sie eine Cron-Aufgabe hinzufügen, die Sie in einer anderen Datenbank ausführen möchten. Bevor Sie die richtige Datenbankspalte aktualisieren, versucht die Aufgabe in solchen Fällen möglicherweise, in der Standarddatenbank (postgres) ausgeführt zu werden. Wenn der Benutzername über Berechtigungen verfügt, wird die Aufgabe erfolgreich in der Standarddatenbank ausgeführt.

Referenz für die pg_cron-Erweiterung

Sie können die folgenden Parameter, Funktionen und Tabellen mit der pg_cron-Erweiterung verwenden. Weitere Informationen finden Sie unter Was ist pg_cron? in der pg_cron-Dokumentation.

Parameter für die Verwaltung der pg_cron-Erweiterung

Es folgt eine Liste der Parameter zur Steuerung des Erweiterungsverhaltens von pg_cron.

Parameter Beschreibung

cron.database_name

Die Datenbank, in der pg_cron-Metadaten aufbewahrt werden.
cron.host

Der Hostname für die Verbindung mit PostgreSQL. Dieser Wert kann nicht verändert werden.
cron.log_run

Protokollieren Sie jeden ausgeführten Auftrag in der Tabelle job_run_details. Die Werte sind on oder off. Weitere Informationen finden Sie unter Tabellen zum Planen von Jobs und zur Erfassung des Status .
cron.log_statement

Protokolliert alle Cron-Anweisungen, bevor Sie ausgeführt werden. Die Werte sind on oder off.
cron.max_running_jobs

Die maximale Anzahl von Aufgaben, die gleichzeitig ausgeführt werden können.
cron.use_background_workers

Verwenden Sie Hintergrund-Worker anstelle von Client-Sitzungen. Dieser Wert kann nicht verändert werden.

Verwenden Sie den folgenden SQL-Befehl, um diese Parameter und ihre Werte anzuzeigen.

postgres=> SELECT name, setting, short_desc FROM pg_settings WHERE name LIKE 'cron.%' ORDER BY name;

Funktionsreferenz: cron.schedule

Diese Funktion plant eine Cron-Aufgabe. Die Aufgabe ist anfänglich in der postgres Standarddatenbank geplant. Die Funktion gibt einen bigint Wert zurück, der den Aufgabenbezeichner darstellt. Informationen zum Planen von Aufgaben für die Ausführung in anderen Datenbanken innerhalb Ihrer PostgreSQL-DB-Instance finden Sie im Beispiel unter Planen einer Cron-Aufgabe für eine andere als die Standard-Datenbank.

Die Funktion hat zwei Syntaxformate.

Syntax
cron.schedule (job_name,
    schedule,
    command
);

cron.schedule (schedule,
    command
);
Parameter
Parameter Beschreibung
job_name

Der Name der Cron-Aufgabe.
schedule

Text, der den Zeitplan für die Cron-Aufgabe angibt. Das Format ist das Standard-Cron-Format.
command Text des auszuführenden Befehls.
Beispiele
postgres=> SELECT cron.schedule ('test','0 10 * * *', 'VACUUM pgbench_history');
 schedule
----------
      145
(1 row)

postgres=> SELECT cron.schedule ('0 15 * * *', 'VACUUM pgbench_accounts');
 schedule
----------
      146
(1 row)

Funktionsreferenz: cron.unschedule

Diese Funktion löscht eine Cron-Aufgabe. Sie können entweder den job_name oder die job_id angeben. Eine Richtlinie stellt sicher, dass Sie der Besitzer sind, um den Plan für die Aufgabe zu entfernen. Die Funktion gibt einen Booleschen Wert zurück, der Erfolg oder Misserfolg anzeigt.

Die Funktion weist die folgende Syntax auf.

Syntax
cron.unschedule (job_id);

cron.unschedule (job_name);
Parameter
Parameter Beschreibung
job_id

Ein Aufgabenbezeichner, der von der cron.schedule Funktion zurückgegeben wurde, als die Cron-Aufgabe geplant wurde.
job_name

Der Name einer Cron-Aufgabe, die mit der cron.schedule Funktion geplant wurde.
Beispiele
postgres=> SELECT cron.unschedule(108);
 unschedule
------------
 t
(1 row)

postgres=> SELECT cron.unschedule('test');
 unschedule
------------
 t
(1 row)

Tabellen zum Planen von Jobs und zur Erfassung des Status

Die folgenden Tabellen werden verwendet, um die Cron-Aufgaben zu planen und aufzuzeichnen, wie die Aufgaben abgeschlossen wurden.

Tabelle Beschreibung
cron.job

Enthält die Metadaten zu jeder geplanten Aufgabe. Die meisten Interaktionen mit dieser Tabelle sollten über die Funktionen cron.schedule und cron.unschedule erfolgen.

Wichtig

Wir empfehlen, dieser Tabelle keine Aktualisierungs- oder Einfügeberechtigungen zu gewähren. Dies würde es dem Benutzer ermöglichen, die username-Spalte zu aktualisieren, die als rds-superuser ausgeführt wird.
cron.job_run_details

Enthält Verlaufsdaten zu vergangenen geplanten Aufträgen, die ausgeführt wurden. Dies ist nützlich, um den Status, die Rückgabe von Nachrichten sowie die Start- und Endzeit des ausgeführten Auftrags zu untersuchen.

Anmerkung

Um zu verhindern, dass diese Tabelle ins Unendliche wächst, bereinigen Sie sie in regelmäßigen Abständen. Ein Beispiel finden Sie unter Löschen der Verlaufstabelle pg_cron.