Ollama mit Docker: Installation und erstes Modell

#Ollama in Docker: Was das wirklich verändert

Das offizielle Image heißt ollama/ollama und ist auf Docker Hub verfügbar, wo es über 100 Millionen Downloads verzeichnet. Es basiert auf Ubuntu 24.04 und startet direkt den Ollama-Server: Die Variable OLLAMA_HOST hat dort den Wert 0.0.0.0:11434, sodass die API innerhalb des Containers auf Port 11434 lauscht. Es bleiben vier Entscheidungen zu treffen: diesen Port für den Host freigeben, ein Volume unter /root/.ollama einbinden, um die Modelle dauerhaft zu speichern, mit --gpus=all Zugriff auf die GPU gewähren, falls Sie eine NVIDIA-Karte haben, und die Version des Images wählen. Der Container startet ohne Modelle: Sie laden diese anschließend mit dem Befehl ollama herunter, den Sie im Container ausführen. Dieselben vier Entscheidungen finden sich auch in einer Compose-Datei wieder.

Sie erhalten eine isolierte Installation ohne Systemdienst, die durch eine einzige Datei beschrieben wird und sich leicht zusammen mit anderen Containern betreiben lässt (Weboberfläche, Vektordatenbank, n8n). Dafür müssen Sie den GPU-Zugriff konfigurieren, unter macOS auf GPU-Zugriff verzichten und kontrollieren, wie der Netzwerkport von außen erreichbar ist – ein Punkt, den die meisten Anleitungen auslassen.

#Welcher Befehl passt zu Ihrer Hardware?

Ein einziges Container-Image deckt alle Fälle ab; nur die Startoptionen ändern sich je nach GPU. Die Tabelle gibt die Dokumentation von Ollama wieder und nennt die Einschränkung, die am häufigsten zur Stolperfalle wird.

#Voraussetzungen

Docker

Docker Engine unter Linux, Docker Desktop unter Windows oder macOS, mit dem Befehl docker compose für den Abschnitt 5.

Speicher

Der Speicherbedarf des Modells plus der Kontext plus eine Reserve für das System. qwen3.5:9b ist 6,6 GB groß: Planen Sie für den Betrieb auf der CPU 16 GB RAM ein, nicht 8.

Festplatte

20 GB freier Speicherplatz für das Image und ein oder zwei Modelle.

NVIDIA-GPU, optional

Der Treiber wird auf dem Host installiert, niemals im Container; das NVIDIA Container Toolkit stellt die Verbindung her.

#Fünfstufige Vorgehensweise

1. 01
   Docker installieren

   Docker Engine unter Linux, Docker Desktop unter Windows oder macOS. Der Befehl docker version muss sowohl auf der Client-Seite als auch auf der Engine-Seite eine Antwort liefern.
2. 02
   Die NVIDIA-GPU vorbereiten (optional)

   Das NVIDIA Container Toolkit installieren, nvidia-ctk runtime configure --runtime=docker ausführen, Docker neu starten und anschließend mit docker run --rm --gpus all ubuntu nvidia-smi testen.
3. 03
   Container starten

   docker run avec -d, --name ollama, -v ollama:/root/.ollama, -p 127.0.0.1:11434:11434 et, avec NVIDIA, --gpus=all.
4. 04
   Ein Modell herunterladen

   docker exec -it ollama ollama pull, suivi de qwen3.5:4b pour une carte de 8 Go, ou de qwen3.5:9b avec plus de marge.
5. 05
   Prüfen

   docker exec ollama ollama ps doit afficher 100% GPU dans la colonne PROCESSOR.

#1. Befehl: docker run

Die Ollama-Dokumentation nennt für den reinen CPU-Betrieb diesen Befehl: docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama. Die nachstehende Version beschränkt die Portfreigabe auf den lokalen Rechner, was im folgenden Abschnitt begründet wird, und ergänzt einen automatischen Neustart.

docker run -d \
  --name ollama \
  -p 127.0.0.1:11434:11434 \
  -v ollama:/root/.ollama \
  --restart unless-stopped \
  ollama/ollama

-p 127.0.0.1:11434:11434

Öffne den Port 11434 des Containers auf dem Host-System ausschließlich für die eigene Maschine.

-v ollama:/root/.ollama

Ein benanntes Volume, das dort eingebunden ist, wo Ollama seine Modelle speichert. Es bleibt auch nach dem Löschen des Containers erhalten.

--restart unless-stopped

Startet den Container nach einem Neustart von Docker oder des Rechners erneut, sofern er nicht manuell gestoppt wurde.

docker ps --filter name=ollama
curl http://localhost:11434/api/version

Die Antwort ist ein JSON-Objekt mit der Versionsnummer, beispielsweise {"version":"0.34.4"}, der stabilen Version mit Stand vom 29. September 2026.

#Port 11434: Wer kann tatsächlich darauf zugreifen?

Bei einer nativen Installation lauscht Ollama standardmäßig auf 127.0.0.1: Nur der eigene Rechner kann darauf zugreifen. Im Container setzt das Image OLLAMA_HOST dagegen auf 0.0.0.0:11434, da der Port sonst von außen nicht erreichbar wäre. Der Schutz hängt daher davon ab, wie Sie den Port veröffentlichen.

Laut der Docker-Dokumentation ist das Veröffentlichen eines Container-Ports standardmäßig unsicher: Er wird von außen erreichbar, nicht nur vom Host aus. Der Befehl -p 11434:11434 bindet ihn an alle Adressen des Rechners. Die lokale API von Ollama verlangt jedoch keine Authentifizierung: Jeder, der den Port erreichen kann, kann Ihre Modelle auflisten, Modelle herunterladen oder Ihre GPU belegen.

-p 11434:11434

Alle Host-Interfaces: erreichbar über das lokale Netzwerk, möglicherweise auch über das Internet.

-p 127.0.0.1:11434:11434

Nur auf dem lokalen Rechner erreichbar. Das ist die Standardeinstellung in diesem Leitfaden.

-p 192.168.1.10:11434:11434

Eine einzige Host-Adresse; ersetzen Sie sie durch Ihre eigene.

Um Ollama bewusst in einem Netzwerk zugänglich zu machen, schalten Sie einen Reverse-Proxy mit Authentifizierung davor, wie es der am Ende der Seite angeführte Sicherheitsleitfaden erklärt.

#Den Port auf der Host-Seite ändern

Port 11434 ist belegt, wenn bereits eine andere Instanz läuft, häufig die native Anwendung. Ändern Sie nichts auf der Containerseite: Ändern Sie nur die Zahl links. Mit -p 127.0.0.1:11435:11434 kommuniziert Ihr Rechner auf Port 11435 mit Ollama; innerhalb des Containers ändert sich nichts.

#Verbindung zu Ollama aus einem anderen Container herstellen

Zwei Dienste in derselben Compose-Datei teilen sich ein Netzwerk, in dem jeder Dienst über seinen Dienstnamen erreichbar ist. Open WebUI verwendet daher http://ollama:11434, ohne den Port nach außen freizugeben. Läuft Ollama stattdessen auf dem Host, weist die Dokumentation von Open WebUI auf den Stolperstein hin: Ollama lauscht auf 127.0.0.1 und ist vom Container aus nicht erreichbar. Es muss über host.docker.internal angesprochen und so konfiguriert werden, dass es auf einer anderen Adresse lauscht.

#2. Die NVIDIA-GPU aktivieren

Docker erkennt Ihre GPU standardmäßig nicht. Auf dem Host benötigen Sie einen aktuellen NVIDIA-Treiber und das NVIDIA Container Toolkit; anschließend verwenden Sie das Flag --gpus. Ollama erfordert einen Treiber der Version 550 oder neuer, für ältere Karten mit Compute Capability 5.0 bis 6.2 die Version 570. Container verwenden den Treiber des Hosts und enthalten keinen eigenen.

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey \
  | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -fsSL 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

Der Befehl nvidia-ctk ändert die Datei /etc/docker/daemon.json, damit Docker die NVIDIA-Runtime kennt; daher ist der Neustart nötig. Für Fedora oder RHEL nennt die Ollama-Dokumentation die Variante mit yum oder dnf. Bevor Sie Änderungen an Ollama vornehmen, grenzen Sie das Problem mit einem Wegwerfcontainer ein: Wenn dieser scheitert, wird auch Ollama Ihre GPU nicht erkennen.

docker run --rm --gpus all ubuntu nvidia-smi

Starten Sie Ollama anschließend mit GPU-Zugriff neu. Das Volume bleibt erhalten: Die bereits heruntergeladenen Modelle sind weiterhin vorhanden.

docker rm -f ollama

docker run -d \
  --name ollama \
  --gpus=all \
  -p 127.0.0.1:11434:11434 \
  -v ollama:/root/.ollama \
  --restart unless-stopped \
  ollama/ollama

Bei einer Radeon unter Linux ersetzen der Tag rocm und die Geräte /dev/kfd und /dev/dri die Option --gpus; der ROCm-Treiber v7 muss noch auf dem Host installiert werden.

docker run -d \
  --device /dev/kfd --device /dev/dri \
  -v ollama:/root/.ollama \
  -p 127.0.0.1:11434:11434 \
  --name ollama \
  ollama/ollama:rocm

• Ollama und AMD-GPUs: ROCm Schritt für Schritt konfigurieren
• Ollama unter WSL2 oder nativ unter Windows: Welche Variante wählen?

#3. Erstes Modell

Der Container läuft, ist aber leer. Der Befehl ollama befindet sich im Container und wird mit docker exec aufgerufen. Dieser Leitfaden verwendet qwen3.5:9b, das in der Ollama-Modellbibliothek mit 6,6 GB, einem Kontextfenster von 256K und Unterstützung für Text und Bilder beschrieben wird.

docker exec -it ollama ollama pull qwen3.5:9b

Diese 6,6 GB müssen in den Speicher passen, noch bevor der Kontext ins Spiel kommt. Auf einer Karte mit 8 GB ist der Spielraum knapp: Die 4B-Variante ist die vorsichtige Wahl.

Die Referenzen der letzten Spalte sind Größenordnungen, nicht Maßangaben: die tatsächliche Größe hängt vom Kontext und der Quantifizierung ab. Um mit dem Modell zu sprechen, starten Sie ollama run dans den Container.

docker exec -it ollama ollama run qwen3.5:9b

Die übliche Nutzung erfolgt über die HTTP-API: Jeder Client kommuniziert mit dem Container wie mit einer nativen Ollama-Installation, und die Dokumentation gibt an, dass die API eine Teilmenge des OpenAI-Formats akzeptiert.

curl http://localhost:11434/api/generate -d '{
  "model": "qwen3.5:9b",
  "prompt": "Explique la quantification Q4 en deux phrases.",
  "stream": false
}'

docker exec ollama ollama ps

In der Spalte PROCESSOR bedeutet 100% GPU, dass sich das Modell vollständig im Speicher der Grafikkarte befindet, 100% CPU, dass es im Systemspeicher liegt, und 48%/52% CPU/GPU, dass es auf beide verteilt ist. Diese Aufteilung verlangsamt die Generierung deutlich: Ein kleineres Modell ist besser als eines, das teilweise in den Systemspeicher ausgelagert werden muss.

#Der Kontext wird im Container eingestellt

Das standardmäßige Kontextfenster hängt vom verfügbaren Speicher ab: 4k bei weniger als 24 GiB VRAM, 32k zwischen 24 und 48 GiB, 256k darüber. Die Dokumentation empfiehlt mindestens 64.000 Tokens für Agenten und Code-Tools. Ein größerer Kontext benötigt mehr Speicher: Übergeben Sie bei docker run die Option -e OLLAMA_CONTEXT_LENGTH=8192, und überprüfen Sie anschließend die Spalte CONTEXT in der Ausgabe von ollama ps.

#4. Persistentes Volume: Hier liegen Ihre Modelle

Die Option -v ollama:/root/.ollama erstellt ein Docker-Volume namens ollama, das vom Container getrennt ist. Die Docker-Dokumentation bestätigt dies: Ein Volume bleibt nach dem Löschen des Containers bestehen, sodass das Image ersetzt werden kann, ohne die Modelle erneut herunterzuladen. Der Befehl docker volume inspect ollama zeigt dessen Mountpoint an, also den Speicherort der Dateien auf dem Host.

Unter Linux speichert die native Installation ihre Modelle in /usr/share/ollama/.ollama/models. Dieser Ordner ist nicht mit dem Docker-Volume verbunden: Ein auf der einen Seite heruntergeladenes Modell erscheint nicht auf der anderen.

docker run --rm \
  -v ollama:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/ollama-models.tar.gz -C /data .

#5. Docker Compose: Die gleiche Lösung in einer Datei

Die unten stehende Datei erledigt dasselbe wie die vorherigen Befehle, lässt sich auf einen Blick prüfen und in Git versionieren. Sie legt die Image-Version fest: Ersetzen Sie 0.34.4 durch die neueste stabile Version zum Zeitpunkt der Lektüre.

services:
  ollama:
    image: ollama/ollama:0.34.4
    container_name: ollama
    ports:
      - "127.0.0.1:11434:11434"
    volumes:
      - ollama:/root/.ollama
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

volumes:
  ollama:

Der deploy-Block reserviert die GPU; laut Compose-Dokumentation ist das Feld capabilities Pflicht, andernfalls schlägt die Bereitstellung fehl. Ohne NVIDIA-GPU entfernen Sie den gesamten Block: Der Rest läuft auf der CPU.

docker compose up -d        # démarrer
docker compose logs -f      # suivre les logs
docker compose pull         # télécharger l'image du tag indiqué
docker compose down         # arrêter, volume conservé
docker compose down -v      # arrêter et supprimer le volume : efface tous les modèles

#Ollama aktualisieren, ohne Ihre Modelle zu verlieren

Stand 29. September 2026 kennzeichnet die Release-Seite von Ollama auf GitHub 0.34.4 als neueste stabile Version, während 0.35.0 dort als Vorabversion aufgeführt ist. Der Tag 0.35.0 existiert jedoch bereits auf Docker Hub, neben rc-Tags, wobei rc für Release Candidate steht. Legen Sie daher eine stabile Versionsnummer fest, statt dem zuletzt veröffentlichten Tag zu folgen: Das Update erfolgt, wenn Sie sich dafür entscheiden.

Mit Compose ändern Sie die Nummer in der Datei und führen anschließend docker compose pull und docker compose up -d aus. Mit docker run laden Sie das neue Image herunter, löschen den alten Container und führen denselben Befehl erneut aus: Solange Sie dasselbe Volume verwenden, bleiben die Modelle erhalten. Prüfen Sie abschließend die Version mit curl http://localhost:11434/api/version.

• Ollama: Aktualisieren, ein Modell löschen, deinstallieren

#Docker oder native Installation: die Wahl

Die beiden Methoden verwenden den gleichen Server auf dem gleichen Port. Die Tabelle beruht auf der Dokumentation von Ollama; sie vergleicht nicht die Geschwindigkeiten, da keine veröffentlichte und zitierbare Messung vorliegt.

Wählen Sie Docker, um mehrere Dienste zusammen zu betreiben, eine Version festzulegen oder einen Rechner gemeinsam zu nutzen. Wählen Sie die native Installation auf einem Mac oder wenn Docker bei der Nutzung durch eine einzelne Person keinen Mehrwert bietet.

#Fehlerbehebung

could not select device driver "nvidia"

Das NVIDIA Container Toolkit fehlt, oder Docker wurde nach nvidia-ctk runtime configure nicht neu gestartet. Wiederholen Sie die Konfiguration, starten Sie Docker neu und testen Sie erneut mit docker run --rm --gpus all ubuntu nvidia-smi.

Die GPU funktioniert, dann wechselt Ollama wieder auf die CPU

Dokumentiertes Symptom: Das Protokoll meldet nach einiger Zeit Fehler bei der GPU-Erkennung. Ollama empfiehlt, die cgroup-Verwaltung durch systemd in Docker zu deaktivieren: Fügen Sie "exec-opts": ["native.cgroupdriver=cgroupfs"] zu /etc/docker/daemon.json hinzu und starten Sie anschließend Docker neu.

GPU-Fehler 3, 46, 100 oder 999

Laden Sie den UVM-Treiber mit sudo rmmod nvidia_uvm und anschließend sudo modprobe nvidia_uvm neu oder starten Sie die Maschine neu.

Port 11434 bereits in Gebrauch

Eine andere Instanz lauscht bereits auf dem Port, häufig ist es die native Anwendung. Beenden Sie diese Instanz oder geben Sie mit -p 127.0.0.1:11435:11434 einen anderen Port frei.

Abgeschnittene Antworten

Die Standardkontextlänge hängt vom VRAM ab. Fügen Sie beim Start -e OLLAMA_CONTEXT_LENGTH=8192 hinzu und behalten Sie dabei die Speichernutzung im Blick.

Herunterladen hinter einem Proxy blockiert

Übergeben Sie dem Container -e HTTPS_PROXY=https://proxy.example.com. Die Dokumentation rät von HTTP_PROXY ab, da dies die Clients beeinträchtigen kann.

Nicht über das lokale Netzwerk erreichbar

Das ist bei -p 127.0.0.1:11434:11434 normal. Öffnen Sie den Port nur mit vorgeschalteter Authentifizierung.

#Häufig gestellte Fragen

#Weiterführende Informationen

Sie haben nun eine funktionsfähige, isolierte Ollama-Instanz mit einem Modell auf der GPU. Die nächsten sinnvollen Schritte: eine Chat-Oberfläche, die Absicherung vor jeder Freigabe im Netzwerk und anschließend ein Produktionsstack.

• Ollama auf allen Systemen installieren: der allgemeine Leitfaden
• Ollama-Fehlerbehebung: GPU nicht erkannt, langsamer Betrieb, Speicherfehler
• Docker Model Runner: LLM mit Docker starten, ohne Ollama

• Quelle: Ollama-Dokumentation, Seite zu Docker
• Quelle: Image ollama/ollama auf Docker Hub
• Quelle: Docker, Portveröffentlichung
• Quelle: NVIDIA Container Toolkit, Installationsanleitung
• Quelle: Ollama-Dokumentation, unterstützte GPUs