Kapitel 14/Premium Rohtext.md hinzugefügt

This commit is contained in:
2025-10-16 18:42:08 +00:00
parent 006cfb0bcf
commit 5d30625bea

View File

@@ -0,0 +1,225 @@
# Premium Wiki.js: Integration, Rollenverwaltung & Systemvernetzung
Das Wiki ist im UCC die Schnittstelle zwischen Dokumentation, Quellcode und Dateiablage.
Im Free-Kapitel wurde die Basis gelegt: ein stabiler Container mit HTTPS-Zugriff.
Dieser Premium-Teil erweitert die Installation zu einem vollständig integrierten System, das Gitea-Repositories, Nextcloud-Dateien und gemeinsame Benutzeranmeldungen vereint.
Ziel ist ein zentrales Informationssystem, das dieselben Konten, Zugriffsrechte und Datenquellen wie der Rest deiner Infrastruktur verwendet.
👉 **Screenshot geeignet:** Architekturübersicht mit Verbindungslinien zwischen Wiki.js, Gitea und Nextcloud
---
## Benutzer- und Rollenverwaltung
Ein sauberes Rechtekonzept ist Grundlage jeder Zusammenarbeit.
Wiki.js unterscheidet Benutzer, Gruppen und Policies. Die Rollen werden zentral in der Administrationsoberfläche gepflegt.
### Gruppenstruktur aufbauen
1. **Administration → Sicherheit → Benutzer & Gruppen** öffnen.
2. Neue Gruppen anlegen:
- `viewer` Lesezugriff auf alle Seiten
- `editor` Bearbeiten und Erstellen
- `maintainer` Vollzugriff auf Inhalte und Struktur
3. Für neue Konten die Standardrolle `viewer` setzen.
### Richtlinien (Policies)
Unter **Administration → Inhalte → Zugriffsregeln** legst du gezielte Policies an.
Beispiel: Git-importierte Doku nur für Editoren bearbeitbar.
| Bereich | viewer | editor | maintainer |
|----------|--------|--------|-------------|
| `docs/**` | Lesen | Lesen/Schreiben | Vollzugriff |
> [!NOTE]
> Policies werden von oben nach unten geprüft spezifische Regeln müssen vor globalen stehen.
---
## Gitea-Integration
Wiki.js kann Git-Repositories als Datenquelle einbinden.
Damit werden Markdown-Dateien aus Gitea automatisch als Wiki-Seiten dargestellt und bleiben versioniert.
### Zugriffstoken erstellen
Erzeuge in Gitea einen Token mit Leserechten:
```bash
docker exec -it gitea \
gitea admin user generate-access-token \
--username admin \
--scope read:repository \
--token-name wiki-sync
```
Token in Vaultwarden speichern und kurz prüfen:
```bash
curl -H "Authorization: token <DEIN_TOKEN>" https://git.deinedomain.tld/api/v1/user
```
### Git-Quelle anlegen
1. In Wiki.js **Administration → Speicher → Neue Quelle**
2. Typ: **Git Repository**
3. Felder:
| Feld | Wert |
|------|------|
| Name | `Bratonien Tutorials` |
| URL | `https://git.deinedomain.tld/admin/tutorials.git` |
| Branch | `main` |
| Authentifizierung | Personal Access Token |
| Token | `<DEIN_TOKEN>` |
4. Speichern und **Synchronisierung starten**
Wiki.js liest jetzt alle Markdown-Dateien ein.
Für manuelles Nachladen:
```bash
docker exec -it wikijs node tools/sync.js
```
> [!TIP]
> Regelmäßige Synchronisierung über Cron:
> ```bash
> */10 * * * * docker exec wikijs node /wiki/tools/sync.js >/dev/null 2>&1
> ```
---
## Nextcloud-Integration
Nextcloud dient als zentraler Speicher für Medien, PDFs oder Anhänge.
Über WebDAV bindet Wiki.js diese Dateien direkt ein, ohne sie zu kopieren.
### WebDAV-Zugang vorbereiten
1. In Nextcloud ein App-Passwort erzeugen (Profil → Sicherheit → Geräte & Sitzungen).
2. Verzeichnisstruktur anlegen, z. B. `/Dokumente/Wiki`.
### Verbindung in Wiki.js
**Administration → Integrationen → Storage → Neue Quelle → WebDAV**
| Feld | Wert |
|------|------|
| URL | `https://cloud.deinedomain.tld/remote.php/webdav/` |
| Benutzer | `wiki-sync` |
| Passwort | App-Passwort |
| Basisverzeichnis | `/Dokumente/Wiki` |
Testen und speichern.
Dateien können anschließend per Markdown-Link verwendet werden:
```markdown
![UCC-Diagramm](https://cloud.deinedomain.tld/remote.php/webdav/Dokumente/Wiki/UCC-Diagramm.png)
```
> [!NOTE]
> Wiki.js cached WebDAV-Inhalte, um Ladezeiten zu verringern. Änderungen werden beim nächsten Seitenaufruf eingelesen.
---
## Zentrale Anmeldung (SSO via Gitea OAuth2)
Um doppelte Konten zu vermeiden, kann Wiki.js Gitea als Authentifizierungsquelle nutzen.
### OAuth2-Provider in Gitea
1. **Site Administration → Applications → OAuth2 Provider → New OAuth2 Application**
2. Werte:
- Name: `Wiki.js Login`
- Redirect URI: `https://wiki.deinedomain.tld/login/gitea/callback`
3. **Client ID** und **Client Secret** notieren.
### OAuth2 in Wiki.js aktivieren
**Administration → Authentifizierung → Neue Strategie → OAuth2**
| Feld | Wert |
|------|------|
| Name | `Gitea` |
| Authorization Endpoint | `https://git.deinedomain.tld/login/oauth/authorize` |
| Token Endpoint | `https://git.deinedomain.tld/login/oauth/access_token` |
| User Info Endpoint | `https://git.deinedomain.tld/api/v1/user` |
| Client ID / Secret | aus Gitea |
| Scope | `user:email` |
| Default Role | `viewer` |
Nach dem Speichern erscheint im Login-Fenster der Button **Mit Gitea anmelden**.
> [!TIP]
> Rollen werden weiterhin in Wiki.js zugewiesen.
> SSO ersetzt nur den Anmeldevorgang, nicht die Rechteverwaltung.
---
## Automatische Aktualisierung
Damit Wiki.js Änderungen aus deinem Git-Repository zuverlässig einliest, muss der Datenabgleich regelmäßig gestartet werden.
Die grafische Automatik im Wiki funktioniert nur bei GitHub oder GitLab **nicht bei selbst gehosteten Gitea-Instanzen**.
Für dein eigenes System richtest du deshalb eine einfache, stabile Lösung direkt im Container ein.
### Warum das nötig ist
Wiki.js speichert Inhalte nicht dauerhaft aus dem Repository, sondern zieht sie bei Bedarf.
Wenn du also Tutorials oder Dokumente in Gitea änderst, merkt das Wiki davon nichts, bis ein neuer Abgleich stattfindet.
Damit du das nicht jedes Mal manuell klicken musst, erledigt ein kleiner Zeitplaner diese Aufgabe automatisch.
### Automatische Synchronisierung einrichten
1. Öffne im **Proxmox-Webinterface** die Konsole deines Wiki-LXC.
2. Starte den Editor für geplante Aufgaben:
```bash
crontab -e
```
3. Trage unten folgende Zeile ein und speichere:
```bash
*/15 * * * * docker exec wikijs node /wiki/tools/sync.js >/dev/null 2>&1
```
Das bedeutet: Alle 15 Minuten ruft der Container intern den Sync-Befehl auf.
Neue oder geänderte Dateien aus Gitea werden automatisch eingelesen.
> [!TIP]
> Wenn du gerade an Inhalten arbeitest, kannst du das Intervall auch auf `*/5` (alle 5 Minuten) stellen.
> Für den Dauerbetrieb sind 15 30 Minuten optimal.
4. Prüfen, ob es funktioniert:
```bash
docker logs wikijs | tail -n 20
```
Wenn dort Einträge wie `Git sync completed` erscheinen, läuft der Abgleich erfolgreich.
👉 **Screenshot geeignet:** Proxmox-Konsole mit sichtbarem Cronjob-Eintrag und Wiki.js-Logausgabe
### Manuelle Aktualisierung (zusätzlich möglich)
Falls du sofort nach einer Änderung synchronisieren möchtest:
```bash
docker exec wikijs node /wiki/tools/sync.js
```
Das kannst du jederzeit über die Proxmox-Konsole ausführen.
> [!NOTE]
> Beide Varianten greifen direkt auf dieselbe Routine zu.
> Der Cronjob sorgt nur dafür, dass du es nicht ständig manuell machen musst.
---
## Ergebnis
Nach dieser Integration arbeitet Wiki.js als zentraler Knoten deines UCC-Ökosystems:
- Zugriff und Authentifizierung über Gitea (ein Login für alle Systeme)
- Markdown-Daten direkt aus Repositories synchronisiert
- Medien aus Nextcloud eingebunden
- Einheitliche Rollen und Rechte über Policies
- Automatische Aktualisierung bei Git-Änderungen
Damit wird das Wiki zum dokumentarischen Backbone des gesamten UCC:
einheitlich, versioniert, sicher und vollständig selbst gehostet.