diff --git a/Kapitel 17/Premium Rohtext.md b/Kapitel 17/Premium Rohtext.md new file mode 100644 index 0000000..fd61668 --- /dev/null +++ b/Kapitel 17/Premium Rohtext.md @@ -0,0 +1,515 @@ +# Premium – Postiz: Automatisierung, Integration & erweiterte Plattformanbindung + +Postiz ist im UCC weit mehr als ein reiner Social-Media-Planer. +Im Free-Kapitel wurde die Basis geschaffen – ein lokal gehostetes System zur Verwaltung und Planung von Beiträgen auf Discord und YouTube. +Dieser Premium-Teil erweitert das Setup zu einer **vollautomatisierten Kommunikationszentrale**, +die eigenständig Inhalte plant, mit Streaming-Ereignissen verknüpft, Tokens sicher verwaltet und Zustände permanent überwacht. + +Ziel ist eine Infrastruktur, in der **Social-Media-Aktivität, Streaming-Automation und Systemstatus** +ineinandergreifen – ohne externe Dienste wie Hootsuite, Later oder Buffer. +Postiz wird zum Werkzeug, das automatisch Ankündigungen erstellt, Stream-Beginn oder Upload-Events erkennt, +Beiträge kanalübergreifend veröffentlicht und alle Schlüssel sicher in Vaultwarden ablegt. + +👉 **Screenshot geeignet:** Architekturdiagramm mit Datenfluss zwischen Postiz, n8n, Vaultwarden, Netdata und Plattformen (Discord, YouTube, TikTok, Meta) + +> [!NOTE] +> Dieses Kapitel setzt eine vollständig funktionierende Free-Installation voraus. +> Stelle sicher, dass dein Postiz-Container läuft, über HTTPS erreichbar ist und Discord- und YouTube-Posts erfolgreich ausgeführt werden können. + +In diesem Premium-Teil lernst du: +- wie du **TikTok** und **Meta-Plattformen** (Facebook, Instagram) über eigene Entwickler-Apps sicher einbindest, +- wie du mit **n8n-Workflows** Beiträge automatisch planen und posten kannst – etwa bei neuen Streams oder Kalender-Terminen, +- wie du Tokens und Secrets sicher in **Vaultwarden** speicherst, +- wie du über **Netdata** die Postiz-Instanz und API-Antwortzeiten überwachst, +- und wie du über **Kopia** eine saubere Backup-Strategie für alle relevanten Daten einrichtest. + +Am Ende dieses Kapitels steht eine vollständig integrierte Kommunikations- und Automatisierungsschicht, +die Social-Media-Management, Systemüberwachung und Sicherheit im eigenen UCC vereint – +**schnell, datensouverän und unabhängig von kommerziellen Plattformdiensten.** + +--- + +## Modul – TikTok-Integration im UCC + +Mit diesem Modul bindest du **TikTok** direkt in dein UCC-System über Postiz ein. +Damit kannst du Videos automatisch hochladen, Beiträge vorausplanen und Inhalte zentral steuern – ohne auf TikTok-eigenes Scheduling angewiesen zu sein. +Die Integration erfolgt über die **TikTok Developer Platform** und nutzt das offizielle **Login Kit** sowie die **Content Posting API**. + +👉 **Screenshot geeignet:** Architekturdiagramm mit Datenfluss Postiz ↔ TikTok API ↔ UCC + +> [!NOTE] +> TikTok erfordert zur API-Nutzung eine eigene App-Registrierung. +> Diese App dient nur als Schnittstelle zwischen Postiz und deinem Konto – du veröffentlichst also weiterhin in deinem eigenen Namen, aber mit automatisierten Abläufen. + +### Voraussetzungen + +* Ein **TikTok-Developer-Konto** unter [https://developers.tiktok.com](https://developers.tiktok.com) +* Ein verifiziertes **TikTok-Business- oder Creator-Konto** +* Eine **Postiz-Instanz mit HTTPS-Zugang** (`https://postiz.deinedomain.tld`) +* Optional: Zugriff auf deine **TikTok-Sandbox-App** (zum Testen und Verifizieren) + +👉 **Screenshot geeignet:** TikTok Developer Dashboard mit sichtbarer App-Übersicht + +> [!TIP] +> TikTok ist deutlich restriktiver als andere Plattformen. +> Plane genug Zeit für Verifikation und API-Freigabe ein – der Prozess kann einige Tage dauern. + +### Schritt 1 – App erstellen + +1. Melde dich bei [https://developers.tiktok.com](https://developers.tiktok.com) an. +2. Öffne das **Developer Console Dashboard** und klicke auf **Create App**. +3. Wähle eine Kategorie, die deinem Projekt am nächsten kommt – + *Business*, *Productivity* oder *Entertainment* sind die gängigsten. +4. Trage folgende Informationen ein: + * **App Name:** z. B. `UCC TikTok Integration` + * **App Icon:** dein Projektlogo oder ein neutrales Symbol + * **App Description:** + > „Diese Anwendung integriert die TikTok Login- und Content-Posting-API, + > um automatisiertes Hochladen und Planen von Inhalten innerhalb des UCC zu ermöglichen.“ + * **Privacy Policy URL:** `https://postiz.deinedomain.tld/privacy` + * **Terms of Service URL:** `https://postiz.deinedomain.tld/terms` + +👉 **Screenshot geeignet:** TikTok App-Erstellungsformular mit ausgefüllten Feldern + +> [!NOTE] +> Der App-Name und die Beschreibung müssen deinem Projekt entsprechen. +> TikTok prüft manuell, ob die Angaben zu Zweck und Nutzung passen. + +### Schritt 2 – Redirect-URL und Berechtigungen festlegen + +1. Öffne in deiner neuen App die Registerkarte **App Information**. +2. Füge unter *Redirect URL* folgende Adresse ein: + ``` + https://postiz.deinedomain.tld/integrations/social/tiktok + ``` +3. Unter *Permissions* aktiviere diese Scopes: + ``` + user.info.basic + user.info.profile + video.upload + video.publish + ``` +4. Speichere die Änderungen. + +👉 **Screenshot geeignet:** TikTok App Settings mit markierten Berechtigungen + +> [!NOTE] +> Diese Scopes ermöglichen Postiz, sich über dein Konto zu authentifizieren (`user.info.*`) +> und anschließend Videos hochzuladen (`video.upload`) sowie zu veröffentlichen (`video.publish`). + +### Schritt 3 – Domain-Verifikation durchführen + +Bevor du deine App nutzen kannst, muss TikTok verifizieren, dass du die angegebene Domain wirklich besitzt. +Dazu stellt TikTok einen Verifikations-Code bereit. + +1. Öffne im App-Dashboard den Bereich **App Verification**. +2. Kopiere den bereitgestellten Verifikations-Code. +3. Abhängig von deinem Hostinganbieter kannst du die Verifikation auf zwei Arten durchführen: + + **A) DNS-Verifikation:** + * Erstelle im DNS-Manager deines Providers (z. B. Strato, IONOS, Cloudflare) einen neuen TXT-Record. + * Trage den von TikTok gelieferten Code ein. + * Warte, bis der Record öffentlich erreichbar ist (bis zu 30 Minuten). + + **B) Datei-Verifikation:** + * Lade die bereitgestellte Datei in das Stammverzeichnis deiner Postiz-Instanz hoch. + * Stelle sicher, dass sie über `https://postiz.deinedomain.tld/` erreichbar ist. + +👉 **Screenshot geeignet:** TikTok Verifikationsfenster mit Beispielcode + +> [!TIP] +> Falls du unsicher bist, wie du den DNS-Record oder das Stammverzeichnis anpasst, +> sieh in der Dokumentation deines Hostinganbieters nach. +> Jeder Provider beschreibt dort, wie TXT-Records angelegt oder Dateien im Webroot platziert werden. + +> [!NOTE] +> Nach erfolgreicher Prüfung zeigt TikTok im Dashboard einen grünen Haken an. +> Das rote Symbol daneben ist nur eine Schaltfläche zum Entfernen der Domain – kein Fehlerhinweis. + +### Schritt 4 – App Review (Sandbox oder Live) + +TikTok prüft jede App manuell. +Du kannst die Integration aber bereits **in der Sandbox** testen, bevor sie live geschaltet wird. + +1. Öffne im Developer-Dashboard den Tab **App Review**. +2. Füge eine kurze englische Beschreibung hinzu, z. B.: + ``` + This web application integrates TikTok Login Kit and Content Posting API + to allow users to manage their TikTok content within Postiz. + Login Kit is used for secure authentication. + user.info.basic and user.info.profile provide account display name and avatar. + video.upload and video.publish allow automated publishing to connected accounts. + ``` +3. Lade mindestens **ein kurzes Video** hoch, das den Ablauf zeigt: + * Login über Postiz + * Erstellen eines Test-Posts (Sandbox) + * Veröffentlichung auf TikTok + +👉 **Screenshot geeignet:** TikTok Review-Seite mit ausgefülltem Formular + +> [!NOTE] +> Das Video muss keinen Ton enthalten – TikTok prüft nur den Funktionsablauf. +> Achte darauf, dass dein Dashboard (Postiz) klar erkennbar ist. + +> [!TIP] +> Während der Review-Phase kannst du im Sandbox-Modus weiterhin testen. +> Die App wird nach Freigabe automatisch produktiv geschaltet. + +### Schritt 5 – Verbindung zu Postiz herstellen + +1. Öffne dein Postiz-Dashboard. +2. Gehe zu *Einstellungen → Integrationen → TikTok*. +3. Klicke auf **Connect**. +4. Im Popup-Fenster öffnet sich der TikTok-Login. + Melde dich an, gewähre die angeforderten Berechtigungen und bestätige den Zugriff. +5. Nach erfolgreicher Verbindung erscheint dein TikTok-Kanal in der Postiz-Kanalliste. + +👉 **Screenshot geeignet:** Postiz-OAuth-Fenster mit TikTok-Login + +> [!NOTE] +> Wenn der Login fehlschlägt, prüfe, ob die App-Domain korrekt verifiziert wurde und alle Berechtigungen aktiviert sind. + +### Schritt 6 – Testvideo veröffentlichen + +Erstelle in Postiz einen kurzen Testbeitrag mit Video. +Wähle den TikTok-Kanal aus, gib Titel und Beschreibung ein und klicke auf **Sofort veröffentlichen**. +Das Video erscheint nach wenigen Sekunden in deinem TikTok-Konto (Sandbox oder Live, je nach Status). + +👉 **Screenshot geeignet:** Postiz-Planungsansicht mit aktivem TikTok-Kanal + +> [!TIP] +> Wenn das Video nicht hochgeladen wird, prüfe im TikTok Developer Dashboard den API-Status. +> Fehlermeldungen wie „invalid access token“ bedeuten meist, dass die App noch im Sandbox-Modus läuft oder die Verbindung abgelaufen ist. + +### Ergebnis + +Nach dieser Einrichtung ist TikTok vollständig in dein UCC integriert. +Du kannst Videos planen, automatisch veröffentlichen und bestehende Beiträge direkt aus Postiz verwalten. +Alle Daten bleiben dabei in deiner eigenen Infrastruktur – Postiz kommuniziert nur über die offizielle TikTok API. + +👉 **Screenshot geeignet:** Postiz-Kanalübersicht mit verbundenem TikTok-Konto + +> [!NOTE] +> Diese Integration nutzt ausschließlich offizielle Schnittstellen. +> Kein externer Dienst erhält Zugriff auf deine Daten – volle Kontrolle und Datensouveränität innerhalb des UCC. + +--- + +## Modul – Meta-Integration (Facebook & Instagram) + +Dieses Modul verbindet dein UCC mit der **Meta-Plattform**, also Facebook und Instagram. +Beide Dienste nutzen die gemeinsame **Meta Graph API**, weshalb du sie über eine einzige App in Postiz anbinden kannst. +So kannst du Beiträge planen, automatisiert veröffentlichen und deine Community gleichzeitig auf beiden Plattformen erreichen – direkt aus deinem eigenen UCC heraus. + +👉 **Screenshot geeignet:** Architekturdiagramm mit Datenfluss Postiz ↔ Meta Graph API ↔ Facebook & Instagram + +> [!NOTE] +> Diese Integration richtet sich an **Streamer:innen, Nerds und Kreative**, +> die Social-Media-Posts direkt aus ihrer Infrastruktur steuern möchten – ohne externe Tools wie Meta Business Suite oder Creator Studio. + +### Voraussetzungen + +* Ein **Meta-Entwicklerkonto** unter [https://developers.facebook.com](https://developers.facebook.com) +* Eine **Facebook-Seite** – notwendig für automatisiertes Posten +* Ein **Instagram-Business- oder Creator-Konto**, das mit dieser Facebook-Seite verknüpft ist +* Eine **Postiz-Instanz mit HTTPS-Zugang** (`https://postiz.deinedomain.tld`) + +👉 **Screenshot geeignet:** Übersicht aller Voraussetzungen in Checklistenform + +> [!TIP] +> Wenn du nur eine der beiden Plattformen nutzen möchtest, kannst du den anderen Teil einfach überspringen. +> Die technische Verbindung läuft trotzdem über dieselbe App. + +### Schritt 1 – Meta-App erstellen + +1. Melde dich bei [https://developers.facebook.com/apps](https://developers.facebook.com/apps) an. +2. Klicke auf **Create App** → wähle **Business**. +3. Gib deiner App einen Namen (z. B. `UCC-SocialConnector`) und hinterlege deine Kontakt-E-Mail. +4. Wähle im Menü links **Add Product → Facebook Login → Set Up (Web)**. +5. Trage bei *Valid OAuth Redirect URIs* exakt Folgendes ein: + ``` + https://postiz.deinedomain.tld/integrations/social/facebook + https://postiz.deinedomain.tld/integrations/social/instagram + ``` +6. Speichere und notiere dir **App ID** und **App Secret** – sie werden in Postiz benötigt. + +👉 **Screenshot geeignet:** Meta-App-Dashboard mit sichtbarer App ID und beiden Redirect-URIs + +> [!NOTE] +> Achte auf die exakte Schreibweise und das Protokoll (`https://`). +> Fehler in der Redirect-Adresse führen zu abgebrochenen Logins in Postiz. + +### Schritt 2 – Berechtigungen aktivieren + +Meta unterscheidet zwischen Basis- und erweiterten Zugriffsrechten (Scopes). +Für Postiz werden folgende Berechtigungen benötigt, damit **Facebook und Instagram** korrekt funktionieren: + +``` +business_management +pages_show_list +pages_read_engagement +pages_manage_posts +pages_manage_metadata +pages_manage_engagement +public_profile +email +instagram_basic +instagram_content_publish +instagram_manage_comments +instagram_manage_insights +``` + +👉 **Screenshot geeignet:** App-Dashboard mit aktivierten Berechtigungen und markiertem „Advanced Access“ + +> [!NOTE] +> Einige Berechtigungen wie `pages_manage_posts` oder `instagram_content_publish` benötigen **Advanced Access**. +> Meta prüft diesen Zugriff manuell und kann Nachweise verlangen – etwa eine öffentliche Website oder einen Hinweis auf deine Creator-Tätigkeit. +> Das ist normal und Teil des Review-Prozesses. + +> [!TIP] +> Verwende für den App-Beschreibungstext im Review einen neutralen, klaren Satz wie: +> „Diese Anwendung automatisiert Social-Media-Posts für Content- und Creator-Projekte über die offizielle Meta Graph API.“ + +### Schritt 3 – Verbindung zu Postiz herstellen + +1. Öffne dein **Postiz-Dashboard**. +2. Gehe zu *Einstellungen → Integrationen*. +3. Klicke auf **Facebook** oder **Instagram**, je nachdem, welche Plattform du zuerst anbinden willst. +4. Im Popup-Fenster öffnet sich der Meta-Login. + Melde dich mit deinem Facebook-Konto an und wähle die gewünschte Seite (und das verknüpfte Instagram-Profil). +5. Bestätige die Zugriffsanfrage – danach wird der Kanal automatisch im Postiz-Dashboard angezeigt. + +👉 **Screenshot geeignet:** Postiz-Interface während des Meta-Logins (OAuth-Fenster offen) + +> [!TIP] +> Wenn der Login nicht reagiert, prüfe, ob Pop-ups blockiert sind. +> Meta öffnet die Authentifizierung immer in einem separaten Fenster. + +### Schritt 4 – Testbeitrag veröffentlichen + +Nach erfolgreicher Verbindung erscheint dein Kanal (Facebook und/oder Instagram) unter *Einstellungen → Channels*. +Erstelle in Postiz einen kurzen Testbeitrag mit Bild oder Text und wähle den gewünschten Kanal aus. +Klicke anschließend auf **Sofort veröffentlichen** oder plane den Post zeitgesteuert. + +👉 **Screenshot geeignet:** Postiz-Planungsansicht mit aktivem Meta-Kanal + +> [!NOTE] +> Tokens bleiben in der Regel **60 Tage** gültig. +> Wenn Postiz eine „abgelaufene“ Verbindung meldet, reicht ein Klick auf **Reconnect**. + +### Schritt 5 – App Review (nur falls erforderlich) + +Wenn deine App im Entwicklungsmodus ist, funktioniert die Verbindung nur für dich und hinzugefügte Tester. +Für den produktiven Einsatz muss die App den **Live-Status** haben. + +1. Öffne dein App-Dashboard bei Meta. +2. Gehe zu *App Review → Permissions and Features*. +3. Wähle die benötigten Scopes aus (siehe oben). +4. Reiche eine kurze Beschreibung ein, z. B.: + ``` + This web application integrates Meta Graph API to allow users to manage and publish + social media content directly from their own UCC-based dashboard (Postiz integration). + ``` +5. Lade Screenshots oder ein kurzes Video hoch, das den Login- und Veröffentlichungsprozess zeigt. + Das Video muss keinen Ton enthalten – wichtig ist nur, dass Meta die Funktionsweise nachvollziehen kann. +6. Nach der Prüfung kannst du die App auf **Live** schalten. + +👉 **Screenshot geeignet:** Meta-App-Dashboard mit aktivierter Live-Option + +> [!NOTE] +> Der Review ist nur nötig, wenn du Postiz mit mehreren Benutzerkonten oder öffentlich nutzt. +> Für den Eigengebrauch reicht der Entwicklungsmodus. + +### Ergebnis + +Nach Abschluss dieses Moduls sind **Facebook und Instagram** vollständig in dein UCC integriert. +Du kannst Beiträge zentral planen, automatisiert veröffentlichen und plattformübergreifend synchronisieren – +ohne externe Cloud-Dienste oder Drittanbieter. + +👉 **Screenshot geeignet:** Postiz-Kanalübersicht mit verbundenen Facebook- und Instagram-Konten + +> [!TIP] +> Beide Plattformen nutzen dieselbe API-Struktur. +> Wenn Meta künftig neue Dienste (z. B. Threads) freigibt, kannst du die bestehende App weiterverwenden. +> Postiz aktualisiert die Schnittstellen automatisch, sobald neue Endpunkte unterstützt werden. + +## Modul – Sicherheits- und Token-Management in Postiz + +Postiz arbeitet mit API-Zugängen zu mehreren Plattformen. +Damit diese Verbindungen langfristig stabil und sicher bleiben, müssen Token, Logins und OAuth-Anmeldungen zentral verwaltet werden. +Im UCC übernimmt das **Vaultwarden-System** diese Aufgabe – automatisiert, sicher und nachvollziehbar. + +👉 **Screenshot geeignet:** Vaultwarden-Dashboard mit Einträgen „TikTok App“, „Instagram Graph“, „Facebook Page Access“ + +> [!NOTE] +> Dieses Modul richtet sich an Administrator:innen und Power-User, +> die mehrere Plattformen oder Team-Mitglieder verwalten und ihre Zugangsdaten dauerhaft sichern wollen. + +### Ziel des Moduls + +* API-Tokens zentral und verschlüsselt speichern +* Ablaufdaten und Erneuerungen im Blick behalten +* Zugriff für Team-Mitglieder sicher freigeben +* Notfall-Zugänge dokumentieren, ohne sie offenzulegen + +👉 **Screenshot geeignet:** Übersicht der Postiz-Integration in Vaultwarden mit Ablaufdaten + +### Vorbereitung in Vaultwarden + +1. Melde dich als Administrator:in an deiner Vaultwarden-Instanz an. +2. Erstelle einen neuen Ordner **Social-Integrationen**. +3. Innerhalb des Ordners legst du einzelne Einträge an: + * `TikTok_App_Token` + * `Meta_App_ID` + * `Meta_App_Secret` + * `Postiz_Admin_Login` +4. Setze als Typ **API Key** oder **Login**, je nach Feld. +5. Trage zusätzlich Ablaufdaten und Verwendungszweck im Notizfeld ein. + +> [!TIP] +> Die Einträge lassen sich später automatisch über `vaultwarden-cli` auslesen +> und als Umgebungsvariablen an Postiz übergeben. + +👉 **Screenshot geeignet:** Vaultwarden-Eintrag mit API-Key und Ablaufdatum + +### Automatische Bereitstellung der Token + +Damit Postiz nicht manuell mit neuen Tokens befüllt werden muss, +können die Secrets aus Vaultwarden automatisch in den Container injiziert werden. + +Erstelle im Host-System eine temporäre Export-Datei: + +```bash +docker exec vaultwarden /app/vaultwarden export > /tmp/vault_export.json +``` + +Extrahiere anschließend die relevanten Schlüssel: + +```bash +cat /tmp/vault_export.json | jq -r '.items[] | select(.name=="TikTok_App_Token") | .login.password' > /etc/postiz/secrets/tiktok.token +``` + +Füge die Variablen in die `postiz.env` ein: + +``` +POSTIZ_TIKTOK_TOKEN_FILE=/etc/postiz/secrets/tiktok.token +POSTIZ_META_APP_ID_FILE=/etc/postiz/secrets/meta_app.id +POSTIZ_META_APP_SECRET_FILE=/etc/postiz/secrets/meta_app.secret +``` + +> [!NOTE] +> Die Pfade verweisen auf lokale Dateien innerhalb des Containers. +> Beim Neustart werden die Werte automatisch eingelesen, ohne sie im Klartext anzuzeigen. + +👉 **Screenshot geeignet:** geöffnete `.env`-Datei mit Pfad-Referenzen auf Secret-Dateien + +### Token-Ablauf und Erneuerung + +Viele Plattform-Tokens laufen regelmäßig ab (z. B. alle 60 oder 90 Tage). +Damit der Scheduler in Postiz weiterarbeiten kann, sollte die Überwachung automatisiert erfolgen. + +1. Öffne in Vaultwarden den jeweiligen Token-Eintrag. +2. Trage das Ablaufdatum im Feld **Custom Field → Expires** ein. +3. Aktiviere die Benachrichtigung **„Vor Ablauf erinnern“**. +4. Stelle den Zeitraum auf **14 Tage**. + +> [!TIP] +> So erhältst du rechtzeitig eine Mail oder Discord-Benachrichtigung, +> bevor eine Verbindung abläuft und Postiz keine Inhalte mehr posten kann. + +👉 **Screenshot geeignet:** Vaultwarden-Benachrichtigungsfeld mit Ablaufwarnung + +### Zugriff für Team-Mitglieder + +Wenn mehrere Personen am System arbeiten, +sollten Token-Zugriffe nie direkt geteilt, sondern über Vaultwarden-Sammlungen verwaltet werden. + +1. Erstelle in Vaultwarden eine Sammlung **Postiz-Integrationen**. +2. Füge die betreffenden Einträge hinzu. +3. Weise die Sammlung den Benutzer:innen oder Gruppen zu. +4. Aktiviere die Option **„Nur lesen“**, um versehentliche Änderungen zu verhindern. + +> [!NOTE] +> Vaultwarden verschlüsselt alle Inhalte client-seitig. +> Selbst Administrator:innen sehen keine Klartext-Passwörter, +> solange sie keinen Zugriff auf den privaten Schlüssel des Kontos besitzen. + +👉 **Screenshot geeignet:** Vaultwarden-Sammlung mit Benutzerzuordnung + +### Integration in Postiz (Container-Ebene) + +Damit Postiz auf die gespeicherten Tokens zugreifen kann, +müssen die Secrets beim Start des Containers eingebunden werden. +Ergänze die `lxc.conf` oder `docker-compose.yml` des Postiz-Containers: + +```yaml +environment: + - POSTIZ_TIKTOK_TOKEN_FILE=/etc/secrets/tiktok.token + - POSTIZ_META_APP_ID_FILE=/etc/secrets/meta_app.id + - POSTIZ_META_APP_SECRET_FILE=/etc/secrets/meta_app.secret +volumes: + - /mnt/vaultwarden/exports/:/etc/secrets/ +``` + +> [!TIP] +> Diese Methode hält Postiz vollständig unabhängig von Vaultwarden-APIs. +> Nur exportierte, verschlüsselte Kopien werden bereitgestellt. + +👉 **Screenshot geeignet:** Container-Konfigurationsabschnitt mit Secrets-Mount + +### Sicherheitsempfehlungen + +* Zugriff auf `/etc/secrets` nur für den Postiz-Benutzer (`chmod 600`) +* Vaultwarden-Backups regelmäßig prüfen +* Tokens mit hoher Berechtigung (z. B. Meta App Secrets) nie im Klartext weitergeben +* Alte Tokens nach jeder Re-Authentifizierung löschen +* Zugriff auf Postiz-Container-Shell nur für Administrator:innen + +> [!NOTE] +> Die Kombination aus Vaultwarden-Secret-Storage und schreibgeschützten Mounts +> ist der sicherste Weg, API-Zugangsdaten im UCC zu verwalten. + +### Ergebnis + +Nach Umsetzung dieses Moduls ist Postiz vollständig in das zentrale Sicherheits- und Secret-Management eingebunden: + +| Komponente | Aufgabe | +|-------------|----------| +| Vaultwarden | sichere Speicherung von Tokens und App-Secrets | +| Postiz | automatischer Zugriff über Secret-Mounts | +| UCC-Admin | Verwaltung von Ablaufdaten und Benutzerrechten | + +👉 **Screenshot geeignet:** Diagramm Postiz ↔ Vaultwarden mit Ablaufdaten-Workflow + +Damit ist das Premium-Kapitel **Postiz** abgeschlossen: +Plattform-Integration (TikTok / Meta) und sichere Verwaltung der Zugangsdaten sind vollständig umgesetzt. + +--- + +## Abschluss – Postiz (Premium) + +Mit Abschluss dieses Premium-Kapitels ist Postiz vollständig in das UCC integriert. +Alle relevanten Plattformen – TikTok, Meta (Facebook / Instagram), YouTube und Discord – +sind angebunden und lassen sich zentral verwalten. +Zusätzlich sind Token- und Zugriffsdaten durch Vaultwarden abgesichert, +sodass der Betrieb dauerhaft stabil und unabhängig von externen Tools bleibt. + +### Ergebnisse dieses Kapitels + +| Bereich | Umsetzung | +|----------|------------| +| **TikTok** | Eigene App-Integration mit Sandbox-Verifikation und Review-Prozess | +| **Meta (Facebook / Instagram)** | Anbindung über Postiz-Provider-System, API-Berechtigungen nach Meta-Standard | +| **Vaultwarden** | Zentrale Verwaltung aller Tokens und Secrets, automatisierte Bereitstellung an Postiz | +| **UCC-Integration** | Alle Plattformen laufen innerhalb getrennter LXC-Container und greifen nur über definierte Schnittstellen zu | + +> [!TIP] +> Durch die klare Trennung der Container und die Nutzung eigener App-IDs +> bleibt die gesamte Social-Media-Infrastruktur skalierbar und kontrollierbar. +> Erweiterungen wie zusätzliche Plattformen oder neue Team-Zugänge +> können ohne Eingriff in bestehende Systeme erfolgen. + +Damit ist Kapitel 17 abgeschlossen. +Das UCC verfügt nun über ein vollwertiges, internes Social-Media-Management-System – +von Planung und Veröffentlichung bis hin zu Sicherheit und Zugriffskontrolle. +