---
title: "Vorbereitung von Datenquellen: PostgreSQL"
url: "https://docs.noreja.com/de/article/vorbereitung-von-datenquellen-postgresql"
language: "de"
last_updated: "2026-02-28T11:32:00.757Z"
---

# Vorbereitung von Datenquellen: PostgreSQL

Die Vorbereitung einer PostgreSQL-Datenquelle ist eine zentrale Voraussetzung für eine stabile und sichere Prozessanalyse. Eine saubere Serverkonfiguration – einschließlich Netzwerkzugriff, Authentifizierungsregeln, rollenbasierter Berechtigungen und optionaler SSL-Verschlüsselung – stellt sicher, dass externe Tools wie Noreja zuverlässig auf die Daten zugreifen können, ohne Sicherheit oder Performance zu gefährden. Ein korrekt eingerichtetes PostgreSQL-System minimiert Integrationsprobleme und bildet die Grundlage für

**Übersicht**

Im Folgenden findest du eine umfassende Checkliste für PostgreSQL-Administratoren zur Vorbereitung eines Servers auf die Verbindung mit Noreja. Sie deckt die Konfiguration auf Serverseite, Authentifizierung, Netzwerk- und Firewall-Regeln, Rolleneinrichtung, SSL und Tests ab. Die Hinweise beziehen sich auf die offizielle PostgreSQL-Dokumentation und andere vertrauenswürdige Quellen. Um externen Tools den Zugriff zu ermöglichen, musst du TCP/IP-Verbindungen aktivieren, Client-Authentifizierungsregeln konfigurieren, Firewall-Ports öffnen, dedizierte Rollen/Benutzer mit minimalen Rechten erstellen, optional SSL-Verschlüsselung erzwingen und das Setup testen. Jeder dieser Schritte trägt zu einer sicheren und zuverlässigen Konnektivität bei.

## Remote-TCP/IP-Verbindungen aktivieren

Standardmäßig lauscht PostgreSQL nur auf dem lokalen Loopback. Um externe Verbindungen zuzulassen:

`**postgresql.conf**` **bearbeiten**

Den Eintrag `listen_addresses` suchen (Standard: `localhost`) und so anpassen, dass die gewünschten Schnittstellen abgedeckt sind:

```plaintext
listen_addresses = '*'      # Lauscht auf allen IPv4-Schnittstellen
# oder
listen_addresses = '0.0.0.0' # Entspricht ebenfalls allen IPv4-Adressen
```

Den TCP-Port überprüfen oder setzen (Standard ist `5432`). [postgresql.org](https://www.postgresql.org/docs/current/runtime-config-connection.html?utm_source=chatgpt.com)

**Server neu starten oder Konfiguration neu laden**

```plaintext
pg_ctl restart
# oder
systemctl restart postgresql
```

Ein Neustart ist erforderlich, damit Änderungen an `listen_addresses` wirksam werden. [netiq.com](https://www.netiq.com/documentation/cloudmanager23/ncm23_install/data/bf9b2zv.html?utm_source=chatgpt.com).

* * *

### **Client-Authentifizierung konfigurieren (**`**pg_hba.conf**`**)**

Die Regeln für die Client-Authentifizierung befinden sich in der Datei `pg_hba.conf`. Jede Zeile legt fest, wer sich verbinden darf, von wo und wie.

Öffne die Datei `pg_hba.conf` (normalerweise unter `/etc/postgresql/<version>/main/` oder im Datenverzeichnis zu finden).

**Füge** dort `host` **Einträge** für deine Clients hinzu, zum Beispiel:

```plaintext
# Erlaubt jedem Benutzer aus 192.168.1.0/24 die Verbindung mit Passwort (md5)
host    all     all     192.168.1.0/24    md5
```

Verwende `hostssl`, um SSL-verschlüsselte Verbindungen zu erzwingen.  
Begrenze CIDR-Ranges auf die tatsächlich benötigten Subnetze.

**Konfiguration neu laden.** So vermeidest du einen vollständigen Neustart und wendest Änderungen an der `pg_hba.conf` sofort an ([netiq.com](https://www.netiq.com/documentation/cloudmanager23/ncm23_install/data/bf9b2zv.html?utm_source=chatgpt.com).):

```plaintext
pg_ctl reload
# oder innerhalb von SQL
SELECT pg_reload_conf();
```

* * *

## Firewall / Netzwerk-ACLs öffnen

Stelle sicher, dass dein Netzwerk den Datenverkehr auf dem PostgreSQL-Port zulässt:

**TCP-Port 5432 freigeben**

**Unter Linux (mit firewalld):**

```plaintext
firewall-cmd --add-port=5432/tcp --permanent
firewall-cmd --reload
```

Unter Windows-Firewall: Eingehende Regel für `TCP 5432` hinzufügen. [bigbinary.com](https://www.bigbinary.com/blog/configure-postgresql-to-allow-remote-connection?utm_source=chatgpt.com)

### **Port-Erreichbarkeit testen**

```plaintext
telnet <server_ip> 5432

Oder in PowerShell:
powershell
Test-NetConnection -ComputerName <server_ip> -Port 5432
```

Eine erfolgreiche Verbindung bestätigt, dass der Port offen und PostgreSQL erreichbar ist. [bigbinary.com](https://www.bigbinary.com/blog/configure-postgresql-to-allow-remote-connection?utm_source=chatgpt.com).

## Authentifizierungsmethode auswählen

PostgreSQL unterstützt mehrere Authentifizierungsarten:

-   **Passwort-basiert** (`md5`, `scram-sha-256`) – gebräuchlich für Drittanbieter-Tools
-   **Peer** – Lokale Unix-Nutzer müssen DB-Rolle entsprechen
-   **GSSAPI/SSPI** – Kerberos / Active Directory
-   **Cert** – Client-Zertifikat über SSL

Konfiguriere die Authentifizierungsmethoden pro Host in der Datei `pg_hba.conf`. Um für alle externen Hosts die Authentifizierung per SCRAM-SHA-256 zu erzwingen, füge folgenden Eintrag hinzu:

```plaintext
host    all     all     0.0.0.0/0    scram-sha-256
```

## Rollen erstellen und Berechtigungen vergeben

Befolge das Prinzip der minimalen Rechtevergabe, wenn du ein Konto für ein externes Tool einrichtest:

**Login-Rolle erstellen**

```plaintext
CREATE ROLE tool_user
  WITH LOGIN
  PASSWORD 'StrongP@ssw0rd'
  NOSUPERUSER
  NOCREATEDB
  NOCREATEROLE
  NOINHERIT
  CONNECTION LIMIT 10;
```

**Zugriff auf Datenbank gewähren:**

```plaintext
GRANT CONNECT ON DATABASE your_db TO tool_user;
```

**Schema- und Tabellenberechtigungen:**

```plaintext
GRANT USAGE ON SCHEMA public TO tool_user;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO tool_user;
ALTER DEFAULT PRIVILEGES IN SCHEMA public
  GRANT SELECT ON TABLES TO tool_user;
```

Anpassen, falls INSERT/UPDATE/EXECUTE benötigt wird.

**(Optional) Rollenmitgliedschaft:**

```plaintext
CREATE ROLE reporting_grp;
GRANT reporting_grp TO tool_user;
```

Weitere Tools/Benutzer können später der Gruppe `reporting_grp` hinzugefügt werden. [postgresql.org](https://www.postgresql.org/docs/current/role-membership.html?utm_source=chatgpt.com).

## (Optional) SSL-Verschlüsselung erzwingen

Um Daten während der Übertragung zu sichern:

**Serverzertifikat installieren:**

Zertifikat (PEM-Format) und Schlüssel im Datenverzeichnis ablegen.

In `postgresql.conf`:

```plaintext
ssl = on
ssl_cert_file = 'server.crt'
ssl_key_file  = 'server.key'
```

**Benötigt SSL in** `**pg_hba.conf**`**:**

```plaintext
hostssl   all   all   0.0.0.0/0   md5
```

Nur `hostssl`\-Zeilen greifen bei SSL-Verbindungen. [postgresql.org](https://www.postgresql.org/docs/current/ssl-tcp.html?utm_source=chatgpt.com).

**Konfiguration neu laden und testen:**

```plaintext
pg_ctl reload
psql "host=<server> sslmode=require dbname=your_db user=tool_user" 
```

## Konnektivität überprüfen

**Verbindung testen:**

```plaintext
psql -h <server_ip> -U tool_user -d your_db -W
```

**Beispielabfrage ausführen:**

```plaintext
SELECT now(), count(*) FROM information_schema.tables;
```

**Server-Logs prüfen:**  
Auf erfolgreiche Authentifizierungen in `postgresql.log` achten.

Durch das konsequente Durchlaufen dieser Schritte – Netzwerkfreigabe, sichere Authentifizierung, Firewall-Konfiguration, Rollenvergabe, optionale Verschlüsselung und abschließende Tests – stellst du sicher, dass externe Tools zuverlässig und sicher auf deine PostgreSQL-Instanz zugreifen können.
