PostgreSQL Engineer Training · vom Anwender zum Database Engineer
Du kennst PostgreSQL. Jetzt lernst du, wie es wirklich arbeitet.
Warum wählt der Planer gerade diesen Plan? Warum wächst die Tabelle, obwohl kaum Daten dazukommen? Wie lange dauert ein Restore wirklich? In 32 Einheiten baust du Systeme auf, belastest sie, machst sie kaputt und holst sie zurück, bis du die Antworten nicht mehr nachschlagen musst.
- 8 Module, 32 Einheiten
- Rund 130 bis 145 Stunden Praxis
- Geprüft auf PostgreSQL 18
- Alle Umgebungen lokal mit Docker
Für wen dieses Training ist
Entwicklung
Du übernimmst Verantwortung über die Abfrage hinaus: Performance, Schema-Änderungen im laufenden Betrieb, Verhalten unter Last.
DBAs und Plattform-Teams
Du betreibst PostgreSQL produktiv und willst Backup, Replikation, Hochverfügbarkeit, Monitoring und Automatisierung professionell aufstellen.
Auf dem Weg zur Senior-Rolle
Du planst Kapazität, leitest Incidents, bewertest Architekturen und gibst Wissen im Team weiter.
Was du in acht Modulen beherrschen lernst
Jedes Thema an einer laufenden Umgebung, die du selbst aufbaust. Die Module 1 und 2 sind das Fundament, danach setzt du Schwerpunkte nach deiner Aufgabe.
Den Planer durchschauen
Ausführungspläne vollständig lesen, Schätzfehler erkennen und ihre Ursache in den Statistiken finden. Transaktionen, Locks, MVCC und VACUUM von innen verstehen.
Performance, die trägt
Indizes gezielt entwerfen, Abfragen systematisch optimieren und Verbindungen mit Pooling beherrschen, gemessen mit pgbench statt geschätzt.
Schemas, die wachsen dürfen
Modellieren jenseits der Normalform, Tabellen partitionieren und Migrationen ohne Ausfallzeit durchführen.
Den Ernstfall üben
Backups mit pgBackRest und Point-in-Time-Recovery, Replikation und ein Patroni-Cluster mit drei Knoten, etcd und HAProxy, dessen Primary du selbst abschaltest.
Sehen, was passiert
Monitoring mit Prometheus, Alertmanager und Grafana, Workload-Analyse mit pg_stat_statements und Automatisierung mit Ansible.
Sicherheit und DSGVO
Rechtekonzepte, Row Level Security für Mandantentrennung, Auditing mit pgAudit und ein Betrieb, der Löschpflichten ernst nimmt.
Spezialwerkzeuge einordnen
PostGIS, Volltextsuche, pgvector und Citus im Einsatz, dazu die Migration aus Oracle oder MySQL.
Senior-Level
Kapazität planen, Incidents strukturiert führen, Zuverlässigkeit mit SLOs messbar machen, Architekturentscheidungen dokumentieren und Stakeholdern verständlich erklären.
Auch für 16 und 17
Wo sich PostgreSQL 18 anders verhält, nennt die Einheit die Versionsgrenze. So wendest du das Gelernte auch auf deine Bestandsinstanzen an.
Kein Folienvortrag. Ein Labor.
Messen statt glauben
Lasttests, Pläne vorher und nachher, Laufzeiten, Metriken. Viele Übungen fragen erst nach deiner Prognose und dann nach der Messung.
Fehler mit Absicht
Deadlocks provozieren, Bloat erzeugen, eine Tabelle löschen und zurückholen, einen Alarm auslösen. Im Ernstfall kennst du das Bild schon.
Echte Umgebungen, komplett im Text
Jede Compose-Datei und jede Konfiguration steht vollständig in der Einheit, vom Monitoring-Stack bis zur MySQL-Quelle für die Migration.
Lösungen mit gemessenen Werten
Zu jeder Einheit gibt es Lösungen und Auswertungshilfen mit Werten aus echten Läufen. Sie bleiben verborgen, bis du sie aufdeckst.
Bist du bereit?
Das Training setzt eine solide Anwendung von SQL und PostgreSQL im Alltag voraus. Prüfe dich kurz:
- Du schreibst Joins über mehrere Tabellen, GROUP BY mit HAVING, EXISTS-Unterabfragen und einfache CTEs ohne Nachschlagen.
- Du kennst die Fallen von NULL, etwa bei NOT IN oder count(*) gegenüber count(spalte).
- Du legst Tabellen mit Schlüsseln und Constraints an und änderst Daten mit INSERT, UPDATE, DELETE und ON CONFLICT.
- Du setzt Transaktionen bewusst ein und weißt, was ein abgebrochener Transaktionszustand bedeutet.
- Du arbeitest sicher mit psql und hast schon einmal mit EXPLAIN die Wirkung eines Index gesehen.
- Shell, Docker und YAML schrecken dich nicht ab.
Mehrere Punkte unsicher? Dann starte mit PostgreSQL Fundamentals. Seine Abschlussaufgabe weist genau diese Vorkenntnisse nach, und das Training knüpft nahtlos daran an.
Alle 32 Einheiten im Überblick
Bevor es um Performance, Betrieb und Architektur geht, steht das Verständnis der Mechanik: wie PostgreSQL eine Abfrage plant und ausführt, wie Transaktionen sich gegenseitig sehen und sperren, und wie MVCC und VACUUM zusammenwirken. Auf diesen fünf Einheiten baut der gesamte Lehrgang auf.
- Query-Verarbeitung in PostgreSQL verstehen Die fünf Phasen Parser, Rewrite, Planner, Executor, Portal kennen. Verstehen, wie ein SQL-Statement intern abläuft.
- EXPLAIN und EXPLAIN ANALYZE meistern Plan-Operatoren lesen (Seq Scan, Index Scan, Nested Loop, Hash Join, Merge Join), Kosten vs. tatsächliche Zeilen interpretieren, Buffers- (seit PG 18 bei ANALYZE standardmäßig an) und Timing-Output nutzen, `MEMORY`/`SERIALIZE` (PG 17) kennen.
- Statistiken und der Query-Planner `pg_statistic` und `pg_stats`, Bedeutung von `n_distinct`, Histogrammen und Korrelation. `ANALYZE`, Autovacuum-Analyse, `default_statistics_target`.
- Transaktionen, Isolation und Locks MVCC, Snapshot-Isolation, die vier Isolationsstufen in PostgreSQL, Serialisierung per SSI. Tabellen- und Zeilensperren, Lock-Warteschlange, Deadlocks, `pg_locks`, Lock-Timeouts. Dauerhaftigkeit über WAL, Commit und Checkpoints, `synchronous_commit`.
- VACUUM und MVCC-Wartung verstehen Seitenaufbau, Tuple-Versionen, Dead Tuples, Bloat, HOT-Updates und fillfactor, Free Space Map, Visibility Map. Autovacuum-Tuning, `VACUUM` vs. `VACUUM FREEZE` vs. `VACUUM FULL`, Wraparound-Gefahr.
- Index-Typen im Überblick B-Tree, Hash, GIN, GiST, SP-GiST, BRIN. Wann welcher Index passt, Funktionsweise von GIN (Posting-Listen) und BRIN (Range-Blöcke).
- Fortgeschrittene Index-Techniken Partielle Indizes, funktionsbasierte Indizes, mehrspaltige Indizes und Column-Order, Covering Indizes (`INCLUDE`), `CREATE INDEX CONCURRENTLY`, `REINDEX CONCURRENTLY`, `pg_stat_user_indexes` (Hit-Rate, ungenutzte Indizes).
- Query-Optimierung in der Praxis Anti-Pattern (N+1, `SELECT *`, OR-Verrenkungen, `OFFSET`-Pagination), CTE-Materialisierung steuern (`MATERIALIZED`/`NOT MATERIALIZED` seit PG 12), Fensterfunktionen effizient einsetzen, Keyset-Pagination, `work_mem` und Spills.
- Connection-Management und Pooling PostgreSQL-Prozessmodell, Kosten pro Verbindung, `max_connections`, PgBouncer (Session vs. Transaction vs. Statement Mode), prepared Statements im Pool, Timeout-Strategien.
- Datenmodellierung jenseits der Normalform Normalformen, Schlüssel- und Datentypwahl, bewusste Denormalisierung, Materialized Views, Array- und JSONB-Spalten (wann Dokumentenmodell, wann relationales Modell), `CHECK`-Constraints, Composite Types.
- Partitionierung Deklarative Range-, List- und Hash-Partitionierung, Partition Pruning, Partition-wise Joins, Routing über Partition Keys, Verwaltung von Partitionen, Grenzen (Indexe je Partition).
- Schema-Migrationen professionell ausführen Lock-Auswirkungen von DDL, `NOT VALID` + `VALIDATE`, gleichzeitige Index- und Constraint-Builds, Squash von Migrationen. Flyway, Liquibase und Sqitch im Vergleich, Rollback-Strategien, Baseline aus bestehender DB.
- Backup und Recovery `pg_dump` vs. `pg_basebackup` vs. WAL-basierte Backups, inkrementelle Bordmittel-Backups seit PG 17 (`pg_basebackup --incremental`, `pg_combinebackup`). pgBackRest einrichten (inkrementelle Backups, Retention, Kompression), PITR (Point-in-Time-Recovery), `recovery_target_time`, Verifikation von Backups.
- Replikation Streaming-Replication (synchron vs. asynchron), WAL-Interna, Replication-Slots (Failover-Slots seit PG 17, `idle_replication_slot_timeout` seit PG 18), `hot_standby` und Query-Konflikte, logische Replikation (Publications, Subscriptions, `pg_createsubscriber`, Konfliktstatistik seit PG 18).
- Hochverfügbarkeit mit Patroni Architektur von Patroni (etcd/Konsens, Leader-Wahl, `pg_hba`-Automatisierung), pg_auto_failover als einfachere Alternative, Split-Brain vermeiden, Routing-Layer (HAProxy, Health-Checks).
- PostgreSQL-Konfiguration und Tuning `shared_buffers`, `effective_cache_size`, `work_mem`, `maintenance_work_mem`, WAL-Einstellungen (`max_wal_size`, `synchronous_commit`), `autovacuum_*`-Grundlagen, asynchrones I/O seit PG 18 (`io_method`, `effective_io_concurrency`), Restart vs. Reload, Conf-Management über `ALTER SYSTEM`.
- Monitoring mit Prometheus und postgres_exporter Kern-Metriken (Verbindungen, WAL, Replikations-Lag, Autovacuum-Rückstand), postgres_exporter-Queries und Custom-Metriken, Alertmanager-Regeln für Lag, Disk-Füllstand, Transaktionsalter und Lock-Wartezeiten.
- pg_stat_statements und Workload-Analyse Top-Queries nach Gesamtzeit und Aufrufen, `shared_blks_*` interpretieren, Regressionserkennung nach Releases, ergänzende Views (`pg_stat_user_tables`, `pg_stat_io` ab PG 16, `pg_wait_sampling`).
- Infrastructure as Code für Datenbanken Docker Compose für lokale Setups, Ansible oder Terraform für Instanz-Setup, Konfig-Drift vermeiden, Secrets-Handling, reproduzierbare Umgebungen. Optional: PostgreSQL in Kubernetes (CloudNativePG).
- Rollen- und Rechtekonzept Rollen-Hierarchien (Mitgliedschafts-Optionen seit PG 16), `GRANT`-Strategien, Default Privileges, `SECURITY DEFINER`-Risiken, separate App- und Admin-Rollen, `pg_hba.conf` und SCRAM-Authentifizierung (MD5 seit PG 18 abgekündigt).
- Row Level Security und Mandanten-Trennung RLS-Policies, Rollen-Wechsel (`SET ROLE`), Performance-Auswirkungen von RLS, Mandantenmodelle (Schema-per-Tenant vs. Shared Tables mit `tenant_id` + RLS).
- Auditing, Verschlüsselung und DSGVO-Betrieb `pgAudit`, `log_statement`-Strategien, TLS erzwingen, Verschlüsselung im Ruhezustand (LUKS, Cloud-KMS), Anonymisierung mit `anon`-Extension, Aufbewahrungsfristen und Löschkonzepte (`DELETE` vs. Partition-Drop).
- PostGIS — Räumliche Daten und Abfragen Geometrie-Typen, SRIDs, räumliche Indizes (GiST), Distanz- und Enthält-Abfragen, Geocoding-Workflows.
- Volltextsuche mit tsvector und pg_trgm `to_tsvector`/`to_tsquery`, Ranking (ts_rank), GIN vs. GiST, Fuzzy-Suche mit `pg_trgm` und Ähnlichkeitsoperatoren, Kombination beider Ansätze.
- pgvector und KI-Workloads — Semantische Suche und Hybrid-Ranking Embeddings speichern (pgvector 0.8: `vector`, `halfvec`), HNSW- vs. IVFFlat-Index, Ähnlichkeitssuche, gefilterte Suche mit iterativem Index-Scan, Hybrid Search (Vektor + Volltext), PostgreSQL als Vektor-Backend bewerten.
- Citus und horizontale Skalierung — Sharding jenseits der einzelnen Instanz Sharding-Konzepte, Verteilungsschlüssel, Co-Located Joins, Rebalancer. Abgrenzung: wann reicht eine große einzelne Instanz, wann Citus oder ein anderes System.
- Migration von Oracle oder MySQL nach PostgreSQL — Werkzeuge, Fallen, Cutover Typ-Mapping, Sequences vs. Auto-Increment, PL/SQL-Übersetzung (Ora2Pg), Casing- und Empty-String-Fallen, Teststrategie mit Schatten-Deployments und Dual-Writes.
- Kapazitätsplanung und Sizing — Messwerte, Szenarien, Kalender Wachstumsmodelle, IOPS- und Throughput-Schätzungen, Storage-Kalkulation (WAL, Bloat, Backups), Hardware- und Cloud-Sizing, Grenzen einer Instanz abschätzen.
- Incident Response und Post-Mortems — Runbooks, Rollen, Ruf-Schwellen Runbooks (Replikations-Lag, Disk voll, Autovacuum-Rückstand, Lock-Sturm), Eskalationspfade, Kommunikationsregeln während Incidents, Post-Mortem-Kultur ohne Schuldzuweisung.
- Database Reliability Engineering — SLOs, Drills und die Zuverlässigkeits-Pipeline SLOs für Datenbanken (Verfügbarkeit, Replikations-Lag, Query-Latenz-P99), Error Budgets, Chaos-Tests (Kill Primary unter Last), automatisierte Failover-Drills, Backup-Restore-Tests als CI-Job.
- Architektur-Reviews und Standards im Team — Checklisten, ADRs, Trade-offs Schema- und Migration-Review-Checkliste, Index-Standards, Benennungskonventionen, technische Entscheidungen dokumentieren (ADR), Trade-off-Analysen (z. B. RLS vs. App-Layer-Sicherheit, Partitionierung vs. Archivierung).
- Mentoring und Stakeholder-Kommunikation — Erklären, Onboarding, Kosten bewerten Komplexe technische Sachverhalte für Nicht-Spezialisten erklären, Onboarding-Material für Junior-Kollegen erstellen, Datenbank-Themen in Projektplanungen einbringen, Kostentreiber (Cloud-Services vs. Self-Hosting) gegenüber dem Business bewerten.
Engineer Training online
Alle 32 Einheiten in der Leseansicht, Lösungen zum Aufdecken, Fortschritt je Einheit.
890,00 € inkl. USt.
Für Unternehmen mit USt-IdNr. aus dem EU-Ausland ohne Umsatzsteuer.
Selbstlernkurs ohne individuelle Betreuung. Fehler im Material kannst du jederzeit an learn@bridge-layer.com melden.
Häufige Fragen
Muss ich die Module der Reihe nach bearbeiten?
Die Module 1 und 2 zuerst, sie sind die Grundlage für alles Weitere. Modul 5 und 6 lassen sich weitgehend parallel bearbeiten, aus Modul 7 wählst du nach Bedarf. Jede Einheit nennt ihre Voraussetzungen.
Brauche ich einen eigenen Server oder ein Cloud-Konto?
Nein. Alle Umgebungen, auch Cluster mit mehreren Knoten, laufen als Container auf deinem Rechner.
Welche Hardware brauche ich?
Empfohlen sind 16 GB Arbeitsspeicher, 4 CPU-Kerne und rund 30 GB freier Speicher; 8 GB Arbeitsspeicher sind das Minimum. Auf Apple Silicon laufen drei Einheiten (PostGIS, Citus, pgloader) über Emulation spürbar langsamer, funktionieren aber.
Ich arbeite noch mit PostgreSQL 16 oder 17. Lohnt sich das Training?
Ja. Die Prinzipien gelten versionsübergreifend, und wo PostgreSQL 18 sich anders verhält oder etwas Neues mitbringt, nennt die Einheit die Versionsgrenze.
Wie viel Zeit sollte ich einplanen?
Eine Einheit dauert etwa 3 bis 5 Stunden. Mit einer Einheit pro Woche bist du gut acht Monate unterwegs, mit zwei rund vier Monate.
Bekomme ich Betreuung oder Antworten auf meine Fragen?
Nein. Das Engineer Training ist ein Selbstlernkurs ohne individuelle Betreuung. Alles, was du brauchst, steht im Text: Jede Einheit beschreibt ihre Übungsumgebung vollständig, und die Lösungen enthalten gemessene Werte zum Abgleich. Fehler im Material kannst du jederzeit an learn@bridge-layer.com melden.
Wo finde ich die Rechnung?
Nach der Zahlung liegt die Rechnung in deinem Konto zum Download bereit.