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\$1cron 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\$1cron?](https://github.com/citusdata/pg_cron) nella documentazione di pg\$1cron. 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\$1cron on your RDS for 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/) (Pianificazione dei processi con pg\$1cron sui database RDS per PostgreSQL o Aurora edizione compatibile con PostgreSQL). **Nota** La versione dell’estensione `pg_cron` viene visualizzata come versione a due cifre, ad esempio 1.6, nella vista pg\$1available\$1extensions. Sebbene in alcuni contesti possano essere elencate versioni a tre cifre, ad esempio 1.6.4 o 1.6.5, è necessario specificare la versione a due cifre quando si esegue un aggiornamento dell’estensione. **Topics** + [Configurazione dell'estensione pg\$1cron](#PostgreSQL_pg_cron.enable) + [Concessione delle autorizzazioni per utilizzare pg\$1cron agli utenti del database](#PostgreSQL_pg_cron.permissions) + [Programmazione di processi pg\$1cron](#PostgreSQL_pg_cron.examples) + [Riferimento per l'estensione pg\$1cron](#PostgreSQL_pg_cron.reference) ## Configurazione dell'estensione pg\$1cron 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 [Limitazione dell'installazione delle estensioni PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.Extensions.md#PostgreSQL.Concepts.General.FeatureSupport.Extensions.Restriction). 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 database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md). 1. 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. 1. 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](#PostgreSQL_pg_cron.otherDB). ## Concessione delle autorizzazioni per utilizzare pg\$1cron 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 dà *db-user* il permesso di accedere allo `cron` schema per pianificare i cron job per gli oggetti a cui hanno i permessi 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, assicurarsi che gli utenti del database a cui sono concesse autorizzazioni per lo schema `cron`, dispongano anche di autorizzazioni sugli oggetti (tabelle, schemi e così via) che intendono pianificare. I dettagli del processo cron e l’esito positivo o negativo sono anche acquisiti nella tabella `cron.job_run_details`. Per ulteriori informazioni, consulta [Tabelle per la pianificazione dei processi e l'acquisizione dello stato](#PostgreSQL_pg_cron.tables). ## Programmazione di processi pg\$1cron 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\$1cron](#PostgreSQL_pg_cron.parameters). **Topics** + [Vacuum di una tabella](#PostgreSQL_pg_cron.vacuum) + [Eliminazione della tabella della cronologia di pg\$1cron](#PostgreSQL_pg_cron.job_run_details) + [Registrazione degli errori solo nel file postgresql.log](#PostgreSQL_pg_cron.log_run) + [Pianificazione di un processo cron per un database diverso da quello predefinito](#PostgreSQL_pg_cron.otherDB) ### 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, [Utilizzo della funzionalità di autovacuum di PostgreSQL in Amazon RDS per PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Autovacuum.md). 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 una query della tabella `cron.job_run_details` per visualizzare i processi non riusciti. ``` 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](#PostgreSQL_pg_cron.tables). ### Eliminazione della tabella della cronologia di pg\$1cron 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](#PostgreSQL_pg_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](#PostgreSQL_pg_cron.tables). ### 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 database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md). 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\$1cron](#PostgreSQL_pg_cron.parameters). ### 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. **Nota** Solo gli utenti con il ruolo `rds_superuser` o i privilegi `rds_superuser` possono elencare tutti i processi cron nel database. Gli altri utenti possono visualizzare solo i propri processi nella tabella `cron.job`. 1. Nel database cron, pianifica il processo come si farebbe normalmente utilizzando [cron.schedule](#PostgreSQL_pg_cron.schedule). ``` postgres=> SELECT cron.schedule('database1 manual vacuum', '29 03 * * *', 'vacuum freeze test_table'); ``` 1. 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; ``` 1. 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\$1cron È possibile utilizzare i seguenti parametri, funzioni e tabelle con l'estensione `pg_cron`. Per ulteriori informazioni, consultare [Che cos'è pg\$1cron?](https://github.com/citusdata/pg_cron) nella documentazione di pg\$1cron. **Topics** + [Parametri per la gestione dell'estensione pg\$1cron](#PostgreSQL_pg_cron.parameters) + [Riferimento alla funzione: cron.schedule](#PostgreSQL_pg_cron.schedule) + [Riferimento alla funzione: cron.unschedule](#PostgreSQL_pg_cron.unschedule) + [Tabelle per la pianificazione dei processi e l'acquisizione dello stato](#PostgreSQL_pg_cron.tables) ### Parametri per la gestione dell'estensione pg\$1cron Di seguito è riportato l'elenco dei parametri che consentono di controllare il comportamento dell'estensione `pg_cron`. | Parametro | Description | | --- | --- | | cron.database\$1name | 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\$1run | 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](#PostgreSQL_pg_cron.tables). | | cron.log\$1statement | Registra tutte le istruzioni cron prima di eseguirle. I valori sono `on` o `off`. | | cron.max\$1running\$1jobs | Numero massimo di processi che possono essere eseguiti contemporaneamente. | | cron.use\$1background\$1workers | 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](#PostgreSQL_pg_cron.otherDB). La funzione ha due diverse sintassi. **Sintassi** ``` cron.schedule (job_name, schedule, command ); cron.schedule (schedule, command ); ``` **Parametri** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/PostgreSQL_pg_cron.html) **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** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/PostgreSQL_pg_cron.html) **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`. 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\$1run\$1details | 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. 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\$1cron](#PostgreSQL_pg_cron.job_run_details). |