Ollama im Unternehmen einsetzen — Enterprise Setup Guide

Was ist Ollama?

Ollama ist eine Open-Source-Plattform (MIT-Lizenz), die den Betrieb von Large Language Models auf lokaler Hardware radikal vereinfacht. Statt sich mit komplexen Python-Umgebungen, CUDA-Treibern und Modell-Konvertierungen auseinanderzusetzen, abstrahiert Ollama die gesamte Infrastruktur in einen einzigen, leichtgewichtigen Service.

Im Kern ist Ollama ein Go-basierter Server, der LLMs über eine REST-API bereitstellt. Die API ist bewusst kompatibel mit der OpenAI-API gestaltet — das bedeutet, dass bestehende Anwendungen, die für OpenAI entwickelt wurden, oft mit minimalen Änderungen auf Ollama umgestellt werden können. Für Unternehmen, die bereits LangChain, LlamaIndex oder eigene Chat-Anwendungen nutzen, ist das ein enormer Vorteil.

Installation & erste Schritte

Systemvoraussetzungen

Bevor Sie Ollama installieren, stellen Sie sicher, dass Ihr Server die folgenden Mindestanforderungen erfüllt:

Detaillierte Hardware-Empfehlungen und TCO-Berechnungen finden Sie in unserem GPU-Server Kaufguide.

Installation auf Linux (Ubuntu/Debian)

Die Installation von Ollama erfolgt mit einem einzigen Befehl:

curl -fsSL https://ollama.com/install.sh | sh

Dieses Script installiert Ollama als Systemd-Service, der automatisch beim Systemstart startet. Überprüfen Sie die Installation:

# Version prüfen
ollama --version

# Service-Status prüfen
sudo systemctl status ollama

# Erstes Modell laden
ollama pull llama3.1:8b

# Test-Anfrage
ollama run llama3.1:8b "Erkläre DSGVO Art. 25 in zwei Sätzen."

Installation mit Docker (empfohlen für Enterprise)

Für Enterprise-Umgebungen empfehlen wir den Docker-basierten Betrieb — er bietet bessere Isolation, einfacheres Deployment und reproduzierbare Umgebungen:

# Docker mit GPU-Support
docker run -d \
  --gpus all \
  --name ollama \
  -p 11434:11434 \
  -v ollama_data:/root/.ollama \
  --restart unless-stopped \
  ollama/ollama:latest

# Modell in den Container laden
docker exec ollama ollama pull llama3.1:70b

# API testen
curl http://localhost:11434/api/generate \
  -d '{"model": "llama3.1:70b", "prompt": "Hallo, wie geht es Ihnen?"}'

sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker

Enterprise-Konfiguration

Die Standard-Konfiguration von Ollama ist für Entwickler-Workstations optimiert. Für den Enterprise-Einsatz müssen Sie mehrere Parameter anpassen. Die Konfiguration erfolgt über Umgebungsvariablen, die Sie in der Systemd-Unit-Datei oder der Docker-Compose-Konfiguration setzen.

Wichtige Umgebungsvariablen

Systemd-Konfiguration für Enterprise

Erstellen Sie eine Override-Datei für den Ollama-Service:

# /etc/systemd/system/ollama.service.d/enterprise.conf
[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_MODELS=/data/ollama/models"
Environment="OLLAMA_MAX_LOADED_MODELS=3"
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_KEEP_ALIVE=30m"

# Ressourcen-Limits
LimitNOFILE=65535
LimitMEMLOCK=infinity

# Restart-Strategie
Restart=always
RestartSec=5

# Konfiguration anwenden
sudo systemctl daemon-reload
sudo systemctl restart ollama

Docker Compose für Produktion

Eine vollständige Docker-Compose-Konfiguration für den Enterprise-Einsatz:

# docker-compose.yml
version: '3.8'
services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama-enterprise
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    ports:
      - "11434:11434"
    volumes:
      - /data/ollama/models:/root/.ollama
    environment:
      - OLLAMA_MAX_LOADED_MODELS=3
      - OLLAMA_NUM_PARALLEL=4
      - OLLAMA_KEEP_ALIVE=30m
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:11434/api/tags"]
      interval: 30s
      timeout: 10s
      retries: 3
    logging:
      driver: json-file
      options:
        max-size: "100m"
        max-file: "5"

Security Hardening

Ollama hat standardmäßig keine Authentifizierung. Das ist für die lokale Entwicklung akzeptabel, aber im Enterprise-Umfeld ein erhebliches Sicherheitsrisiko. Jeder, der den Port 11434 erreichen kann, hat vollen Zugriff auf alle Modelle und kann Prompts ohne Einschränkungen senden — einschließlich potenziell sensibler Unternehmensdaten.

Reverse Proxy mit NGINX

Setzen Sie NGINX als Reverse Proxy vor Ollama für TLS-Terminierung, Authentifizierung und Rate Limiting:

# /etc/nginx/sites-available/ollama
upstream ollama_backend {
    server 127.0.0.1:11434;
    keepalive 32;
}

server {
    listen 443 ssl http2;
    server_name llm.intern.example.de;

    # TLS-Konfiguration
    ssl_certificate /etc/ssl/certs/llm.intern.example.de.pem;
    ssl_certificate_key /etc/ssl/private/llm.intern.example.de.key;
    ssl_protocols TLSv1.3;

    # API-Key Authentifizierung
    location /api/ {
        # API-Key prüfen
        if ($http_authorization != "Bearer IHR_GEHEIMER_API_KEY") {
            return 401;
        }

        # Rate Limiting
        limit_req zone=ollama_limit burst=20 nodelay;

        # Proxy zu Ollama
        proxy_pass http://ollama_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_read_timeout 600s;  # Lange Timeouts für LLM-Generierung
        proxy_buffering off;       # Streaming-Responses
    }

    # Access Log für Audit-Trail (DSGVO)
    access_log /var/log/nginx/ollama_access.log combined;
}

Netzwerk-Segmentierung

Für maximale Sicherheit empfehlen wir eine dedizierte Netzwerkzone für den LLM-Server:

• VLAN-Isolation: Separates VLAN für GPU-Server
• Firewall-Regeln: Nur spezifische Anwendungsserver dürfen zugreifen
• Kein Internet-Zugang: Der Ollama-Server braucht nach der initialen Modell-Download kein Internet
• Jump-Host: SSH-Zugriff nur über einen dedizierten Bastion-Host

Diese Maßnahmen sind besonders relevant für Branchen mit strengen Compliance-Anforderungen wie Kanzleien (§ 203 StGB) oder das Gesundheitswesen (DSGVO Art. 9).

Audit-Logging für DSGVO-Compliance

Gemäß DSGVO Art. 5 Abs. 2 (Rechenschaftspflicht) und Art. 30 (Verzeichnis von Verarbeitungstätigkeiten) müssen Sie nachweisen können, wer wann welche Daten verarbeitet hat. Implementieren Sie ein strukturiertes Logging:

# Beispiel: Structured Logging mit Fluent Bit
# /etc/fluent-bit/fluent-bit.conf
[INPUT]
    Name    tail
    Path    /var/log/nginx/ollama_access.log
    Tag     ollama.access

[FILTER]
    Name    parser
    Match   ollama.*
    Key_Name log
    Parser  nginx

[OUTPUT]
    Name    es
    Match   ollama.*
    Host    elasticsearch.intern.example.de
    Index   ollama-audit
    Type    _doc

Skalierung & Hochverfügbarkeit

Für den Enterprise-Einsatz mit mehr als 10–20 gleichzeitigen Nutzern müssen Sie Ollama skalieren. Es gibt zwei Ansätze: vertikale Skalierung (mehr GPUs im selben Server) und horizontale Skalierung (mehrere Ollama-Instanzen hinter einem Load Balancer).

Vertikale Skalierung: Multi-GPU

Ollama unterstützt Multi-GPU automatisch. Wenn mehrere GPUs verfügbar sind, verteilt Ollama große Modelle automatisch über alle GPUs (Tensor Parallelism). Für ein 70B-Modell benötigen Sie z.B. zwei A100 40 GB oder eine A100 80 GB.

# GPU-Zuordnung steuern
CUDA_VISIBLE_DEVICES=0,1 ollama serve  # Nur GPU 0 und 1 nutzen

# GPU-Auslastung überwachen
watch -n 1 nvidia-smi

Horizontale Skalierung: Load Balancing

Für echte Hochverfügbarkeit setzen Sie mehrere Ollama-Instanzen hinter einem Load Balancer:

# NGINX Load Balancer
upstream ollama_cluster {
    least_conn;  # Verteilt auf den am wenigsten ausgelasteten Server

    server gpu-server-01:11434 weight=3;  # H100 — mehr Gewicht
    server gpu-server-02:11434 weight=2;  # A100
    server gpu-server-03:11434 weight=1;  # RTX 4090 — Fallback

    keepalive 64;
}

Beachten Sie: Jede Ollama-Instanz muss die gleichen Modelle geladen haben. Synchronisieren Sie die Modelle entweder über ein Shared NFS-Volume oder automatisieren Sie den Pull-Prozess.

Monitoring & Observability

Im produktiven Betrieb müssen Sie den Zustand Ihrer Ollama-Instanzen kontinuierlich überwachen. Die wichtigsten Metriken:

Prometheus & Grafana Setup

Nutzen Sie den NVIDIA DCGM Exporter für GPU-Metriken und einen Custom Exporter für Ollama:

# docker-compose.monitoring.yml
services:
  dcgm-exporter:
    image: nvcr.io/nvidia/k8s/dcgm-exporter:latest
    deploy:
      resources:
        reservations:
          devices:
            - capabilities: [gpu]
    ports:
      - "9400:9400"

  prometheus:
    image: prom/prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana

Modellverwaltung im Enterprise

Im Enterprise-Umfeld müssen Sie genau kontrollieren, welche Modelle verfügbar sind. Nicht jeder Mitarbeiter sollte beliebige Modelle herunterladen können. Implementieren Sie eine gesteuerte Modellverwaltung:

Modell-Registry und Versionierung

# Genehmigte Modelle laden
ollama pull llama3.1:70b-instruct-q4_K_M
ollama pull mistral:7b-instruct-v0.3-q5_K_M
ollama pull qwen2.5:72b-instruct-q4_K_M

# Modelle auflisten
ollama list

# Custom Modelfile für unternehmensspezifische Konfiguration
cat << 'EOF' > Modelfile
FROM llama3.1:70b-instruct-q4_K_M

SYSTEM """
Sie sind ein hilfreicher Assistent für die Firma Example GmbH.
Antworten Sie immer auf Deutsch und in professionellem Ton.
Geben Sie niemals vertrauliche Informationen weiter.
Verweisen Sie bei Rechtsfragen immer auf die Rechtsabteilung.
"""

PARAMETER temperature 0.3
PARAMETER top_p 0.9
PARAMETER num_ctx 8192
EOF

ollama create example-assistant -f Modelfile

Integration in bestehende Systeme

Ollama bietet eine OpenAI-kompatible API, die den Wechsel von Cloud-Diensten erleichtert. Hier zeigen wir die wichtigsten Integrationsmuster:

Python-Integration (LangChain)

from langchain_community.llms import Ollama

llm = Ollama(
    base_url="https://llm.intern.example.de",
    model="example-assistant",
    headers={"Authorization": "Bearer IHR_API_KEY"},
    temperature=0.3,
)

response = llm.invoke("Fasse die wichtigsten Punkte des Vertrags zusammen.")
print(response)

OpenAI SDK Kompatibilität

from openai import OpenAI

client = OpenAI(
    base_url="https://llm.intern.example.de/v1",
    api_key="IHR_API_KEY",
)

response = client.chat.completions.create(
    model="example-assistant",
    messages=[
        {"role": "system", "content": "Sie sind ein hilfreicher Assistent."},
        {"role": "user", "content": "Was besagt DSGVO Art. 25?"},
    ],
)
print(response.choices[0].message.content)

Für die Integration mit SAP, DATEV und anderen Enterprise-Systemen lesen Sie unseren SAP & DATEV Integrations-Guide.

Troubleshooting & Best Practices

Häufige Probleme und Lösungen

Best Practices Checkliste

• ✅ Reverse Proxy mit TLS und Authentifizierung vor Ollama
• ✅ Dedicated User Account für den Ollama-Service (nicht root)
• ✅ Modell-Storage auf separater NVMe-Partition
• ✅ Automatische Backups der Custom Modelfiles
• ✅ GPU-Monitoring mit Alerts (Prometheus + Grafana)
• ✅ Access Logs für DSGVO Audit-Trail
• ✅ Regelmäßige Updates von Ollama und CUDA-Treibern
• ✅ Netzwerk-Segmentierung (VLAN für GPU-Server)
• ✅ Rate Limiting pro User/Abteilung
• ✅ Incident-Response-Plan für GPU-Ausfälle

Wann Sie von Ollama zu vLLM wechseln sollten

Ollama ist ideal für den Einstieg und Teams bis ~20–30 Nutzer. Wenn Sie folgende Anforderungen haben, sollten Sie einen Wechsel zu vLLM erwägen:

• Mehr als 50 gleichzeitige Anfragen
• Maximaler Durchsatz (Tokens/Sekunde) ist kritisch
• PagedAttention und Continuous Batching werden benötigt
• Kubernetes-native Deployment ist erforderlich
• Tensor Parallelism über mehrere Nodes

Einen detaillierten Vergleich mit Benchmarks finden Sie in unserem vLLM vs. Ollama Vergleich.

Weiterführende Ressourcen

• vLLM vs. Ollama — Detailvergleich
• GPU-Server Kaufguide
• Open-Source LLM Vergleich
• RAG-Systeme für On-Premise
• DSGVO & KI — Compliance Guide