Redis mit Docker installieren: Schnellster In-Memory-Key-Value-Store für Cache, Messaging und KI

Redis ist der unangefochtene Industriestandard, wenn es um Geschwindigkeit geht: Der In-Memory-Key-Value-Store liefert Antwortzeiten im Mikrosekundenbereich und wird in modernen Stacks als Cache vor Datenbanken, als Pub/Sub-Message-Broker, als Session-Speicher für Webanwendungen und – seit Version 8.0 – als Vektor-Datenbank für KI-Embeddings und Semantic Search eingesetzt. Mit über 74.000 GitHub-Stars ist Redis für Entwickler und DevOps-Teams weltweit erste Wahl, wenn Low-Latency zählt. Diese Anleitung zeigt dir, wie du Redis 8 als Docker-Compose-Service aufsetzte, mit einem sicheren Passwort absicherst, Persistenz korrekt konfigurierst und mit RedisInsight per Browser überwachst – plattformneutral auf jedem Linux-Host.

Voraussetzungen

1. Docker Engine >= 24.x und Docker Compose Plugin >= 2.x auf einem Linux-Host (Ubuntu, Debian, oder ein NAS mit Docker-Support). Falls du noch kein Docker installiert hast, folge zunächst der Anleitung Docker und Docker Compose auf Linux installieren.
2. Mindestens 512 MB freies RAM für Redis und RedisInsight zusammen; für Produktiv-Workloads 1–2 GB empfohlen.
3. openssl zum Generieren eines sicheren Passworts (auf allen gängigen Linux-Systemen vorinstalliert).
4. Optional: ein laufender Reverse Proxy (Traefik, Caddy oder Nginx Proxy Manager) für HTTPS-Zugriff auf RedisInsight von außen.
5. Einen Texteditor und Shell-Zugriff auf den Host. Redis-Port 6379 muss nicht öffentlich erreichbar sein – die Konfiguration bindet ihn nur an localhost.

Schritt 1: Projektordner anlegen

Lege einen dedizierten Ordner für das Projekt an. Alle projektbezogenen Dateien – compose.yaml und .env – landen hier. Docker Compose verwendet den Ordnernamen als Stack-Präfix für Container und Volumes.

mkdir -p /opt/redis
cd /opt/redis

Du kannst stattdessen auch ~/redis nutzen, wenn du keinen Root-Zugriff hast. Wichtig ist nur, dass beide Dateien im selben Verzeichnis liegen.

Verifizieren: ls /opt/redis zeigt ein leeres Verzeichnis. Der Befehl pwd gibt /opt/redis zurück.

Schritt 2: .env-Datei mit sicherem Passwort anlegen

Das offizielle Redis-Docker-Image wertet keine REDIS_PASSWORD-Umgebungsvariable nativ aus – das Passwort muss über den command:-Block als --requirepass-Argument an redis-server übergeben werden. Die .env-Datei stellt den Wert bereit, den Docker Compose in der compose.yaml interpoliert.

Generiere zunächst ein sicheres Passwort:

openssl rand -base64 32

Kopiere die Ausgabe und lege die .env-Datei an:

REDIS_PASSWORD=dein-generiertes-passwort-hier

Speichere die Datei als /opt/redis/.env. Setze restriktive Berechtigungen, damit kein anderer Systembenutzer das Passwort lesen kann:

chmod 600 /opt/redis/.env

Verifizieren: ls -la /opt/redis/.env zeigt Berechtigungen -rw-------. Mit cat /opt/redis/.env siehst du die Zeile mit deinem Passwort – stelle sicher, dass sie kein Leerzeichen oder Anführungszeichen enthält.

Schritt 3: compose.yaml erstellen

Die folgende compose.yaml startet zwei Services: Redis 8 (Alpine-Image) und RedisInsight als Browser-GUI. Beide laufen im selben internen Docker-Netzwerk redis-net, sodass RedisInsight Redis über den internen Hostnamen redis erreicht. Redis selbst ist nur über 127.0.0.1:6379 erreichbar – nicht öffentlich exponiert.

Erstelle /opt/redis/compose.yaml mit folgendem Inhalt:

services:
  redis:
    image: redis:8-alpine
    container_name: redis
    restart: unless-stopped
    ports:
      - "127.0.0.1:6379:6379"
    volumes:
      - redis-data:/data
    command: >
      redis-server
      --requirepass ${REDIS_PASSWORD}
      --appendonly yes
      --appendfilename "appendonly.aof"
      --loglevel warning
      --maxmemory 256mb
      --maxmemory-policy allkeys-lru
    environment:
      - REDIS_PASSWORD=${REDIS_PASSWORD}
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 5s
    networks:
      - redis-net

  redisinsight:
    image: redis/redisinsight:latest
    container_name: redisinsight
    restart: unless-stopped
    ports:
      - "5540:5540"
    volumes:
      - redisinsight-data:/data
    depends_on:
      redis:
        condition: service_healthy
    networks:
      - redis-net

volumes:
  redis-data:
    driver: local
  redisinsight-data:
    driver: local

networks:
  redis-net:
    driver: bridge

Einige Punkte zur Konfiguration verdienen eine kurze Erklärung: --maxmemory 256mb verhindert, dass Redis unbegrenzt Arbeitsspeicher belegt und der Container durch den OOM-Killer abgeschossen wird. Die Policy allkeys-lru ist für reine Cache-Szenarien ideal – Redis verwirft bei Speicherdruck die am längsten nicht genutzten Keys. Wer Redis primär als Datenbank (nicht nur Cache) betreibt, sollte stattdessen noeviction wählen. Der Healthcheck sorgt dafür, dass RedisInsight erst startet, wenn Redis tatsächlich antwortet – und er enthält zwingend -a ${REDIS_PASSWORD}, weil ein Ping ohne Authentifizierung bei gesetztem Passwort NOAUTH Authentication required zurückliefert und als unhealthy gewertet wird.

Verifizieren: cat /opt/redis/compose.yaml zeigt die vollständige Konfiguration ohne Syntaxfehler. Mit docker compose -f /opt/redis/compose.yaml config kannst du die Compose-Syntax vorab prüfen – die Ausgabe zeigt die interpolierte Konfiguration ohne Fehlermeldung.

Schritt 4: Stack starten

Wechsle in den Projektordner und starte den Stack:

cd /opt/redis
docker compose up -d

Docker Compose lädt beide Images herunter (redis:8-alpine ca. 50 MB, redisinsight:latest ca. 150 MB) und startet die Container. RedisInsight wartet dank depends_on mit service_healthy, bis der Redis-Healthcheck fünfmal erfolgreich war.

Prüfe den Status:

docker compose ps

Erwartete Ausgabe (nach ca. 30–60 Sekunden):

NAME           IMAGE                      SERVICE        STATUS
redis          redis:8-alpine             redis          Up (healthy)
redisinsight   redis/redisinsight:latest  redisinsight   Up

Sieh dir die Logs an, um sicherzustellen, dass Redis ohne Fehler gestartet ist:

docker compose logs redis

Typische, unbedenkliche Ausgabe enthält Zeilen wie * Ready to accept connections. Keine Fehlermeldungen zu Volume-Berechtigungen, Passwort oder Ports sollten erscheinen.

Verifizieren: docker compose ps zeigt STATUS = Up (healthy) für Redis. docker compose logs redis endet mit Ready to accept connections. Falls der Status starting bleibt, warte weitere 30 Sekunden und prüfe erneut.

Schritt 5: Verbindung testen mit redis-cli

Teste die Redis-Verbindung direkt aus dem Container heraus. Das offizielle Alpine-Image enthält redis-cli bereits:

docker exec -it redis redis-cli -a $REDIS_PASSWORD ping

Erwartete Antwort:

Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
PONG

Die Warnung ist normal und kann ignoriert werden – sie erinnert nur daran, dass das Passwort im Prozess-Listing sichtbar sein kann. Das PONG bestätigt, dass Redis läuft und die Authentifizierung funktioniert.

Teste zusätzlich, ob AOF-Persistenz aktiv ist:

docker exec -it redis redis-cli -a $REDIS_PASSWORD CONFIG GET appendonly

Erwartete Ausgabe:

1) "appendonly"
2) "yes"

Setze und lese einen Test-Key, um grundlegende Schreib- und Leseoperationen zu prüfen:

docker exec -it redis redis-cli -a $REDIS_PASSWORD SET testkey "s-edv.com"
docker exec -it redis redis-cli -a $REDIS_PASSWORD GET testkey

Antwort: OK und dann "s-edv.com".

Verifizieren: PONG auf ping, appendonly = yes in CONFIG GET, SET gibt OK zurück, GET liefert den gespeicherten Wert.

Schritt 6: RedisInsight im Browser einrichten

RedisInsight läuft unter http://localhost:5540. Öffne die URL im Browser. Beim ersten Aufruf musst du die Nutzungsbedingungen akzeptieren.

Füge eine neue Redis-Verbindung hinzu:

1. Host: redis (interner Docker-Netzwerkname, nicht localhost)
2. Port: 6379
3. Password: dein Redis-Passwort aus der .env
4. Name: frei wählbar, z. B. Redis lokal

Nach dem Verbindungsaufbau siehst du das RedisInsight-Dashboard mit Echtzeit-Metriken: Speicherverbrauch, Trefferquote (Hit Rate), verbundene Clients, Befehle pro Sekunde und eine Key-Browser-Ansicht. Der Test-Key aus Schritt 5 ist dort bereits sichtbar.

Prüfe zusätzlich den Health-Endpoint von RedisInsight per Kommandozeile:

curl -s http://localhost:5540/api/health/

Erwartete Antwort:

{"status":"ok"}

Verifizieren: Browser öffnet http://localhost:5540 ohne Fehler. Verbindung zu Redis über Hostnamen redis klappt. curl auf den Health-Endpoint liefert {"status":"ok"}. Im Key-Browser ist der Test-Key sichtbar.

Schritt 7: Updates und Backups

Redis-Images werden regelmäßig aktualisiert. Das Update läuft mit zwei Befehlen:

cd /opt/redis
docker compose pull && docker compose up -d

Docker Compose lädt das neue Image herunter und startet den Container mit demselben Volume neu. Die Daten in redis-data bleiben erhalten. Wenn du Container-Updates automatisieren möchtest, sieh dir Docker-Container automatisch aktualisieren nach dem Watchtower-Aus an.

Für Backups kannst du entweder den gesamten Docker-Volume-Ordner sichern oder direkt einen Redis-Snapshot auslösen:

# Manuellen RDB-Snapshot ausloesen (zusaetzlich zur AOF)
docker exec redis redis-cli -a $REDIS_PASSWORD BGSAVE

# Datei-Backup: Volume-Inhalt in tar-Archiv packen
docker run --rm \
  -v redis_redis-data:/data \
  -v /opt/backups:/backup \
  alpine tar czf /backup/redis-data-$(date +%Y%m%d).tar.gz -C /data .

Passe /opt/backups an deinen gewünschten Backup-Pfad an. Für eine vollständige Backup-Strategie empfiehlt sich ein Blick auf 3-2-1-Backup-Strategie umsetzen.

Den Stack stoppen (ohne Daten zu löschen):

docker compose down

Volumes werden dabei nicht gelöscht. Nur docker compose down -v würde die Volumes ebenfalls entfernen – das solltest du im Produktiveinsatz vermeiden.

Verifizieren: Nach docker compose pull && docker compose up -d zeigt docker compose ps wieder Up (healthy). docker exec redis redis-cli -a $REDIS_PASSWORD GET testkey liefert nach dem Update noch immer "s-edv.com" – die Daten sind erhalten geblieben.

Troubleshooting / Typische Fehler

1. Passwort greift nicht / Redis ohne Authentifizierung erreichbar: Häufigste Ursache ist, dass REDIS_PASSWORD nur als environment:-Eintrag gesetzt wurde, aber nicht im command:-Block als --requirepass ${REDIS_PASSWORD} weitergeführt wird. Das offizielle Redis-Image kennt diesen ENV-Key nicht – er wird stillschweigend ignoriert. Lösung: Stelle sicher, dass der command:-Block vollständig ist und --requirepass ${REDIS_PASSWORD} enthält.
2. NOAUTH Authentication required: Ein Redis-Client (oder der Healthcheck) verbindet sich ohne Passwort, obwohl --requirepass gesetzt ist. Jedes redis-cli muss -a $REDIS_PASSWORD enthalten. Im Healthcheck der compose.yaml muss "-a", "${REDIS_PASSWORD}" im test:-Array stehen.
3. Healthcheck bleibt auf starting / Container startet nicht: Prüfe mit docker compose logs redis auf Fehler. Häufige Ursachen: .env fehlt oder liegt nicht im selben Verzeichnis wie compose.yaml; Passwort enthält Sonderzeichen, die Shell-Expansion auslösen – in diesem Fall in der .env mit einfachen Anführungszeichen schützen: REDIS_PASSWORD='p@$$wort!'.
4. Permission denied on /data: Redis läuft als User redis (UID 999). Bei Bind-Mounts muss das Host-Verzeichnis für UID 999 schreibbar sein: chown 999:999 /pfad/zum/data-ordner. Mit Named Volumes (wie in dieser Anleitung) tritt das Problem nicht auf.
5. OOM – Redis wird abgeschossen: Kein --maxmemory gesetzt, Redis belegt den gesamten verfügbaren RAM bis der Kernel den Prozess killt. Lösung: --maxmemory und eine passende --maxmemory-policy setzen.
6. Port 6379 von außen erreichbar: In der compose.yaml steht 6379:6379 statt 127.0.0.1:6379:6379. Ohne explizite Localhost-Bindung hört Docker auf allen Interfaces. Für interne Dienste immer an Loopback binden.
7. RedisInsight zeigt „Connection refused": In RedisInsight als Host localhost statt redis eingetragen. Da RedisInsight im selben Docker-Netzwerk (redis-net) läuft, muss der interne Service-Name redis als Hostname verwendet werden.
8. ACL-Fehler nach Update auf Redis 8: Wer eigene ACL-Regeln mit +@all -@write hatte, stellt fest, dass Modul-Befehle wie JSON.SET, FT.CREATE oder TS.ADD nun Standard-Kategorien zugeordnet sind. ACL-Regeln nach dem Upgrade prüfen und anpassen.

Häufige Fragen

Brauche ich noch redis/redis-stack für JSON, Search oder TimeSeries?

Nein. Seit Redis 8.0 (GA 2025) sind alle früher separaten Redis-Stack-Module – JSON, RediSearch, RedisTimeSeries, RedisBloom und die Probabilistic-Strukturen – direkt in das offizielle redis-Image integriert. Das redis/redis-stack-Image ist ein Legacy-Image und wird für neue Projekte nicht mehr benötigt. Du kannst sofort JSON.SET, FT.CREATE oder TS.ADD gegen eine plain redis:8-alpine-Instanz ausführen.

Kann Redis als Vektor-Datenbank für KI eingesetzt werden?

Ja, und das ist einer der spannendsten Aspekte von Redis 8: RediSearch (im Basis-Image enthalten) unterstützt HNSW- und Flat-Indizes für hochdimensionale Vektoren. Mit FT.CREATE legst du einen Vektorindex an, mit FT.SEARCH und KNN-Operator führst du Ähnlichkeitssuchen durch. Ergänzend gibt es seit Redis 8 den neuen Datentyp „Vector Sets" (Beta), der Embeddings direkt als First-Class-Citizen speichert. Damit eignet sich Redis als schneller Vektorspeicher für RAG-Systeme, Semantic Search und Recommender-Systeme – zu Redis-Latenzen statt Sub-Second-Latenz klassischer Vektordatenbanken. Wer ein vollständiges RAG-System aufbauen möchte, findet dazu eine ausführliche Anleitung unter Lokales RAG-System mit Qdrant und Embeddings selbst bauen.

Was ist der Unterschied zwischen RDB und AOF?

RDB (Redis Database) erstellt periodische Point-in-Time-Snapshots der gesamten Datenbank. Die Dateigröße ist kompakt, und die Wiederherstellung ist schnell – aber beim Absturz gehen alle Schreibvorgänge seit dem letzten Snapshot verloren (typischerweise mehrere Minuten). AOF (Append-Only File) schreibt jeden einzelnen Schreibbefehl sequenziell in eine Log-Datei. Im Absturzfall gehen maximal eine Sekunde (bei fsync everysec, Standard) oder gar keine Daten verloren. Nachteil: Die AOF-Datei wächst kontinuierlich und muss gelegentlich komprimiert werden (Redis macht das automatisch mit BGREWRITEAOF). Für Produktiv-Caches und Session-Stores ist AOF die bessere Wahl – deshalb aktiviert diese Anleitung --appendonly yes.

Wie binde ich Redis in eine andere Docker-Anwendung ein?

Füge deine Anwendung demselben Docker-Netzwerk redis-net hinzu – entweder im gleichen Compose-File oder als externes Netzwerk mit external: true in einer anderen compose.yaml. Dann ist Redis über den Hostnamen redis auf Port 6379 erreichbar. Beispiel für einen externen Stack:

networks:
  redis-net:
    external: true

Der Connection-String in deiner App wäre dann z. B. redis://:${REDIS_PASSWORD}@redis:6379.

Welche Lizenz hat Redis 8 – darf ich es kommerziell einsetzen?

Redis 8 steht unter der RSALv2/SSPLv1-Dual-Lizenz (seit 2024). Für interne Unternehmensnutzung, als Entwicklungs-Cache oder als Bestandteil eigener Anwendungen bleibt Redis für die allermeisten Anwendungsfälle uneingeschränkt nutzbar. Die SSPLv1-Klausel trifft primär Cloud-Provider, die Redis als Managed Service anbieten. Wenn du unsicher bist, ob dein Use-Case unter die Lizenz fällt, lies die offizielle Lizenz auf redis.io.

Fazit

Redis 8 ist mit zwei Dateien (compose.yaml + .env) in unter zehn Minuten produktionsreif aufgesetzt. Das Alpine-Image ist schlank, unterstützt alle gängigen Architekturen und enthält seit Version 8.0 sämtliche Module, die früher ein separates redis-stack-Image erforderten. Die drei häufigsten Fehler – kein Passwort über command: weitergereicht, kein Volume für Persistenz, Port öffentlich exponiert – lassen sich durch die in dieser Anleitung gezeigte Konfiguration vollständig vermeiden. RedisInsight gibt als Browser-GUI sofortigen Einblick in Speicherverbrauch, Trefferquoten und Key-Browser, ohne dass du ein separates Monitoring-Werkzeug brauchst. Für anspruchsvollere Produktiv-Umgebungen – TLS, Redis Sentinel für Hochverfügbarkeit oder Redis Cluster für horizontale Skalierung – bildet dieser Stack die solide Ausgangsbasis.

Für den sicheren Betrieb mehrerer Docker-Services mit Secrets-Management ohne Klartext-Passwörter in Compose-Dateien empfiehlt sich ein Blick auf Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb.

Weiterführende Anleitungen und Quellen

1. Docker und Docker Compose auf Linux installieren (Ubuntu/Debian): die Self-Hosting-Grundlage
2. Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb
3. Docker-Container automatisch aktualisieren nach dem Watchtower-Aus: Diun, WUD und Renovate im Vergleich
4. Lokales RAG-System mit Qdrant und Embeddings selbst bauen: Schritt-für-Schritt-Anleitung
5. Supabase mit Docker installieren: Open-Source-Firebase-Alternative
6. Meilisearch mit Docker installieren: Blitzschnelle Suchmaschinen-Engine

Offizielle Quellen: Redis auf Docker Hub – Image-Tags, Architektur-Support und Release-Notes. Redis Install on Docker (redis.io) – offizielle Installations-Dokumentation. What's new in Redis 8.0 – Neuerungen und Modul-Integration. RedisInsight Install on Docker – Port- und Volume-Dokumentation.