Come posso annullare query lente nella mia istanza database Amazon RDS per PostgreSQL o Aurora compatibile con PostgreSQL?
Desidero annullare un processo lento nella mia istanza database (DB) Amazon Relational Database Service (Amazon RDS) per PostgreSQL o Amazon Aurora compatibile con PostgreSQL.
Breve descrizione
A seconda del caso d'uso, puoi utilizzare la funzione pg_cacnel_backend(pid) o pg_terminate_backend(pid).
Utilizza la funzione pg_cancel_backend(pid) per inviare un segnale SIGINT a uno specifico processo di backend e annullare la query lenta corrente. Durante tale processo, la connessione al database rimane attiva. Il backend può continuare a elaborare altre query o transazioni dopo che la funzione ha annullato correttamente la query corrente.
Utilizza la funzione pg_terminate_backend(pid) per annullare una query e chiudere la connessione. La funzione invia un segnale SIGTERM a uno specifico processo di backend e annulla forzatamente la connessione associata al processo. Tale processo esegue il rollback e rilascia le transazioni aperte o i blocchi presenti all'interno della connessione.
Per ulteriori informazioni, consulta Server signaling functions (Funzioni di segnalazione del server) sul sito web PostgreSQL.
Nota: alcune versioni di Aurora compatibile con PostgreSQL non possono annullare un processo di autovacuum, anche quando soddisfi tutti i requisiti di sistema. Quando tenti di annullare un processo di autovacuum in queste versioni, potresti ricevere il seguente messaggio di errore:
"ERROR: 42501: must be a superuser to terminate superuser process LOCATION: pg_terminate_backend, signalfuncs.c:227."
Alcune versioni secondarie consentono a rds_superuser di annullare i processi di autovacuum che non sono esplicitamente associati a un ruolo. Per verificare se la versione consente a rds_superuser di annullare i processi di autovacuum, consulta Aggiornamenti di Amazon Aurora PostgreSQL.
Risoluzione
Per utilizzare pg_cacnel_backend(pid) o pg_terminate_backend(pid), devi essere uno dei seguenti utenti:
- Sei un rds_superuser o un membro del ruolo predefinito pg_signal_backend.
- Sei connesso al database come lo stesso utente del database della sessione che desideri annullare.
Per terminare la query lenta, devi disporre dell'ID di processo (PID) della transazione. Per individuare il PID, esegui la query pg_stat_activity e visualizza la colonna pid. Per ulteriori informazioni, consulta pg_stat_activity sul sito web PostgreSQL.
Utilizza la funzione pg_cancel_backend(pid)
Quando esegui questo comando da un'altra sessione, la funzione utilizza il PID della query lenta per annullare la query dal backend del database:
SELECT pg_cancel_backend(8121);
Nota: nel comando precedente, il PID della query è 8121.
Output atteso:
pg_cancel_backend ------------------------ t
Nell'output precedente, il valore t per "true" mostra che la funzione ha annullato la query. Se la query non esiste più o se non c'è una connessione al database attiva, l'output mostra un valore f per "false".
Utilizza la funzione pg_terminate_backend(pid)
Quando esegui questo comando da una sessione diversa, la funzione termina la connessione al database con pid 8121:
SELECT pg_terminate_backend(8121);
Output atteso:
pg_terminate_backend ------------------------ t
L'output precedente mostra t anche se la funzione non ha annullato la query. La risposta mostra che la funzione ha inviato correttamente il segnale SIGTERM. La funzione non interrompe immediatamente il processo di backend. Per mantenere la memoria condivisa in uno stato coerente, il comando avvia un regolare processo di spegnimento durante CHECK_FOR_INTERRUPTS.
Annulla un processo lungo che non termina
Quando esegui pg_cancel_backend(pid) o pg_terminate_backend(pid) in una sezione interrompibile, le funzioni non possono annullare la query. Ad esempio, il processo tenta di acquisire un blocco leggero. Oppure il processo è in attesa del completamento di una chiamata di sistema in lettura o scrittura dallo storage. In questi casi, il processo di backend non riceve il segnale di annullamento e il processo si blocca a tempo indeterminato.
Se il processo non risponde ai metodi di annullamento, riavvia l'intero motore di database e termina forzatamente il processo in stallo.
È consigliabile regolare i parametri di timeout, come statement_timeout, idle_in_transaction_session_timeout e idle_session_timeout per PostgreSQL 14 e versioni successive. È inoltre consigliabile configurare i timeout lato client e lato server, come tcp_keepalives_idle, tcp_keepalives_interval e tcp_keepalives_count.
Nota: poiché questi parametri di timeout sono dinamici, non serve riavviare il database per apportare modifiche.
Configura i parametri in base alle esigenze. Ad esempio, puoi impostare i parametri ai seguenti livelli:
- A livello di singola istruzione per query specifiche
- A livello di utente per tutte le query di un utente specifico
- A livello di database per controllare il comportamento in un intero database
- A livello di gruppo di parametri dell'istanza per stabilire impostazioni globali
Nota: poiché un timeout breve annulla le query lunghe intenzionali, non impostare un timeout breve a livello di istanza o di database. Se imposti log_min_error_statement su ERROR o su un valore inferiore, Amazon RDS registra l'istruzione scaduta. Per ulteriori informazioni, consulta Statement behavior (Comportamento dell'istruzione) sul sito web PostgreSQL.
Informazioni correlate
- Argomenti
- Database
- Lingua
- Italiano
