From 39c9a5e9df3f688508cfba2e36cb0d55dbeeeb5e Mon Sep 17 00:00:00 2001 From: Thomas Dannenberg Date: Wed, 22 Oct 2025 20:28:21 +0000 Subject: [PATCH] =?UTF-8?q?Kapitel=2018/Premium=20Rohtext.mde=20hinzugef?= =?UTF-8?q?=C3=BCgt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Kapitel 18/Premium Rohtext.mde | 506 +++++++++++++++++++++++++++++++++ 1 file changed, 506 insertions(+) create mode 100644 Kapitel 18/Premium Rohtext.mde diff --git a/Kapitel 18/Premium Rohtext.mde b/Kapitel 18/Premium Rohtext.mde new file mode 100644 index 0000000..39e4f19 --- /dev/null +++ b/Kapitel 18/Premium Rohtext.mde @@ -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://: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.`). +2. Gehe zu **Hosts → Add Proxy Host**. +3. Trage folgende Werte ein: + +| Feld | Wert | +|------|------| +| **Domain** | `ollama.` | +| **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.` 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. \ No newline at end of file