# Ollama-Install mit Docker: Schritt für Schritt zum eigenen Ollama-Server

Je nach geplantem Einsatz kann für den Betrieb von Ollama ein anderer Servertyp sinnvoll sein: Für kleine Chatbots genügt oft ein größerer VPS, während Agenten, Coding-Workloads oder sehr große Modelle meist eine GPU oder sogar dedizierte Hardware benötigen. Ollama erleichtert den lokalen oder serverseitigen Betrieb großer Sprachmodelle deutlich, indem es Modelle verwaltet, startet und über eine einfache API bereitstellt.

## Was ist Ollama?

Ollama ist eine Software, mit der Sie [große Sprachmodelle](https://www.ionos.de/digitalguide/server/knowhow/large-language-model/) wie Gemma, Qwen, DeepSeek oder andere kompatible Modelle **lokal oder auf einem eigenen Server** ausführen können. Die Plattform stellt dafür eine einfache Kommandozeilenoberfläche sowie eine [REST](https://www.ionos.de/digitalguide/server/knowhow/rest-die-http-loesung-fuer-webservices/)-API bereit, über die sich Modelle starten und in eigene Anwendungen integrieren lassen. Ollama eignet sich auf diese Weise nicht nur zum Chatten im Terminal, sondern auch als **Modell-Backend** für eigene Tools, Assistenten oder Entwicklungsumgebungen.

Besonders attraktiv ist Ollama für Nutzerinnen und Nutzer, die Modelle nicht über einen fremden [Cloud](https://www.ionos.de/digitalguide/server/knowhow/was-ist-eine-cloud/)-Dienst ansprechen, sondern auf **eigener Infrastruktur betreiben** möchten. Die Interaktionen erfolgen lokal und die Software übernimmt das Laden und Ausführen der Modelle sowie den Zugriff per CLI oder [API](https://www.ionos.de/digitalguide/websites/web-entwicklung/was-ist-eine-api/). Für Einsteigerinnen und Einsteiger ist das praktisch, weil sie kein komplettes Inferenz-Setup von Grund auf selbst bauen müssen, sondern mit wenigen Befehlen starten können.

Hinweis Ollama dient in vielen KI-Projekten lediglich als Modell-Backend, das Sprachmodelle lokal oder auf einem Server ausführt und über eine API bereitstellt. Darauf aufbauend können Agent-Frameworks wie [OpenClaw mit Ollama](https://www.ionos.de/digitalguide/server/konfiguration/openclaw-ollama/) genutzt werden, um komplexe Workflows zu automatisieren. In solchen Setups übernimmt Ollama die eigentliche Modell-Inferenz, während OpenClaw Aufgaben wie Tool-Nutzung, mehrstufige Agentenprozesse oder automatisierte Aktionen steuert.

## Welcher Server passt zu Ihrem Vorhaben?

Bevor Sie mit der Installation beginnen, sollten Sie festlegen, wofür Sie Ollama tatsächlich einsetzen möchten. **Nicht jede Anwendung braucht eine GPU**, aber sobald Antworten flüssig kommen sollen, mehrere Anfragen parallel laufen oder größere [KI](https://www.ionos.de/digitalguide/online-marketing/verkaufen-im-internet/was-ist-kuenstliche-intelligenz/)-Modelle eingesetzt werden, steigen die Anforderungen schnell an. Die **Modellgröße ist dabei ein entscheidender Faktor**: Ollama nennt für 7B-Modelle mindestens 8 GB [RAM](https://www.ionos.de/digitalguide/server/knowhow/was-ist-ein-arbeitsspeicher/), für 13B-Modelle mindestens 16 GB RAM und für 70B-Modelle mindestens 64 GB RAM als grobe Orientierung. Zusätzlich spielt die verfügbare VRAM-Ausstattung der GPU eine wichtige Rolle, weil sie Geschwindigkeit, Kontextlänge und praktische Nutzbarkeit stark beeinflusst.

### Use Case 1: Einfache Textaufgaben, Tests und kleine Chatbots

Wenn Sie Ollama vor allem zum Ausprobieren, für einfache Textgenerierung, kleine Hilfsbots oder interne Tests nutzen möchten, reicht oft ein leistungsstärkerer [VPS](https://www.ionos.de/server/vps "VPS günstig mieten bei IONOS") ohne dedizierte GPU aus. In diesem Szenario laufen typischerweise **kleinere KI-Modelle**. Diese benötigen mindestens 8 GB RAM, wobei in der Praxis etwas **Reserve sinnvoll ist**, damit Betriebssystem, [Docker](https://www.ionos.de/digitalguide/server/knowhow/was-ist-docker/) und Hintergrundprozesse den Server nicht ausbremsen. Für einen Einstiegs-Ollama-Server sind daher 16 GB RAM meist die vernünftigere Untergrenze. Rechnen Sie außerdem mit zusätzlichem Speicherplatz, denn neben dem Docker-Setup müssen auch die Modelldateien abgelegt werden, die schnell mehrere Gigabyte groß sein können.

Der große Vorteil eines VPS liegt in den **überschaubaren Kosten und der einfachen Bereitstellung**. Der Nachteil ist die deutlich geringere Geschwindigkeit im Vergleich zu GPU-Servern. Für Lernzwecke, Demo-Projekte und einfache API-Endpunkte ist ein VPS mit 4 vCPU, 16 GB RAM und [SSD](https://www.ionos.de/digitalguide/server/knowhow/was-ist-ssd/)-Speicher dennoch oft ein sinnvoller Einstieg.

### Use Case 2: Interne Wissensbots, kleine APIs und Embeddings

Wenn Sie Ollama als Backend für eine kleine interne Wissensdatenbank, für [Retrieval-Augmented-Generation](https://www.ionos.de/digitalguide/server/knowhow/retrieval-augmented-generation/) oder für Embeddings nutzen möchten, steigen die Anforderungen bereits an. Hier geht es nicht nur um eine einzelne Chat-Ausgabe, sondern oft um wiederholte API-Aufrufe, Hintergrundverarbeitung und eine stabilere Laufzeit. Zwar können solche Szenarien weiterhin auf einem [CPU](https://www.ionos.de/digitalguide/server/knowhow/cpu/)-Server oder großen VPS laufen, sinnvoll wird aber **mehr Arbeitsspeicher**, damit Modelle und Daten nicht ständig neu geladen werden müssen. Ein Server mit 16 bis 32 GB RAM ist für solche Aufgaben deutlich angenehmer.

Wenn zusätzlich mehrere Nutzerinnen und Nutzer gleichzeitig auf den Dienst zugreifen, lohnt sich eine CPU mit mehr Kernen oder der Umstieg auf einen [GPU-Server](https://www.ionos.de/digitalguide/server/knowhow/gpu-server/). Ollama unterstützt neben Textgenerierung auch Embeddings über die API, was es auch für Such- und Wissensanwendungen interessant macht. Für kleine Teams oder interne Tools kann deshalb ein großer VPS oder ein kleiner [Dedicated Server](https://www.ionos.de/server/dedicated-server "Dedicated Server mit Windows oder Linux – IONOS") ohne GPU bereits ausreichen, sofern keine extrem niedrigen Antwortzeiten erwartet werden. Wer allerdings eine sichtbar **flüssige Benutzererfahrung** möchte, sollte auch in diesem Bereich eine GPU in Erwägung ziehen. Grundsätzlich gilt: Je interaktiver und je paralleler Ihr Dienst genutzt wird, desto eher stößt ein reiner CPU-Server an seine Grenzen.

### Use Case 3: Coding-Assistenten und flüssig laufende Agenten

Sobald Ollama für Coding-Assistenten, halbautonome Agenten oder andere interaktive Workflows genutzt werden soll, wird eine GPU deutlich empfehlenswerter. Der Grund ist simpel: Solche Anwendungen profitieren massiv davon, wenn Antworten schnell generiert werden und Modelle mit größerem Kontext flüssig arbeiten können. Dabei hängen die Standard-Kontextlängen unter anderem **von der verfügbaren VRAM-Größe ab**. Für Agenten, Websuche, Coding-Tools oder längere Arbeitskontexte empfiehlt die Dokumentation mindestens 32.000 bis 64.000 [AI-Tokens](https://www.ionos.de/digitalguide/websites/web-entwicklung/ai-token/) Kontext.

Damit wird klar, dass ein einfacher CPU-VPS für solche Vorhaben meist nicht die ideale Wahl ist. Besser geeignet ist ein GPU-[Cloud-Server](https://www.ionos.de/digitalguide/server/knowhow/was-ist-ein-cloud-server/) mit aktueller NVIDIA-GPU, kombiniert mit ausreichend RAM und schnellem [NVMe](https://www.ionos.de/digitalguide/server/knowhow/was-ist-nvme/)-Speicher. Damit lassen sich mittelgroße Modelle deutlich angenehmer betreiben. Auch **mehrstufige Agenten-Workflows** werden auf diese Weise praktikabel. Für ambitionierte Einzelprojekte, Prototypen und Entwicklungsteams ist dies häufig der beste Mittelweg zwischen Kosten und Leistung.

### Use Case 4: Professionelle Anwendungen mit mehreren Usern

Wenn Sie Ollama als **festen Bestandteil einer professionellen Anwendung** einsetzen möchten, ändern sich die Anforderungen erneut. Dann geht es nicht mehr nur darum, ob ein Modell grundsätzlich läuft, sondern ob es stabil, reproduzierbar und unter Last performant arbeitet. In solchen Szenarien sollten Sie an genügend RAM, eine leistungsfähige GPU, Reserven für mehrere parallele Prozesse, Monitoring und ausreichend Speicherplatz für mehrere Modelle denken. Da Ollama Modelle per API bereitstellt, kann es gut als internes Modell-Backend dienen, aber die Serverauswahl muss auf Verfügbarkeit und Lastverhalten ausgelegt sein.

Ein leistungsfähiger GPU-Dedicated-Server oder ein professioneller GPU-Cloud-Server ist hier in aller Regel die bessere Wahl als ein kleiner VPS. Sinnvoll sind in diesem Bereich oft 64 GB RAM oder mehr, dazu eine starke NVIDIA-GPU und ein **sauberer Betriebsaufbau mit Persistenz** für Modelldateien. Gerade bei produktiven Anwendungen ist außerdem wichtig, dass Docker und gegebenenfalls die NVIDIA-Container-Toolkit-Konfiguration sauber eingerichtet werden, damit die GPU im [Docker-Container](https://www.ionos.de/digitalguide/server/knowhow/docker-container/) auch wirklich genutzt werden kann.

### Use Case 5: Sehr große Modelle und High-End-Inferenz

Wenn Sie sehr große Modelle im Bereich 70B oder darüber ausführen möchten, bewegen Sie sich klar im High-End-Segment. Ollama nennt für 70B-Modelle mindestens 64 GB RAM als grobe Mindestanforderung. In der Praxis reichen Server basierend auf [Virtualisierung](https://www.ionos.de/digitalguide/server/konfiguration/virtualisierung/) hier meist nicht aus, insbesondere wenn die Antwortzeiten gut sein sollen oder mehrere Prozesse parallel laufen. Für solche Szenarien ist ein **dedizierter Server mit sehr leistungsfähiger GPU-Hardware** deutlich realistischer als ein normaler VPS.

Im professionellen Umfeld kommen dafür typischerweise spezialisierte GPU-Systeme mit viel VRAM infrage, etwa Server mit NVIDIA-A100- oder [NVIDIA-H100](https://www.ionos.de/digitalguide/server/knowhow/nvidia-h100/)-Karten oder vergleichbar ausgestattete Hochleistungsumgebungen. Das ist kostspielig, aber für große Modelle, lange Kontexte und produktive High-End-Workloads **quasi alternativlos**.

### Übersicht: Welcher Server für welchen Zweck?

<table>
  <thead>
    <tr>
      <th><strong>Ziel</strong></th>
      <th><strong>Empfohlene Hardware</strong></th>
      <th><strong>Kosten (geschätzt)</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><strong>Einfacher Bot / API</strong></td>
      <td>VPS mit 4 vCPU, 16 GB RAM, SSD</td>
      <td>+</td>
    </tr>
    <tr>
      <td><strong>Interne Wissensbots / Embeddings</strong></td>
      <td>Großer VPS oder kleiner Dedicated Server mit 16–32 GB RAM</td>
      <td>+ / ++</td>
    </tr>
    <tr>
      <td><strong>Coding und Agenten</strong></td>
      <td>GPU-Cloud-Server mit moderner GPU</td>
      <td>++</td>
    </tr>
    <tr>
      <td><strong>Professionelle Anwendungen</strong></td>
      <td>Leistungsstarker GPU-Cloud-Server oder Dedicated Server mit viel RAM</td>
      <td>++ / +++</td>
    </tr>
    <tr>
      <td><strong>High-End (70B+)</strong></td>
      <td>Dedicated Server mit A100/H100 oder vergleichbarer High-End-GPU</td>
      <td>+++</td>
    </tr>
  </tbody>
</table>

**Kostenlegende**: + = gering, ++ = mittel, +++ = hoch

## Ollama auf einem Server mit Docker installieren: Schritt für Schritt

Im folgenden Abschnitt zeigen wir den Ollama-Install auf einem Linux-Server mit Docker. Für Einsteigerinnen und Einsteiger ist die Kombination von Ollama und Docker besonders praktisch, weil Ollama dabei in einem Container läuft und Sie weniger manuell im System verändern müssen. Für GPU-Betrieb unter Linux mit NVIDIA-GPU benötigen Sie zusätzlich das NVIDIA Container Toolkit, damit Docker die GPU an den Container durchreichen kann.

### Schritt 1: Mit dem Server verbinden

Verbinden Sie sich zunächst per SSH mit Ihrem Server. Dazu benötigen Sie die IP-Adresse des Servers sowie einen User mit sudo-Rechten.

```bash
ssh BENUTZERNAME@SERVER-IP
```

Wenn Sie sich zum ersten Mal verbinden, fragt Ihr System in der Regel nach einer Bestätigung des Host-Schlüssels. Geben Sie yes ein und anschließend Ihr Passwort oder verwenden Sie Ihren SSH-Schlüssel. Danach befinden Sie sich im **Terminal Ihres Servers** und können mit der Einrichtung beginnen.

### Schritt 2: System aktualisieren

Bevor Sie Docker und Ollama installieren, sollten Sie die Paketlisten aktualisieren und vorhandene Pakete auf den neuesten Stand bringen. Damit stellen Sie sicher, dass Ihr System aktuelle Sicherheitsupdates und Paketversionen verwendet. Gerade auf frisch bereitgestellten Servern ist das ein sinnvoller erster Schritt, bevor weitere Software installiert wird.

```bash
sudo apt update && sudo apt upgrade -y
```

### Schritt 3: Docker installieren

Für Ubuntu 24.04 empfiehlt Docker die Installation über das offizielle APT-Repository. Dabei wird die aktuelle Repository-Datei im Deb822-Format unter `/etc/apt/sources.list.d/docker.sources` eingerichtet. Unterstützt werden unter anderem Ubuntu 24.04 sowie mehrere Architekturen wie beispielsweise amd64 und arm64. Installieren Sie hierzu zunächst die benötigten Hilfspakete:

```bash
sudo apt install ca-certificates curl -y
```

Erstellen Sie danach das Verzeichnis für den Schlüsselbund:

```bash
sudo install -m 0755 -d /etc/apt/keyrings
```

Laden Sie anschließend den offiziellen Docker-Schlüssel herunter:

```bash
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
```

Richten Sie nun wie folgt das Docker-Repository ein:

```bash
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF
```

Aktualisieren Sie anschließend erneut die Paketliste:

```bash
sudo apt update
```

Installieren Sie außerdem die Docker Engine inklusive Compose-Plugin:

```bash
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y
```

Überprüfen Sie danach, ob Docker korrekt läuft:

```bash
sudo systemctl status docker
```

Sie sollten die Anzeige „active (running)“ sehen, die bestätigt, dass Docker läuft.

[![Bild: Statusanzeige von Docker auf Ihrem Ollama-Server](https://www.ionos.de/digitalguide/fileadmin/_processed_/4/5/csm_ollama-docker-status_f2f06d92e5.webp "Statusanzeige von Docker auf Ihrem Ollama-Server")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-docker-status.jpg) Die Anzeige „active“ bestätigt, dass Docker läuft. Zusätzlich können Sie einen Testcontainer starten:

```bash
sudo docker run hello-world
```

Wenn dabei eine Bestätigungsmeldung erscheint, ist Docker erfolgreich installiert.

[![Bild: Hello-World-Container auf Ihrem Ollama-Server](https://www.ionos.de/digitalguide/fileadmin/_processed_/1/4/csm_ollama-docker-hello-world_8f4acb83c1.webp "Hello-World-Container auf Ihrem Ollama-Server")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-docker-hello-world.jpg) Wenn Docker erfolgreich installiert ist, können Sie den Hello-World-Container als ersten Test starten. ### Schritt 4: Optional Docker ohne sudo verwenden

Standardmäßig wird Docker unter Linux meist mit `sudo` ausgeführt. Wenn Sie Docker dennoch ohne `sudo` verwenden möchten, führen Sie diese Befehle aus:

```bash
sudo groupadd docker
sudo usermod -aG docker $USER
newgrp docker
```

Danach können Sie testen, ob Docker ohne sudo funktioniert:

```bash
docker run hello-world
```

### Schritt 5: Bei NVIDIA-GPU das NVIDIA Container Toolkit installieren

Diesen Schritt benötigen Sie **nur dann, wenn Ihr Server eine NVIDIA-GPU besitzt** und Ollama die GPU im Docker-Container nutzen soll. Installieren Sie zunächst die nötigen Pakete:

```bash
sudo apt-get update && sudo apt-get install -y --no-install-recommends ca-certificates curl gnupg2
```

Fügen Sie dann das NVIDIA-Repository hinzu:

```bash
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
```

Aktualisieren Sie die Paketliste und installieren Sie das Toolkit:

```bash
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
```

Konfigurieren Sie Docker für den NVIDIA-Runtime-Support:

```bash
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
```

Wenn Ihre GPU-Treiber korrekt installiert sind, kann Docker danach GPU-Ressourcen an Container durchreichen.

### Schritt 6: Ollama-Container starten

Nun können Sie Ollama selbst als Docker-Container starten. Das offizielle Image heißt `ollama/ollama`. Für den reinen CPU-Betrieb verwenden Sie folgenden Befehl:

```bash
sudo docker run -d \
-v ollama:/root/.ollama \
-p 11434:11434 \
--name ollama \
ollama/ollama
```

Wenn Sie eine NVIDIA-GPU verwenden und bereits Schritt 5 abgeschlossen haben, starten Sie den Container stattdessen so:

```bash
sudo docker run -d \
--gpus=all \
-v ollama:/root/.ollama \
-p 11434:11434 \
--name ollama \
ollama/ollama
```

### Schritt 7: Prüfen, ob der Container läuft

Kontrollieren Sie nun mit folgendem Terminalbefehl, ob der Container auf Ihrem Ollama-Server erfolgreich gestartet wurde:

```bash
sudo docker ps
```

In der Ausgabe sollte ein Container mit dem Namen ollama erscheinen. Zusätzlich sollte zu sehen sein, dass Port 11434 veröffentlicht wurde. Genau dort stellt Ollama später die API bereit.

[![Bild: Screenshot der Ausgabe von docker ps](https://www.ionos.de/digitalguide/fileadmin/_processed_/4/3/csm_ollama-docker-container_e2e71f111b.webp "Screenshot der Ausgabe von docker ps")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-docker-container.jpg) Der Befehl „docker ps“ liefert eine Anzeige über Ihre Container. Hier sollte nun der Ollama-Container zu sehen sein. ### Schritt 8: Ein erstes Modell herunterladen und starten

Sobald der Container läuft, können Sie ein **Modell starten**. Das offizielle Image zeigt als Beispiel den Aufruf per `docker exec`. Dadurch führen Sie den Ollama-Befehl direkt im laufenden Container aus.

```bash
sudo docker exec -it ollama ollama run llama3
```

Beim ersten Start lädt Ollama das Modell zunächst herunter. Das kann je nach Modellgröße und Serveranbindung **einige Zeit dauern**. Anschließend landen Sie in einer interaktiven Konsole, in der Sie direkt Fragen stellen können.

[![Bild: Ollama mit Llama3](https://www.ionos.de/digitalguide/fileadmin/_processed_/e/1/csm_ollama-run-llama3_a8fb667e84.webp "Ollama mit Llama3")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-run-llama3.jpg) Nachdem Sie Llama3 (oder ein anderes Sprachmodell) gestartet haben, können Sie in der Chatkonsole mit der LLM interagieren. Wenn Sie lieber ein anderes Modell als [Llama3](https://www.ionos.de/digitalguide/server/knowhow/llama-3/) ausprobieren möchten, können Sie entsprechend einen anderen Modellnamen verwenden. Welche Modelle verfügbar sind, finden Sie in der Ollama-Bibliothek. Die Dokumentation nennt dort unter anderem aktuelle Modelle wie **Gemma 3, Qwen3, DeepSeek-R1** und weitere.

### Schritt 9: Die Ollama-API testen

Ollama stellt nach dem Start automatisch eine API zur Verfügung. Laut offizieller Dokumentation lautet die Standardbasis `http://localhost:11434/api`. Einen einfachen Test können Sie direkt auf dem Server mit `curl` ausführen.

Ein Beispiel für eine einfache Generierungsanfrage könnte in etwa so aussehen:

```bash
curl http://localhost/api/generate -d '{
"model": "gemma3",
"prompt": "Erkläre in zwei Sätzen, was Ollama ist.",
"stream": false
}'
```

Wenn alles korrekt funktioniert, erhalten Sie eine JSON-Antwort oder einen gestreamten Output vom Modell. Damit wissen Sie, dass nicht nur der Container läuft, sondern auch die API ordnungsgemäß erreichbar ist.

[![Bild: Aufruf an die Ollama-API](https://www.ionos.de/digitalguide/fileadmin/_processed_/3/f/csm_ollama-api-antwort-json_cd70223250.webp "Aufruf an die Ollama-API")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-api-antwort-json.jpg) Die API liefert Ihnen die Antwort direkt im JSON-Format. ### Schritt 10: Alternativ mit Docker Compose arbeiten

Für einen dauerhaft betriebenen Server ist [Docker Compose](https://www.ionos.de/digitalguide/server/konfiguration/docker-compose-tutorial/) oft **angenehmer** als ein langer `docker run`-Befehl. Damit können Sie die Konfiguration in einer Datei speichern und später einfacher anpassen. Erstellen Sie hierzu zunächst ein Verzeichnis für Ihr Setup:

```bash
mkdir -p ~/ollama
cd ~/ollama
```

Erstellen Sie dann eine Datei namens compose.yaml. Wir nutzen hierfür den Editor nano, Sie können aber jeden beliebigen Texteditor verwenden:

```bash
nano compose.yaml
```

Fügen Sie für CPU-Betrieb diesen Inhalt ein:

```yaml
services:
    ollama:
        image: ollama/ollama
        container_name: ollama
        ports:
            - "11434:11434"
        volumes:
            - ollama:/root/.ollama
        restart: unless-stopped
volumes:
    ollama:
```

Für NVIDIA-GPU-Betrieb können Sie je nach Docker-Umgebung eine GPU-Konfiguration ergänzen. In der Praxis ist die einfachste und am häufigsten nachvollziehbare Variante für Anfängerinnen und Anfänger oft weiterhin der direkte Start mit docker run --gpus=all, weil Compose-Setups je nach Docker-Version leicht unterschiedlich aussehen können. Entscheidend ist in jedem Fall, dass Docker die NVIDIA-Runtime korrekt nutzt. Diese Voraussetzung beschreibt NVIDIA in seiner Toolkit-Dokumentation ausdrücklich.

Starten Sie den Dienst anschließend mit folgendem Befehl:

```bash
sudo docker compose up -d
```

[![Bild: Container starten mit compose](https://www.ionos.de/digitalguide/fileadmin/_processed_/7/1/csm_ollama-docker-compose_c5242c6946.webp "Container starten mit compose")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-docker-compose.jpg) Ein Start des Ollama-Containers mit Docker Compose ist angenehmer bei häufiger Nutzung. Prüfen Sie erneut den Status:

```bash
sudo docker compose ps
```

[![Bild: Container-Status](https://www.ionos.de/digitalguide/fileadmin/_processed_/7/3/csm_ollama-container-status-compose_c12a87cd84.webp "Container-Status")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/ollama-container-status-compose.jpg) Sie können sich mit compose ebenfalls den Status Ihres Ollama-Containers anzeigen lassen. ### Schritt 11: Wichtige Hinweise für den praktischen Betrieb

Wenn Sie Ollama produktiv oder für andere Geräte im Netzwerk bereitstellen möchten, sollten Sie den Dienst nicht unüberlegt offen ins Internet hängen. Zwar nutzt Ollama standardmäßig Port 11434, im hier gezeigten Docker-Setup wird die API durch `-p 11434:11434` jedoch auf dem Host veröffentlicht. Je nach Netzwerk- und [Firewall](https://www.ionos.de/digitalguide/server/sicherheit/was-ist-eine-firewall/)-Konfiguration kann sie damit auch von außen erreichbar sein. Wenn Sie den Zugriff auf den Server selbst beschränken möchten, binden Sie den Port stattdessen nur an `127.0.0.1`, etwa mit `-p 127.0.0.1:11434:11434`, und setzen Sie Ihre Firewall-Regeln entsprechend restriktiv.

Außerdem sollten Sie bedenken, dass Modelle lokal gespeichert werden und daher genügend Speicherplatz verfügbar sein muss. Unter Windows nennt die Dokumentation bereits mehrere Gigabyte nur für die Binärinstallation und zusätzlich teils sehr große Modell-Dateien; auf Linux gilt derselbe Grundgedanke: Modelle brauchen Platz, und zwar nicht zu knapp. Für längere Kontexte, Agenten oder Coding-Anwendungen ist außerdem die **verfügbare VRAM-Größe wichtig**, weil Ollama die Standard-Kontextlänge an der VRAM-Ausstattung ausrichtet.


This is a markdown version of: [https://www.ionos.de/digitalguide/server/konfiguration/ollama-docker/](https://www.ionos.de/digitalguide/server/konfiguration/ollama-docker/) for AI/LLM consumption.