Qdrant mit Docker auf einem Ubuntu Server selbst hosten

Möchtest du KI-Apps mit Vektorsuche betreiben, aber die volle Kontrolle über deine Infrastruktur behalten? Durch das Selbst-Hosting von Qdrant auf einem Linux Ubuntu Server kannst du nutzungsbasierte Preise vermeiden und sicherstellen, dass deine Daten dort bleiben, wo du sie haben möchtest.

Diese umfassende Anleitung führt dich durch die Bereitstellung einer produktionsreifen Qdrant-Instanz mit Docker und Caddy für automatisches HTTPS. Du lernst über Sicherheit, Monitoring, Backups und Performance-Optimierung.

Warum Qdrant selbst hosten?

• Kostenkontrolle: Vermeide Pro-Vektor-Preise und nutzungsbasierte Gebühren
• Datenschutz: Behalte deine Vektoren und Metadaten auf deiner eigenen Infrastruktur
• Volle Kontrolle: Konfiguriere genau das, was du brauchst, ohne Plattformbeschränkungen
• Keine Anbieterabhängigkeit: Migriere deine Daten jederzeit ohne Einschränkungen
• Eigene Netzwerke: Richte VPNs, eigene Domains und erweiterte Firewall-Regeln ein

Voraussetzungen

Bevor wir beginnen, stelle sicher, dass du hast:

• Einen laufenden Ubuntu Linux Server (20.04 LTS oder neuer empfohlen)
• Mindestens 2GB RAM und 2 CPU-Kerne (4GB+ empfohlen für Produktion)
• 20GB+ verfügbaren Speicherplatz
• Einen Domainnamen, der auf deinen Server zeigt (optional, aber empfohlen)
• Grundlegende SSH- und Kommandozeilen-Kenntnisse

Möchtest du Qdrant ohne eigenen Server selbst hosten? Stelle es auf Sliplane bereit in 45 Sekunden mit eingebautem HTTPS und Volume-Persistenz.

Schritt 1: Server aktualisieren

Melde dich per SSH bei deinem Ubuntu Server an und installiere Updates:

sudo apt-get update
sudo apt-get upgrade -y

Dies stellt sicher, dass dein Server die neuesten Sicherheitspatches und Pakete hat.

Schritt 2: Firewall konfigurieren

Da Docker traditionelle Linux-Firewalls wie UFW umgeht, nutze die Firewall deines Cloud-Anbieters:

• Hetzner: Cloud Firewall
• DigitalOcean: Firewall-Regeln im Control Panel
• AWS: Security Groups
• Google Cloud: VPC Firewall-Regeln
• Azure: Network Security Groups

Konfiguriere diese eingehenden Regeln:

• Port 22 (SSH) - Nur deine IP
• Port 80 (HTTP) - Öffentlich
• Port 443 (HTTPS) - Öffentlich

Cloud-Anbieter-Firewalls arbeiten auf Netzwerkebene, bevor der Verkehr deinen Server erreicht, und bieten bessere Sicherheit als Host-basierte Firewalls.

Schritt 3: Docker Installation

Installiere Docker und Abhängigkeiten:

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg

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
sudo chmod a+r /etc/apt/keyrings/docker.gpg

Füge Dockers offizielles Repository hinzu:

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-get update

Installiere Docker Engine und Plugins:

sudo apt-get install docker-ce docker-ce-cli \
containerd.io docker-buildx-plugin docker-compose-plugin -y

Überprüfe, ob Docker funktioniert:

sudo docker run hello-world

Schritt 4: Caddy für automatisches HTTPS installieren

Caddy wird als Reverse Proxy zu Qdrant fungieren und Let's Encrypt Zertifikate verwalten.

Installiere Caddy:

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl

curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' \
| sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg

curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' \
| sudo tee /etc/apt/sources.list.d/caddy-stable.list

sudo apt update
sudo apt install caddy -y

Bearbeite die Caddyfile-Konfiguration:

sudo nano /etc/caddy/Caddyfile

Verwende deine Domain:

deinedomain.com {
    reverse_proxy localhost:6333
}

Oder temporär zum Testen mit lokaler IP:

:80 {
    reverse_proxy localhost:6333
}

Starte Caddy neu:

sudo systemctl restart caddy

Schritt 5: Qdrant mit Docker Compose ausführen

Erstelle ein Verzeichnis für Qdrant und wechsle hinein:

mkdir ~/qdrant
cd ~/qdrant

Erstelle docker-compose.yml:

services:
  qdrant:
    image: qdrant/qdrant:latest
    container_name: qdrant
    restart: unless-stopped
    ports:
      - "6333:6333"  # REST API
      - "6334:6334"  # gRPC API (optional)
    volumes:
      - qdrant_data:/qdrant/storage
      - ./config:/qdrant/config
    environment:
      - QDRANT__SERVICE__API_KEY=dein-geheimer-schlüssel-hier
      - QDRANT__LOG_LEVEL=INFO
      - QDRANT__SERVICE__HTTP_PORT=6333
      - QDRANT__SERVICE__GRPC_PORT=6334
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:6333/healthz"]
      interval: 30s
      timeout: 10s
      retries: 3
    networks:
      - qdrant-network

networks:
  qdrant-network:
    driver: bridge

volumes:
  qdrant_data:
    driver: local

Wichtig: Ersetze dein-geheimer-schlüssel-hier mit einem starken, zufällig generierten API-Schlüssel. Generiere einen mit:

openssl rand -hex 32

Wenn du die API-Schlüssel-Umgebungsvariable entfernst, läuft Qdrant ohne Authentifizierung (nicht empfohlen für Produktion).

Erstelle ein Konfigurationsverzeichnis und eine optionale Konfigurationsdatei:

mkdir config

Erstelle config/production.yaml (optional, für erweiterte Konfiguration):

service:
  http_port: 6333
  grpc_port: 6334
  enable_cors: true

storage:
  performance:
    max_search_threads: 0  # Nutze alle verfügbaren CPU-Kerne
    max_optimization_threads: 0

log_level: "INFO"

Starte Qdrant:

sudo docker compose up -d

Überprüfe, ob es läuft:

sudo docker compose ps
sudo docker compose logs qdrant

Qdrant läuft jetzt und ist auf Port 6333 erreichbar.

Schritt 6: Auf deine selbst gehostete Qdrant-Instanz zugreifen

Öffne deine Domain in einem Browser. Du solltest das Qdrant-Dashboard sehen unter:

https://deinedomain.com/dashboard

Teste die API mit curl:

# Health Check
curl https://deinedomain.com/healthz

# Collections auflisten (benötigt API-Schlüssel)
curl -X GET 'https://deinedomain.com/collections' \
  -H 'api-key: dein-geheimer-schlüssel-hier'

# Test-Collection erstellen
curl -X PUT 'https://deinedomain.com/collections/test' \
  -H 'Content-Type: application/json' \
  -H 'api-key: dein-geheimer-schlüssel-hier' \
  -d '{
    "vectors": {
      "size": 4,
      "distance": "Cosine"
    }
  }'

Sicherheitshärtung

Wichtige Sicherheitsmaßnahmen

1. Starke API-Schlüssel

# Generiere einen sicheren 32-Byte API-Schlüssel
openssl rand -hex 32

2. Regelmäßige Sicherheitsupdates

# Automatische Sicherheitsupdates einrichten
sudo apt install unattended-upgrades -y
sudo dpkg-reconfigure -plow unattended-upgrades

3. Fail2ban-Schutz

sudo apt install fail2ban -y
sudo systemctl enable fail2ban
sudo systemctl start fail2ban

4. SSH-Schlüssel-Authentifizierung

# Passwort-Authentifizierung in /etc/ssh/sshd_config deaktivieren
sudo sed -i 's/#PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config
sudo systemctl restart ssh

5. IP-Allowlisting

Für IP-basierte Zugriffskontrolle konfiguriere die Firewall deines Cloud-Anbieters, um nur bestimmte IP-Bereiche auf den Ports 80/443 zuzulassen. Das ist zuverlässiger als Beschränkungen auf Anwendungsebene.

Monitoring und Wartung

Health Monitoring

Erstelle ein einfaches Health-Check-Skript:

nano ~/health-check.sh

#!/bin/bash
API_KEY="dein-geheimer-schlüssel-hier"
QDRANT_URL="https://deinedomain.com"

response=$(curl -s -w "%{http_code}" -X GET "${QDRANT_URL}/healthz" -H "api-key: ${API_KEY}")
http_code="${response: -3}"

if [ "$http_code" = "200" ]; then
    echo "$(date): Qdrant ist gesund"
else
    echo "$(date): Qdrant Health Check fehlgeschlagen (HTTP $http_code)"
    # Optional: Sende Alert-E-Mail oder Benachrichtigung
fi

Mache es ausführbar und füge es zu cron hinzu:

chmod +x ~/health-check.sh
crontab -e
# Hinzufügen: */5 * * * * /home/ubuntu/health-check.sh >> /var/log/qdrant-health.log

Backup-Strategie

Für Produktionsbereitstellungen empfehlen wir die Nutzung der eingebauten Backup-Lösungen deines Cloud-Anbieters:

Option 1: Cloud-Anbieter Block Storage Snapshots (Empfohlen)

Die meisten Cloud-Anbieter bieten automatisierte Volume-Snapshots:

• Hetzner: Nutze Cloud Volume Snapshots über die Konsole oder API
• DigitalOcean: Aktiviere automatisierte Droplet-Backups oder Volume-Snapshots
• AWS: Nutze EBS Snapshots mit Lifecycle-Richtlinien
• Google Cloud: Nutze Persistent Disk Snapshots

Diese Snapshots sind inkrementell, absturzkonsistent und können mit Aufbewahrungsrichtlinien automatisiert werden.

Option 2: Restic + S3 für Cloud-übergreifende Backups

Für eine Cloud-unabhängige Backup-Lösung nutze Restic mit S3-kompatiblem Speicher:

# Restic installieren
sudo apt update
sudo apt install restic -y

# Repository initialisieren (einmalig)
export AWS_ACCESS_KEY_ID="dein-access-key"
export AWS_SECRET_ACCESS_KEY="dein-secret-key"
restic -r s3:s3.amazonaws.com/dein-bucket/qdrant-backups init

# Backup-Skript erstellen
nano ~/backup-qdrant.sh

#!/bin/bash
export AWS_ACCESS_KEY_ID="dein-access-key"
export AWS_SECRET_ACCESS_KEY="dein-secret-key"
RESTIC_REPOSITORY="s3:s3.amazonaws.com/dein-bucket/qdrant-backups"

# Qdrant für Konsistenz stoppen (optional aber empfohlen)
docker compose stop qdrant

# Docker Volume sichern
restic -r $RESTIC_REPOSITORY backup /var/lib/docker/volumes/qdrant_qdrant_data/_data \
  --tag qdrant \
  --cleanup-cache

# Qdrant wieder starten
docker compose start qdrant

# Alte Backups aufräumen (behalte letzte 7 täglich, 4 wöchentlich, 12 monatlich)
restic -r $RESTIC_REPOSITORY forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune

Plane automatisierte Backups:

chmod +x ~/backup-qdrant.sh
crontab -e
# Hinzufügen: 0 2 * * * /home/ubuntu/backup-qdrant.sh >> /var/log/qdrant-backup.log 2>&1

Restic bietet Deduplizierung, Verschlüsselung und funktioniert mit jedem S3-kompatiblen Speicher (AWS S3, Backblaze B2, Wasabi, MinIO).

Deine Qdrant-Installation aktualisieren

Um auf die neueste Version zu aktualisieren:

cd ~/qdrant
sudo docker compose pull
sudo docker compose up -d

Deine Daten bleiben dank Docker Volumes über Updates hinweg erhalten.

Kostenvergleich mit anderen Anbietern

Qdrant selbst zu hosten kann erheblich Geld sparen:

Selbst-Hosting vermeidet Pro-Vektor- oder nutzungsbasierte Preise, erfordert aber grundlegende Systemadministrations-Kenntnisse.

Performance-Optimierung

System-Level-Tuning

Optimiere deinen Ubuntu Server für Qdrant:

# Dateideskriptor-Limits erhöhen
echo "* soft nofile 65536" | sudo tee -a /etc/security/limits.conf
echo "* hard nofile 65536" | sudo tee -a /etc/security/limits.conf

# Kernel-Parameter für Vektor-Workloads optimieren
echo "vm.swappiness=10" | sudo tee -a /etc/sysctl.conf
echo "net.core.rmem_max=134217728" | sudo tee -a /etc/sysctl.conf
echo "net.core.wmem_max=134217728" | sudo tee -a /etc/sysctl.conf

# Änderungen anwenden
sudo sysctl -p

Docker Ressourcen-Management

Überwache die Ressourcen deines Qdrant-Containers:

# Aktuelle Ressourcennutzung prüfen
docker stats qdrant

# Container-Details anzeigen
docker inspect qdrant

Falls du Ressourcen begrenzen musst, kannst du den Container mit Limits neu starten:

sudo docker compose down
sudo docker run -d \
  --name qdrant \
  --memory="2g" \
  --cpus="1.0" \
  --restart unless-stopped \
  -p 6333:6333 \
  -v qdrant_data:/qdrant/storage \
  -e QDRANT__SERVICE__API_KEY=dein-geheimer-schlüssel-hier \
  qdrant/qdrant:latest

Fehlerbehebung bei häufigen Problemen

Port-Konflikte

# Prüfen, was Port 6333 nutzt
sudo netstat -tlnp | grep :6333
sudo ss -tulpn | grep :6333

Speicherprobleme

# Docker-Container-Ressourcen überwachen
docker stats qdrant

# Systemspeicher prüfen
free -h
htop

Berechtigungsfehler

# Docker-Volume-Berechtigungen reparieren
sudo docker exec qdrant chown -R qdrant:qdrant /qdrant/storage

Log-Analyse

# Echtzeit-Logs anzeigen
sudo docker compose logs -f qdrant

# Letzte 100 Zeilen prüfen
sudo docker compose logs --tail=100 qdrant

# Nach Fehlern filtern
sudo docker compose logs qdrant | grep -i error

Skalierungsüberlegungen

Vertikale Skalierung

• Upgrade auf einen Server mit mehr RAM und CPU-Kernen
• Docker-Ressourcenlimits entsprechend erhöhen
• Qdrant-Konfiguration für größere Datensätze optimieren

Horizontale Skalierung

• Qdrant-Cluster mit mehreren Knoten einrichten
• Load Balancer (HAProxy, Nginx) für Anfragenverteilung nutzen
• Daten-Sharding-Strategien implementieren

Was ist enthalten vs. Qdrant Cloud

Selbst gehostetes Qdrant beinhaltet:

• Volle Vektorsuch-Fähigkeiten
• Erweiterte Filterung und Hybridsuche
• Web-Dashboard und REST/gRPC-APIs
• Clustering und Replikation
• Snapshots und Backups

Qdrant Cloud zusätzliche Features:

• Verwaltete Backups und Monitoring
• Automatische Skalierung und Updates
• 24/7 Support und SLA-Garantien
• Multi-Region-Bereitstellung

Für die meisten Anwendungsfälle bietet Selbst-Hosting alles, was du brauchst. Prüfe die offizielle Qdrant-Dokumentation für detaillierte Feature-Vergleiche.

Fazit

Du hast jetzt eine produktionsreife Qdrant-Vektordatenbank auf deinem Ubuntu Server laufen! Dieses Setup gibt dir:

• Vollständige Kontrolle über deine Vektorsuch-Infrastruktur
• Erhebliche Kosteneinsparungen im Vergleich zu verwalteten Diensten
• Datenschutz mit deinen Vektoren auf deinen eigenen Servern
• Skalierbarkeit für wachsende KI-Workloads

Denke daran, regelmäßige Backups, Sicherheitsupdates und Monitoring aufrechtzuerhalten, um deine Instanz reibungslos am Laufen zu halten.

Möchtest du die Leistung von selbst gehostetem Qdrant ohne eigenen Server verwalten? Stelle es auf Sliplane bereit in 45 Sekunden mit eingebautem HTTPS und Volume-Persistenz.