Pianificazione della manutenzione con l'estensione PostgreSQL pg_cron - Amazon Relational Database Service
Configurazione dell'estensione pg_cronConcessione delle autorizzazioni per utilizzare pg_cron agli utenti del databaseProgrammazione di processi pg_cronRiferimento per l'estensione pg_cron

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Pianificazione della manutenzione con l'estensione PostgreSQL pg_cron

Puoi utilizzare l'estensione PostgreSQL pg_cron per pianificare i comandi di manutenzione all'interno di un database PostgreSQL. Per ulteriori informazioni sull'estensione, consulta Che cos'è pg_cron? nella documentazione di pg_cron.

L'estensione pg_cron è supportata sul motore RDS for PostgreSQL versioni 12.5 e successive.

Per ulteriori informazioni sull'uso di pg_cron, consulta Schedule jobs with pg_cron on your RDS for PostgreSQL or your Aurora PostgreSQL-Compatible Edition databases (Pianificazione dei processi con pg_cron sui database RDS per PostgreSQL o Aurora edizione compatibile con PostgreSQL).

Configurazione dell'estensione pg_cron

Configura l'estensione pg_cron come riportato di seguito:

  1. Modifica il gruppo di parametri personalizzati associato all'istanza database PostgreSQL aggiungendo pg_cron al valore del parametro shared_preload_libraries.

    • Se l'istanza database RDS per PostgreSQL utilizza il parametro rds.allowed_extensions per elencare in maniera esplicita le estensioni che possono essere installate, è necessario aggiungere l'estensione pg_cron all'elenco. Solo alcune versioni di RDS per PostgreSQL supportano il parametro rds.allowed_extensions. Per impostazione predefinita, tutte le estensioni disponibili sono consentite. Per ulteriori informazioni, consulta SQLLimitazione dell'installazione delle estensioni Postgre.

    Per rendere effettive le modifiche apportate al gruppo di parametri, riavvia l'istanza database PostgreSQL. Per ulteriori informazioni sull'utilizzo dei gruppi di parametri, consulta Modifica dei parametri in un gruppo di parametri DB in Amazon RDS .

  2. Dopo il riavvio dell'istanza database PostgreSQL, esegui il comando riportato di seguito utilizzando un account che dispone delle autorizzazioni rds_superuser. Ad esempio, se hai utilizzato le impostazioni di default quando hai creato l'istanza database RDS for PostgreSQL, connettiti come utente postgres e crea l'estensione. 

    CREATE EXTENSION pg_cron;

    Lo scheduler pg_cron è impostato nel database PostgreSQL predefinito denominato postgres. Gli oggetti pg_cron vengono creati in questo database postgres e tutte le azioni di pianificazione vengono eseguite in questo database.

  3. Puoi usare le impostazioni predefinite oppure puoi pianificare i processi da eseguire in altri database all'interno dell'istanza database di PostgreSQL. Per pianificare i processi per altri database all'interno dell'istanza database di PostgreSQL, consulta l'esempio in Pianificazione di un processo cron per un database diverso da quello predefinito.

Concessione delle autorizzazioni per utilizzare pg_cron agli utenti del database

L'installazione dell'estensione pg_cron richiede privilegi rds_superuser. Tuttavia, le autorizzazioni per utilizzare pg_cron possono essere concesse (da un membro del gruppo/ruolo rds_superuser) ad altri utenti del database, in modo che possano pianificare i propri lavori. Ti consigliamo di concedere le autorizzazioni allo schema cron solo se in base alle esigenze se migliora le operazioni nell'ambiente di produzione.

Per concedere a un database l'autorizzazione utente nello schema cron, esegui il seguente comando:

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

Questo fornisce l'autorizzazione db-user per accedere allo schema cron per pianificare i processi cron per gli oggetti per i quali si dispone di autorizzazione di accesso. Se l'utente del database non dispone di autorizzazioni, il processo non va a buon fine dopo aver pubblicato il messaggio di errore nel file postgresql.log, come mostrato di seguito:

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

In altre parole, assicurati che gli utenti del database a cui sono concesse le autorizzazioni sullo cron schema dispongano anche delle autorizzazioni per gli oggetti (tabelle, schemi e così via) che intendono pianificare.

Nella tabella vengono inoltre registrati i dettagli del cron job e del suo esito positivo o negativo. cron.job_run_details Per ulteriori informazioni, consulta Tabelle per la pianificazione dei processi e l'acquisizione dello stato .

Programmazione di processi pg_cron

Nelle sezioni seguenti viene illustrato come è possibile pianificare varie attività di gestione utilizzando le attività pg_cron.

Nota

Quando crei processi pg_cron, controlla che l'impostazione max_worker_processes sia maggiore del numero di cron.max_running_jobs. Un processo pg_cron non riesce se i processi worker in background vengono esauriti. Il numero predefinito di processi pg_cron è 5. Per ulteriori informazioni, consulta Parametri per la gestione dell'estensione pg_cron.

Vacuum di una tabella

Autovacuum gestisce la manutenzione del vacuum per la maggior parte dei casi. Tuttavia, potresti voler programmare un vacuum di una tabella specifica in un momento di tua scelta.

Consulta anche, Lavorare con l'SQLautovacuum Postgre su Amazon for Postgre RDS SQL.

Di seguito è riportato un esempio di utilizzo della funzione cron.schedule per impostare un processo in modo da utilizzare VACUUM FREEZE su una tabella specifica ogni giorno alle 22:00 (GMT).

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

Dopo l'esecuzione dell'esempio precedente, è possibile controllare la cronologia nella tabella cron.job_run_details come riportato di seguito.

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)

Di seguito è riportata un'interrogazione della cron.job_run_details tabella per vedere i job falliti.

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)

Per ulteriori informazioni, consulta Tabelle per la pianificazione dei processi e l'acquisizione dello stato .

Eliminazione della tabella della cronologia di pg_cron

La tabella cron.job_run_details contiene una cronologia di processi cron che può crescere a dismisura nel tempo. Si consiglia di pianificare un processo che elimini questa tabella. Ad esempio, conservare una settimana di voci può essere sufficiente per la risoluzione dei problemi.

Nell'esempio seguente viene utilizzata la funzione cron.schedule per pianificare un processo che viene eseguito ogni giorno a mezzanotte per rimuovere la tabella cron.job_run_details. Il processo conserva solo gli ultimi sette giorni. Utilizza l'account rds_superuser per pianificare il processo come riportato di seguito.

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

Per ulteriori informazioni, consulta Tabelle per la pianificazione dei processi e l'acquisizione dello stato .

Registrazione degli errori solo nel file postgresql.log

Per disattivare la scrittura nella tabella cron.job_run_details, modifica il gruppo di parametri associato all'istanza database PostgreSQL e disattiva il parametro cron.log_run. L'estensione pg_cron non scrive più nella tabella e acquisisce gli errori solo nel file postgresql.log. Per ulteriori informazioni, consulta Modifica dei parametri in un gruppo di parametri DB in Amazon RDS .

Utilizza il seguente comando per controllare il valore del parametro cron.log_run.

postgres=> SHOW cron.log_run;

Per ulteriori informazioni, consulta Parametri per la gestione dell'estensione pg_cron.

Pianificazione di un processo cron per un database diverso da quello predefinito

I metadati per pg_cron sono tutti contenuti nel database predefinito PostgreSQL denominato postgres. Poiché i worker in background vengono utilizzati per l'esecuzione dei processi cron di manutenzione, puoi pianificare un processo in uno qualsiasi dei database all'interno dell'istanza database PostgreSQL.

  1. Nel database cron, pianifica il processo come si farebbe normalmente utilizzando cron.schedule.

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

  2. Con il ruolo rds_superuser, aggiorna la colonna del database per il processo appena creato in modo che venga eseguito in un altro database all'interno dell'istanza database PostgreSQL.

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

  3. Verifica eseguendo una query sulla tabella 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)
Nota

In alcune situazioni, è possibile aggiungere un processo cron che si intende eseguire in un database diverso. In questi casi, il processo potrebbe essere eseguito nel database predefinito (postgres) prima di aggiornare la colonna del database corretta. Se il nome utente dispone delle autorizzazioni, il processo viene eseguito correttamente nel database predefinito.

Riferimento per l'estensione pg_cron

È possibile utilizzare i seguenti parametri, funzioni e tabelle con l'estensione pg_cron. Per ulteriori informazioni, consultare Che cos'è pg_cron? nella documentazione di pg_cron.

Parametri per la gestione dell'estensione pg_cron

Di seguito è riportato l'elenco dei parametri che consentono di controllare il comportamento dell'estensione pg_cron.

Parametro Descrizione

cron.database_name

Il database in cui vengono conservati i metadati pg_cron.
cron.host

Il nome host per connettersi a PostgressQL. Non è possibile modificare questo valore.
cron.log_run

Registra tutti i processi eseguiti nella tabella job_run_details. I valori sono on o off. Per ulteriori informazioni, consulta Tabelle per la pianificazione dei processi e l'acquisizione dello stato .
cron.log_statement

Registra tutte le istruzioni cron prima di eseguirle. I valori sono on o off.
cron.max_running_jobs

Numero massimo di processi che possono essere eseguiti contemporaneamente.
cron.use_background_workers

Utilizza i worker in background anziché le sessioni client. Non è possibile modificare questo valore.

Puoi utilizzare il comando SQL seguente per visualizzare questi parametri e i relativi valori.

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

Riferimento alla funzione: cron.schedule

Questa funzione pianifica un processo cron. Il processo viene inizialmente pianificato nel database postgres predefinito. La funzione restituisce un valore bigint che rappresenta l'identificativo del processo. Per pianificare l'esecuzione di processi in altri database all'interno dell'istanza database di PostgreSQL, consulta l'esempio in Pianificazione di un processo cron per un database diverso da quello predefinito.

La funzione ha due diverse sintassi.

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

cron.schedule (schedule,
    command
);
Parametri
Parametro Descrizione
job_name

Il nome del processo cron.
schedule

Il testo che indica la pianificazione per il processo cron. Il formato è il formato cron standard.
command Testo del comando da eseguire.
Esempi
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)

Riferimento alla funzione: cron.unschedule

Questa funzione elimina un processo cron. Puoi specificare job_name o job_id. Una policy assicura che l'utente sia il proprietario e possa rimuovere la pianificazione per il processo. La funzione restituisce un valore Booleano che indica la riuscita o l'errore.

La funzione ha la seguente sintassi.

Sintassi
cron.unschedule (job_id);

cron.unschedule (job_name);
Parametri
Parametro Descrizione
job_id

Un identificativo di processo restituito dalla funzione cron.schedule quando è stato pianificato il processo cron.
job_name

Il nome di un processo cron pianificato con la funzione cron.schedule.
Esempi
postgres=> SELECT cron.unschedule(108);
 unschedule
------------
 t
(1 row)

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

Tabelle per la pianificazione dei processi e l'acquisizione dello stato

Le seguenti tabelle vengono create e utilizzate per pianificare i processi cron e registrare il modo in cui i processi vengono completati.

Tabella Descrizione
cron.job

Contiene i metadati relativi a ciascun processo pianificato. La maggior parte delle interazioni con questa tabella dovrebbe essere eseguita tramite le funzioni cron.schedule e cron.unschedule.

Importante

Si sconsiglia di concedere privilegi di aggiornamento/inserimento direttamente a questa tabella. In questo modo, si consente all'utente di aggiornare la colonna username da eseguire come rds-superuser.
cron.job_run_details

Contiene informazioni cronologiche sulle esecuzioni precedenti dei processi pianificati. Ciò è utile per analizzare lo stato, i messaggi restituiti e l'ora di inizio e di fine dall'esecuzione del processo.

Nota

Per evitare che questa tabella cresca in maniera indefinita, è necessario eliminarla su base regolare. Per un esempio, consulta Eliminazione della tabella della cronologia di pg_cron.