PostgreSQL in Docker: Eine Schritt-für-Schritt-Anleitung für Anfänger

Einrichten von PostgreSQL in Docker

Das Einzige, was du brauchst, um die Postgres-Datenbank in Docker zu betreiben, ist die Docker-Engine selbst.

In diesem Abschnitt führe ich dich durch den Prozess, um die Voraussetzungen zu schaffen und eine voll funktionsfähige PostgreSQL-Datenbank in einem Docker-Container zu betreiben.

Voraussetzungen

Bevor du mit PostgreSQL in Docker loslegen kannst, musst du Docker auf deinem System installiert.

Die Installation variiert je nach Betriebssystem. Windows- und macOS-Nutzer können einfach DockerDesktop installieren, eine einfach zu bedienende grafische Oberfläche zur Verwaltung von Containern. Lade es von der offiziellen Docker-Website herunter.

Linux-Nutzer können die Docker Engine direkt über den Paketmanager ihrer Distribution installieren. Zum Beispiel unter Ubuntu:

sudo apt update
sudo apt install docker.io
sudo systemctl enable --now docker

Du solltest nicht nur Docker installiert haben, sondern auch mit den grundlegenden Terminalbefehlen und den grundlegenden Docker-Konzepten wie Images, Containern und Volumes vertraut sein. Diese praktischen Leitfäden von DataCamp helfen dir dabei:

• Docker für Einsteiger: Ein praktischer Leitfaden zu Containern
• Installiere Docker auf Ubuntu: Vom Aufbau zum ersten Container

Das PostgreSQL Docker-Image abrufen

Bevor du PostgreSQL ausführen kannst, musst du das offizielle PostgreSQL Docker-Image von Docker Hub herunterladen. Dieses Bild dient als Vorlage für die Erstellung von Containern.

Um das neueste PostgreSQL-Image zu ziehen, öffne dein Terminal oder die Eingabeaufforderung und führe es aus:

docker pull postgres

Dieser Befehl lädt die neueste stabile Version von PostgreSQL herunter. Wenn du eine bestimmte Version brauchst, kannst du sie mit einem Tag angeben:

docker pull postgres:17

Bild 1 - Ziehen der neuesten stabilen Version des PostgreSQL-Datenbank-Images

Einige häufig verwendete PostgreSQL-Bild-Tags sind:

• postgres:latest - Die neueste stabile PostgreSQL-Version
• postgres:17 - PostgreSQL Version 14.x (der neueste Patch von Version 17)
• postgres:17.4 - Eine bestimmte Version (in diesem Fall 17.4).
• postgres:bookworm - PostgreSQL basiert auf der Linux-Distribution Debian Bookworm.

Du kannst alle verfügbaren Tags auf der offiziellen PostgreSQL Docker Hub Seite einsehen.

PostgreSQL in einem Docker-Container ausführen

Sobald du das PostgreSQL-Image hast, kannst du mit einem einzigen Befehl einen Container erstellen und starten:

docker run --name postgres-db -e POSTGRES_PASSWORD=mypassword postgres

Abbildung 2 - Starten eines PostgreSQL-Containers

Dieser Befehl erstellt einen neuen Container namens postgres-db und setzt eine Umgebungsvariable für das PostgreSQL-Passwort.

Dieser grundlegende Befehl hat jedoch seine Grenzen. Ich empfehle, zusätzliche Optionen zu nutzen:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mypassword \
  -e POSTGRES_USER=myuser \
  -e POSTGRES_DB=mydatabase \
  -p 5432:5432 \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

Abbildung 3 - Starten eines PostgreSQL-Containers mit env-Variablen im Detached-Modus

Lass mich diese zusätzlichen Optionen aufschlüsseln:

• Umgebungsvariablen:
  • POSTGRES_PASSWORD: Setzt das Passwort für den PostgreSQL-Superuser (erforderlich).
  • POSTGRES_USER: Legt einen neuen Superuser mit diesem Namen an (der Standardwert ist "postgres", wenn er nicht angegeben wird).
  • POSTGRES_DB: Legt eine neue Datenbank mit diesem Namen an (der Standardwert ist der Benutzername, wenn er nicht angegeben wird).
• Das Port-Mapping (-p 5432:5432 ) ordnet den PostgreSQL-Port des Containers (5432) dem gleichen Port auf deinem Host-Rechner zu, sodass du dich über localhost:5432 mit PostgreSQL verbinden kannst.
• Volume Mounting (-v postgres-data:/var/lib/postgresql/data ) erstellt ein Docker-Volume namens postgres-data, das die Datenbankdateien außerhalb des Containers aufbewahrt. So ist sichergestellt, dass deine Daten nicht verloren gehen, wenn der Container anhält oder entfernt wird.
• Das -d Flag stellt sicher, dass der Container im losgelösten Modus läuft. Im Klartext bedeutet das, dass der Container im Hintergrund läuft.

Du kannst überprüfen, ob der Container läuft mit:

docker ps

Abbildung 4 - Auflistung aller laufenden Container

Im nächsten Abschnitt zeige ich dir, wie du deinen PostgreSQL-Container für bestimmte Anwendungsfälle weiter konfigurieren kannst.

PostgreSQL in Docker konfigurieren

Die Grundeinstellungen, die ich im vorherigen Abschnitt beschrieben habe, reichen für den Anfang aus, aber für fortgeschrittenere Aufgaben wirst du deinen PostgreSQL-Container wahrscheinlich anpassen wollen.

Darum geht es in diesem Abschnitt.

Einrichten von persistentem Speicher mit Volumes

Einer der wichtigsten Aspekte beim Betrieb einer Datenbank in Docker ist die Sicherstellung, dass deine Daten über den Lebenszyklus des Containers hinaus bestehen bleiben. Standardmäßig gehen alle Daten in einem Container verloren, wenn der Container entfernt wird. Bei einer Datenbank ist das selten das, was du willst.

Docker-Volumes bieten eine Lösung für dieses Problem, indem sie Daten außerhalb des Container-Dateisystems speichern.

Um es einzurichten, musst du zunächst ein benanntes Volume erstellen:

docker volume create postgres-data

Du kannst optional die Details des Volumes einsehen, indem du den folgenden Befehl ausführst:

docker volume inspect postgres-data

Abbildung 5 - Auflistung der Volumendetails

Wenn du nun deinen PostgreSQL-Container startest, mountest du das Volume in das PostgreSQL-Datenverzeichnis:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

Der Parameter -v postgres-data:/var/lib/postgresql/data verbindet das benannte Volume mit dem Datenverzeichnis des Containers.

Zusammenfassend lässt sich sagen, dass die Verwendung von Volumes für PostgreSQL diese Vorteile mit sich bringt:

• Deine Daten bleiben erhalten, auch wenn du den Container entfernst.
• Du kannst deinen Container stoppen, starten oder aktualisieren, ohne Daten zu verlieren.
• Du kannst Backups deiner Daten erstellen, indem du den Datenträger sicherst.
• Bessere Leistung im Vergleich zu Bind-Mounts (besonders unter macOS und Windows).

Freigeben von Ports zur Verbindung mit PostgreSQL

Um eine Verbindung zu deiner PostgreSQL-Datenbank von Anwendungen aus herzustellen, die auf deinem Host-Rechner laufen, musst du den PostgreSQL-Port (5432) für dein lokales System freigeben.

Die einfachste Methode ist, den Port 5432 des Containers auf denselben Port auf deinem Host zu mappen:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -p 5432:5432 \
  -d postgres

Der Parameter -p 5432:5432 ordnet den Port 5432 des Containers dem Port 5432 auf deinem Hostrechner zu.

Wenn du bereits PostgreSQL oder einen anderen Dienst hast, der Port 5432 auf deinem Host verwendet, kannst du einen anderen Port zuordnen:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -p 5433:5432 \
  -d postgres

Jetzt wird der Port 5432 des Containers auf Port 5433 auf deinem Host abgebildet. Wenn du eine Verbindung herstellst, musst du Port 5433 statt des Standardports 5432 angeben.

Standardmäßig ist der Port auf allen Netzwerkschnittstellen offen (0.0.0.0). Für zusätzliche Sicherheit kannst du sie optional auf localhost beschränken:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -p 127.0.0.1:5432:5432 \
  -d postgres

Dies erlaubt nur Verbindungen von deinem lokalen Rechner, nicht von anderen Rechnern im Netzwerk.

Konfigurieren der PostgreSQL-Einstellungen

Du kannst viele Standardeinstellungen von PostgreSQL ändern, wenn du deinen Container startest. Ein gängiger Ansatz, aber nicht der einzige, ist die Verwendung von Umgebungsvariablen.

Hier sind ein paar Variablen, die du zur Konfiguration der Datenbank verwenden kannst:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -e POSTGRES_USER=myuser \
  -e POSTGRES_DB=mydatabase \
  -e POSTGRES_INITDB_ARGS="--data-checksums" \
  -e POSTGRES_HOST_AUTH_METHOD=scram-sha-256 \
  -d postgres

Und hier ist, was jeder von ihnen tut:

• POSTGRES_PASSWORD: Legt das Superuser-Passwort fest (erforderlich).
• POSTGRES_USER: Legt den Superuser-Namen fest (Standardwert ist "postgres").
• POSTGRES_DB: Legt den Standarddatenbanknamen fest (standardmäßig der Benutzername).
• POSTGRES_INITDB_ARGS: Übergibt Argumente an den Befehl initdb von PostgreSQL.
• POSTGRES_HOST_AUTH_METHOD: Legt die Authentifizierungsmethode fest.

Zusätzlich zu den Umgebungsvariablen kannst du auch die PostgreSQL-Konfiguration anpassen, um erweiterte Änderungen an der Datenbankkonfiguration vorzunehmen.

Einige häufig angepasste PostgreSQL-Einstellungen sind:

• max_connections: Steuert, wie viele Verbindungen PostgreSQL akzeptiert (Standard ist 100).
• shared_buffers: Legt den für die Zwischenspeicherung verwendeten Speicher fest (die Standardeinstellung ist für die Produktion oft zu niedrig).
• work_mem: Speicher, der für Abfrageoperationen verwendet wird.
• maintenance_work_mem: Speicher, der für Wartungsarbeiten verwendet wird.

Für eine praktische Umsetzung erstellen wir zunächst eine Datei, nennen wir sie my-postgres-conf:

max_connections = 200
shared_buffers = 1GB
work_mem = 16MB
maintenance_work_mem = 256MB

Hänge diese Datei nun ein, wenn du den Container startest:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -v ./my-postgres.conf:/etc/postgresql/postgresql.conf \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres \
  -c 'config_file=/etc/postgresql/postgresql.conf'

Kurz gesagt: Wenn du die Persistenz, den Netzwerkzugriff und die PostgreSQL-Einstellungen richtig konfigurierst, kannst du eine Docker-basierte PostgreSQL-Umgebung erstellen, die genau so läuft, wie du willst. Das Basisbild von postgres:latest ist genau das - die Basis - es gibt eine Menge, was du verändern kannst.

Im nächsten Abschnitt zeige ich dir, wie du dich mit der PostgreSQL-Datenbank, die in Docker läuft, verbindest.

Verbinden mit PostgreSQL in Docker

Nachdem du deinen PostgreSQL-Container eingerichtet hast, ist der nächste Schritt, sich mit ihm zu verbinden. Warum würdest du sonst eine Datenbank betreiben?

In diesem Abschnitt zeige ich dir zwei Möglichkeiten, wie du dich mit deiner containerisierten PostgreSQL-Datenbank verbinden kannst: mit dem Kommandozeilen-Tool psql und mit einer grafischen Oberfläche.

Als Referenz führe ich meinen Datenbankcontainer mit diesem Befehl aus:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -e POSTGRES_USER=myuser \
  -e POSTGRES_DB=mydatabase \
  -v postgres-data:/var/lib/postgresql/data \
  -p 5432:5432 \
  -d postgres

Verbindung mit dem Befehlszeilentool psql

Das Befehlszeilentool psql ist der offizielle PostgreSQL-Client, mit dem du über SQL-Befehle mit der Datenbank interagieren kannst. 

Um dich von deinem Host-Rechner aus mit der PostgreSQL-Datenbank im Container zu verbinden, führe den folgenden Befehl aus, aber denke daran, die Benutzer- und Datenbankwerte zu aktualisieren:

docker exec -it postgres-db psql -U myuser -d mydatabase

Abbildung 6 - Verbindung zur Postgres-Datenbank mit psql

Und das war's!

Wenn du dir nicht sicher bist, was der Befehl bewirkt, findest du hier eine einfache Erklärung:

• docker exec -it postgres-db: Führe einen interaktiven Befehl innerhalb des Containers namens "postgres-db" aus.
• psql -U myuser -d mydatabase: Starte psql und verbinde dich als "myuser" mit der Datenbank "mydatabase".

Wenn du Probleme mit der Verbindung hast, überprüfe diese häufigen Probleme:

• Bestätige, dass der Container mit docker ps läuft.
• Überprüfe die Portzuordnung mit docker port postgres-db.

Verbinden mit einem GUI-Tool

Viele Entwickler bevorzugen die Verwendung eines grafischen Tools gegenüber einem CLI - so auch ich. pgAdmin ist eine beliebte und kostenlose Wahl für PostgreSQL, aber der Verbindungsprozess ist bei anderen Tools wie DBeaver, DataGrip oder TablePlus ähnlich.

Die Installation von pgAdmin ist ganz einfach, deshalb werde ich hier nicht darauf eingehen.

Angenommen, du hast es installiert und gestartet, dann klicke mit der rechten Maustaste auf "Server" im Browserfenster und wähle "Registrieren > Server". Auf der Registerkarte Allgemein gibst du deiner Verbindung einen Namen:

Abbildung 7 - pgAdmin allgemeiner Reiter

Wechsle dann zur Registerkarte "Verbindung" und gib diese Details ein:

• Name/Adresse des Gastgebers: localhost
• Port: 5432 (oder der Port, auf den du gemappt hast)
• Wartungsdatenbank: mydatabase
• Benutzername: myuser
• Passwort: Dein PostgreSQL-Passwort

Abbildung 8 - Registerkarte "pgAdmin-Verbindung

Zum Schluss klickst du auf "Speichern", um die Verbindung herzustellen:

Bild 9 - Erfolgreiche Verbindung

Sobald du verbunden bist, kannst du mit deiner Datenbank genauso arbeiten wie mit einer lokal installierten oder in der Cloud bereitgestellten PostgreSQL-Instanz. Das Schöne an Docker ist, dass es aus Sicht deiner Anwendung oder deines Kunden keinen Unterschied macht - es ist einfach eine PostgreSQL-Datenbank, die unter der angegebenen Adresse erreichbar ist.

>Brauchst du programmatischen Zugriff auf deine PostgreSQL-Datenbank? Hier erfährst du, wie du von Python aus darauf zugreifen kannst.

Im nächsten Abschnitt gehe ich darauf ein, wie du deinen PostgreSQL-Container verwaltest, d.h. wie du ihn stoppen, starten und überwachen kannst.

PostgreSQL in Docker verwalten

Es ist eine Sache, eine PostgreSQL-Datenbank in einem Container zu betreiben und sich mit ihr zu verbinden, aber die Verwaltung ist eine ganz andere Sache. Zum Glück gibt es eine Handvoll Befehle, die dir zur Verfügung stehen.

In diesem Abschnitt gehe ich auf wichtige Vorgänge ein, wie das Stoppen und Starten deines Containers, das Überprüfen von Logs und das Aktualisieren deiner PostgreSQL-Version.

Stoppen, Neustarten und Entfernen des PostgreSQL-Containers

Mit den Kommandozeilen-Tools von Docker kannst du den Lebenszyklus deines PostgreSQL-Containers verwalten.

Um einen laufenden PostgreSQL-Container anzuhalten, führe Folgendes aus:

docker stop postgres-db

Ebenso führst du den folgenden Befehl aus, wenn du ihn wieder starten musst:

docker start postgres-db

Abbildung 10 - Anhalten und Starten des Containers

Wenn du einen laufenden Container neu starten willst, was nach der Änderung bestimmter Konfigurationen nützlich sein kann, führe den folgenden Befehl aus:

docker restart postgres-db

In Fällen, in denen du mit einem Container fertig bist und ihn entfernen willstbrauchst du nur diese beiden Befehle zu befolgen:

docker stop postgres-db
docker rm postgres-db

Denke daran, dass das Entfernen eines Containers deine Daten nicht löscht, wenn du ein Volume richtig eingerichtet hast. Deine Daten befinden sich weiterhin auf dem zuvor erstellten postgres-data Volume.

Du kannst überprüfen, ob der Container entfernt wurde, indem du ihn ausführst:

docker ps -a

Das Flag -a zeigt alle Container an, auch die gestoppten. Wenn dein Container erfolgreich entfernt wurde, wird er nicht in dieser Liste erscheinen:

Abbildung 11 - Auflistung aller Container

Inspektion der Baumstämme

Wenn etwas schief läuft oder du deine Datenbankaktivitäten überwachen willst, ist die Überprüfung der Logs ein guter erster Schritt.

Führe diesen Befehl aus, um die Logs für deinen PostgreSQL-Container einzusehen:

docker logs postgres-db

Hier werden alle Logs seit dem Start des Containers angezeigt. Bei einer großen Menge an Logs möchtest du die Ausgabe vielleicht auf die letzten 50 Logs beschränken:

docker logs --tail 50 postgres-db

Abbildung 12 - Anzeige der Containerprotokolle

Wenn du hingegen die die Protokolle in Echtzeit verfolgen willstist dies der Befehl, den du ausführen solltest:

docker logs -f postgres-db

Abbildung 13 - Anzeige von Containerprotokollen in Echtzeit

Dies ist besonders nützlich, um Verbindungsprobleme zu beheben oder die Datenbankaktivitäten während der Entwicklung zu beobachten.

Drücke Ctrl+C/CMD+C, um die Verfolgung der Protokolle zu beenden.

PostgreSQL in Docker aktualisieren

Mit der Zeit wirst du deine PostgreSQL-Version aktualisieren wollen, um die neuesten Funktionen, Leistungsverbesserungen und Sicherheitspatches zu erhalten.

Zum Zeitpunkt der Erstellung dieses Artikels ist postgres:17.4 die neueste Version, aber nehmen wir theoretisch an, dass postgres:17.5 veröffentlicht wurde. Dieser Abschnitt zeigt dir, wie du die Datenbankversion in deinem Container aktualisieren kannst.

Um zu beginnen, ziehe das neueste PostgreSQL-Image (oder eine bestimmte Version):

docker pull postgres:17.5

Als Nächstes hältst du an und entfernst den vorhandenen Container:

docker stop postgres-db
docker rm postgres-db

Zum Schluss erstellst du einen neuen Container mit demselben Volumen:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -e POSTGRES_USER=myuser \
  -e POSTGRES_DB=mydatabase \
  -v postgres-data:/var/lib/postgresql/data \
  -p 5432:5432 \
  -d postgres:17.5

Da du das gleiche Volume verwendest (postgres-data), bleiben alle deine bestehenden Daten erhalten.

Wenn du ein Upgrade auf eine neue Version durchführst (z. B. von 17 auf 18), führt PostgreSQL beim Start automatisch alle notwendigen Datenmigrationen durch. Behalte diese Dinge einfach im Hinterkopf:

• Größere Versions-Upgrades sollten zuerst in einer Nicht-Produktionsumgebung getestet werden.
• Sichern Sie vor einem größeren Versions-Upgrade immer Ihr Datenvolumen.
• Überprüfe die PostgreSQL Versionshinweise auf alle wichtigen Änderungen.

An vor dem Upgrade ein Backup zu erstellenführen Sie den folgenden Befehl aus:

docker run --rm -v postgres-data:/data -v $(pwd):/backup postgres:17.4 \
  bash -c "pg_dumpall -U myuser > /backup/postgres_backup.sql"

Dadurch wird eine SQL-Sicherungsdatei in deinem aktuellen Verzeichnis erstellt, mit der du deine Daten wiederherstellen kannst, falls etwas schief geht.

>Unser Spickzettel zu den PostgreSQL-Grundlagen könnte dirundy als schnelle Referenz bei der Arbeit in Docker.

Im nächsten Abschnitt gehe ich auf die besten Praktiken für die Verwendung von PostgreSQL in Docker ein, einschließlich Sicherheitsüberlegungen und Optimierungstipps.

Best Practices für die Verwendung von PostgreSQL in Docker

Die Flexibilität von Docker ist mit Verantwortung verbunden. In diesem Abschnitt stelle ich dir einige Best Practices vor, mit denen du sicherstellen kannst, dass dein containerisiertes PostgreSQL-System zuverlässig und sicher ist und den Branchenstandards entspricht.

Halte deine Daten mit regelmäßigen Backups sicher

Unabhängig davon, wie du PostgreSQL betreibst, sind regelmäßige Backups ein Muss. Im vorigen Abschnitt habe ich bereits über Backups gesprochen, aber jetzt möchte ich noch einen draufsetzen. 

Der einfachste Weg, eine PostgreSQL-Datenbank in Docker zu sichern, ist die Verwendung von pg_dump:

docker exec -t postgres-db pg_dump -U myuser mydatabase > backup.sql

Abbildung 14 - PostgreSQL-Backup

Für ein vollständiges Backup aller Datenbanken, einschließlich Rollen und Tablespaces, verwendest du pg_dumpall:

docker exec -t postgres-db pg_dumpall -U myuser > full_backup.sql

Abbildung 15 - Vollständige Sicherung der PostgreSQL-Datenbank

Dieses Bild zeigt nur ein paar Sicherungsbefehle, da es nicht möglich ist, das Ganze auf den Bildschirm zu bringen.

An deine Backups zu automatisierenkannst du ein einfaches Shell-Skript erstellen und es mit cron ausführen:

#!/bin/bash
# backup.sh
TIMESTAMP=$(date +"%Y%m%d")
BACKUP_DIR="/Users/dradecic/Documents/pg-backups"

# Make sure the backup directory exists
mkdir -p $BACKUP_DIR

# Create the backup
docker exec postgres-db pg_dumpall -U myuser | gzip > $BACKUP_DIR/postgres_$TIMESTAMP.sql.gz

# Remove backups older than 30 days
find $BACKUP_DIR -name "postgres_*.sql.gz" -mtime +30 -delete

Mach das Skript ausführbar und führe es aus:

chmod +x backup.sh

bash backup.sh

Abbildung 16 - Ausführen eines PostgreSQL-Datenbank-Backup-Skripts

Um das Backup vollständig zu automatisieren, kannst du das Skript zu deiner crontab hinzufügen, damit es täglich ausgeführt wird:

0 3 * * * /path/to/backup.sh

Dieser Zeitplan lässt das Backup jeden Tag um 3 Uhr morgens laufen, aber natürlich kannst du den Zeitpunkt und die Häufigkeit nach deinem Bedarf anpassen. 

>Sieh dir meinen fLeitfaden über Cron-Jobs, um mehr über dieses nützliche Automatisierungstool zu erfahren.

Für Produktionsumgebungen, die Speicherung von Backups außerhalb des Standorts oder in der Cloud für Disaster Recovery in Betracht ziehen.

Benannte Volumes für die Datenpersistenz verwenden

Ich habe zwar schon kurz über die Bände gesprochen, aber es lohnt sich, sie noch einmal genauer zu betrachten.

Generell solltest du PostgreSQL nie ohne ein richtig konfiguriertes Volumein Docker ausführen. Wenn du das tust, gehen deine Daten verloren, wenn der Container entfernt wird oder wenn Docker Aufräumarbeiten durchführt.

Die Verwendung von benannten Volumes (anstelle von anonymen Volumes) macht die Datensicherung und -verwaltung viel einfacher:

# Create a named volume
docker volume create postgres-data

# Use it when running the container
docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

Das ist nichts Neues.

Benannte Volumes sind auch einfacher zu sichern. Um ein Backup des gesamten Datenträgers zu erstellen, führe den folgenden Befehl aus:

docker run --rm -v postgres-data:/data -v $(pwd):/backup alpine tar czf /backup/postgres-data-backup.tar.gz /data

Dadurch wird eine Datei postgres-data-backup.tar.gz in demselben Ordner erstellt, in dem du den Befehl ausgeführt hast.

Um dieses Volume wiederherzustellen, führe Folgendes aus:

docker run --rm -v postgres-data:/data -v $(pwd):/backup alpine sh -c "cd /data && tar xzf /backup/postgres-data-backup.tar.gz --strip 1"

Das war's!

PostgreSQL in Docker absichern

Wenn es um Datenbanken geht, sollte die Sicherheit nie ein nachträglicher Gedanke sein. In diesem Unterkapitel lernst du einige wichtige Praktiken zur Sicherung deines PostgreSQL-Containers kennen.

Verwende starke und einzigartige Passwörter

Vermeide voreingestellte oder schwache Passwörter. Erstelle ein sicheres, zufälliges Passwort für deinen PostgreSQL-Superuser:

export POSTGRES_PASSWORD=$(openssl rand -base64 32)
echo "$POSTGRES_PASSWORD" > postgres-password.txt

docker run --name postgres-db \
  -e POSTGRES_PASSWORD="$POSTGRES_PASSWORD" \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

Abbildung 17 - Verwendung eines sicheren Passworts

Bewahre dieses Passwort sicher auf, z. B. in einem Passwortmanager oder in einer Umgebungsvariablendatei, die nicht in die Versionskontrolle eingecheckt wird.

Netzwerkzugang einschränken

Standardmäßig stellt Docker den PostgreSQL-Port auf allen Schnittstellen zur Verfügung. Für mehr Sicherheit, vor allem in der Produktion, solltest du den Zugriff auf localhost beschränken:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -p 127.0.0.1:5432:5432 \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

Benutzerdefinierte PostgreSQL-Konfiguration verwenden

Erstelle eine sicherere PostgreSQL-Konfiguration, indem du Parameter wie die folgenden änderst:

# Require SSL
ssl = on
ssl_cert_file = '/etc/ssl/certs/ssl-cert-snakeoil.pem'
ssl_key_file = '/etc/ssl/private/ssl-cert-snakeoil.key'

# Limit connection attempts
max_connections = 100
authentication_timeout = 1min

# Restrict access
listen_addresses = 'localhost'

Hänge diese Konfigurationsdatei ein, wenn du deinen Container startest:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -v ./pg_hba.conf:/var/lib/postgresql/data/pg_hba.conf \
  -v ./postgresql.conf:/var/lib/postgresql/data/postgresql.conf \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

Aktualisiere regelmäßig dein PostgreSQL-Image

Halte deine PostgreSQL-Version auf dem neuesten Stand, um die neuesten Sicherheitspatches zu erhalten:

docker pull postgres:latest
docker stop postgres-db
docker rm postgres-db
# Then recreate with the latest image

Mit diesen Best Practices kannst du eine zuverlässigere und sicherere PostgreSQL-Umgebung in Docker erstellen, die sowohl für die Entwicklung als auch für die Produktion geeignet ist.

Im nächsten Abschnitt beschreibe ich, wie du häufige Probleme behebst, die beim Betrieb von PostgreSQL in Docker auftreten können.

Fehlersuche bei PostgreSQL in Docker

Früher oder später wirst du auf Probleme stoßen, wenn du PostgreSQL in Docker ausführst. In diesem Abschnitt gehe ich auf häufige Probleme und ihre Lösungen ein, die dir auf deinem Weg Zeit und Frustration ersparen werden.

Häufige Probleme mit PostgreSQL-Containern

Ein häufiges Problem, mit dem viele Nutzer konfrontiert sind, ist, dass ihr Container sofort nach dem Start vonbeendet wird. Wenn das bei dir der Fall ist, überprüfe die Logs, um das Problem zu identifizieren:

docker logs postgres-db

Dein Fehler könnte mit Berechtigungsproblemen bei gemounteten Volumeszusammenhängen . Wenn das der Fall ist, wirst du eine ähnliche Logmeldung sehen:

initdb: could not change permissions of directory "/var/lib/postgresql/data": Operation not permitted

Um dieses Problem zu lösen, überprüfe die Eigentümerschaft und die Berechtigungen deines Datenträgers und behebe es dann, falls nötig:

# Check the ownership
docker run --rm -v postgres-data:/data alpine ls -la /data

# Fix the permissions
docker run --rm -v postgres-data:/data alpine chmod 700 /data

Ein weiteres häufiges Problem ist das Fehlen der erforderlichen Umgebungsvariablen. Eine typische Log-Meldung, wenn das passiert, sieht so aus:

Database is uninitialized and superuser password is not specified

Um das Problem zu lösen, stelle sicher, dass du die erforderliche Umgebungsvariable POSTGRES_PASSWORD - oder eine andere Umgebungsvariable - setzt:

docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -v postgres-data:/var/lib/postgresql/data \
  -d postgres

Der Fehler "Datenverzeichnis nicht leer, aber fehlende PostgreSQL-Dateien" ist ebenfalls häufig. Das ist die Log-Meldung, die du wahrscheinlich sehen wirst:

PostgreSQL Database directory appears to contain a database; Skipping initialization

Gefolgt von Fehlermeldungen über fehlende Dateien.

Das passiert normalerweise, wenn du ein Volume gemountet hast, das zwar Dateien, aber keine gültige PostgreSQL-Datenbank enthält. Möglicherweise musst du die Initialisierung mit einem neuen Volume durchführen:

docker volume create postgres-data-new
docker run --name postgres-db \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -v postgres-data-new:/var/lib/postgresql/data \
  -d postgres

Behebung von Verbindungsproblemen

Wenn du keine Verbindung zu deiner PostgreSQL-Datenbank herstellen kannst, die in einem Container läuft, musst du zunächst Überprüfe, ob der Container läuft:

docker ps | grep postgres-db

Wenn sie nicht aufgelistet ist, ist sie vielleicht abgestürzt. Überprüfe die Protokolle wie oben beschrieben.

Wenn er aufgeführt ist, du aber trotzdem keine Verbindung herstellen kannst, überprüfe die Portzuordnung:

docker port postgres-db

Du solltest so etwas wie das hier sehen:

Abbildung 18 - Containerhafenkartierung

Wenn nicht, ist deine Portzuordnung möglicherweise falsch. Erstelle den Container mit der richtigen -p Option neu.

Wenn du dich immer noch nicht mit der Datenbank verbinden kannst, ist es an der Zeit, deine Verbindungseinstellungenzu überprüfen. Überprüfe diese Parameter:

• Hostname: localhost oder 127.0.0.1 (nicht der Containername).
• Hafen: Der Host-Port aus deinem Mapping (normalerweise 5432).
• Benutzername: Der Wert von POSTGRES_USER (Standard ist "postgres").
• Passwort: Der Wert von POSTGRES_PASSWORD.
• Datenbank: Der Wert von POSTGRES_DB (Standardwert ist derselbe wie POSTGRES_USER).

Versuche es noch einmal, nachdem du diese Fragen geklärt hast. Wenn das Problem weiterhin besteht, solltest du die Konnektivität innerhalb des Containers testen:

docker exec -it postgres-db psql -U postgres

Wenn das funktioniert, liegt das Problem bei deiner Portzuordnung oder deinem externen Netzwerk.

Schließlich kannst du auch nach Firewall-Problemen suchen. Möglicherweise blockiert die Firewall deines Systems die Verbindungen zum PostgreSQL-Port:

# Linux
sudo iptables -L | grep 5432

# macOS
sudo pfctl -sr | grep 5432

Wenn du diese häufigen Probleme überprüfst, solltest du in der Lage sein, die meisten Probleme mit PostgreSQL in Docker zu identifizieren und zu beheben. Wenn du immer noch nicht weiterkommst, sind die PostgreSQL- und Docker-Dokumentation und die Community-Foren hervorragende Ressourcen für eine genauere Fehlersuche.

Zusammenfassung der PostgreSQL Datenbank in Docker

Das ist die ultimative Anleitung zum Konfigurieren und Ausführen von PostgreSQL-Datenbanken in Docker! Ich habe alles behandelt, was du für den Einstieg wissen musst, von der Einrichtung deines ersten Containers bis zur Konfiguration, Verbindung und Verwaltung deiner Datenbank. 

Herkömmliche PostgreSQL-Optionen, wie die lokale Installation der Datenbank oder die Bereitstellung in der Cloud, sind für Entwicklungszwecke entweder suboptimal oder teuer. Docker schließt diese Lücke. Egal, ob du es für lokale Entwicklungs-, Test- oder sogar Produktionsumgebungen verwendest, PostgreSQL in Containern bietet eine unschlagbare Flexibilität und Konsistenz.

Du bist jetzt mehr als bereit, die Postgres-Datenbank mit Docker in deine Anwendungen zu integrieren.

Wenn du tiefer eintauchen willst, empfehle ich dir diese Kurse von DataCamp:

• PostgreSQL-Datenbanken erstellen
• Einführung in Docker
• SQL für Datenbankadministratoren
• Funktionen zur Bearbeitung von Daten in PostgreSQL