PostgreSQL auf Ubuntu: Installation, Konfiguration und Leistungsoptimierung

28. Januar 2026

14 Min. Lesezeit

Aktuell

PostgreSQL ist das fortschrittlichste relationale Open-Source-Datenbanksystem im produktiven Einsatz heute. Von Organisationen von Startups bis zu Großunternehmen vertraut, betreibt es alles von kleinen Webanwendungen bis hin zu massiven Data-Warehousing-Systemen, die Milliarden von Zeilen verarbeiten. Diese Anleitung führt Sie durch die Installation von PostgreSQL auf Ubuntu Server, die Konfiguration für den Produktionseinsatz, die Einrichtung von Authentifizierung und Fernzugriff, die Implementierung von Backup-Strategien und die Optimierung von Leistungsparametern für optimalen Durchsatz.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie haben:

Ubuntu Server 20.04, 22.04 oder 24.04 LTS
Terminalzugang mit sudo-Berechtigungen
Mindestens 1 GB RAM (2 GB oder mehr für Produktion empfohlen)
Grundlegende Vertrautheit mit SQL und Linux-Kommandozeilenoperationen
Eine konfigurierte Firewall (siehe unsere UFW-Anleitung für die Einrichtung)

Was ist PostgreSQL?

PostgreSQL (oft “Postgres” genannt) ist ein objekt-relationales Datenbankmanagementsystem (ORDBMS), das seit über 35 Jahren aktiv entwickelt wird. Ursprünglich an der University of California, Berkeley entwickelt, wird es jetzt von einer globalen Gemeinschaft von Beitragenden gepflegt.

Schlüsselmerkmale von PostgreSQL:

ACID-konform — vollständige Unterstützung für Atomarität, Konsistenz, Isolation und Dauerhaftigkeit
MVCC (Multi-Version Concurrency Control) — Leser blockieren niemals Schreiber und Schreiber blockieren niemals Leser
Erweiterbar — benutzerdefinierte Datentypen, Operatoren, Funktionen und Indexmethoden
Standardkonform — die nächste Implementierung zum SQL-Standard unter allen Datenbanken
Erweiterte Funktionen — JSON/JSONB, Volltextsuche, Tabellenpartitionierung, logische Replikation, CTEs, Fensterfunktionen
Robuste Sicherheit — Sicherheit auf Zeilenebene, SSL/TLS, mehrere Authentifizierungsmethoden

Installation von PostgreSQL auf Ubuntu

Option 1: Aus den Ubuntu-Repositories installieren

Der einfachste Ansatz verwendet die Standard-Ubuntu-Pakete:

sudo apt update
sudo apt install postgresql postgresql-contrib

Dies installiert die mit Ihrer Ubuntu-Version gebündelte Version (PostgreSQL 14 auf 22.04, PostgreSQL 16 auf 24.04).

Option 2: Die neueste Version aus dem offiziellen Repository installieren

Um die neueste PostgreSQL-Version (Version 17 zum Zeitpunkt der Erstellung) zu erhalten, fügen Sie das offizielle PostgreSQL-APT-Repository hinzu:

sudo apt install -y gnupg2 wget
sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo gpg --dearmor -o /usr/share/keyrings/postgresql-archive-keyring.gpg

Aktualisieren Sie die Repository-Referenzen in der Quellenliste, um den signierten Schlüsselring zu verwenden:

sudo sed -i 's|deb http://apt.postgresql.org|deb [signed-by=/usr/share/keyrings/postgresql-archive-keyring.gpg] http://apt.postgresql.org|' /etc/apt/sources.list.d/pgdg.list
sudo apt update
sudo apt install -y postgresql-17 postgresql-contrib-17

Installation überprüfen

Nach der Installation startet PostgreSQL automatisch. Überprüfen Sie, ob es läuft:

sudo systemctl status postgresql

Überprüfen Sie die installierte Version:

psql --version

Erwartete Ausgabe:

psql (PostgreSQL) 17.x

Erstkonfiguration

PostgreSQL speichert seine Konfiguration in zwei Hauptdateien. Auf Ubuntu befinden sich diese unter /etc/postgresql/<version>/main/.

postgresql.conf — Serverkonfiguration

Diese Datei steuert das Serververhalten, Leistungseinstellungen, Protokollierung und Verbindungsparameter:

sudo nano /etc/postgresql/17/main/postgresql.conf

Wichtige Einstellungen zur sofortigen Überprüfung:

# Verbindungseinstellungen
listen_addresses = 'localhost'    # Ändern zu '*' oder spezifischer IP für Fernzugriff
port = 5432                       # Standard-PostgreSQL-Port
max_connections = 100             # Maximale gleichzeitige Verbindungen

# Speichereinstellungen (anpassen basierend auf Server-RAM)
shared_buffers = 256MB            # Beginnen mit 25% des gesamten RAM
work_mem = 4MB                    # Sortierspeicher pro Operation
maintenance_work_mem = 128MB      # Für VACUUM, CREATE INDEX

# Write-Ahead Logging
wal_level = replica               # Aktiviert Replikation und PITR
max_wal_size = 1GB
min_wal_size = 80MB

# Protokollierung
logging_collector = on
log_directory = 'log'
log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'
log_statement = 'ddl'             # DDL-Anweisungen protokollieren
log_min_duration_statement = 1000 # Abfragen protokollieren, die länger als 1 Sekunde dauern

pg_hba.conf — Client-Authentifizierung

Diese Datei steuert, wer sich verbinden kann, von wo und wie sie sich authentifizieren:

sudo nano /etc/postgresql/17/main/pg_hba.conf

Die Standardkonfiguration sieht typischerweise so aus:

# TYPE  DATABASE  USER      ADDRESS         METHOD
local   all       postgres                  peer
local   all       all                       peer
host    all       all       127.0.0.1/32    scram-sha-256
host    all       all       ::1/128         scram-sha-256

Nach Änderungen an einer der Dateien starten Sie PostgreSQL neu:

sudo systemctl restart postgresql

Oder laden Sie neu ohne Neustart (für die meisten pg_hba.conf-Änderungen):

sudo systemctl reload postgresql

Authentifizierungsmethoden

PostgreSQL unterstützt mehrere Authentifizierungsmethoden. Ihr Verständnis ist essentiell für die Absicherung Ihrer Datenbank.

peer-Authentifizierung

Ordnet den Betriebssystem-Benutzernamen einer PostgreSQL-Rolle zu. Wenn Sie als postgres-Systembenutzer angemeldet sind, können Sie sich ohne Passwort mit der postgres-Datenbankrolle verbinden:

sudo -u postgres psql

Dies ist der Standard für lokale Unix-Socket-Verbindungen und ist sicher, da es auf der Betriebssystem-Authentifizierung basiert.

md5-Authentifizierung

Verwendet MD5-gehashte Passwörter. Obwohl noch funktional, gilt es als veraltet:

host    all    all    192.168.1.0/24    md5

scram-sha-256-Authentifizierung (Empfohlen)

Die sicherste passwortbasierte Methode, die den SCRAM-SHA-256-Challenge-Response-Mechanismus verwendet:

host    all    all    192.168.1.0/24    scram-sha-256

Um sicherzustellen, dass neue Passwörter SCRAM-SHA-256 verwenden, setzen Sie dies in postgresql.conf:

password_encryption = scram-sha-256

Wichtig: Wenn Sie von md5 zu scram-sha-256 wechseln, müssen bestehende Benutzerpasswörter zurückgesetzt werden, da das gespeicherte Hash-Format unterschiedlich ist.

Erstellen von Datenbanken und Benutzern

Verbinden Sie sich mit PostgreSQL als Superuser:

sudo -u postgres psql

Neue Rolle (Benutzer) erstellen

CREATE ROLE appuser WITH LOGIN PASSWORD 'StrongPassword123!';

Spezifische Fähigkeiten gewähren:

ALTER ROLE appuser CREATEDB;

Datenbank erstellen

CREATE DATABASE myappdb OWNER appuser;

Oder von der Kommandozeile:

sudo -u postgres createdb -O appuser myappdb

Berechtigungen gewähren

GRANT ALL PRIVILEGES ON DATABASE myappdb TO appuser;

Für genauere Kontrolle über Schemas und Tabellen:

\c myappdb
GRANT USAGE ON SCHEMA public TO appuser;
GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO appuser;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO appuser;

Als neuer Benutzer verbinden

psql -U appuser -d myappdb -h localhost

Fernzugriffskonfiguration

Standardmäßig akzeptiert PostgreSQL nur Verbindungen von localhost. Um den Fernzugriff zu aktivieren:

Schritt 1: listen_addresses aktualisieren

Bearbeiten Sie postgresql.conf:

listen_addresses = '*'

Oder beschränken Sie auf eine bestimmte Schnittstelle:

listen_addresses = '192.168.1.10'

Schritt 2: pg_hba.conf-Eintrag hinzufügen

Ein bestimmtes Subnetz erlauben:

host    myappdb    appuser    192.168.1.0/24    scram-sha-256

Einen einzelnen Host erlauben:

host    all    all    10.0.0.50/32    scram-sha-256

Schritt 3: Firewall konfigurieren

Erlauben Sie PostgreSQL durch UFW:

sudo ufw allow from 192.168.1.0/24 to any port 5432

Oder erlauben Sie von überall (nicht empfohlen für Produktion):

sudo ufw allow 5432/tcp

Schritt 4: Neustart und Test

sudo systemctl restart postgresql

Testen Sie vom entfernten Rechner:

psql -h 192.168.1.10 -U appuser -d myappdb

Wesentliche psql-Befehle

Das interaktive psql-Terminal ist das primäre Werkzeug für die Arbeit mit PostgreSQL. Hier sind die Befehle, die Sie täglich verwenden werden:

Verbinden

# Als postgres-Superuser verbinden
sudo -u postgres psql

# Mit einer bestimmten Datenbank verbinden
psql -U appuser -d myappdb -h localhost

# Mit einer Verbindungszeichenfolge verbinden
psql "postgresql://appuser:password@localhost:5432/myappdb"

-- Alle Datenbanken auflisten
\l

-- Mit einer anderen Datenbank verbinden
\c myappdb

-- Alle Tabellen im aktuellen Schema auflisten
\dt

-- Tabellenstruktur beschreiben
\d tablename

-- Alle Schemas auflisten
\dn

-- Alle Rollen/Benutzer auflisten
\du

-- Aktuelle Verbindungsinformationen anzeigen
\conninfo

Abfrageausführung

-- Eine Abfrage ausführen
SELECT * FROM users LIMIT 10;

-- Erweiterte Anzeige für breite Tabellen aktivieren
\x auto

-- Abfrageausführungszeit messen
\timing on

-- Eine SQL-Datei ausführen
\i /path/to/script.sql

-- Abfrageausgabe in eine Datei speichern
\o /tmp/output.txt
SELECT * FROM users;
\o

Beenden

-- psql beenden
\q

Sicherung und Wiederherstellung

Eine solide Backup-Strategie ist für Produktionsdatenbanken nicht verhandelbar.

pg_dump — Logische Backups

Eine einzelne Datenbank exportieren:

# SQL-Format (menschenlesbar)
sudo -u postgres pg_dump myappdb > /backups/myappdb_$(date +%Y%m%d).sql

# Benutzerdefiniertes Format (komprimiert, unterstützt parallele Wiederherstellung)
sudo -u postgres pg_dump -Fc myappdb > /backups/myappdb_$(date +%Y%m%d).dump

# Nur bestimmte Tabellen
sudo -u postgres pg_dump -t users -t orders myappdb > /backups/tables_$(date +%Y%m%d).sql

Alle Datenbanken exportieren:

sudo -u postgres pg_dumpall > /backups/all_databases_$(date +%Y%m%d).sql

pg_restore — Backups wiederherstellen

Aus benutzerdefiniertem Format wiederherstellen:

sudo -u postgres pg_restore -d myappdb /backups/myappdb_20260128.dump

Mit parallelen Jobs für schnellere Wiederherstellung:

sudo -u postgres pg_restore -j 4 -d myappdb /backups/myappdb_20260128.dump

Aus SQL-Format wiederherstellen:

sudo -u postgres psql myappdb < /backups/myappdb_20260128.sql

pg_basebackup — Physische Backups

Für Point-in-Time-Recovery (PITR) und Replikationseinrichtung:

sudo -u postgres pg_basebackup -D /backups/base -Ft -Xs -P

Optionen erklärt:

-D — Zielverzeichnis
-Ft — Tar-Format
-Xs — WAL-Dateien während des Backups streamen
-P — Fortschritt anzeigen

Automatisiertes Backup-Skript

Erstellen Sie einen Cron-Job für tägliche Backups:

sudo nano /usr/local/bin/pg_backup.sh

#!/bin/bash
BACKUP_DIR="/backups/postgresql"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
RETENTION_DAYS=30

mkdir -p "$BACKUP_DIR"

# Alle Datenbanken im benutzerdefinierten Format exportieren
for DB in $(sudo -u postgres psql -At -c "SELECT datname FROM pg_database WHERE datistemplate = false AND datname != 'postgres';"); do
    sudo -u postgres pg_dump -Fc "$DB" > "$BACKUP_DIR/${DB}_${TIMESTAMP}.dump"
done

# Backups älter als die Aufbewahrungsfrist löschen
find "$BACKUP_DIR" -name "*.dump" -mtime +$RETENTION_DAYS -delete

echo "Backup completed: $TIMESTAMP"

sudo chmod +x /usr/local/bin/pg_backup.sh
sudo crontab -e

Fügen Sie den Cron-Eintrag hinzu:

0 2 * * * /usr/local/bin/pg_backup.sh >> /var/log/pg_backup.log 2>&1

Leistungsoptimierung

Die PostgreSQL-Leistung hängt stark von einer ordnungsgemäßen Konfiguration ab. Die Standardeinstellungen sind konservativ und für minimale Hardware ausgelegt.

shared_buffers

Der wichtigste Speicherparameter. Legt fest, wie viel Speicher PostgreSQL zum Zwischenspeichern von Datenblöcken verwendet:

# Empfohlen: 25% des gesamten System-RAM
# Für einen Server mit 16 GB RAM:
shared_buffers = 4GB

work_mem

Speicher, der für jede Sortieroperation, jeden Hash-Join oder ähnliche Operation zugewiesen wird. Vorsicht — dies ist pro Operation, nicht pro Verbindung:

# Für OLTP-Arbeitslasten mit vielen Verbindungen:
work_mem = 4MB

# Für analytische Abfragen mit weniger Verbindungen:
work_mem = 64MB

effective_cache_size

Teilt dem Abfrageplaner mit, wie viel Speicher für das Caching verfügbar ist (Betriebssystem-Cache + shared_buffers). Dies reserviert keinen Speicher — es beeinflusst nur die Abfrageplanung:

# Empfohlen: 50-75% des gesamten System-RAM
# Für einen Server mit 16 GB RAM:
effective_cache_size = 12GB

WAL-Konfiguration

Write-Ahead-Logging-Einstellungen beeinflussen die Schreibleistung erheblich:

# Checkpoint-Einstellungen
checkpoint_completion_target = 0.9
max_wal_size = 2GB
min_wal_size = 1GB

# Für schreibintensive Arbeitslasten
wal_buffers = 64MB
synchronous_commit = on          # Nur auf 'off' setzen, wenn minimaler Datenverlust tolerierbar ist

Verbindungen und Parallelismus

# Maximale Verbindungen (jede verbraucht ~10MB RAM)
max_connections = 200

# Parallele Abfrageausführung
max_parallel_workers_per_gather = 2
max_parallel_workers = 4
max_worker_processes = 8

Nach der Optimierung

Wenden Sie die Änderungen durch Neustart von PostgreSQL an:

sudo systemctl restart postgresql

Überprüfen Sie die Einstellungen:

SHOW shared_buffers;
SHOW work_mem;
SHOW effective_cache_size;

Überwachung mit pg_stat_activity

Die View pg_stat_activity liefert Echtzeitinformationen über alle aktiven Verbindungen und Abfragen.

Aktive Abfragen anzeigen

SELECT pid, usename, datname, state, query, query_start,
       now() - query_start AS duration
FROM pg_stat_activity
WHERE state = 'active'
ORDER BY duration DESC;

Lang laufende Abfragen finden

SELECT pid, usename, datname, query,
       now() - query_start AS duration
FROM pg_stat_activity
WHERE state = 'active'
  AND now() - query_start > interval '5 minutes';

Abfrage abbrechen oder beenden

-- Elegantes Abbrechen (sendet SIGINT)
SELECT pg_cancel_backend(12345);

-- Erzwungene Beendigung (sendet SIGTERM)
SELECT pg_terminate_backend(12345);

Datenbankstatistiken

-- Statistiken auf Datenbankebene
SELECT datname, numbackends, xact_commit, xact_rollback,
       blks_read, blks_hit,
       round(blks_hit::numeric / (blks_read + blks_hit) * 100, 2) AS cache_hit_ratio
FROM pg_stat_database
WHERE datname = 'myappdb';

Tabellenstatistiken

-- Tabellenzugriffsstatistiken
SELECT relname, seq_scan, idx_scan, n_tup_ins, n_tup_upd, n_tup_del, n_live_tup
FROM pg_stat_user_tables
ORDER BY seq_scan DESC;

Sperrüberwachung

-- Aktuelle Sperren anzeigen
SELECT pid, locktype, relation::regclass, mode, granted
FROM pg_locks
WHERE NOT granted;

psql-Befehlsreferenztabelle

Befehl	Beschreibung
`\l`	Alle Datenbanken auflisten
`\c dbname`	Mit einer Datenbank verbinden
`\dt`	Tabellen im aktuellen Schema auflisten
`\dt+`	Tabellen mit Größen auflisten
`\d tablename`	Eine Tabelle beschreiben
`\di`	Indizes auflisten
`\dv`	Views auflisten
`\df`	Funktionen auflisten
`\du`	Rollen/Benutzer auflisten
`\dn`	Schemas auflisten
`\dp`	Tabellenzugriffsrechte auflisten
`\x`	Erweiterte Anzeige umschalten
`\timing`	Abfragezeitmessung umschalten
`\i file.sql`	Eine SQL-Datei ausführen
`\o file.txt`	Ausgabe in Datei senden
`\e`	Abfrage im Editor öffnen
`\copy`	Client-seitiger COPY-Befehl
`\password`	Benutzerpasswort ändern
`\conninfo`	Verbindungsinformationen anzeigen
`\q`	psql beenden

Fehlerbehebung

PostgreSQL startet nicht

Überprüfen Sie die Protokolle auf Fehler:

sudo journalctl -u postgresql -n 50
sudo cat /var/log/postgresql/postgresql-17-main.log

Häufige Ursachen:

Port 5432 wird bereits von einer anderen Instanz verwendet
Beschädigte Konfigurationsdateien (Syntaxfehler in postgresql.conf)
Unzureichender gemeinsamer Speicher — überprüfen Sie den Wert von shared_buffers

Verbindung abgelehnt

Wenn Sie psql: error: connection refused erhalten:

# Überprüfen, ob PostgreSQL läuft
sudo systemctl status postgresql

# Überprüfen, auf welcher Adresse und welchem Port gelauscht wird
sudo ss -tlnp | grep 5432

# Überprüfen, ob pg_hba.conf Ihre Verbindung erlaubt
sudo cat /etc/postgresql/17/main/pg_hba.conf

Authentifizierung fehlgeschlagen

FATAL: password authentication failed for user "appuser"

Überprüfen Sie das Passwort und die Authentifizierungsmethode:

# Authentifizierungsmethode in pg_hba.conf überprüfen
sudo grep -v '^#' /etc/postgresql/17/main/pg_hba.conf | grep -v '^$'

# Passwort über peer-Authentifizierung zurücksetzen
sudo -u postgres psql -c "ALTER USER appuser PASSWORD 'NewPassword123!';"

Langsame Abfragen

Aktivieren Sie die Protokollierung langsamer Abfragen:

# In postgresql.conf
log_min_duration_statement = 500  # Abfragen protokollieren, die länger als 500ms dauern

Verwenden Sie EXPLAIN ANALYZE zur Diagnose:

EXPLAIN ANALYZE SELECT * FROM orders WHERE customer_id = 42;

Suchen Sie nach sequentiellen Scans auf großen Tabellen und fügen Sie bei Bedarf Indizes hinzu:

CREATE INDEX idx_orders_customer_id ON orders(customer_id);

Speicherplatzprobleme

Überprüfen Sie die Datenbankgrößen:

SELECT pg_database.datname,
       pg_size_pretty(pg_database_size(pg_database.datname)) AS size
FROM pg_database
ORDER BY pg_database_size(pg_database.datname) DESC;

Finden Sie die größten Tabellen:

SELECT relname, pg_size_pretty(pg_total_relation_size(relid)) AS total_size
FROM pg_catalog.pg_statio_user_tables
ORDER BY pg_total_relation_size(relid) DESC
LIMIT 10;

Führen Sie VACUUM aus, um Speicherplatz zurückzugewinnen:

sudo -u postgres vacuumdb --all --analyze

Zusammenfassung

PostgreSQL ist eine leistungsstarke, produktionsreife Datenbank, die eine ordnungsgemäße Konfiguration belohnt. In dieser Anleitung haben Sie gelernt, wie Sie PostgreSQL aus dem offiziellen Repository installieren, die Authentifizierung mit scram-sha-256 konfigurieren, Datenbanken und Rollen erstellen, den Fernzugriff sicher aktivieren, Backup-Strategien mit pg_dump und pg_basebackup implementieren, Leistungsparameter für Ihre Hardware optimieren und die Datenbankaktivität mit pg_stat_activity überwachen.

Für einen umfassenden Ansatz zur Serverhärtung kombinieren Sie diese Konfiguration mit einer ordnungsgemäß konfigurierten Firewall — siehe unsere UFW-Firewall-Anleitung für detaillierte Anweisungen. Sie sollten auch unsere Linux-Server-Sicherheitscheckliste überprüfen, um sicherzustellen, dass Ihr gesamter Server-Stack die bewährten Sicherheitspraktiken von der Betriebssystemebene an befolgt.

Nächste Schritte zu berücksichtigen:

Streaming-Replikation für Hochverfügbarkeit einrichten
Verbindungspooling mit PgBouncer für Hochlast-Anwendungen implementieren
SSL/TLS-Verbindungen für verschlüsselte Client-Server-Kommunikation konfigurieren
Logische Replikation für Migrationen ohne Ausfallzeit erkunden

Frequently Asked Questions

Was ist der Unterschied zwischen PostgreSQL und MySQL?

PostgreSQL ist ein fortschrittliches objekt-relationales Datenbanksystem, das Standardkonformität, Erweiterbarkeit und Datenintegrität betont. Es unterstützt komplexe Abfragen, JSON, Volltextsuche und erweiterte Indizierung. MySQL ist einfacher und traditionell schneller für leseintensive Arbeitslasten, aber PostgreSQL zeichnet sich bei komplexen Transaktionen, gleichzeitigen Schreibvorgängen und Datengenauigkeit aus. PostgreSQL ist die bevorzugte Wahl für Anwendungen, die ACID-Konformität und erweiterte SQL-Funktionen erfordern.

Wie setze ich das Passwort des postgres-Benutzers zurück?

Wechseln Sie zum postgres-Systembenutzer mit 'sudo -u postgres psql', dann führen Sie ALTER USER postgres PASSWORD 'neuespasswort'; im psql-Prompt aus. Wenn Sie vollständig ausgesperrt sind, bearbeiten Sie pg_hba.conf, um die Authentifizierungsmethode vorübergehend auf 'trust' für lokale Verbindungen zu setzen, starten Sie PostgreSQL neu, ändern Sie das Passwort, setzen Sie dann pg_hba.conf auf 'scram-sha-256' zurück und starten Sie erneut neu.

Akzeptiert PostgreSQL standardmäßig Fernverbindungen?

Nein. Standardmäßig lauscht PostgreSQL nur auf localhost (127.0.0.1). Um Fernverbindungen zu aktivieren, müssen Sie listen_addresses in postgresql.conf auf die Server-IP oder '*' für alle Schnittstellen ändern und einen entsprechenden Eintrag in pg_hba.conf hinzufügen, um den Remote-Host oder das Subnetz zuzulassen. Eine Firewall-Regel, die Port 5432 erlaubt, ist ebenfalls erforderlich.

Was ist die empfohlene Backup-Strategie für PostgreSQL?

Für kleine bis mittlere Datenbanken verwenden Sie pg_dump für logische Backups, die SQL- oder benutzerdefinierte Formatdateien erzeugen. Für große Produktionsdatenbanken verwenden Sie pg_basebackup für physische Basis-Backups kombiniert mit WAL-Archivierung für Point-in-Time-Recovery (PITR). Automatisieren Sie Backups mit cron, speichern Sie sie extern und testen Sie Wiederherstellungen regelmäßig. Das benutzerdefinierte Format (-Fc) wird für pg_dump bevorzugt, da es parallele Wiederherstellung und selektive Tabellenwiederherstellung unterstützt.