From 93d42d6f78839ae168560b58dd45a05376845bc0 Mon Sep 17 00:00:00 2001 From: Thomas Dannenberg Date: Sun, 19 Oct 2025 11:37:25 +0000 Subject: [PATCH] =?UTF-8?q?Kapitel=2017/Free=20Rohtext.md=20hinzugef=C3=BC?= =?UTF-8?q?gt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Kapitel 17/Free Rohtext.md | 895 +++++++++++++++++++++++++++++++++++++ 1 file changed, 895 insertions(+) create mode 100644 Kapitel 17/Free Rohtext.md diff --git a/Kapitel 17/Free Rohtext.md b/Kapitel 17/Free Rohtext.md new file mode 100644 index 0000000..0533b71 --- /dev/null +++ b/Kapitel 17/Free Rohtext.md @@ -0,0 +1,895 @@ +# Kapitel 17 – Postiz (Social Media Verwaltung & Automatisierung) + +## 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: + ```bash + ssh root@ + ``` + Ersetze `` 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: + +```bash +apt update && apt upgrade -y +``` + +Nach Abschluss des Updates den Container neu starten: + +```bash +reboot +``` + +Melde dich nach dem Neustart erneut an: + +```bash +ssh root@ +``` + +> [!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. + +```bash +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: + +```bash +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: + +```bash +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: + +```bash +mkdir -p /opt/postiz +cd /opt/postiz +``` + +Erstelle anschließend die Standardverzeichnisse: + +```bash +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: + +```bash +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: + +```bash +nano /opt/postiz/docker-compose.yml +``` + +Füge folgenden Inhalt ein: + +```yaml +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: + +```bash +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: + +```bash +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://: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 +> ```bash +> 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://: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: + +```bash +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: + +```bash +reboot +``` + +Nach dem Reboot erneut einloggen und prüfen, ob die Dienste automatisch gestartet wurden: + +```bash +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: + +```bash +docker compose restart +``` + +oder – bei einem vollständigen Neuaufbau nach Updates – + +```bash +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 + +1. Öffne das Dashboard des **Nginx Proxy Manager**. +2. Klicke auf **Add Proxy Host**. +3. Trage folgende Werte ein: + +| Feld | Wert | +|------|------| +| **Domain Names** | `postiz.deinedomain.tld` | +| **Scheme** | `http` | +| **Forward Hostname / IP** | `` | +| **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: +> ```bash +> 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. + +1. Klicke in Postiz auf **Channels → Add Channel → Discord**. +2. Ein neues Fenster öffnet den Discord-OAuth-Dialog. +3. Melde dich mit deinem Discord-Account an und wähle den Server aus, auf dem Postiz posten darf. +4. Bestätige mit **Authorize**. +5. 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 + +1. Öffne die **Google Cloud Console** und lege ein neues Projekt an (oder wähle ein bestehendes). +2. Gehe zu **APIs & Services → Bibliothek** und aktiviere die **YouTube Data API v3**. +3. 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 + +1. Gehe zu **APIs & Services → Anmeldedaten → Anmeldedaten erstellen → OAuth-Client-ID**. +2. Wähle **Anwendungstyp: Webanwendung**. +3. Trage als **autorisierte Weiterleitungs-URI** ein: + ``` + https:///integrations/social/youtube + ``` +4. 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: + +```bash +nano /opt/postiz/.env +``` + +Ergänze: + +``` +YOUTUBE_CLIENT_ID="" +YOUTUBE_CLIENT_SECRET="" +``` + +Speichern und Postiz neu starten: + +```bash +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 + +1. In Postiz **Channels → Add Channel → YouTube** öffnen. +2. Der Browser öffnet Googles OAuth-Dialog. +3. Melde dich mit deinem Account an (der unter Test Users eingetragen wurde). +4. Zugriff erlauben und bestätigen. +5. Nach erfolgreicher Rückleitung erscheint dein YouTube-Kanal in der Channel-Liste. + +👉 **Screenshot geeignet:** Postiz-Channels-Ansicht mit verbundenem YouTube-Kanal + +##### Schritt 5 – Funktionstest + +1. Öffne in Postiz **Posts → New Post**. +2. Wähle als Channel **YouTube** und gib einen Testtitel ein. +3. Füge ein Thumbnail hinzu und speichere als **Draft**. +4. Optional plane die Veröffentlichung zu einem bestimmten Zeitpunkt. +5. Ü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:///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: + ```bash + 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 + +1. Gib im Feld **Content** einen kurzen Testtext ein, z. B. + ``` + Testpost aus dem UCC – automatisiert über Postiz 🦉 + ``` +2. Wähle unter **Channels** mindestens einen aktiven Kanal aus: + - **Discord** (Textnachricht im ausgewählten Channel) + - **YouTube** (Post oder Community-Eintrag, je nach Kontoart) +3. Optional: Lade ein Bild oder Thumbnail hoch. + Klicke dazu auf **Add Media** und wähle eine Datei aus dem lokalen Speicher. +4. 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 + +1. Öffne den Reiter **Posts → Scheduled**. + Dein geplanter Beitrag sollte dort mit Status *Waiting* angezeigt werden. +2. Nach Ablauf des Zeitpunkts wird der Status automatisch auf *Posted* gesetzt. +3. 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: + +1. Öffne den Beitrag unter **Posts → Drafts**. +2. Klicke auf **Publish now**. +3. 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:** + +1. Container-Status prüfen + ```bash + docker compose ps + ``` + Wenn einer der Container gestoppt ist: + ```bash + docker compose up -d + ``` + +2. Port und Proxy-Eintrag kontrollieren + Im Nginx Proxy Manager sicherstellen, dass **Forward Hostname/IP** und **Port 8080** korrekt eingetragen sind. + +3. 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: +> ```bash +> 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:** + +1. Prüfe die Bot-Berechtigungen auf dem Discord-Server. + Der Bot benötigt mindestens **Send Messages** und **Embed Links**. +2. Token ungültig? + Trenne den Channel in Postiz (**Remove Channel**) und füge ihn erneut hinzu. +3. 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:** + +1. Ü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. +2. Trenne in Postiz den YouTube-Channel und verbinde ihn erneut. +3. 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:** + +1. Logs prüfen + ```bash + docker compose logs postiz + ``` + Häufige Ursachen: + - Tippfehler in `.env` + - ungültiger `POSTIZ_PORT` + - fehlerhafte DB-Verbindung +2. Datenbankstatus prüfen + ```bash + docker compose logs db + ``` + Wenn PostgreSQL fehlerhaft initialisiert wurde: + ```bash + 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:** + +1. Speicherbelegung prüfen + ```bash + df -h /opt/postiz + ``` +2. Alte Logs und temporäre Daten löschen + ```bash + rm -rf /opt/postiz/data/logs/* + ``` +3. Storage erweitern + ```bash + pct resize 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: + +```bash +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: + +```bash +cd /opt/postiz +docker compose pull +docker compose down +docker compose up -d +``` + +Nach dem Neustart die Versionsnummer prüfen: + +```bash +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. \ No newline at end of file