Souveräne KI für mich und für dich: So baue ich meinen eigenen, unabhängigen Ollama-Server mit Docker und NVIDIA GPU-Power

Nie wieder für Tokens zahlen: Meine Schritt-für-Schritt-Anleitung, um die KI auf dem eigenen Server zu installieren

In der heutigen digitalen Welt möchte ich die volle Kontrolle über meine Daten, meine Modelle und natürlich die Performance haben. Mein Ziel ist die souveräne KI – also KI, die ich selbst betreibe und die nicht von externen Cloud-Anbietern abhängig ist.

Ich zeige euch heute, wie ich genau das geschafft habe. Ich habe einen Ubuntu-Server mit zwei NVIDIA RTX 4090 GPUs genutzt, um meine eigene, hochperformante Ollama-Instanz aufzubauen. Ich habe mich dabei bewusst dafür entschieden, das Docker-Image selbst zu bauen und jede Konfiguration (wie den Speicherort) persönlich festzulegen. Dies ist der einzig wahre Weg zur digitalen Souveränität, den ich euch hier als Hands-On-Anleitung mitgeben möchte.

Meine Ausgangsbasis für diese Schritt für Schritt Anleitung

Für diesen Guide gehe ich davon aus, dass ihr, genau wie ich, bereits einen Ubuntu-Server habt, auf dem die NVIDIA CUDA-Treiber für NVIDIA GPUs wie z.B. zwei RTX 4090-Karten installiert sind. Die NVIDIA GPUs sind das Fundament für diese Anleitung! Es geht auch rein mit CPU Power aber eben nicht so schnell und gut.

Phase 1: Die Infrastruktur installieren (Meine ersten Schritte)

Um Ollama stabil und flexibel in einem Container zu betreiben, musste ich die richtigen Werkzeuge installieren. Ich habe mich für die offizielle Paketverwaltung entschieden, da dies die beste Kompatibilität mit den NVIDIA-GPUs garantiert.

NVIDIA CUDA Treiber installieren

Für die Installation der NVIDIA CUDA Treiber bin ich folgt vorgegangen:

1. Öffne einen Browser und navigieren zum offiziellen NVIDIA CUDA Toolkit Archiv: https://developer.nvidia.com/cuda-toolkit-archive
2. Wähle eine aktuelle Version aus (z.B. 12.9.0) aber ich empfehle nicht die neueste Version zu nehmen sondern eine die ca. 1/4 Jahr alt ist.
3. Klicke Dich durch das Menü und wählen zu Beginn das Betriebssystem aus (Ubuntu) das auf Deinem KI-Server bereits installiert ist: Linux → x86_64 → Ubuntu → 24.04 → deb (network)

Jetzt intallierst Du wie beschrieben die CUDA Treiber. Die Befehle dafür findest Du in der Box „CUDA Toolkit Installer“ und Du führst diese jetzt Schritt für Schritt im Terminal Fenster aus.

CUDA Toolkit installer commands

Nach der erfolgreichen Installation kannst Du mit dem Befehl nvidia-smi überprüfen ob die Treiber erfolgreich installiert wurden.

NVIDIA-SMI Dual RTX4090

Jetzt sind die NVIDIA Treiber installiert und die GPUs können verwendet werden.

Docker und Docker Compose installieren

Auf dem frisch aufgesetzten Ubuntu Server muss noch Docker und Docker Compose installiert werden. Dazu habe ich mir das Skript install_docker.sh auf meinem Server angelegt. Ich habe mit dem Text-Editor Nano die install_docker.sh Datei angelegt. Wie das Skript aufgebaut ist seht ihr nachfolgend. Kopiert diesen Ihalt in die install_docker.sh Datei und speichert diese. Wenn ihr mit Nano nicht vertraut seid könnt ihr auch die Datei mit einem grafischen Text-Editor eurer Wahl anlegen.

#!/bin/bash

# --- Skript zum Installieren von Docker Engine und Docker Compose Plugin auf Ubuntu ---

# Funktion, um im Fehlerfall eine Meldung auszugeben und das Skript zu beenden
exit_on_error() {
echo "❌ FEHLER: Installation fehlgeschlagen. Bitte überprüfen Sie die vorherigen Meldungen."
exit 1
}

echo "========================================================"
echo " STARTE DOCKER & DOCKER COMPOSE INSTALLATION AUF UBUNTU "
echo "========================================================"

# 1. System aktualisieren und notwendige Pakete installieren
echo "-> 1/5: System aktualisieren und notwendige Pakete installieren..."
sudo apt update || exit_on_error
sudo apt install -y ca-certificates curl gnupg || exit_on_error

# 2. Docker GPG-Schlüssel und Repository hinzufügen
echo "-> 2/5: Offiziellen Docker GPG-Schlüssel und Repository hinzufügen..."
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg || exit_on_error

echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update || exit_on_error

# 3. Docker Engine und Docker Compose installieren
echo "-> 3/5: Docker Engine (CE) und Docker Compose Plugin installieren..."
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin || exit_on_error

# 4. Benutzer zur 'docker'-Gruppe hinzufügen (für die Ausführung ohne sudo)
echo "-> 4/5: Aktuellen Benutzer ($USER) zur 'docker'-Gruppe hinzufügen..."
sudo usermod -aG docker "$USER"

# 5. Überprüfung
echo "-> 5/5: Installation abgeschlossen. Überprüfe Versionen..."
echo "--------------------------------------------------------"
echo "Docker Engine Version:"
docker --version
echo "Docker Compose Version:"
docker compose version
echo "--------------------------------------------------------"

echo "✅ ERFOLG: Docker und Docker Compose wurden installiert."
echo "********************************************************"
echo "!!! WICHTIG: Sie müssen sich ABMELDEN und WIEDER ANMELDEN !!!"
echo "!!! damit die Gruppenänderung wirksam wird. !!!"
echo "********************************************************"

Nach dem ihr das Skript angelegt habt müsst ihr dieses noch ausführbar machen. Dazu führt ihr den folgenden Befehl aus.

Befehl: chmod +x install_docker.sh

Jetzt musst Du das Skript nur noch ausführen. Das geht mit dem folgenden Befehl.

Befehl: ./install_docker.sh

NVIDIA Container Toolkit

Jetzt benötigt unser System noch die NVIDIA Unterstützung für Docker. Nur so kann Docker auf die GPUs zugreifen. Ich bin der Installation wie offiziell von NVIDIA hier beschrieben gefolgt.

https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html

Nach der Installation habe ich den Server einmal mit dem Befehl sudo reboot neu gestartet.

Zwischenschritt: Den Ollama Quellcode lokal klonen

Bevor ich die docker-compose.yml erstelle, muss ich die Basis für den Eigenbau schaffen. Anstatt einfach ein fertiges Ollama Image zu ziehen, habe ich den gesamten Ollama Quellcode mit dem folgenden Befehl geklont. Das gibt mir die volle Versionskontrolle und ist der Schlüssel zur Unabhängigkeit.

Befehl: git clone https://github.com/ollama/ollama.git

Dieser Befehl erzeugt den Ordner ollama, auf den ich mich gleich in meiner docker-compose.yml beziehe.

Phase 2: Ollama im Docker-Container – Souveränität konfigurieren (Meine docker-compose.yml)

Nach der Installation der Basis-Tools habe ich die docker-compose.yml erstellt. Hier definiere ich alle Regeln für meinen Ollama-Container: Wie er gebaut wird, wo er speichert und welche Hardware er nutzt.

Ich habe die Datei docker-compose.yml in mein Home-Verzeichnis wieder mit dem Text-Editor Nano gelegt (wo der geklonte ollama-Ordner liegt) und wie folgt konfiguriert:

services:
  ollama:
  # 1. Ich baue mein Image aus dem geklonten Quellcode
  build:
    context: ./ollama
    dockerfile: Dockerfile

  container_name: ollama

  ports:
    - "11434:11434"

  # 2. Netzwerkkontrolle: Ich will Zugriff aus dem gesamten LAN
  environment:
    - OLLAMA_HOST=0.0.0.0

  # 3. Speicherkontrolle: Ich nutze mein dediziertes Laufwerk für die Sparchenmodelle
  # Ich habe meinen Pfad hier natürlich angepasst.
  volumes:
    - <lokaler Pfad zu Deinem Laufwerk>:/root/.ollama

  # 4. Leistungskontrolle: Ich weise beide RTX 4090s zu
    deploy:
      resources:
        reservations:
          devices:
        - driver: nvidia
            count: all # Maximale Power aus meinen beiden 4090ern
            capabilities: [gpu]

  restart: always

Mein Ziel ist es in dieser Anleitung die volle Kontrolle über drei Bereiche zu haben:

1. Code: Ich baue das Image (build).
2. Daten: Ich wähle den Speicherort (volumes).
3. Hardware: Ich nutze die volle Leistung meiner zwei GPUs (count: all).

Phase 3: Starten und Testen (Meine Erfahrung)

Der Moment der Wahrheit! Mit einem einzigen Befehl habe ich den Build-Prozess und den Start meines Servers initiiert.

Image bauen und Container starten: docker compose up -d --build

Meine Erfahrung zeigt: Der Build-Prozess dauert beim ersten Mal seine Zeit, aber das Warten lohnt sich für die Unabhängigkeit!

Verifizierung der GPU-Leistung: Nach dem Start musste ich natürlich prüfen, ob meine 4090er auch wirklich arbeiten. Ich habe das kleine Llama3-Modell gestartet das mit diesem Befehl erst einmal herutner gealden wird: docker exec -it ollama ollama run llama3:8b

Und was soll ich sagen?

Als ich parallel nvidia-smi im zweiten Terminal ausgeführt habe, sah ich sofort, wie die Speichernutzung und die Auslastung auf beiden Karten in die Höhe schossen. Ein voller Erfolg!

NVIDIA-SMI Dual RTX4090 ollama

Netzwerk-Check: Da ich OLLAMA_HOST=0.0.0.0 konfiguriert hatte, konnte ich sofort von meinem Laptop aus über die IP-Adresse des Servers auf Ollama zugreifen. Perfekt für die Anbindung an ein Web-Interface.

Wie Du Dein selbstgebautes Ollama-Image aktualisierst

Da wir uns bewusst für den souveränen Weg entschieden haben, indem wir den Ollama-Quellcode geklont und das Docker-Image selbst gebaut haben, erhalten wir Updates nicht automatisch über den Docker Hub. Stattdessen haben wir die volle Kontrolle über den Zeitpunkt und die Version des Updates – ein zentraler Pfeiler der digitalen Souveränität.

Die Aktualisierung ist dank Docker Compose ein einfacher Prozess, der nur drei Befehle erfordert:

1. Neuen Quellcode herunterladen (pull)

Zuerst wechseln wir in den geklonten ollama-Ordner und holen die neuesten Änderungen aus dem offiziellen GitHub-Repository.

Befehl: cd ollama

Befehl: git pull

Dieser Befehl aktualisiert den lokalen Ordner ollama auf die neueste Version des Projekts.

2. Alten Container stoppen und entfernen (down)

Um das neue Image bauen zu können, muss der alte Container gestoppt und entfernt werden. Der Befehl docker compose down liest Deine docker-compose.yml und stoppt alle definierten Dienste.

Wichtig: Durch das Entfernen des Containers (nicht des Volumes!) bleiben Deine heruntergeladenen Modelle und Daten unberührt an dem von Dir definierten Pfad wie z.B. /mnt/data_1 gespeichert.

Befehl: cd ..

Befehl: docker compose down

3. Neues Image bauen und Container starten (up --build)

Jetzt führst Du einfach denselben Befehl aus, den Du bereits zum Starten verwendet hast. Der Zusatz --build weist Docker Compose an, das Image unter Verwendung des neu heruntergeladenen Quellcodes (git pull) neu zu bauen.

Befehl: docker compose up -d --build

Erklärung: Dein alter Container wird durch eine brandneue Instanz ersetzt, die auf dem neuesten Ollama-Quellcode basiert. Dein Ollama-Server läuft nun in seiner aktuellsten Version, ohne dass Du Deine Konfiguration oder Deine Modelle verloren hast. Souveränität durch Versionskontrolle: Mission erfüllt!

Der gängigste und sicherste Weg, um innerhalb Deines laufenden ollama-Containers die Version abzufragen, lautet:

Befehl: docker compose exec -it ollama ollama --version

Hinweis: Es wird so wie das docker image gebaut wird immer die Version 0.0.0 angezeigt. Das liegt daran das während dem Buildprozess die Versionsnummer nicht manuell von mir gesetzt wird. Der Hintegrund ist, dass ich keine manuellen Anpassungen haben wollte.

Mein persöniches Fazit:

Ich habe nicht nur einen Ollama-Server installiert, sondern einen vollständig unabhängigen, souveränen und leistungsorientierten KI-Server geschaffen. Meine Modelle, meine Daten, meine Performance – das ist der wahre Wert von Self-Hosting. Ich kann euch nur ermutigen, diesen Weg ebenfalls zu gehen! Wenn Du auf der Suche bist nach leistungsstarken KI-Rechnern dann schau bei der münchner Firma MIFCOM einmal vorbei.