Ollama mit Docker: Containerisierte lokale KI

Was dieser Artikel über Ollama mit Docker behandelt

• Wie Du Ollama als Docker-Container startest, mit und ohne GPU
• Was Volumes und Port Mapping für Deinen Container bedeuten
• Wie Du eine reproduzierbare Konfiguration mit docker-compose erstellst
• Welche Stolpersteine es bei GPU-Support und Persistenz gibt
• Wie Du Ollama in Docker auf Windows, macOS und Linux nutzt

Einleitung: Ollama mit Docker verständlich erklärt

Ollama ist eine Laufzeitumgebung für lokale Sprachmodelle. Du lädst ein Modell herunter und startest es direkt auf Deinem Rechner. Wenn Du Ollama bereits kennst, weißt Du, dass die Installation auf Linux, macOS oder Windows schnell erledigt ist. Manchmal reicht das aber nicht. Vielleicht willst Du Ollama auf einem Server betreiben, auf einem NAS oder einfach sauber von Deinem restlichen System trennen. Genau hier kommt Docker ins Spiel.

Docker verpackt Ollama in einen Container, eine isolierte Umgebung mit allem, was das Tool zum Laufen braucht. Du startest den Container, nutzt das Modell und stoppst ihn wieder. Keine Konflikte mit anderen Programmen, keine verstreuten Dateien auf Deinem System. Dieser Artikel führt Dich Schritt für Schritt durch die Einrichtung von Ollama mit Docker, vom ersten docker pull bis zur fertigen docker-compose-Konfiguration.

Wenn Du Ollama noch nicht kennst, lies zuerst die Ollama Übersicht und die Anleitung zur Ollama Installation. Grundlagen zu Docker findest Du im Artikel Docker Grundlagen.

Warum brauche ich Docker für Ollama?

Stell Dir vor, Du betreibst auf Deinem Server bereits mehrere Dienste. Ein Webserver läuft, dazu eine Datenbank und vielleicht noch ein Media-Server. Jetzt willst Du Ollama hinzufügen. Ohne Docker installierst Du es direkt auf dem System. Ollama legt Dateien in Systemverzeichnissen ab, richtet einen Dienst ein und bindet sich in die Netzwerkkonfiguration ein. Wenn Du es später entfernen willst, bleiben oft Reste zurück.

Mit Docker sieht das anders aus. Du lädst das offizielle Ollama-Image, startest einen Container und alles läuft isoliert. Willst Du Ollama aktualisieren, ziehst Du einfach das neueste Image und startest den Container neu. Die Konfiguration bleibt erhalten, weil sie in einem Volume liegt. Du kannst den Container stoppen, löschen und neu erstellen, ohne dass Deine Modelle verloren gehen.

Docker gibt Dir außerdem eine reproduzierbare Konfiguration. Du definierst in einer docker-compose.yml, wie Ollama laufen soll, und kannst das gleiche Setup auf jedem Rechner oder Server nachbauen. Das ist besonders wertvoll, wenn Du Ollama auf mehreren Maschinen betreibst oder Deine Konfiguration mit anderen teilen willst.

Ollama mit Docker kurz erklärt

Du lädst das offizielle Image ollama/ollama von Docker Hub, startest einen Container mit Port Mapping für die API und bindest ein Volume für die Modellpersistenz ein. Für GPU-Support ergänzt Du das NVIDIA Container Toolkit und übergibst dem Container die GPU mit --gpus all. Mit docker-compose lässt sich das gesamte Setup in einer Datei beschreiben und mit einem Befehl starten.

Für wen ist Docker mit Ollama gedacht?

Docker mit Ollama richtet sich an alle, die mehr Kontrolle und Sauberkeit wollen als bei einer Direktinstallation. Das sind Server-Administratoren, die mehrere Dienste auf einer Maschine betreiben und Konflikte vermeiden wollen. Das sind NAS-Besitzer, die Ollama auf ihrem Synology- oder Ugreen-Gerät laufen lassen. Und das sind Entwickler, die eine reproduzierbare Umgebung für Tests und Integrationen brauchen.

Wenn Du Ollama nur mal kurz auf Deinem Laptop ausprobieren willst, ist die Direktinstallation einfacher. Sobald es aber um dauerhaften Betrieb, mehrere Modelle oder Server-Setups geht, ist Docker die bessere Wahl.

Wichtige Begriffe rund um Ollama und Docker

Begriff	Bedeutung
Docker	Plattform, die Anwendungen in Containern isoliert ausführt
Container	Laufende Instanz eines Images, isoliert vom Host-System
Image	Vorlage für Container, enthält alle Dateien und Einstellungen
Volume	Persistenter Speicher, der Daten über den Container-Lebenszyklus hinaus sichert
docker-compose	Tool, um mehrere Container über eine YAML-Datei zu definieren und zu starten
GPU Runtime	Docker-Erweiterung, die Containern Zugriff auf die Grafikkarte gibt
NVIDIA Container Toolkit	Software-Paket, das Nvidia-GPUs in Docker-Containern verfügbar macht
Port Mapping	Weiterleitung eines Host-Ports an den Container, damit Dienste von außen erreichbar sind
Persistenz	Eigenschaft, dass Daten auch nach dem Stoppen oder Löschen des Containers erhalten bleiben
Image Tag	Versionierung eines Images, beispielsweise ollama/ollama:latest

Voraussetzungen

Bevor Du startest, brauchst Du Docker auf Deinem System. Auf Linux installierst Du Docker über den offiziellen Installer oder das Paket Deiner Distribution. Auf Windows und macOS nutzt Du Docker Desktop. Mehr dazu findest Du im Artikel Docker Grundlagen.

Wenn Du Ollama mit GPU-Support betreiben willst, brauchst Du zusätzlich:

• Einen aktuellen Nvidia-Treiber auf dem Host-System
• Das NVIDIA Container Toolkit, damit Docker auf die GPU zugreifen kann

Auf reinen CPU-Setups reicht Docker allein. Weitere Details zur GPU-Konfiguration in Docker findest Du im Artikel GPU-Unterstützung in Docker. Einen Überblick über CPU- vs. GPU-Betrieb findest Du unter CPU vs. GPU.

Schritt 1: Ollama Image pullen

Lade das offizielle Ollama-Image von Docker Hub:

docker pull ollama/ollama

Standardmäßig zieht Docker das Tag latest. Wenn Du eine bestimmte Version willst, gibst Du den Tag explizit an:

docker pull ollama/ollama:0.3.0

Das Image enthält die Ollama-Binärdatei und alle Abhängigkeiten. Es ist die Grundlage für jeden Container, den Du danach startest.

Schritt 2: Ersten Container starten (CPU)

Der einfachste Start ohne GPU sieht so aus:

docker run -d --name ollama -p 11434:11434 ollama/ollama

Die einzelnen Parameter bedeuten:

• -d: Startet den Container im Hintergrund (detached mode)
• --name ollama: Gibt dem Container den Namen ollama, damit Du ihn leicht ansprechen kannst
• -p 11434:11434: Leitet den Port 11434 des Hosts an den Container weiter
• ollama/ollama: Das Image, auf dem der Container basiert

Nach dem Start prüfst Du, ob der Container läuft:

docker ps

Die Ollama-API ist jetzt unter http://localhost:11434 erreichbar. Mehr zur API findest Du im Artikel Ollama API nutzen.

Schritt 3: Container mit GPU-Support

Für GPU-Support brauchst Du zuerst das NVIDIA Container Toolkit. Auf Ubuntu installierst Du es so:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

Danach startest Du Ollama mit GPU-Support:

docker run -d --gpus all --name ollama-gpu -p 11434:11434 ollama/ollama

Der Parameter --gpus all übergibt alle verfügbaren GPUs an den Container. Wenn Du mehrere GPUs hast und nur eine nutzen willst, kannst Du gezielt zuweisen:

docker run -d --gpus '"device=0"' --name ollama-gpu -p 11434:11434 ollama/ollama

Ob die GPU im Container erkannt wird, prüfst Du mit:

docker exec -it ollama-gpu nvidia-smi

Wenn nvidia-smi die GPU anzeigt, ist alles richtig eingerichtet. Mehr zur GPU-Konfiguration findest Du unter GPU-Unterstützung in Docker.

Schritt 4: Persistenz mit Volumes

Ohne Volume gehen Deine heruntergeladenen Modelle verloren, sobald Du den Container löschst. Ein Volume speichert die Modelle außerhalb des Containers, sodass sie auch nach einem Neustart oder einer Neuerstellung erhalten bleiben.

docker run -d --gpus all --name ollama-gpu -p 11434:11434 -v ollama-data:/root/.ollama ollama/ollama

Der Parameter -v ollama-data:/root/.ollama erstellt ein benanntes Volume namens ollama-data und bindet es im Container unter /root/.ollama ein. Dort speichert Ollama Modelle, Konfigurationen und Metadaten.

Du kannst auch ein lokales Verzeichnis statt eines benannten Volumes nutzen:

docker run -d --gpus all --name ollama-gpu -p 11434:11434 -v /home/user/ollama:/root/.ollama ollama/ollama

Das gibt Dir direkten Zugriff auf die Dateien auf dem Host-System, was für Backups und Inspektion praktisch ist.

Schritt 5: docker-compose.yml

Für reproduzierbare Setups empfiehlt sich docker-compose. Du beschreibst den Container in einer YAML-Datei und startest alles mit einem Befehl.

Erstelle eine Datei namens docker-compose.yml:

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    restart: unless-stopped
    # Für GPU-Support entferne die Kommentare der folgenden Zeilen:
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: all
    #           capabilities: [gpu]

volumes:
  ollama-data:

Starte den Container mit:

docker compose up -d

Stoppen und entfernen geht mit:

docker compose down

Das Volume ollama-data bleibt dabei erhalten. Wenn Du es ebenfalls löschen willst, nutzt Du docker compose down -v.

Für GPU-Support entfernst Du die Kommentare bei den deploy-Einträgen. In älteren Docker-Versionen kannst Du stattdessen runtime: nvidia verwenden, was aber mittlerweile als veraltet gilt.

Schritt 6: Modell im Container laden

Nachdem der Container läuft, lädst Du ein Modell hinein. Dafür nutzt Du docker exec, um einen Befehl innerhalb des laufenden Containers auszuführen:

docker exec -it ollama ollama pull llama3

Danach startest Du das Modell:

docker exec -it ollama ollama run llama3

Der interaktive Chat öffnet sich direkt im Terminal. Mit /bye beendest Du die Sitzung.

Da Du ein Volume eingebunden hast, bleibt das Modell auch erhalten, wenn Du den Container neu startest. Du musst es nicht erneut herunterladen.

Schritt 7: API von außen erreichen

Der Parameter -p 11434:11434 in Deinem docker run-Befehl oder der ports-Eintrag in docker-compose sorgen dafür, dass die Ollama-API vom Host-System erreichbar ist. Standardmäßig lauscht Ollama im Container auf 0.0.0.0:11434.

Teste die Verbindung vom Host:

curl http://localhost:11434/

Wenn Du Ollama von anderen Geräten im Netzwerk erreichen willst, bindest Du den Port an die Netzwerk-IP Deines Hosts. In docker-compose sieht das so aus:

ports:
  - "0.0.0.0:11434:11434"

Achte dabei auf Firewall-Regeln und Authentifizierung. Mehr zum sicheren Netzwerkzugriff findest Du im Artikel Ollama Netzwerkzugriff.

Docker auf Windows und macOS

Auf Windows und macOS nutzt Du Docker Desktop. Es bringt eine grafische Oberfläche und das WSL2-Backend auf Windows mit. Du kannst die gleichen docker run-Befehle und docker-compose-Dateien wie auf Linux verwenden.

Auf Windows mit WSL2-Backend funktioniert GPU-Support, wenn Du eine Nvidia-GPU hast und die WSL2-GPU-Treiber installiert sind. Der Container-Befehl bleibt identisch:

docker run -d --gpus all --name ollama -p 11434:11434 -v ollama-data:/root/.ollama ollama/ollama

Auf macOS mit Apple Silicon nutzt Docker Desktop automatisch die Metal-Beschleunigung. Der Parameter --gpus all wird auf macOS nicht benötigt und kann ignoriert werden. Apple-GPUs werden über das Host-System bereitgestellt, nicht über das NVIDIA Container Toolkit.

Eine Einschränkung auf Windows und macOS: Docker läuft in einer virtuellen Maschine, was zu leichtem Performance-Verlust führen kann. Für maximale Performance auf einem dedizierten Server ist natives Linux die beste Wahl.

Typische Stolpersteine bei Ollama mit Docker

GPU wird im Container nicht erkannt. Oft fehlt das NVIDIA Container Toolkit oder die Docker-Runtime wurde nicht neu konfiguriert. Prüfe mit nvidia-smi auf dem Host und mit docker exec -it ollama nvidia-smi im Container.

Modelle verschwinden nach Neustart. Du hast kein Volume eingebunden. Ohne -v speichert Ollama Modelle nur im Container-Dateisystem, das beim Löschen des Containers verloren geht.

Port 11434 ist bereits belegt. Wenn Ollama bereits direkt auf dem Host installiert ist, nutzt es den gleichen Port. Stoppe den lokalen Ollama-Dienst oder mappe den Container auf einen anderen Port, beispielsweise -p 11435:11434.

Container startet nicht nach Image-Update. Wenn Du ein neues Image pullst und den alten Container nicht löschst, läuft weiterhin die alte Version. Stoppe den Container, entferne ihn und starte ihn neu. Das Volume sichert Deine Modelle.

OOM-Killer beendet den Container. Große Modelle brauchen viel RAM. Wenn der Host nicht genug Arbeitsspeicher hat, killt der Linux-Kernel den Container. Prüfe den RAM-Verbrauch mit docker stats und wähle ein kleineres Modell oder füge mehr RAM hinzu.

docker-compose ignoriert GPU-Einstellungen. In neueren Docker-Versionen funktioniert runtime: nvidia nicht mehr. Nutze stattdessen den deploy.resources.reservations.devices-Block wie im Beispiel oben gezeigt.

Firewall blockiert Port 11434. Wenn Du Ollama von einem anderen Rechner erreichen willst, stelle sicher, dass die Firewall des Hosts den Port 11434 durchlässt. Auf Ubuntu mit UFW nutzt Du sudo ufw allow 11434.

Hardware, Kosten und Sicherheit bei Ollama mit Docker

Die Hardware-Anforderungen hängen vom Modell ab, das Du ausführen willst. Ein 7B-Modell wie Llama 3 läuft auf 8 GB RAM, idealerweise mit einer GPU, die mindestens 6 GB VRAM hat. Größere Modelle wie Llama 3 70B brauchen deutlich mehr Ressourcen. Mehr dazu im Artikel CPU vs. GPU und unter LLM lokal betreiben.

Kosten entstehen durch die Hardware selbst. Ollama und Docker sind kostenlos und Open Source. Es fallen keine Lizenzgebühren oder API-Kosten an, solange Du lokal betreibst.

Sicherheitstechnisch solltest Du den Port 11434 nicht ungeschützt ins Internet öffnen. Nutze einen Reverse-Proxy mit Authentifizierung, wenn Du Ollama remote erreichbar machen willst. Details dazu findest Du im Artikel Ollama Netzwerkzugriff. In Docker kannst Du außerdem Netzwerk-Isolation nutzen, indem Du ein eigenes Docker-Netzwerk definieren und nur die benötigten Ports freigeben.

Weiterführende Links und Infos zu Ollama mit Docker

• Ollama Übersicht für einen allgemeinen Einstieg
• Ollama Installation für die Direktinstallation ohne Docker
• Ollama API nutzen für die HTTP-Schnittstelle
• Ollama Konfiguration für Umgebungsvariablen und Pfade
• Ollama Netzwerkzugriff für sicheren Remote-Zugriff
• LLM lokal betreiben für Grundlagen zu lokalen Modellen
• Docker Grundlagen für den Einstieg in Docker
• GPU-Unterstützung in Docker für GPU-Konfiguration
• CPU vs. GPU für den Vergleich von CPU- und GPU-Betrieb

FAQ: Ollama mit Docker - Typische Fragen

Brauche ich Docker, um Ollama zu nutzen?

Nein. Ollama lässt sich auch direkt auf Linux, macOS und Windows installieren. Docker ist optional und eignet sich besonders für Server, NAS und isolierte Umgebungen.

Funktioniert Ollama in Docker auch ohne GPU?

Ja. Ohne den Parameter --gpus all läuft Ollama auf der CPU. Das ist langsamer, aber für kleinere Modelle und Tests ausreichend.

Wo speichert Docker die Ollama-Modelle?

Im Container unter /root/.ollama. Wenn Du ein Volume einbindest, liegen die Modelle im Volume und bleiben beim Löschen des Containers erhalten.

Wie aktualisiere ich Ollama in Docker?

Pull das neueste Image mit docker pull ollama/ollama, stoppe den laufenden Container, entferne ihn und starte ihn neu. Das Volume sichert Deine Modelle und Konfiguration.

Kann ich mehrere Ollama-Container gleichzeitig laufen lassen?

Ja. Gib jedem Container einen eigenen Namen und einen eigenen Port, beispielsweise -p 11435:11434 für den zweiten Container. Nutze separate Volumes, wenn die Container unterschiedliche Modelle halten sollen.

Wie nutze ich Ollama mit Docker auf einem Synology-NAS?

Synology bietet eine grafische Docker-Oberfläche unter Container Manager. Du kannst das Image ollama/ollama dort laden und mit den gleichen Parametern wie im Terminal konfigurieren. Achte auf ausreichend RAM und CPU-Leistung.

Was ist der Unterschied zwischen benannten Volumes und Bind Mounts?

Benannte Volumes werden von Docker verwaltet und liegen im Docker-Datenverzeichnis. Bind Mounts binden ein beliebiges Verzeichnis auf dem Host ein und geben Dir direkten Zugriff auf die Dateien. Beide sichern Persistenz.

Funktioniert GPU-Support auch auf Windows mit Docker Desktop?

Ja, mit WSL2-Backend und den passenden Nvidia-Treibern. Der Parameter --gpus all funktioniert wie auf Linux. Auf macOS mit Apple Silicon wird die GPU automatisch über Metal genutzt.

Kann ich Open WebUI zusammen mit Ollama in Docker betreiben?

Ja. Du definierst beide Dienste in einer docker-compose.yml und verbindest sie über ein gemeinsames Docker-Netzwerk. Open WebUI greift dann auf den Ollama-Container über den Containernamen zu.

Wie stelle ich sicher, dass Ollama nach einem Reboot automatisch startet?

Nutze restart: unless-stopped in docker-compose oder den Parameter --restart unless-stopped bei docker run. Docker startet den Container dann automatisch, wenn der Docker-Dienst hochfährt.

Kann ich Ollama in Docker mit Podman betreiben?

Ja. Podman ist weitgehend kompatibel mit Docker-Befehlen und docker-compose. Die Syntax für Volumes und Ports ist identisch. Für GPU-Support nutzt Du bei Podman --device nvidia.com/gpu=all.

Quellen und weiterführende Literatur

• Ollama Docker Hub Repository
• Ollama offizielle Dokumentation
• Docker Dokumentation zu Volumes und Port Mapping
• NVIDIA Container Toolkit Installationsanleitung
• Docker Compose Spezifikation