Einrichten von Alerts und Benachrichtigungen bei Problemen

Wir alle wollen über Probleme Bescheid wissen, bevor unser Server abstürzt oder das Leben der User schwer macht. PostgreSQL bringt Tools mit, um Benachrichtigungen zu erstellen und Tasks zu starten: pg_notify und pg_cron. Das sind quasi unser persönlicher Wecker und Task-Planer für die Datenbank.

Stell dir vor: Du hast eine Datenbank für einen Währungskurs-Kurs, und plötzlich blockiert ein Prozess alle anderen. Anstatt ständig manuell den Zustand der DB zu checken, kannst du Alerts einrichten, um immer im Bilde zu sein. Und für regelmäßige Checks des DB-Zustands ist pg_cron super praktisch. Das schauen wir uns jetzt genauer an.

Schnelle Benachrichtigungen aus der Datenbank: pg_notify

Starten wir mit pg_notify. Das ist eine eingebaute Funktion in PostgreSQL, mit der du eine Benachrichtigung aus der Datenbank an einen bestimmten "Kanal" schicken kannst. Du kannst sie nutzen, um auf Events wie das Ende von langen Queries, das Finden von Locks oder andere ungewöhnliche Situationen zu reagieren.

Der Syntax von pg_notify ist ziemlich simpel:

NOTIFY <channel>, <message>;

• channel — der Name des Kanals, an den die Benachrichtigung geschickt wird.
• message — ein String mit dem Benachrichtigungstext.

Hier ein Beispiel für pg_notify. Lass uns eine Benachrichtigung erstellen, wenn ein Lock entdeckt wird:

DO $$
BEGIN
    IF EXISTS (
        SELECT 1
        FROM pg_locks l
        JOIN pg_stat_activity a
        ON l.pid = a.pid
        WHERE NOT l.granted
    ) THEN
        PERFORM pg_notify('alerts', 'Sperre in der Datenbank!');
    END IF;
END $$;

Dieser Code prüft, ob es einen nicht freigegebenen Lock gibt, und schickt dann eine Benachrichtigung an den alerts-Kanal.

Um Benachrichtigungen zu empfangen, nutze den Befehl LISTEN in einer anderen Verbindung:

LISTEN alerts;

Jetzt, wenn pg_notify eine Nachricht an den alerts-Kanal schickt, siehst du die Benachrichtigung in der Konsole.

Beispiel:

NOTIFY alerts, 'Hey, hier gibt es eine Sperre!';

In der anderen Verbindung, wo LISTEN alerts läuft, bekommst du sofort:
NOTIFY: Hey, hier gibt es eine Sperre!

Der Einsatz von pg_notify ist nicht auf einfache Benachrichtigungen beschränkt. Du kannst es z.B. mit Triggern verbinden, um automatisch Alerts bei neuen, geänderten oder gelöschten Daten zu bekommen:

Benachrichtigung über neue Einträge

CREATE OR REPLACE FUNCTION notify_new_record()
RETURNS trigger AS $$
BEGIN
    PERFORM pg_notify('table_changes', 'Neuer Eintrag wurde zur Tabelle hinzugefügt!');
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER record_added
AFTER INSERT ON your_table
FOR EACH ROW EXECUTE FUNCTION notify_new_record();

Jetzt bekommst du jedes Mal eine Benachrichtigung, wenn ein neuer Eintrag in your_table landet.

Mehr zu Triggern und eingebauten Funktionen lernst du schon in ein paar Levels weiter :P

Typische Fehler und wie du sie vermeidest

Wenn du LISTEN nutzt, aber keine Benachrichtigungen siehst, check mal:

1. Arbeitest du in derselben Verbindung, aus der die Benachrichtigungen gesendet werden?
2. Ist der Kanalname korrekt geschrieben?
3. Hast du pg_notify innerhalb einer Transaktion aufgerufen, die auch wirklich mit COMMIT abgeschlossen wurde?

Task-Planer in PostgreSQL: pg_cron

pg_cron ist eine Erweiterung für PostgreSQL, mit der du Tasks nach Zeitplan ausführen kannst – wie der klassische cron in Linux. Du kannst z.B. regelmäßig Locks checken oder Statistiken sammeln lassen.

Tasks mit pg_cron erstellen

Jetzt, wo pg_cron installiert und bereit ist, erstellen wir einen Task, der jeden Tag alte Einträge aus der logs-Tabelle löscht.

SELECT cron.schedule('Löschen alter Logs',
'0 0 * * *',
$$ DELETE FROM logs WHERE created_at < NOW() - INTERVAL '30 days' $$);

Was passiert hier?

• '0 0 * * *' — das ist der Zeitplan (jeden Tag um Mitternacht).
• DELETE FROM logs ... — das ist das SQL-Statement, das cron ausführt.

Tasks anzeigen

Um alle Tasks zu sehen, die über pg_cron laufen, benutze:

SELECT * FROM cron.job;

Tasks deaktivieren

Du kannst einen Task so ausschalten:

SELECT cron.unschedule(jobid);

Wobei jobid die ID des Tasks ist. Die findest du in der Tabelle cron.job.

Nützliche Beispiele mit pg_cron

Regelmäßiges Prüfen aktiver Queries

Wir erstellen einen Task, der alle 5 Minuten nach lang laufenden Queries sucht:

SELECT cron.schedule('Prüfen langer Queries',
'*/5 * * * *',
$$ SELECT pid, query, state
    FROM pg_stat_activity
    WHERE state = 'active'
        AND now() - query_start > INTERVAL '5 minutes' $$);

Dieser Task sucht nach Queries, die länger als 5 Minuten laufen.

Integration mit externen Systemen

Sowohl pg_notify als auch pg_cron lassen sich mit externen Systemen wie Slack, Telegram oder Monitoring-Tools (z.B. Prometheus) verbinden.

Telegram

Du kannst pg_notify mit einem Telegram-Bot kombinieren, um Benachrichtigungen zu verschicken. Die Grundidee: Ein Python-Skript (oder in einer anderen Sprache), das Benachrichtigungen empfängt und an Telegram weiterleitet.

Hier ein einfaches Python-Bot-Beispiel:

import psycopg2
import telegram

# Verbindung zu PostgreSQL
conn = psycopg2.connect("dbname=your_database user=your_user")

# Telegram-Bot erstellen
bot = telegram.Bot(token='your_telegram_bot_token')

# Cursor zum Lauschen öffnen
conn.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)
cur = conn.cursor()
cur.execute("LISTEN alerts;")

# Benachrichtigungen empfangen
print("Lausche auf Benachrichtigungen...")
while True:
    conn.poll()
    while conn.notifies:
        notify = conn.notifies.pop()
        print("Benachrichtigung erhalten:", notify.payload)
        bot.send_message(chat_id='your_chat_id', text=notify.payload)

Jetzt bekommt dein Bot alle Benachrichtigungen, die über pg_notify geschickt werden.

Wann pg_notify und pg_cron nutzen?

Nutze pg_notify für sofortige Reaktionen (z.B. Admin bei Locks benachrichtigen).

Nutze pg_cron für regelmäßige Tasks (Query-Aktivität prüfen, alte Daten löschen).

Hinweise und Stolperfallen

pg_notify schickt Benachrichtigungen sofort, speichert aber keine Historie. Am besten kombinierst du es mit File-Logs oder externen Systemen.

pg_cron kann für unerwartete Last sorgen, wenn Tasks zu oft laufen. Teste deine Queries immer, bevor du sie in den Zeitplan packst.

Jetzt bist du bereit, dein Monitoring zu optimieren und das Datenbank-Management zu automatisieren. Los geht's – Alerts einrichten und nicht nur SQL-Programmierer, sondern richtiger DBA werden!