Postgres in Docker – ein praktischer Leitfaden

Wenn du eine Anwendung baust, die in Produktion PostgreSQL zur Datenspeicherung nutzt, musst du PostgreSQL früher oder später wahrscheinlich auch zur Entwicklung auf deinem lokalen Rechner betreiben.

Manchmal kann man in der Entwicklung etwas wie SQLite und in Produktion Postgres verwenden, aber sobald du es mit deiner App ernst meinst, willst du, dass deine Umgebungen übereinstimmen.

Postgres-Docker-Beispiel für die lokale Entwicklung

Ich nutze lieber docker-compose statt der Docker-CLI, aber die Entscheidung liegt bei dir. Ich zeige hier beides.

Ich empfehle, das hier verwendete Image auf dieselbe Version zu ändern, die du in Produktion nutzt, zum Beispiel postgres:9.4 statt postgres:latest.

PostgreSQL mit der Docker-CLI

docker run -d \
  --name psql \
  -e POSTGRES_USER=postgres \
  -e POSTGRES_PASSWORD=example \
  -v psql:/var/lib/postgresql/data \
  -p 5555:5432 \
  postgres:latest

Damit startest du deinen PostgreSQL-Server, der dann unter localhost:5555 erreichbar ist. Pack das in ein Skript wie dev/postgres und starte es immer, wenn du deine App startest.

PostgreSQL mit Docker Compose

Ich bevorzuge Docker Compose, weil man damit die Datenbankkonfiguration leicht ändern und bei Bedarf weitere Dienste (z. B. Redis) hinzufügen kann.

version: '3'
volumes:
  psql:
services:
  psql:
    image: postgres:latest
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: example # only do this in development
    volumes:
      - psql:/var/lib/postgresql/data # save data between restarts
    ports:
      - 5555:5432 # binds port 5555 on your computer to the postgres port!

Auch hier ist deine Entwicklungsdatenbank unter localhost:5555 erreichbar

Empfehlungen für die lokale Postgres-Entwicklung

Wir empfehlen, Postgres für die Entwicklung folgendermaßen zu verwalten:

1. Achte darauf, das offizielle Postgres-Image zu verwenden.
2. Speichere deine Postgres-Konfiguration in einer Docker-Compose-Datei (ein Beispiel findest du unten).
3. Checke die Docker-Compose-Datei zusammen mit dem Quellcode deines Projekts in die Versionsverwaltung (z. B. Git) ein.
4. Sorg dafür, dass alle in deinem Team in der Entwicklung dieselben Postgres-Einstellungen nutzen.
5. Richte dein Postgres-Image (falls nötig) mit einigen der fortgeschrittenen Features des Docker-Images ein.
6. Gib unbedingt ein volume an, in dem der Container seine Daten speichert, damit sie zwischen den Starts erhalten bleiben.
7. Nutze die eingebauten Features des Images, um Bootstrap-SQL auszuführen, Zugangsdaten festzulegen und Datenbanken anzulegen.

Docker vs. Systeminstallation von Postgres

Du kannst Postgres auch einfach auf deinem Rechner installieren. Es gibt Builds für alle drei großen Betriebssysteme. Das scheint der einfachste Weg zu sein, aber dieser Ansatz hat ein paar Probleme.

Probleme einer systemweiten Postgres-Installation

• Postgres läuft immer als Systemdienst
• Es lässt sich problemlos nur eine Postgres-Version gleichzeitig installieren und betreiben
• Jede App, die eine eigene Postgres-Datenbank braucht, muss sich dieselbe Instanz teilen
• Erfordert Root-/Admin-Zugriff auf deinen Rechner
• Wenn du im Team arbeitest, ist jedes Setup womöglich etwas anders, was das Teilen von Dev-Konfigurationen schwierig macht.

Docker löst (die meisten) dieser Probleme

Mit Docker kann jedes Projekt in Entwicklung sein eigenes Postgres mit der richtigen Version haben – mit einem Standard-Setup, das im Team geteilt und in die Versionsverwaltung eingecheckt werden kann.

Das größte Problem beim Betrieb von Postgres in einem Docker-Container ist, nun ja, Docker zu lernen, falls du es noch nie benutzt hast.

Docker für Postgres in Produktion nutzen

Wenn du in Produktion reines Docker verwendest, ist eine Postgres-Datenbank unserer Entwicklungskonfiguration ziemlich ähnlich

version: '3.8'
volumes:
  psql_data:
    driver: local
services:
  postgres:
    image: postgres:14
    container_name: postgres
    restart: always
    environment:
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mysecurepassword
      POSTGRES_DB: mydatabase
    volumes:
      - psql_data:/var/lib/postgresql/data
      - ./backups:/backups
    ports:
      - 5432:5432
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U myuser"]
      interval: 30s
      timeout: 10s
      retries: 5

Backup und Wiederherstellung von Postgres-Datenbanken in Docker

Das Folgende ist keine umfassende Anleitung zur Verwaltung von Postgres in Produktion, sollte aber als einfacher Ausgangspunkt für eine simple Backup-Strategie dienen.

In einer Produktionsumgebung lassen sich PostgreSQL-Backups automatisieren, indem die Datenbank regelmäßig in eine Backup-Datei exportiert wird. Dazu kannst du einen Cronjob oder einen eigenen Backup-Container einplanen, der regelmäßig einen pg_dump-Befehl ausführt und die Datenbankdaten in ein auf dem Host eingebundenes Verzeichnis (z. B. /backups) exportiert. Der Ordner backups in der obigen Konfiguration ist in ein Verzeichnis auf dem Host-Rechner eingebunden, wo Backup-Dateien sicher gespeichert werden können.

Backups in Docker-Postgres erstellen

Für eine einfache Backup-Strategie:

1. Führe pg_dump aus, um die Datenbank zu exportieren:

   docker exec postgres pg_dump -U myuser mydatabase > ./backups/backup_$(date +%F).sql
   

   Dieser Befehl erstellt ein Backup der Datenbank im Verzeichnis backups.

2. Du kannst einen Cronjob einrichten oder einen anderen Scheduling-Mechanismus nutzen, um diesen Befehl in regelmäßigen Abständen (z. B. täglich oder wöchentlich) auszuführen.

     0 2 * * * docker exec postgres pg_dump -U myuser mydatabase > /path/to/backups/backup_$(date +\%F).sql
   

3. Lade das Backup zu S3 oder einem ähnlichen Speicherort hoch

     aws s3 cp ./backups/backup_$(date +%F).sql s3://your-bucket-name/path/to/backup/
   

   Zusätzlich könntest du WAL-Archivierung (Write-Ahead Logging) einrichten, um fortlaufende Backups der Änderungen zu erstellen und eine Point-in-Time-Recovery zu ermöglichen. Das würde diesen Artikel aber sprengen – mehr Infos findest du in der offiziellen Dokumentation.

Ein Backup wiederherstellen

1. Lade das Backup von S3 herunter

     aws s3 cp s3://your-bucket-name/path/to/backup/backup_YYYY-MM-DD.sql ./backups/
   

   Dieser Befehl lädt die Backup-Datei von S3 in dein lokales Backup-Verzeichnis herunter.

2. Stelle es in deiner Datenbank wieder her

     docker exec -i postgres psql -U myuser -d mydatabase < ./backups/backup_YYYY-MM-DD.sql
   

   Dieser Befehl stellt die Backup-Datei mit psql in deinem laufenden PostgreSQL-Container wieder her.

Fazit

Jetzt solltest du die Grundlagen kennen, wie man einen Postgres-Docker-Container startet und verwaltet. Beachte, dass du für den Betrieb eines Postgres-Clusters in Produktion noch vieles mehr brauchst (z. B. Monitoring, Alerts), aber hoffentlich hilft dir das oben Gezeigte beim Einstieg.