Thomas/Homelab--Bratonein-Kontrollzentrum--Tutorial
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Kapitel 18/Premium Rohtext.mde hinzugefügt

Browse Source
This commit is contained in:
Thomas Dannenberg
2025-10-22 20:28:21 +00:00
parent dfc1ce2b92
commit 39c9a5e9df
1 changed files with 506 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

506
Kapitel 18/Premium Rohtext.mde Normal file
View File

@@ -0,0 +1,506 @@
# Kapitel 18 – Premium: Ollama im UCC
Ollama ist im UCC weit mehr als nur eine lokale KI-Engine.
In der Free-Version wurde die Basis gelegt – ein Container, der Sprachmodelle lokal bereitstellt.
In diesem Premium-Kapitel wird Ollama zu einer **vollwertigen, interaktiven KI-Plattform**,
die GPU-Beschleunigung nutzt, eine eigene GUI bereitstellt, über Python gesteuert werden kann
und sich dynamisch an die CPU-Leistung des Systems anpasst.
Ziel ist eine Umgebung, in der **lokale KI-Prozesse, GPU-Compute und Steuerung per API oder Interface**
ineinandergreifen – stabil, performant und komplett offline betreibbar.
Ollama dient hier als zentraler Baustein für Automatisierungen, Assistenz-Funktionen und Content-Workflows.
👉 **Screenshot geeignet:** Architekturübersicht mit Ollama LXC, GPU-Passthrough, GUI-Frontend und Python-Anbindung
> [!NOTE]
> Dieses Kapitel setzt eine funktionierende Free-Installation von Ollama voraus.
> Stelle sicher, dass dein LXC-Container läuft, über HTTPS erreichbar ist
> und mindestens ein Modell (z. B. `llama3`, `mistral`) erfolgreich geladen wurde.
> [!TIP]
> Falls dein System keine dedizierte GPU besitzt, kann dieses Kapitel trotzdem durchgeführt werden.
> CPU-Optimierungen und GUI-Einrichtung funktionieren unabhängig vom GPU-Passthrough.
---
## GPU-Durchreichen in Proxmox
Damit Ollama Modelle wie `llama3`, `gemma` oder `mistral` mit maximaler Leistung ausführen kann,
muss der LXC-Container direkten Zugriff auf die Grafikkarte erhalten.
In diesem Abschnitt richten wir das GPU-Passthrough korrekt ein – vollständig über die Proxmox-GUI,
aber **erst nachdem** die GPU auf Host-Ebene gemappt und für Container freigegeben wurde.
👉 **Screenshot geeignet:** Proxmox Host-Übersicht mit markierter GPU unter "Hardware → PCI-Geräte"
> [!NOTE]
> Proxmox kann GPUs an Container nur durchreichen, wenn die Geräte im Hostsystem
> bereits als `/dev/nvidia*` (NVIDIA) oder `/dev/dri/*` (Intel/AMD) verfügbar sind.
> Fehlen diese Einträge, liegt das Problem **nicht** am Container, sondern am Host-Treiber.
### Schritt 1 – GPU-Verfügbarkeit auf dem Host prüfen
Öffne auf dem Proxmox-Host eine Shell:
```bash
lspci | egrep "NVIDIA|AMD|Intel"
```
Beispielausgabe (NVIDIA):
```
01:00.0 VGA compatible controller: NVIDIA Corporation GA104 [GeForce RTX 3070] (rev a1)
01:00.1 Audio device: NVIDIA Corporation GA104 High Definition Audio Controller (rev a1)
```
Danach prüfen, ob die Gerätedateien existieren:
```bash
ls /dev/nvidia* /dev/dri/* 2>/dev/null
```
👉 **Screenshot geeignet:** Terminalausgabe mit sichtbaren `/dev/nvidia0`, `/dev/nvidiactl`, `/dev/dri/renderD128`
> [!TIP]
> Wenn hier nichts erscheint, installiere zuerst die offiziellen GPU-Treiber im Host
> (z. B. `apt install nvidia-driver` oder `apt install firmware-amd-graphics`).
### Schritt 2 – GPU als Device freigeben
1. Öffne im Proxmox-Webinterface den **Host** (nicht den Container).
2. Gehe auf **Hardware → PCI-Geräte**.
3. Suche deine GPU in der Liste (z. B. „NVIDIA Corporation GA104 [GeForce RTX 3070]“).
4. Notiere die PCI-ID (z. B. `0000:01:00.0`).
5. Stelle sicher, dass das Gerät **nicht bereits einer VM** zugeordnet ist.
👉 **Screenshot geeignet:** Proxmox Host-Hardwareliste mit markierter GPU und sichtbarer PCI-ID
> [!NOTE]
> Für Container wird die GPU **nicht direkt** über „Hardware → GPU hinzufügen“ eingebunden,
> sondern über die **Gerätedateien** (`/dev/nvidia*`).
> Diese werden per GUI in den Container gemountet.
### Schritt 3 – Gerät per GUI an den Container anbinden
1. Öffne im linken Menü deinen **Ollama-Container**.
2. Wähle **Ressourcen → Optionen → Geräte** (je nach Version auch unter *Reiter „Hardware“*).
3. Klicke auf **Hinzufügen → Gerät → Allgemein (Custom)**.
4. Wähle den Typ **Gerätedatei (bind mount)**.
5. Füge nacheinander folgende Pfade hinzu (je nach GPU-Typ verfügbar):
```
/dev/nvidia0
/dev/nvidiactl
/dev/nvidia-uvm
/dev/dri/renderD128
```
6. Aktiviere die Option **Nur Lesen deaktivieren** (d. h. Lese-/Schreibzugriff erlauben).
7. Bestätige mit **Hinzufügen**.
👉 **Screenshot geeignet:** Dialogfenster „Gerät hinzufügen“ mit eingetragenem `/dev/nvidia0`
> [!TIP]
> Bei Intel- oder AMD-GPUs reicht meist `/dev/dri/renderD128`.
> NVIDIA benötigt in der Regel alle vier Gerätedateien.
### Schritt 4 – Container starten und GPU-Test
1. Starte den Container im Proxmox-Webinterface neu.
2. Öffne die **Konsole** des Containers.
3. Prüfe die GPU-Erkennung:
```bash
nvidia-smi
```
oder (bei AMD/Intel):
```bash
ls /dev/dri/
```
4. Wenn die GPU erkannt wird, sollte `nvidia-smi` das Modell, den Treiber und den Status anzeigen.
👉 **Screenshot geeignet:** Konsolenansicht mit erfolgreicher `nvidia-smi`-Ausgabe im Ollama-LXC
> [!NOTE]
> Sollte keine GPU erscheinen, überprüfe im Host die Gruppenrechte:
> ```bash
> chmod 666 /dev/nvidia*
> ```
> Danach Container erneut starten.
### Schritt 5 – Test mit Ollama
Im Container:
```bash
ollama run llama3
```
Wenn alles korrekt ist, erscheint:
```
GPU acceleration enabled: NVIDIA RTX 3070
```
👉 **Screenshot geeignet:** Terminalausgabe mit Hinweis „GPU acceleration enabled“
> [!TIP]
> GPU-Beschleunigung bleibt nach Neustarts aktiv.
> Nur bei Kernel- oder Treiberupdates sollte das Mapping kurz überprüft werden.
---
## GUI für Ollama
Die lokale GUI erweitert Ollama um eine komfortable Weboberfläche,
mit der Modelle, Sessions und Chats übersichtlich verwaltet werden können – **direkt im selben LXC** wie Ollama selbst.
Sie kommuniziert intern mit der Ollama-API (`http://localhost:11434`) und ist nach außen nur über den separaten Proxy-LXC (Nginx Proxy Manager) erreichbar.
Dadurch bleibt der Container isoliert, während die Oberfläche sicher im internen Netz verfügbar ist.
👉 **Screenshot geeignet:** Architekturübersicht mit Ollama-LXC ↔ Proxy-LXC ↔ Client-Browser
> [!NOTE]
> Diese GUI läuft vollständig lokal und benötigt keinen Internetzugang.
> Modellverwaltung, Eingaben und Antworten bleiben im Container – keine externen API-Aufrufe.
### Installation im Ollama-LXC
1. Öffne im Proxmox-Webinterface die **Konsole** des Ollama-Containers.
2. Aktualisiere die Paketquellen und installiere die benötigten Werkzeuge:
```bash
apt update && apt install -y curl unzip
```
3. Lade die aktuelle Version der Ollama-Weboberfläche herunter:
```bash
curl -L -o ollama-gui.zip https://github.com/ollama-webui/ollama-webui/releases/latest/download/webui.zip
unzip ollama-gui.zip -d /opt/ollama-webui
```
👉 **Screenshot geeignet:** Terminalausgabe mit entpackten Dateien unter `/opt/ollama-webui`
4. Starte die GUI testweise:
```bash
cd /opt/ollama-webui
nohup ./ollama-webui --api http://localhost:11434 --port 3000 &
```
Danach ist sie intern erreichbar unter:
```
http://<LXC-IP>:3000
```
👉 **Screenshot geeignet:** Browserfenster mit lokal aufgerufenem GUI-Dashboard (`http://192.168.xxx.xxx:3000`)
> [!TIP]
> Die GUI sollte ausschließlich intern erreichbar bleiben.
> Eine öffentliche Freigabe ohne Reverse Proxy ist aus Sicherheitsgründen nicht empfohlen.
### Autostart konfigurieren
Damit die GUI nach jedem Neustart automatisch startet:
```bash
nano /etc/systemd/system/ollama-gui.service
```
Inhalt:
```
[Unit]
Description=Ollama Web GUI
After=network.target
[Service]
ExecStart=/opt/ollama-webui/ollama-webui --api http://localhost:11434 --port 3000
WorkingDirectory=/opt/ollama-webui
Restart=always
User=root
[Install]
WantedBy=multi-user.target
```
Speichern und aktivieren:
```bash
systemctl daemon-reload
systemctl enable ollama-gui
systemctl start ollama-gui
```
👉 **Screenshot geeignet:** Terminalausgabe `systemctl status ollama-gui` mit Status „active (running)“
> [!NOTE]
> Der Dienst läuft im Hintergrund und startet automatisch, sobald das Netzwerk verfügbar ist.
### Zugriff über externen Nginx Proxy Manager (NPM-LXC)
Der Zugriff erfolgt über den zentralen **Nginx Proxy Manager**, der in einem eigenen LXC betrieben wird.
Dieser leitet die Anfragen intern an den Ollama-LXC weiter.
So bleibt der Container vollständig abgeschottet, und die GUI kann sicher unter einer eigenen Subdomain aufgerufen werden.
1. Öffne im NPM-Container die Weboberfläche (`https://npm.<deine-domain.tld>`).
2. Gehe zu **Hosts → Add Proxy Host**.
3. Trage folgende Werte ein:
| Feld | Wert |
|------|------|
| **Domain** | `ollama.<deine-domain.tld>` |
| **Forward Hostname / IP** | IP-Adresse des Ollama-LXC (z. B. `192.168.100.42`) |
| **Forward Port** | `3000` |
| **Scheme** | `http` |
| **Block Common Exploits** | aktiviert |
| **SSL (Let's Encrypt)** | aktiviert, *Force SSL* anhaken |
4. Unter *Access Lists* optional Zugriffsbeschränkungen einrichten
(z. B. nur lokale IP-Bereiche oder Benutzer-Authentifizierung aktivieren).
5. Speichern und den Proxy-Host aktivieren.
👉 **Screenshot geeignet:** NPM-Konfigurationsfenster mit eingetragener Ziel-IP und aktiviertem SSL
> [!TIP]
> Wenn du eine interne Subdomain nutzt (z. B. `ollama.ucc.local`),
> kann das Zertifikat über dein internes CA-System oder manuell hinterlegt werden.
> Für öffentliche Domains ist Let’s Encrypt die empfohlene Lösung.
### Ergebnis
Die Ollama-GUI ist jetzt über deinen zentralen Proxy erreichbar –
sicher, verschlüsselt und getrennt vom restlichen System.
Sie zeigt verfügbare Modelle, laufende Sessions und GPU-Status an
und kann als Basis für weitere lokale Tools (z. B. n8n oder Stream-Automationen) dienen.
👉 **Screenshot geeignet:** Browseransicht mit aktiver GUI über `https://ollama.<deine-domain.tld>` und sichtbarem Modellstatus
---
## Internetzugang für Ollama LXC
Damit Ollama aktuelle Informationen nutzen kann,
bekommt es im Container eine kleine **Internet-Bridge**.
Sie verbindet Ollama mit dem Internet – aber sicher und kontrolliert.
Egal welches Modell du in Ollama verwendest (z. B. Llama 3, Mistral oder Phi 3):
die Bridge erkennt es automatisch und funktioniert mit allen.
👉 **Screenshot geeignet:** einfache Darstellung „Ollama ↔ Internet-Bridge ↔ Internet“
> [!NOTE]
> Ollama selbst bleibt komplett offline.
> Nur die Bridge holt gezielt Webseiten und liefert den Text an Ollama zurück.
### Schritt 1 – Bridge installieren
1. Öffne in **Proxmox** den Container, in dem Ollama läuft.
2. Klicke auf **Konsole**.
3. Gib diese Befehle ein:
```bash
apt update
apt install -y python3-pip
pip3 install ollama requests beautifulsoup4
mkdir -p /opt/ollama-bridge
nano /opt/ollama-bridge/internetbridge.py
```
### Schritt 2 – Bridge-Programm einfügen
Kopiere diesen Code in die Datei:
```python
from ollama import chat
import requests
from bs4 import BeautifulSoup
import subprocess
# Modell automatisch erkennen
def aktuelles_modell():
"""Ermittelt automatisch das erste installierte Ollama-Modell."""
result = subprocess.run(["ollama", "list"], capture_output=True, text=True)
for line in result.stdout.splitlines():
if line and not line.startswith("NAME"):
return line.split()[0]
return "llama3"
modell = aktuelles_modell()
print(f"[Bridge] Verwende Modell: {modell}")
def internet_bruecke(url: str) -> str:
"""Holt Text einer Webseite und gibt ihn an Ollama weiter."""
r = requests.get(url, timeout=10, headers={"User-Agent": "UCC-Bridge"})
soup = BeautifulSoup(r.text, "html.parser")
text = " ".join(soup.stripped_strings)
return text[:1500]
nachricht = [
{"role": "system", "content": "Wenn du neue Informationen brauchst, nutze das Tool internet_bruecke."},
{"role": "user", "content": "Was steht aktuell in der Proxmox-Dokumentation über GPU-Passthrough?"}
]
antwort = chat(model=modell, messages=nachricht, tools=[internet_bruecke])
print(antwort["message"]["content"])
```
Speichern mit
`STRG + O`, `Enter`, `STRG + X`.
### Schritt 3 – Automatisch starten
1. Erstelle eine kleine Startdatei:
```bash
nano /etc/systemd/system/ollama-internetbridge.service
```
2. Füge ein:
```ini
[Unit]
Description=Ollama Internet-Bridge
After=network.target ollama.service
[Service]
ExecStart=/usr/bin/python3 /opt/ollama-bridge/internetbridge.py
Restart=always
User=root
[Install]
WantedBy=multi-user.target
```
3. Aktivieren:
```bash
systemctl daemon-reload
systemctl enable --now ollama-internetbridge
```
👉 **Screenshot geeignet:** `systemctl status ollama-internetbridge` → grünes „active (running)“
### Ergebnis
Die Internet-Bridge erkennt dein installiertes Modell automatisch,
registriert das benötigte Tool und hält die Verbindung aktiv.
Ollama kann dadurch auf Webseiten zugreifen, Informationen lesen
und sie direkt in seine Antworten einbauen – alles lokal, sicher und unabhängig.
👉 **Screenshot geeignet:** vereinfachte Darstellung „Ollama ↔ Bridge ↔ Webseite ↔ Ollama“
---
## CPU-Optimierung für Ollama LXC
Ollama braucht viel Rechenleistung – besonders bei größeren Modellen wie Llama 3 oder Mistral.
Damit dein System dabei ruhig und stabil bleibt, kannst du in **Proxmox** genau festlegen,
wie viel CPU-Leistung der Container bekommt und wie dein Host damit umgeht.
So bleibt alles kühl, leise und zuverlässig – auch bei langen Sessions.
👉 **Screenshot geeignet:** Reiter „Ressourcen“ im Proxmox-Interface mit markierter CPU-Zuweisung
> [!NOTE]
> Die folgenden Schritte funktionieren für alle Setups:
> • CPU-only-Systeme
> • Kombination aus CPU + GPU
> • GPU-only (CPU dient dann nur zur Steuerung)
### Schritt 1 – CPU-Kerne festlegen
1. Öffne in **Proxmox** deinen Ollama-Container.
2. Gehe zu **Optionen → Ressourcen**.
3. Unter **CPU** stellst du die gewünschte Kernzahl ein, z. B. **4 Kerne**.
4. Aktiviere **CPU-Pinning**, damit Ollama immer dieselben Kerne nutzt.
👉 **Screenshot geeignet:** CPU-Einstellungen mit aktivem Pinning (z. B. Kerne 0–3)
> [!TIP]
> Für kleine Modelle reichen meist 2 bis 4 Kerne.
> Mehr Kerne lohnen sich nur, wenn dein Modell sie tatsächlich verwendet.
### Schritt 2 – CPU-Leistung im Container begrenzen
Damit dein Host nicht dauerhaft auf 100 % läuft:
1. Öffne den Reiter **Ressourcen → Erweitert**.
2. Setze das **CPU-Limit** auf etwa **80 %**.
3. Trage bei **CPU Units** einen Wert zwischen **1000 und 2000** ein.
So bekommt Ollama Leistung, aber andere Container bleiben flüssig.
👉 **Screenshot geeignet:** Ansicht mit CPU-Limit bei 80 %
> [!NOTE]
> Diese Begrenzung schützt die CPU, hält die Temperatur niedrig
> und sorgt für gleichmäßige Leistung ohne Lüftergebrüll.
### Schritt 3 – CPU-Takt auf dem Host regeln
Die folgenden Befehle werden **nicht im Container**,
sondern auf dem **Proxmox-Host selbst** ausgeführt – also auf dem physischen Rechner,
auf dem alle Container laufen.
1. Öffne im Proxmox-Interface oben den Punkt **Shell** (nicht Konsole des Containers).
2. Gib dort ein:
```bash
apt install -y cpufrequtils
cpufreq-set -g schedutil
```
Dadurch verwaltet der Host die CPU-Taktfrequenz automatisch:
hohe Leistung bei Bedarf, sparsamer Betrieb im Leerlauf.
👉 **Screenshot geeignet:** Host-Shell mit erfolgreicher `cpufreq-set`-Ausgabe
> [!TIP]
> „schedutil“ ist der dynamische Standardmodus.
> Er verhindert, dass die CPU dauerhaft auf Max-Takt läuft,
> ohne Ollama spürbar auszubremsen.
### Schritt 4 – Auslastung überwachen
Behalte die Werte im Blick:
* Im **Proxmox-Reiter „Ressourcen“**, oder
* über **Netdata** (falls im UCC installiert).
Dort siehst du: CPU-Temperatur, Taktfrequenz und Auslastung pro Kern.
> [!TIP]
> Wenn einzelne Kerne dauerhaft auf 100 % liegen,
> reduziere gleichzeitige Anfragen oder gib dem Container 1–2 Kerne mehr.
### Ergebnis
Dein System läuft jetzt ruhig, effizient und sicher.
Ollama bekommt genug Rechenleistung, ohne dass dein Host überhitzt oder andere Dienste leiden.
Ideal für lange KI-Sessions, Streaming-Setups oder parallele Container-Workflows.
👉 **Screenshot geeignet:** Vergleichsgrafik „CPU-Last vor / nach Optimierung“
---
## Abschluss – Ollama (Premium)
Mit diesem Premium-Kapitel hast du Ollama vollständig in dein UCC integriert –
stabil, sicher und für den Dauerbetrieb optimiert.
Das System kombiniert Leistung, Datenschutz und Flexibilität – ganz ohne Cloud-Zwang.
### Zusammenfassung
| Bereich | Umsetzung |
|----------|------------|
| **GUI für Ollama** | Lokale Weboberfläche zur Modellsteuerung im selben LXC |
| **GPU-Durchreichung** | Einbindung über Proxmox für beschleunigte Berechnungen |
| **Internetzugang** | Kontrollierte Python-Bridge, die Webseiten abruft und Texte an Ollama übergibt |
| **CPU-Optimierung** | Leistungsbegrenzung, Pinning und Temperaturregelung für stabilen Dauerbetrieb |
👉 **Screenshot geeignet:** Architekturübersicht „Ollama LXC mit GUI, GPU, Bridge und Optimierung“
### Fazit
* Ollama läuft vollständig in deiner eigenen Infrastruktur.
* Alle Modelle, Eingaben und Verläufe bleiben privat.
* Die Internet-Bridge liefert bei Bedarf aktuelle Informationen – kontrolliert und sicher.
* Durch CPU-Optimierung und GPU-Durchreichung nutzt du dein System effizient, ohne es zu überlasten.
* Alles bleibt wartungsarm, nachvollziehbar und zukunftssicher.
Damit ist das Premium-Kapitel **Ollama** abgeschlossen.
Dein UCC verfügt nun über eine vollständig integrierte, selbstverwaltete KI-Umgebung,
die lokal, performant und datensouverän arbeitet.