Homelab--Bratonein-Kontrollzentrum--Tutorial/Kapitel 17/Free Rohtext.md

# 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@<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:

```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@<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.

```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://<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  
> ```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://<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:

```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** | `<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:
> ```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://<deine-postiz-domain>/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="<deine-client-id>"
YOUTUBE_CLIENT_SECRET="<dein-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://<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:
  ```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 <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:

```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.