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. # Planification de la maintenance avec l’extension PostgreSQL pg\$1cron Vous pouvez utiliser l’extension `pg_cron` PostgreSQL pour planifier des commandes de maintenance dans une base de données PostgreSQL. Pour plus d’informations concernant l’extension, consultez [What is pg\$1cron?](https://github.com/citusdata/pg_cron) (Qu’est-ce que pg\$1cron ?) dans la documentation pg\$1cron. L’extension `pg_cron` est prise en charge sur RDS pour PostgreSQL versions 12.5 et ultérieures du moteur. Pour en savoir plus sur l’utilisation de `pg_cron`, consultez [Schedule jobs with pg\$1cron on your RDS pour PostgreSQL or your Aurora PostgreSQL-Compatible Edition databases](https://aws.amazon.com/blogs/database/schedule-jobs-with-pg_cron-on-your-amazon-rds-for-postgresql-or-amazon-aurora-for-postgresql-databases/) (Planifier des tâches avec pg\$1cron sur votre RDS pour PostgreSQL ou sur vos bases de données Aurora Édition compatible avec PostgreSQL). **Note** La version d’extension `pg_cron` est affichée sous forme de version à deux chiffres, par exemple 1.6, dans la vue pg\$1available\$1extensions. Bien que des versions à trois chiffres, comme 1.6.4 ou 1.6.5, puissent apparaître dans certains contextes, il est nécessaire d’indiquer la version à deux chiffres lors de la mise à niveau d’une extension. **Topics** + [Configuration de l’extension pg\$1cron](#PostgreSQL_pg_cron.enable) + [Octroi d’autorisations utilisateurs de la base de données pour l’utilisation de pg\$1cron](#PostgreSQL_pg_cron.permissions) + [Planification des tâches pg\$1cron](#PostgreSQL_pg_cron.examples) + [Référence pour l’extension pg\$1cron](#PostgreSQL_pg_cron.reference) ## Configuration de l’extension pg\$1cron Configurez l’extension `pg_cron` comme suit : 1. Modifiez le groupe de paramètres personnalisé employé avec votre instance de base de données PostgreSQL en ajoutant `pg_cron` à la valeur du paramètre `shared_preload_libraries`. + Si votre instance de base de données RDS pour PostgreSQL utilise le paramètre `rds.allowed_extensions` pour lister explicitement les extensions qui peuvent être installées, vous devez ajouter l’extension `pg_cron` à la liste. Seules certaines versions de RDS pour PostgreSQL prennent en charge le paramètre `rds.allowed_extensions`. Par défaut, toutes les extensions disponibles sont autorisées. Pour plus d’informations, consultez [Restriction de l'installation des extensions PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.Extensions.md#PostgreSQL.Concepts.General.FeatureSupport.Extensions.Restriction). Redémarrez l’instance de la base de données PostgreSQL pour que les modifications du groupe de paramètres prennent effet. Pour en savoir plus sur l’utilisation des groupes de paramètres, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md). 1. Après le redémarrage de l’instance de base de données PostgreSQL, exécutez la commande suivante à l’aide d’un compte disposant d’autorisations `rds_superuser`. Par exemple, si vous avez utilisé les paramètres par défaut lors de la création de votre instance de base de données RDS pour PostgreSQL, connectez-vous en tant qu’utilisateur `postgres` et créez l’extension. ``` CREATE EXTENSION pg_cron; ``` Le planificateur `pg_cron` est défini dans la base de données PostgreSQL par défaut nommée `postgres`. Les objets `pg_cron` sont créés dans cette base de données `postgres` et toutes les actions de planification s’y exécutent. 1. Vous pouvez utiliser les paramètres par défaut ou planifier des tâches à exécuter dans d’autres bases de données de votre instance de base de données PostgreSQL. Pour planifier des tâches dans d’autres bases de données de votre instance de base de données PostgreSQL, consultez l’exemple disponible dans [Planification d’une tâche cron pour une base de données autre que la base de données par défaut](#PostgreSQL_pg_cron.otherDB). ## Octroi d’autorisations utilisateurs de la base de données pour l’utilisation de pg\$1cron L’installation de l’extension `pg_cron` requiert les privilèges `rds_superuser`. Toutefois, les autorisations d’utiliser le `pg_cron` peuvent être accordées (par un membre du groupe/rôle `rds_superuser`) à d’autres utilisateurs de la base de données, afin qu’ils puissent planifier leurs propres tâches. Nous vous recommandons de n’accorder des autorisations au schéma `cron` qu’en cas de besoin, si cela améliore les opérations dans votre environnement de production. Pour accorder à un utilisateur de base de données des autorisations dans le schéma `cron`, exécutez la commande suivante : ``` postgres=> GRANT USAGE ON SCHEMA cron TO db-user; ``` Cela donne *db-user* l'autorisation d'accéder au `cron` schéma pour planifier des tâches cron pour les objets auxquels ils sont autorisés à accéder. Si l’utilisateur de la base de données ne dispose pas des autorisations nécessaires, la tâche échoue après avoir validé le message d’erreur dans le fichier `postgresql.log`, comme indiqué ci-dessous : ``` 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 ``` En d’autres termes, assurez-vous que les utilisateurs de la base de données disposant d’autorisations sur le schéma `cron` ont également des autorisations sur les objets (tables, schémas, etc.) qu’ils prévoient de planifier. Les détails de la tâche cron et sa réussite ou son échec sont également saisis dans la table `cron.job_run_details`. Pour plus d’informations, consultez [Tableaux pour planifier les tâches et capturer leur statut](#PostgreSQL_pg_cron.tables). ## Planification des tâches pg\$1cron Les sections suivantes montrent comment vous pouvez planifier diverses tâches de gestion à l’aide de tâches `pg_cron`. **Note** Lorsque vous créez des tâches `pg_cron`, vérifiez que le paramètre `max_worker_processes` est supérieur au nombre de `cron.max_running_jobs`. Une tâche `pg_cron` échoue si elle manque de processus de travail en arrière-plan. Le nombre de tâches `pg_cron` par défaut est de `5`. Pour plus d’informations, consultez [Paramètres de gestion de l’extension pg\$1cron](#PostgreSQL_pg_cron.parameters). **Topics** + [Vidage d’une table](#PostgreSQL_pg_cron.vacuum) + [Purge de la table Historique pg\$1cron](#PostgreSQL_pg_cron.job_run_details) + [Journalisation des erreurs dans le fichier postgresql.log uniquement](#PostgreSQL_pg_cron.log_run) + [Planification d’une tâche cron pour une base de données autre que la base de données par défaut](#PostgreSQL_pg_cron.otherDB) ### Vidage d’une table Autovacuum gère la maintenance dans la plupart des cas. Toutefois, vous pouvez vider une table spécifique quand bon vous semble. Consultez également [Utilisation de la fonction autovacuum de PostgreSQL sur Amazon RDS pour PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Autovacuum.md). L’exemple suivant montre comment utiliser la fonction `cron.schedule` pour configurer une tâche de manière à ce qu’elle utilise `VACUUM FREEZE` sur une table spécifique tous les jours à 22:00 (GMT). ``` SELECT cron.schedule('manual vacuum', '0 22 * * *', 'VACUUM FREEZE pgbench_accounts'); schedule ---------- 1 (1 row) ``` Une fois l’exemple précédent exécuté, vous pouvez vérifier l’historique dans la table `cron.job_run_details` comme suit. ``` 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) ``` Voici une requête de la table `cron.job_run_details` permettant d’afficher les tâches qui ont échoué. ``` 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) ``` Pour plus d’informations, consultez [Tableaux pour planifier les tâches et capturer leur statut](#PostgreSQL_pg_cron.tables). ### Purge de la table Historique pg\$1cron La table `cron.job_run_details` contient un historique des tâches cron et celui-ci peut considérablement s’étoffer au fil du temps. Nous vous recommandons de planifier une tâche afin de purger cette table. Par exemple, conserver les entrées d’une semaine peut s’avérer suffisant à des fins de dépannage. L’exemple suivant utilise la fonction [cron.schedule](#PostgreSQL_pg_cron.schedule) pour planifier une tâche qui s’exécute tous les jours à minuit afin de purger la table `cron.job_run_details`. Cette tâche ne conserve que les entrées des sept derniers jours. Utilisez votre compte `rds_superuser` pour planifier la tâche comme suit : ``` SELECT cron.schedule('0 0 * * *', $$DELETE FROM cron.job_run_details WHERE end_time < now() - interval '7 days'$$); ``` Pour plus d’informations, consultez [Tableaux pour planifier les tâches et capturer leur statut](#PostgreSQL_pg_cron.tables). ### Journalisation des erreurs dans le fichier postgresql.log uniquement Pour empêcher les écritures dans la table `cron.job_run_details`, modifiez le groupe de paramètres associé à l’instance de base de données PostgreSQL et désactivez le paramètre `cron.log_run`. L’extension `pg_cron` n’écrit plus dans la table et consigne uniquement des erreurs dans le fichier `postgresql.log`. Pour plus d’informations, consultez [Modification de paramètres dans un groupe de paramètres de base de données dans Amazon RDS](USER_WorkingWithParamGroups.Modifying.md). Utilisez la commande suivante pour vérifier la valeur du paramètre `cron.log_run`. ``` postgres=> SHOW cron.log_run; ``` Pour plus d’informations, consultez [Paramètres de gestion de l’extension pg\$1cron](#PostgreSQL_pg_cron.parameters). ### Planification d’une tâche cron pour une base de données autre que la base de données par défaut Toutes les métadonnées de `pg_cron` sont conservées dans la base de données par défaut PostgreSQL nommée `postgres`. Des exécutants étant utilisés en arrière-plan pour exécuter les tâches de maintenance cron, vous pouvez planifier une tâche dans n’importe quelle base de données de l’instance de base de données PostgreSQL. **Note** Seuls les utilisateurs disposant du rôle `rds_superuser` ou de privilèges `rds_superuser` peuvent répertorier toutes les tâches cron de la base de données. Les autres utilisateurs peuvent uniquement consulter leurs propres tâches dans la table `cron.job`. 1. Dans la base de données cron, planifiez la tâche comme vous le faites normalement à l’aide de la fonction [cron.schedule](#PostgreSQL_pg_cron.schedule). ``` postgres=> SELECT cron.schedule('database1 manual vacuum', '29 03 * * *', 'vacuum freeze test_table'); ``` 1. En tant qu’utilisateur ayant le rôle `rds_superuser`, mettez à jour la colonne de base de données correspondant à la tâche que vous venez de créer de manière à l’exécuter dans une autre base de données de votre instance de base de données PostgreSQL. ``` postgres=> UPDATE cron.job SET database = 'database1' WHERE jobid = 106; ``` 1. Procédez à une vérification en interrogeant la table `cron.job`. ``` 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) ``` **Note** Dans certains cas, vous pouvez ajouter une tâche cron que vous avez l’intention d’exécuter sur une base de données différente. Dans de tels cas, le tâche peut essayer de s’exécuter dans la base de données par défaut (`postgres`) avant la mise à jour de la colonne de base de données correcte. Si le nom d’utilisateur dispose d’autorisations, la tâche s’exécute correctement dans la base de données par défaut. ## Référence pour l’extension pg\$1cron Vous pouvez utiliser les paramètres, fonctions et tables suivants avec l’extension `pg_cron`. Pour plus d’informations, consultez [Qu’est-ce que pg\$1cron](https://github.com/citusdata/pg_cron) dans la documentation pg\$1cron. **Topics** + [Paramètres de gestion de l’extension pg\$1cron](#PostgreSQL_pg_cron.parameters) + [Référence de fonction : cron.schedule](#PostgreSQL_pg_cron.schedule) + [Référence de fonction : cron.unschedule](#PostgreSQL_pg_cron.unschedule) + [Tableaux pour planifier les tâches et capturer leur statut](#PostgreSQL_pg_cron.tables) ### Paramètres de gestion de l’extension pg\$1cron La liste ci-dessous répertorie les paramètres permettant de contrôler le comportement de l’extension `pg_cron`. | Paramètre | Description | | --- | --- | | cron.database\$1name | Base de données dans laquelle les métadonnées `pg_cron` sont conservées. | | cron.host | Nom d’hôte permettant de se connecter à PostgreSQL. Vous ne pouvez pas modifier cette valeur. | | cron.log\$1run | Enregistrez chaque tâche qui s’exécute dans la table `job_run_details`. Les valeurs sont `on` ou `off`. Pour plus d’informations, consultez [Tableaux pour planifier les tâches et capturer leur statut](#PostgreSQL_pg_cron.tables). | | cron.log\$1statement | Enregistre toutes les instructions cron avant leur exécution. Les valeurs sont `on` ou `off`. | | cron.max\$1running\$1jobs | Nombre maximal de tâches pouvant être exécutées simultanément. | | cron.use\$1background\$1workers | Utilisez des exécutants en arrière-plan plutôt que des sessions client. Vous ne pouvez pas modifier cette valeur. | Utilisez la commande SQL suivante pour afficher ces paramètres et leurs valeurs. ``` postgres=> SELECT name, setting, short_desc FROM pg_settings WHERE name LIKE 'cron.%' ORDER BY name; ``` ### Référence de fonction : cron.schedule Cette fonction planifie une tâche cron. Cette tâche est initialement planifiée dans la base de données `postgres` par défaut. La fonction renvoie une valeur `bigint` correspondant à l’identifiant de la tâche. Pour planifier l’exécution de tâches dans d’autres bases de données de votre instance de base de données PostgreSQL, consultez l’exemple disponible dans [Planification d’une tâche cron pour une base de données autre que la base de données par défaut](#PostgreSQL_pg_cron.otherDB). La fonction présente deux formats de syntaxe. **Syntaxe** ``` cron.schedule (job_name, schedule, command ); cron.schedule (schedule, command ); ``` **Paramètres** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/PostgreSQL_pg_cron.html) **Exemples** ``` 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) ``` ### Référence de fonction : cron.unschedule Cette fonction supprime une tâche cron. Vous pouvez spécifier soit le `job_name` ou le `job_id`. Une politique assure que vous soyez le propriétaire pouvant supprimer la planification de la tâche. La fonction renvoie une valeur booléenne indiquant la réussite ou l’échec. La fonction a les formats de syntaxe suivants. **Syntaxe** ``` cron.unschedule (job_id); cron.unschedule (job_name); ``` **Paramètres** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/PostgreSQL_pg_cron.html) **Exemples** ``` postgres=> SELECT cron.unschedule(108); unschedule ------------ t (1 row) postgres=> SELECT cron.unschedule('test'); unschedule ------------ t (1 row) ``` ### Tableaux pour planifier les tâches et capturer leur statut Les tables suivantes sont utilisées pour planifier les tâches cron et enregistrer la façon dont elles ont été accomplies. | Tableau  | Description | | --- | --- | | cron.job | Contient les métadonnées relatives à chaque tâche planifiée. La plupart des interactions avec cette table doivent être effectuées à l’aide des fonctions `cron.schedule` et `cron.unschedule`. Nous vous recommandons de ne pas accorder de privilèges de mise à jour ou d’insertion directement à cette table. Ce faisant, l’utilisateur pourrait mettre à jour la colonne `username` à exécuter en tant que `rds-superuser`. | | cron.job\$1run\$1details | Contient des informations historiques sur l’exécution de tâches planifiées antérieures. Ces informations sont utiles pour examiner l’état, les messages renvoyés et les heures de début et de fin d’exécution de la tâche. Pour éviter que cette table évolue indéfiniment, purgez-la de manière régulière. Pour obtenir un exemple, consultez [Purge de la table Historique pg\$1cron](#PostgreSQL_pg_cron.job_run_details). |