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\$1cron 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\$1cron?](https://github.com/citusdata/pg_cron) in der pg\$1cron-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\$1cron auf RDS für PostgreSQL oder Ihren Datenbanken der mit Aurora PostgreSQL kompatiblen Edition](https://aws.amazon.com/blogs/database/schedule-jobs-with-pg_cron-on-your-amazon-rds-for-postgresql-or-amazon-aurora-for-postgresql-databases/). **Anmerkung** Die `pg_cron`-Erweiterungsversion wird in der Ansicht „pg\$1available\$1extensions“ als zweistellige Version angezeigt, beispielsweise 1.6. In einigen Kontexten werden möglicherweise dreistellige Versionen aufgeführt, z. B. 1.6.4 oder 1.6.5, Sie müssen jedoch die zweistellige Version angeben, wenn Sie ein Upgrade der Erweiterung durchführen. **Topics** + [Einrichten der pg\$1con-Erweiterung](#PostgreSQL_pg_cron.enable) + [Gewähren von Berechtigungen zur Verwendung von pg\$1cron für Datenbankbenutzer](#PostgreSQL_pg_cron.permissions) + [Planen von pg\$1cron-Aufträgen](#PostgreSQL_pg_cron.examples) + [Referenz für die pg\$1cron-Erweiterung](#PostgreSQL_pg_cron.reference) ## Einrichten der pg\$1con-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 [Beschränkung der Installation von PostgreSQL-Erweiterungen](PostgreSQL.Concepts.General.FeatureSupport.Extensions.md#PostgreSQL.Concepts.General.FeatureSupport.Extensions.Restriction). 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](USER_WorkingWithParamGroups.Modifying.md). 1. 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. 1. 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](#PostgreSQL_pg_cron.otherDB). ## Gewähren von Berechtigungen zur Verwendung von pg\$1cron 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; ``` Dies gibt die *db-user* Erlaubnis, auf das `cron` Schema zuzugreifen, um Cron-Jobs 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`-Schemas gewährt werden, auch über Berechtigungen für die Objekte (Tabellen, Schemas usw.) verfügen, die sie planen wollen. Die Details des cron-Auftrags und dessen Erfolg oder Misserfolg werden ebenfalls in der Tabelle `cron.job_run_details` erfasst. Weitere Informationen finden Sie unter [Tabellen zum Planen von Jobs und zur Erfassung des Status](#PostgreSQL_pg_cron.tables). ## Planen von pg\$1cron-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\$1cron-Erweiterung](#PostgreSQL_pg_cron.parameters). **Topics** + [Bereinigen von Tabellen](#PostgreSQL_pg_cron.vacuum) + [Löschen der Verlaufstabelle pg\$1cron](#PostgreSQL_pg_cron.job_run_details) + [Protokollieren von Fehlern nur in der Datei postgresql.log](#PostgreSQL_pg_cron.log_run) + [Planen einer Cron-Aufgabe für eine andere als die Standard-Datenbank](#PostgreSQL_pg_cron.otherDB) ### 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 der PostgreSQL-Selbstbereinigung in Amazon RDS für PostgreSQL ](Appendix.PostgreSQL.CommonDBATasks.Autovacuum.md). 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) ``` Nachfolgend finden Sie eine Abfrage der Tabelle `cron.job_run_details`, um fehlgeschlagene 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](#PostgreSQL_pg_cron.tables). ### Löschen der Verlaufstabelle pg\$1cron 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](#PostgreSQL_pg_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](#PostgreSQL_pg_cron.tables). ### 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](USER_WorkingWithParamGroups.Modifying.md). 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\$1cron-Erweiterung](#PostgreSQL_pg_cron.parameters). ### 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. **Anmerkung** Nur Benutzer mit der Rolle `rds_superuser` oder mit `rds_superuser`-Berechtigungen können alle cron-Aufträge in der Datenbank auflisten. Andere Benutzer können nur ihre eigenen Aufträge in der Tabelle `cron.job` anzeigen. 1. Planen Sie die Aufgabe in der Cron-Datenbank wie gewohnt mit [cron.schedule](#PostgreSQL_pg_cron.schedule). ``` postgres=> SELECT cron.schedule('database1 manual vacuum', '29 03 * * *', 'vacuum freeze test_table'); ``` 1. 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; ``` 1. Ü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\$1cron-Erweiterung Sie können die folgenden Parameter, Funktionen und Tabellen mit der `pg_cron`-Erweiterung verwenden. Weitere Informationen finden Sie unter [Was ist pg\$1cron?](https://github.com/citusdata/pg_cron) in der pg\$1cron-Dokumentation. **Topics** + [Parameter für die Verwaltung der pg\$1cron-Erweiterung](#PostgreSQL_pg_cron.parameters) + [Funktionsreferenz: cron.schedule](#PostgreSQL_pg_cron.schedule) + [Funktionsreferenz: cron.unschedule](#PostgreSQL_pg_cron.unschedule) + [Tabellen zum Planen von Jobs und zur Erfassung des Status](#PostgreSQL_pg_cron.tables) ### Parameter für die Verwaltung der pg\$1cron-Erweiterung Es folgt eine Liste der Parameter zur Steuerung des Erweiterungsverhaltens von `pg_cron`. | Parameter | Description | | --- | --- | | cron.database\$1name | 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\$1run | 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](#PostgreSQL_pg_cron.tables). | | cron.log\$1statement | Protokolliert alle Cron-Anweisungen, bevor Sie ausgeführt werden. Die Werte sind `on` oder `off`. | | cron.max\$1running\$1jobs | Die maximale Anzahl von Aufgaben, die gleichzeitig ausgeführt werden können. | | cron.use\$1background\$1workers | 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](#PostgreSQL_pg_cron.otherDB). Die Funktion hat zwei Syntaxformate. **Syntax** ``` cron.schedule (job_name, schedule, command ); cron.schedule (schedule, command ); ``` **Parameter** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/PostgreSQL_pg_cron.html) **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** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/PostgreSQL_pg_cron.html) **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. 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\$1run\$1details | 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. 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\$1cron](#PostgreSQL_pg_cron.job_run_details). |