Homelab--Bratonein-Kontrollzentrum--Tutorial/Free Rohtext.md at 39c9a5e9df3f688508cfba2e36cb0d55dbeeeb5e

Thomas/Homelab--Bratonein-Kontrollzentrum--Tutorial

Files

Thomas Dannenberg 93d42d6f78 Kapitel 17/Free Rohtext.md hinzugefügt

2025-10-19 11:37:25 +00:00

33 KiB

Raw Blame History

Einleitung

Im UCC spielt Social-Media-Management eine immer größere Rolle – besonders für Streamer:innen, Creator und kleine Teams, die Inhalte regelmäßig veröffentlichen, ohne auf kommerzielle Plattform-Tools angewiesen zu sein.
Postiz ist dabei die zentrale Schaltstelle: ein selbstgehostetes System, das Beiträge für Plattformen wie Discord, YouTube, Instagram, TikTok und viele andere planen, automatisieren und koordinieren kann – mit vollständiger Datenhoheit.

In diesem Kapitel baust du eine eigene Postiz-Instanz auf Basis eines Debian-12-LXC auf.
Du lernst, wie du sie installierst, konfigurierst und über den Nginx Proxy Manager sicher in dein UCC integrierst.
Anschließend verbindest du Postiz mit deinen ersten Plattformen – in der Free-Variante mit Discord und YouTube, da diese ohne komplexe API-Freigaben direkt nutzbar sind.

👉 Screenshot geeignet: UCC-Übersicht mit markiertem Postiz-Container zwischen n8n und Netdata

Note

Die Anbindung externer Plattformen ist unterschiedlich stark reglementiert.
Während Discord und YouTube relativ offen integriert werden können,
gelten bei TikTok, Instagram und allen Meta-Diensten (Facebook, Threads, WhatsApp) deutlich strengere Auflagen.

In unserer Praxis mussten wir diesen Prozess vollständig durchlaufen,
um Postiz mit Meta-Diensten produktiv einsetzen zu können.
Dazu gehörte unter anderem der Nachweis einer gewerblichen Tätigkeit,
die Einrichtung einer eigenen Meta-App, mehrere manuelle Prüfungen
und teils lange Wartezeiten, bis bestimmte API-Bereiche freigegeben wurden.

Auch TikTok hat die Entwicklerregistrierung verschärft:
einfache Konten erhalten keinen direkten Zugriff mehr auf Post- oder Medien-APIs.

Dieses Kapitel konzentriert sich daher bewusst auf Plattformen,
die ohne eigene App-Zulassung sofort funktionieren – Discord und YouTube.
Erweiterte Integrationen (TikTok, Meta, LinkedIn etc.) werden später im Premium-Bereich behandelt.

Postiz kombiniert eine übersichtliche Weboberfläche mit leistungsstarken Hintergrunddiensten für Planung, API-Anbindung und Automatisierung.
So kannst du Beiträge zentral erfassen, zeitlich steuern und später mit Tools wie n8n erweitern – bis hin zu vollständig automatisierten Veröffentlichungsketten.

👉 Screenshot geeignet: Browseransicht mit Postiz-Dashboard (Kalenderansicht, geplanter Discord-Post und YouTube-Upload sichtbar)

Voraussetzungen & Ressourcen

Postiz ist ressourcenschonend, benötigt aber eine stabile Umgebung, um API-Abfragen, Authentifizierungen und Uploads zuverlässig zu verarbeiten.
Da im Hintergrund mehrere Prozesse (Backend, Scheduler, API-Connectoren) laufen, sollte der Container klar definiert dimensioniert werden.

Container-Ressourcen

CPU: 2 vCPU
Erforderlich, um parallele Aufgaben (z. B. API-Abfragen an Discord und YouTube) ohne Verzögerungen abzuarbeiten.
RAM: 4 GB
Stellt sicher, dass Node.js, Datenbank und Hintergrundprozesse stabil laufen, auch bei mehreren aktiven Konten.
Speicherplatz: 15 GB
Deckt System, Logs, Medien-Cache und temporäre Upload-Dateien ab.
Reicht für den kontinuierlichen Betrieb im Free-Umfang vollständig aus.
Netzwerk: Statische IP-Adresse oder DHCP-Reservierung
Notwendig für stabile Proxy-Integration und zuverlässige API-Callbacks (z. B. YouTube-Webhooks).
Betriebssystem: Ubuntu 24.04 LTS
Stabil, langfristig supportet und optimal für Node.js-basierte Dienste geeignet.

👉 Screenshot geeignet: Ressourcenübersicht beim Erstellen des Postiz-LXC (vCPU 2 | RAM 4 GB | Storage 15 GB | Ubuntu 24.04 LTS)

Technische Voraussetzungen

Vor der Installation sollte das UCC folgende Bedingungen erfüllen:

Proxmox VE ist eingerichtet und aktiv.
Der Container wird wie gewohnt direkt über die Proxmox-Oberfläche erstellt und verwaltet.
Nginx Proxy Manager (NPM) ist funktionsfähig.
Er stellt später die Weboberfläche von Postiz über HTTPS bereit.
DNS- oder DynDNS-Eintrag für postiz.deinedomain.tld existiert.
Dieser ist notwendig, um ein gültiges SSL-Zertifikat ausstellen zu können.
Internetverbindung im Container ist aktiv.
Postiz lädt seine Pakete über die offiziellen Node.js- und Postiz-Repositories.
SSH-Zugriff auf den Container ist möglich, zum Beispiel:
```
ssh root@<IP-des-Containers>
```
Ersetze <IP-des-Containers> durch die tatsächliche Adresse deines Postiz-LXC.

Important

Der Container sollte auf einem Host mit stabiler Netzwerkanbindung liegen.
Unterbrechungen während API-Aufrufen können zu fehlerhaften Token-Validierungen oder abgebrochenen Uploads führen.

👉 Screenshot geeignet: Proxmox-Interface mit markiertem Postiz-LXC in der Containerliste

Schritt-für-Schritt-Anleitung

Schritt 1 – System vorbereiten und aktualisieren

Starte den frisch erstellten Container und öffne die Konsole – direkt in Proxmox oder per SSH.
Führe anschließend ein vollständiges System-Update durch, um alle Pakete auf den neuesten Stand zu bringen:

apt update && apt upgrade -y

Nach Abschluss des Updates den Container neu starten:

reboot

Melde dich nach dem Neustart erneut an:

ssh root@<IP-des-Containers>

Note

Ein aktuelles System ist Pflicht.
Postiz benötigt moderne Node.js-Pakete und aktuelle SSL-Bibliotheken.
Veraltete Basis-Images können zu Installations- oder Zertifikatsfehlern führen.

👉 Screenshot geeignet: Proxmox-Konsole mit erfolgreichem Abschluss von apt upgrade (keine ausstehenden Pakete)

Schritt 2 – Basis-Pakete installieren

Postiz wird über Docker Compose betrieben.
Damit das System später stabil läuft, installierst du jetzt die notwendigen Pakete für Container-Management und HTTPS-Kommunikation.

apt install -y ca-certificates curl gnupg lsb-release

Im Anschluss fügst du das offizielle Docker-Repository hinzu und installierst die aktuelle Engine + Compose-Komponenten:

mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" \
  | tee /etc/apt/sources.list.d/docker.list > /dev/null

apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Prüfe anschließend, ob Docker korrekt arbeitet:

docker --version
docker compose version

Die Ausgaben sollten etwa so aussehen:

Docker version 26.1.x
Docker Compose version v2.29.x

Note

Postiz nutzt offiziell Docker Compose als bevorzugte Installationsmethode.
Manuelle Installationen über npm oder System-Pakete werden vom Projekt derzeit nicht mehr gepflegt.
Diese Vorgehensweise entspricht den aktuellen Empfehlungen aus der offiziellen Dokumentation.

👉 Screenshot geeignet: Terminalausgabe mit sichtbarer Docker- und Compose-Version nach erfolgreicher Installation

Schritt 3 – Verzeichnisstruktur und Konfigurationsbasis anlegen

Postiz wird sauber in einem eigenen Systemverzeichnis betrieben.
Dort liegen später sowohl die Docker-Compose-Datei als auch die zugehörige Konfiguration und Daten.

Lege zunächst das Hauptverzeichnis an und wechsle hinein:

mkdir -p /opt/postiz
cd /opt/postiz

Erstelle anschließend die Standardverzeichnisse:

mkdir -p data redis db

Damit sind drei Hauptpfade vorbereitet:

data → App-Daten und Upload-Medien
redis → Cache-Daten für Hintergrundprozesse
db → PostgreSQL-Datenbank

👉 Screenshot geeignet: Terminal mit ausgeführtem ls -l /opt/postiz (alle drei Unterordner sichtbar)

Jetzt folgt die grundlegende Konfigurationsdatei .env.
Sie steuert die Ports, Datenbankverbindung und Sicherheitseinstellungen.
Öffne den Editor:

nano /opt/postiz/.env

Füge folgenden Basisinhalt ein:

# Basis-Konfiguration
TZ=Europe/Berlin
POSTIZ_PORT=8080
POSTIZ_SECRET=$(openssl rand -hex 32)

# Admin-Benutzer
POSTIZ_ADMIN_EMAIL=admin@localhost
POSTIZ_ADMIN_PASSWORD=changeMe123!

# Datenbank
POSTGRES_DB=postiz
POSTGRES_USER=postiz
POSTGRES_PASSWORD=$(openssl rand -hex 16)

# Redis
REDIS_HOST=redis
REDIS_PORT=6379

# Persistente Pfade
DATA_PATH=/opt/postiz/data
DB_PATH=/opt/postiz/db
REDIS_PATH=/opt/postiz/redis

Speichern (STRG + O, Enter) und schließen (STRG + X).

Note

Diese Datei enthält alle wichtigen Umgebungsvariablen.
Sie wird von Docker Compose automatisch eingelesen, sobald die Container gestartet werden.
Achte darauf, dass die Datei nur root- oder Admin-Benutzern zugänglich ist,
da sie Passwörter und geheime Schlüssel enthält.

👉 Screenshot geeignet: geöffnete .env-Datei mit markierten Variablen (Ports, Datenbank, Admin-Login)

Im nächsten Schritt wird die eigentliche docker-compose.yml erstellt.
Sie definiert die drei benötigten Dienste (Postiz, PostgreSQL und Redis) und verbindet sie über ein internes Netzwerk.

Öffne den Editor:

nano /opt/postiz/docker-compose.yml

Füge folgenden Inhalt ein:

version: "3.9"

services:
  postiz:
    image: ghcr.io/postiz/postiz:latest
    container_name: postiz
    restart: unless-stopped
    env_file:
      - .env
    ports:
      - "8080:8080"
    volumes:
      - ./data:/app/data
    depends_on:
      - db
      - redis

  db:
    image: postgres:16
    container_name: postiz_db
    restart: unless-stopped
    environment:
      - POSTGRES_DB=${POSTGRES_DB}
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
    volumes:
      - ./db:/var/lib/postgresql/data

  redis:
    image: redis:7
    container_name: postiz_redis
    restart: unless-stopped
    volumes:
      - ./redis:/data

Speichern (STRG + O, Enter) und schließen (STRG + X).

Tip

Diese Struktur folgt den aktuellen Empfehlungen der offiziellen Postiz-Dokumentation.
Alle Dienste sind voneinander getrennt, nutzen lokale Volumes und starten automatisch neu,
falls der Container oder der Host neu gestartet wird.

👉 Screenshot geeignet: Terminalansicht mit geöffneter docker-compose.yml und markierten Diensten (postiz, db, redis)

Schritt 4 – Container starten und Erstinitialisierung prüfen

Mit der vorbereiteten .env- und docker-compose.yml-Datei kannst du Postiz jetzt starten.
Alle benötigten Dienste (Postiz, PostgreSQL, Redis) werden automatisch im Hintergrund erzeugt.

Starte den Stack mit folgendem Befehl:

docker compose up -d

Der Vorgang lädt zunächst die Images von GitHub Container Registry (Postiz) und Docker Hub (PostgreSQL, Redis)
und startet anschließend alle Container im Hintergrund.

Du kannst den Startvorgang überwachen mit:

docker compose ps

Die Ausgabe sollte alle drei Dienste als „running“ anzeigen:

NAME           IMAGE                           STATUS         PORTS
postiz         ghcr.io/postiz/postiz:latest    Up 2 minutes   0.0.0.0:8080->8080/tcp
postiz_db      postgres:16                     Up 2 minutes
postiz_redis   redis:7                         Up 2 minutes

👉 Screenshot geeignet: Terminalausgabe von docker compose ps mit allen drei Containern im Status Up

Öffne im Browser anschließend:

http://<IP-des-Containers>:8080

Wenn die Einrichtung erfolgreich war, sollte die Postiz-Loginseite erscheinen.
Hier kannst du dich mit den in der .env-Datei definierten Zugangsdaten anmelden:

Benutzername (E-Mail): admin@localhost
Passwort: changeMe123!

Nach dem Login öffnet sich das Dashboard mit einer leeren Kalenderansicht.
Damit ist die Installation abgeschlossen und die Instanz funktionsfähig.

Note

Wenn die Seite nicht lädt oder der Container sofort stoppt, prüfe mit
docker compose logs postiz
auf Fehlermeldungen. Häufige Ursachen sind Tippfehler in der .env-Datei oder
fehlender Arbeitsspeicher während des ersten Starts.

👉 Screenshot geeignet: Browseransicht mit Postiz-Login unter http://<IP-des-Containers>:8080

Schritt 5 – Dienst dauerhaft aktivieren und Neustart-Verhalten prüfen

Damit Postiz nach einem Neustart des Containers oder Hosts automatisch wieder zur Verfügung steht,
wird das Verhalten von Docker Compose dauerhaft aktiviert und getestet.

Zuerst prüfen, ob die Container korrekt mit dem Flag restart: unless-stopped laufen.
Das sollte bereits in der docker-compose.yml gesetzt sein.
Zur Kontrolle:

grep restart /opt/postiz/docker-compose.yml

Die Ausgabe sollte dreimal restart: unless-stopped enthalten – für postiz, db und redis.

Führe jetzt einen kontrollierten Neustart des Containers durch:

reboot

Nach dem Reboot erneut einloggen und prüfen, ob die Dienste automatisch gestartet wurden:

docker compose ps

Alle Container sollten wieder im Status Up erscheinen.
Damit ist das automatische Startverhalten bestätigt.

Note

Docker Compose verwaltet den Neustart unabhängig von systemd.
Ein zusätzlicher systemd-Service ist nicht erforderlich.
Das vereinfacht die Wartung und reduziert potenzielle Konflikte zwischen Containern und Hostprozessen.

👉 Screenshot geeignet: Terminalausgabe nach docker compose ps (alle Container aktiv nach Neustart)

Wenn du Postiz zu einem späteren Zeitpunkt manuell neu starten möchtest, genügt:

docker compose restart

oder – bei einem vollständigen Neuaufbau nach Updates –

docker compose down
docker compose pull
docker compose up -d

Tip

Dieser Ansatz stellt sicher, dass alle Dienste aktualisiert und mit den neuesten Images gestartet werden,
ohne dass Daten oder Einstellungen im /opt/postiz-Verzeichnis verloren gehen.

👉 Screenshot geeignet: Terminalausgabe mit erfolgreichem Neustart der Postiz-Container nach docker compose up -d

Schritt 6 – Integration in Nginx Proxy Manager (NPM)

Damit Postiz sicher und bequem erreichbar ist, wird der interne Port 8080 jetzt über den Nginx Proxy Manager veröffentlicht.
So erhältst du eine HTTPS-Verbindung mit gültigem SSL-Zertifikat und kannst die Oberfläche direkt über eine Subdomain wie
https://postiz.deinedomain.tld öffnen.

Proxy-Host anlegen

Öffne das Dashboard des Nginx Proxy Manager.
Klicke auf Add Proxy Host.
Trage folgende Werte ein:

Feld	Wert
Domain Names	`postiz.deinedomain.tld`
Scheme	`http`
Forward Hostname / IP	`<IP-des-Postiz-Containers>`
Forward Port	`8080`
Block Common Exploits	aktivieren
Websockets Support	aktivieren

Wechsle danach in den Reiter SSL und aktiviere:

Request a new SSL Certificate
Force SSL
HTTP/2 Support
HSTS Enabled

Klicke anschließend auf Save.

Note

Der Proxy Manager erstellt automatisch ein gültiges Let’s-Encrypt-Zertifikat.
Ab sofort ist Postiz verschlüsselt über HTTPS erreichbar.
Bei der ersten Zertifikatsanforderung muss die Domain auf deinen Server zeigen,
sonst schlägt die Validierung fehl.

👉 Screenshot geeignet: NPM-Dashboard mit geöffnetem Proxy-Host postiz.deinedomain.tld

Verbindung testen

Öffne im Browser:

https://postiz.deinedomain.tld

Wenn die Anmeldemaske erscheint und der Browser ein Schloss-Symbol anzeigt, funktioniert die Integration.
Melde dich anschließend mit den zuvor definierten Zugangsdaten an:

Benutzername (E-Mail): admin@localhost
Passwort: changeMe123!

Tip

Sollte die Seite nicht laden, überprüfe im NPM-Dashboard IP-Adresse und Port (8080).
In vielen Fällen hilft ein einfacher Neustart des Dienstes:
docker compose restart

👉 Screenshot geeignet: Browserfenster mit Postiz-Login unter https://postiz.deinedomain.tld (Schloss-Symbol sichtbar)

Schritt 7 – Oberfläche verstehen und erste Einrichtung durchführen

Nach erfolgreicher Anmeldung öffnet sich das Postiz-Dashboard.
Die Weboberfläche ist übersichtlich, modern und vollständig webbasiert.
Sie lässt sich über Desktop, Tablet oder Smartphone gleichermaßen bedienen und dient als zentrale Schaltstelle für alle angebundenen Social-Media-Konten.

Im linken Bereich befindet sich das Hauptmenü, oben die Kalenderansicht mit geplanten Beiträgen und rechts der Schnellzugriff für neue Posts.
Beim ersten Start ist das Dashboard leer – noch keine Plattformen, keine Beiträge, keine Medien.

👉 Screenshot geeignet: Browseransicht mit leerem Postiz-Dashboard (Menü links, Kalenderansicht sichtbar)

Hauptbereiche der Oberfläche

Bereich	Beschreibung
Dashboard	Kalenderansicht aller geplanten und vergangenen Beiträge.
Channels	Verwaltung der verbundenen Social-Media-Konten.
Posts	Übersicht aller erstellten, geplanten oder veröffentlichten Beiträge.
Media	Upload-Bereich für Bilder, Videos und Thumbnails.
Settings	Globale Einstellungen wie Zeitzone, Sprache und API-Zugänge.

Note

Postiz läuft vollständig lokal und speichert alle Medien, Tokens und Beiträge im eigenen Container.
Es werden keine Daten an Dritte übertragen – jede API-Verbindung erfolgt direkt zwischen deinem Server und der jeweiligen Plattform.

👉 Screenshot geeignet: geöffnete „Channels“-Seite mit leerer Liste und sichtbarem Button Add Channel

Discord-Kanal verbinden

Discord ist die einfachste Plattform, um Postiz zu testen.
Die Integration funktioniert vollständig über OAuth2, ohne dass du eine eigene App erstellen musst.

Klicke in Postiz auf Channels → Add Channel → Discord.
Ein neues Fenster öffnet den Discord-OAuth-Dialog.
Melde dich mit deinem Discord-Account an und wähle den Server aus, auf dem Postiz posten darf.
Bestätige mit Authorize.
Nach der Weiterleitung erscheint dein Discord-Server in der Channel-Liste.

👉 Screenshot geeignet: Discord-OAuth2-Dialog mit Serverauswahl und aktivierter Berechtigung Send Messages

Tip

Wenn du Postiz auf mehreren Discord-Servern nutzen möchtest,
wiederhole den Vorgang pro Server.
Jeder Server wird als eigener Channel geführt und kann unabhängig geplant werden.

YouTube-Kanal verbinden (YouTube Data API v3, OAuth)

Im Gegensatz zu Discord benötigt YouTube eine eigene OAuth-App.
Dieser Prozess ist kostenlos, aber notwendig, um Postiz Zugriff auf dein YouTube-Konto zu gewähren.
Du richtest diese App einmalig in der Google Cloud Console ein.

Schritt 1 – Google Cloud-Projekt und API aktivieren

Öffne die Google Cloud Console und lege ein neues Projekt an (oder wähle ein bestehendes).
Gehe zu APIs & Services → Bibliothek und aktiviere die YouTube Data API v3.
Wechsle zu APIs & Services → OAuth-Zustimmungsbildschirm
- Wähle User Type: External
- Trage App-Namen, Support-Mail und Entwickler-Kontakt ein
- Unter Test Users deine Google-Adresse hinzufügen
- Speichern

👉 Screenshot geeignet: Google Cloud Console mit aktivierter YouTube Data API v3

Note

Für den privaten Betrieb reicht der Testmodus völlig aus.
Eine Verifizierung der App ist nicht erforderlich, solange nur freigegebene Testnutzer sie verwenden.

Schritt 2 – OAuth-Client-ID erstellen

Gehe zu APIs & Services → Anmeldedaten → Anmeldedaten erstellen → OAuth-Client-ID.
Wähle Anwendungstyp: Webanwendung.

Trage als autorisierte Weiterleitungs-URI ein:

https://<deine-postiz-domain>/integrations/social/youtube

Erstelle die App und notiere Client-ID und Client-Secret.

👉 Screenshot geeignet: Dialog „OAuth-Client-ID erstellen“ mit eingetragener Redirect-URI

Schritt 3 – Zugangsdaten in Postiz eintragen

Öffne deine Postiz-Konfiguration:

nano /opt/postiz/.env

Ergänze:

YOUTUBE_CLIENT_ID="<deine-client-id>"
YOUTUBE_CLIENT_SECRET="<dein-client-secret>"

Speichern und Postiz neu starten:

cd /opt/postiz
docker compose down
docker compose up -d

👉 Screenshot geeignet: Terminalausgabe docker compose up -d (Container erfolgreich neu gestartet)

Note

Änderungen an Umgebungsvariablen werden erst nach einem vollständigen Compose-Neustart übernommen.

Schritt 4 – YouTube-Kanal in Postiz hinzufügen

In Postiz Channels → Add Channel → YouTube öffnen.
Der Browser öffnet Googles OAuth-Dialog.
Melde dich mit deinem Account an (der unter Test Users eingetragen wurde).
Zugriff erlauben und bestätigen.
Nach erfolgreicher Rückleitung erscheint dein YouTube-Kanal in der Channel-Liste.

👉 Screenshot geeignet: Postiz-Channels-Ansicht mit verbundenem YouTube-Kanal

Schritt 5 – Funktionstest

Öffne in Postiz Posts → New Post.
Wähle als Channel YouTube und gib einen Testtitel ein.
Füge ein Thumbnail hinzu und speichere als Draft.
Optional plane die Veröffentlichung zu einem bestimmten Zeitpunkt.
Überprüfe den Status unter Posts → Scheduled / Posted.

👉 Screenshot geeignet: Postiz-Post-Detailansicht mit aktivem Channel „YouTube“ und Status Scheduled

Häufige Fehler und Lösungen

redirect_uri_mismatch
Die eingetragene URI stimmt nicht exakt mit der Weiterleitungsadresse überein.
Sie muss exakt lauten:
```
https://<deine-postiz-domain>/integrations/social/youtube
```
App blockiert oder Warnmeldung
Stelle sicher, dass dein Account als Test User hinterlegt ist.
Andernfalls blockiert Google den Login.
Änderungen ohne Wirkung
Compose-Neustart vergessen.
Immer mit:
```
docker compose down && docker compose up -d
```

👉 Screenshot geeignet: Google OAuth-Fehlerseite mit markiertem Feld redirect_uri_mismatch

Schritt 8 – Ersten Beitrag planen und veröffentlichen

Nach der erfolgreichen Einrichtung von Discord und YouTube kannst du jetzt deinen ersten Beitrag erstellen und die Veröffentlichung testen.
Dieser Schritt dient nicht nur der Funktionsprüfung, sondern auch dem Verständnis, wie Postiz Beiträge verwaltet und mit mehreren Plattformen gleichzeitig arbeitet.

Öffne im Menü Posts → New Post.
Es öffnet sich der Editor mit Feldern für Text, Medien, Zielkanäle und Veröffentlichungszeitpunkt.

👉 Screenshot geeignet: Postiz-Editor mit leeren Feldern für Text, Media und Channel-Auswahl

Beitrag erstellen

Gib im Feld Content einen kurzen Testtext ein, z. B.

Testpost aus dem UCC – automatisiert über Postiz 🦉

Wähle unter Channels mindestens einen aktiven Kanal aus:
- Discord (Textnachricht im ausgewählten Channel)
- YouTube (Post oder Community-Eintrag, je nach Kontoart)
Optional: Lade ein Bild oder Thumbnail hoch.
Klicke dazu auf Add Media und wähle eine Datei aus dem lokalen Speicher.
Wähle im Feld Schedule date & time einen Zeitpunkt in der Zukunft.
Die Zeitzone richtet sich nach deiner Einstellung unter Settings → General (z. B. Europe/Berlin).

Tip

Wenn du keinen Zeitpunkt angibst, kannst du den Beitrag sofort mit Publish now veröffentlichen.
Geplante Posts erscheinen automatisch im Kalender und wechseln nach Ablauf der Zeit auf den Status Posted.

👉 Screenshot geeignet: ausgefülltes Postiz-Formular mit gewähltem Discord-Channel, Datum und Textinhalt

Veröffentlichung prüfen

Öffne den Reiter Posts → Scheduled.
Dein geplanter Beitrag sollte dort mit Status Waiting angezeigt werden.
Nach Ablauf des Zeitpunkts wird der Status automatisch auf Posted gesetzt.
Prüfe anschließend die Zielplattform:
- In Discord sollte der Post als Bot-Nachricht erscheinen.
- In YouTube findest du den Eintrag im Community-Tab (sofern aktiviert).

👉 Screenshot geeignet: Discord-Channel mit sichtbarer Bot-Nachricht „Testpost aus dem UCC – automatisiert über Postiz 🦉“

Note

Der YouTube-Post erscheint nur, wenn dein Kanal Community-Posts erlaubt.
Bei neueren oder kleineren Kanälen kann diese Funktion von Google noch deaktiviert sein.

Veröffentlichung manuell auslösen

Wenn du Beiträge sofort testen möchtest, ohne zu warten, kannst du sie direkt manuell veröffentlichen:

Öffne den Beitrag unter Posts → Drafts.
Klicke auf Publish now.
Der Beitrag wird sofort an alle ausgewählten Plattformen gesendet.

👉 Screenshot geeignet: Postiz-Postansicht mit markiertem Button Publish now

Tip

Die manuelle Veröffentlichung eignet sich für spontane Ankündigungen oder Posts außerhalb des normalen Zeitplans.
Im späteren Workflow kann sie auch durch n8n-Trigger oder automatisierte Events ausgelöst werden.

Troubleshooting & Tipps

Auch wenn Postiz im Alltag zuverlässig läuft, können während der Einrichtung oder im Betrieb gelegentlich Fehler auftreten.
Dieser Abschnitt hilft dir, typische Probleme schnell zu erkennen und gezielt zu beheben.

👉 Screenshot geeignet: Übersicht im UCC-Dashboard mit markiertem Postiz-Container

Problem: Weboberfläche nicht erreichbar

Symptome:
Beim Aufruf von https://postiz.deinedomain.tld erscheint eine Fehlermeldung oder der Browser kann keine Verbindung herstellen.

Lösungen:

Container-Status prüfen
```
docker compose ps
```
Wenn einer der Container gestoppt ist:
```
docker compose up -d
```
Port und Proxy-Eintrag kontrollieren
Im Nginx Proxy Manager sicherstellen, dass Forward Hostname/IP und Port 8080 korrekt eingetragen sind.
SSL-Zertifikat prüfen
Falls Let’s Encrypt-Validierung fehlschlug, Domain-Eintrag und DNS-Ziel überprüfen.

Tip

Wenn der Browser einen 502-Fehler meldet, läuft meist der Backend-Container nicht.
In diesem Fall helfen die Logs weiter:
docker compose logs postiz

👉 Screenshot geeignet: NPM-Dashboard mit markiertem Proxy-Host postiz.deinedomain.tld

Problem: Discord-Posts werden nicht gesendet

Symptome:
Der Beitrag erscheint im Postiz-Kalender, aber nicht im Discord-Channel.

Lösungen:

Prüfe die Bot-Berechtigungen auf dem Discord-Server.
Der Bot benötigt mindestens Send Messages und Embed Links.
Token ungültig?
Trenne den Channel in Postiz (Remove Channel) und füge ihn erneut hinzu.
Rate-Limit?
Discord blockiert bei zu vielen Nachrichten in kurzer Zeit.
Warte einige Minuten und teste erneut.

Note

Discord erlaubt maximal einen automatisierten Post pro Sekunde pro Kanal.
Höhere Frequenzen werden verworfen.

👉 Screenshot geeignet: Discord-Serverrollen mit aktivierten Berechtigungen Send Messages und Embed Links

Problem: YouTube-Verbindung bricht ab

Symptome:
Postiz zeigt „Token expired“ oder keine neuen YouTube-Posts werden ausgeführt.

Lösungen:

Überprüfe, ob der Google-OAuth-Zugang abgelaufen ist.
In der Google Cloud Console unter OAuth 2.0 Client IDs kannst du die Token-Gültigkeit prüfen.
Trenne in Postiz den YouTube-Channel und verbinde ihn erneut.
Wenn die Fehlermeldung „invalid grant“ erscheint, ist der Refresh-Token ungültig – erneute Anmeldung behebt das Problem.

Tip

Google-Tokens laufen regelmäßig ab.
Postiz verlängert sie automatisch, sofern der Container dauerhaft läuft und Zugriff auf die Datenbank hat.

👉 Screenshot geeignet: Postiz-Channels-Ansicht mit Warnsymbol bei YouTube-Channel

Problem: Container startet nicht oder beendet sich sofort

Symptome:
Nach docker compose up -d stoppt der Postiz-Container direkt wieder.

Lösungen:

Logs prüfen
```
docker compose logs postiz
```
Häufige Ursachen:
- Tippfehler in .env
- ungültiger POSTIZ_PORT
- fehlerhafte DB-Verbindung
Datenbankstatus prüfen
```
docker compose logs db
```
Wenn PostgreSQL fehlerhaft initialisiert wurde:
```
docker compose down
rm -rf db/*
docker compose up -d
```
(nur im Testbetrieb, Daten gehen dabei verloren)

Note

Stoppt der Container unmittelbar nach dem Start, ist fast immer ein Variablen- oder Portfehler die Ursache.

👉 Screenshot geeignet: Terminalausgabe von docker compose logs postiz mit markierter Fehlermeldung

Problem: Speicherplatz läuft voll

Symptome:
Uploads oder Medienverarbeitung schlagen fehl, Logs zeigen I/O-Fehler.

Lösungen:

Speicherbelegung prüfen
```
df -h /opt/postiz
```
Alte Logs und temporäre Daten löschen
```
rm -rf /opt/postiz/data/logs/*
```
Storage erweitern
```
pct resize <CTID> rootfs +10G
```

Tip

Der Medien-Cache wächst mit jedem Upload.
Plane regelmäßige Bereinigung oder Auslagerung auf ein separates Volume.

👉 Screenshot geeignet: Terminalausgabe von df -h mit markiertem Postiz-Container

Backups

Postiz nutzt lokale Volumes für Datenbank, Medien und Konfiguration.
Diese können direkt gesichert werden, idealerweise über Kopia oder dein zentrales UCC-Backup-System.

Pfad	Inhalt	Sicherung notwendig
`/opt/postiz/data/`	App- und Metadaten	✅
`/opt/postiz/db/`	PostgreSQL-Datenbank	✅
`/opt/postiz/redis/`	Cache-Daten (optional)	optional
`/opt/postiz/.env`	Umgebungsvariablen	✅

Beispiel für ein manuelles Backup:

tar -czf /srv/backup/postiz-$(date +%F).tar.gz /opt/postiz/data /opt/postiz/db /opt/postiz/.env

👉 Screenshot geeignet: Terminalausgabe nach erfolgreicher Archiv-Erstellung (postiz-YYYY-MM-DD.tar.gz sichtbar)

Note

Redis-Daten müssen nicht zwingend gesichert werden – sie werden beim Neustart automatisch neu aufgebaut.

Updates und Wartung

Postiz wird aktiv weiterentwickelt.
Neue Versionen erscheinen regelmäßig als Container-Image in der GitHub Container Registry.

Aktualisierung durchführen:

cd /opt/postiz
docker compose pull
docker compose down
docker compose up -d

Nach dem Neustart die Versionsnummer prüfen:

docker compose logs postiz | grep "version"

Tip

Vor größeren Updates empfiehlt sich ein vollständiges Backup der Verzeichnisse /opt/postiz/data und /opt/postiz/db.
So kannst du bei Problemen jederzeit zur vorherigen Version zurückkehren.

👉 Screenshot geeignet: Terminalausgabe docker compose pull mit sichtbarem Update-Download

Ergebnis

Nach Abschluss dieses Kapitels läuft Postiz als zentraler Bestandteil deines UCC-Ökosystems.
Du hast eine vollständig selbst gehostete Social-Media-Management-Lösung eingerichtet,
die mehrere Plattformen gleichzeitig ansteuern kann – ohne Cloud-Abhängigkeiten oder Fremdzugriffe.

Dein aktuelles Setup umfasst:

Postiz-Container – Verwaltung von Beiträgen, Kanälen und Zeitplänen
PostgreSQL-Datenbank – Speicherung von Post-Metadaten, Tokens und Zeitstempeln
Redis-Cache – Optimierung von API-Abfragen und Queue-Prozessen
Nginx Proxy Manager – sichere HTTPS-Bereitstellung unter https://postiz.deinedomain.tld
Verbundenen Discord- und YouTube-Channel – für unmittelbare Tests und Veröffentlichung
Automatische Startlogik – alle Dienste starten selbständig nach einem Reboot

👉 Screenshot geeignet: Postiz-Dashboard mit verbundenen Channels (Discord, YouTube) und sichtbaren geplanten Beiträgen

Damit bietet dein UCC nun eine vollwertige Social-Automation-Schicht.
Postiz kann Posts planen, zeitgesteuert veröffentlichen und künftig mit n8n-Workflows verknüpft werden,
um Trigger-gesteuerte Posts, Stream-Ankündigungen oder automatische Upload-Benachrichtigungen zu erzeugen.

Tip

Im Premium-Kapitel lernst du, wie Postiz mit n8n gekoppelt wird,
um Beiträge automatisch aus Streaming-Ereignissen, Nextcloud-Uploads oder Kalender-Terminen zu erstellen.
Außerdem erfährst du dort, wie du erweiterte Plattformen (TikTok, Meta, LinkedIn)
über eigene App-Integrationen sicher und dauerhaft einbindest.

Postiz erweitert dein Homelab damit um einen entscheidenden Bereich –
kommunikative Automatisierung.
Was bisher manuell über einzelne Plattformen lief, wird jetzt zentral gesteuert, dokumentiert und planbar –
direkt aus deiner eigenen Infrastruktur, sicher, kontrolliert und unabhängig.

33 KiB Raw Blame History Unescape Escape

Kapitel 17 – Postiz (Social Media Verwaltung & Automatisierung)

Einleitung

Voraussetzungen & Ressourcen

Container-Ressourcen

Technische Voraussetzungen

Schritt-für-Schritt-Anleitung

Schritt 1 – System vorbereiten und aktualisieren

Schritt 2 – Basis-Pakete installieren

Schritt 3 – Verzeichnisstruktur und Konfigurationsbasis anlegen

Schritt 4 – Container starten und Erstinitialisierung prüfen

Schritt 5 – Dienst dauerhaft aktivieren und Neustart-Verhalten prüfen

Schritt 6 – Integration in Nginx Proxy Manager (NPM)

Proxy-Host anlegen

Verbindung testen

Schritt 7 – Oberfläche verstehen und erste Einrichtung durchführen

Hauptbereiche der Oberfläche

Discord-Kanal verbinden

YouTube-Kanal verbinden (YouTube Data API v3, OAuth)

Schritt 1 – Google Cloud-Projekt und API aktivieren

Schritt 2 – OAuth-Client-ID erstellen

Schritt 3 – Zugangsdaten in Postiz eintragen

Schritt 4 – YouTube-Kanal in Postiz hinzufügen

Schritt 5 – Funktionstest

Häufige Fehler und Lösungen

Schritt 8 – Ersten Beitrag planen und veröffentlichen

Beitrag erstellen

Veröffentlichung prüfen

Veröffentlichung manuell auslösen

Troubleshooting & Tipps

Problem: Weboberfläche nicht erreichbar

Problem: Discord-Posts werden nicht gesendet

Problem: YouTube-Verbindung bricht ab

Problem: Container startet nicht oder beendet sich sofort

Problem: Speicherplatz läuft voll

Backups

Updates und Wartung

Ergebnis

33 KiB

Raw Blame History