Meilisearch ist eine Such-API mit Tippfehlertoleranz, Filtern, Geo-Suche, Synonymen und Hybridsuche. Ein Docker-Container genügt, eine externe Datenbank ist nicht erforderlich. Diese Anleitung beschreibt Docker Compose auf Linux, ein persistentes Daten-Volume, API-Zugriff, Sicherung und Updates.

Voraussetzungen

Docker Engine >= 20.10 und Docker Compose V2 (als Plugin docker compose) sind installiert. Falls nicht: Docker und Docker Compose auf Linux installieren (Ubuntu/Debian).
Linux-Host, VM oder NAS mit Docker-Unterstützung (amd64 oder arm64, beide Architekturen werden offiziell unterstützt).
Mindestens 512 MB RAM verfügbar; für aktive Indexierung 1 bis 2 GB empfohlen. Auf kleinen VMs mit 512 MB unbedingt MEILI_MAX_INDEXING_MEMORY begrenzen.
Mindestens 1 GB freier Speicherplatz für das Daten-Volume.
Port 7700 am Host noch nicht belegt (prüfen: ss -tlnp | grep 7700).
Für Produktionsbetrieb: Reverse Proxy mit HTTPS (z. B. Traefik als Docker-Reverse-Proxy mit automatischem HTTPS). Meilisearch selbst bietet kein natives TLS.

Eckdaten auf einen Blick

Parameter	Wert
Docker-Image	getmeili/meilisearch:v1.54.3
Registry	Docker Hub (hub.docker.com)
Port	7700 (HTTP-API + Web-Dashboard)
Volume	meili_data:/meili_data
Mindest-RAM	512 MB (1 bis 2 GB empfohlen)
Architektur	linux/amd64 und linux/arm64
Lizenz	MIT (Community Edition)
Externe DB nötig	Nein, eigene LMDB eingebaut

Schritt 1: Projektordner anlegen

Legen Sie einen Projektordner für die Konfigurationsdateien an. Docker verwaltet das Daten-Volume.

mkdir -p /opt/meilisearch
cd /opt/meilisearch

Alternativ verwenden Sie ~/meilisearch; die weiteren Schritte bleiben gleich.

Verifizieren: ls /opt/meilisearch gibt ein leeres Verzeichnis zurück. Das ist korrekt, die Dateien folgen in den nächsten Schritten.

Schritt 2: .env-Datei mit Secrets anlegen

Der Master-Key schützt die API und muss mindestens 16 UTF-8-Bytes enthalten. Erzeugen Sie einen Zufallswert:

openssl rand -hex 32

Das Ergebnis (64 hexadezimale Zeichen) in die .env-Datei eintragen:

MEILI_MASTER_KEY=hier_ihren_generierten_key_eintragen
MEILI_ENV=production
MEILI_NO_ANALYTICS=true
MEILI_LOG_LEVEL=INFO

Dateirechte einschränken, damit der Key nicht für andere Systemnutzer lesbar ist:

chmod 600 /opt/meilisearch/.env

Wichtig: Die Datei muss vor dem ersten docker compose up existieren. Fehlt sie oder ist MEILI_MASTER_KEY nicht gesetzt, startet Meilisearch im Produktionsmodus gar nicht, Sie erhalten den Fehler „A master key must be provided“.

Verifizieren: cat /opt/meilisearch/.env zeigt die vier Variablen. ls -la /opt/meilisearch/.env zeigt -rw------- als Berechtigung.

Schritt 3: compose.yaml erstellen

Die compose.yaml enthält Healthcheck, Daten-Volume und Umgebungsvariablen. MEILI_HTTP_ADDR=0.0.0.0:7700 lässt den Dienst im Container auf allen IPv4-Schnittstellen lauschen; Port-Mapping allein genügt bei einer Bindung an containerinternes localhost nicht.

services:
  meilisearch:
    image: getmeili/meilisearch:v1.54.3
    container_name: meilisearch
    restart: unless-stopped
    ports:
      - "7700:7700"
    environment:
      - MEILI_MASTER_KEY=${MEILI_MASTER_KEY}
      - MEILI_ENV=${MEILI_ENV:-production}
      - MEILI_HTTP_ADDR=0.0.0.0:7700
      - MEILI_UPGRADE_DB=${MEILI_UPGRADE_DB:-false}
      - MEILI_NO_ANALYTICS=${MEILI_NO_ANALYTICS:-true}
      - MEILI_LOG_LEVEL=${MEILI_LOG_LEVEL:-INFO}
      - MEILI_DB_PATH=/meili_data/data.ms
      - MEILI_DUMP_DIR=/meili_data/dumps
      - MEILI_SNAPSHOT_DIR=/meili_data/snapshots
      - MEILI_SCHEDULE_SNAPSHOT=${MEILI_SCHEDULE_SNAPSHOT:-false}
      - MEILI_MAX_INDEXING_MEMORY=${MEILI_MAX_INDEXING_MEMORY:-1Gb}
    volumes:
      - meili_data:/meili_data
    healthcheck:
      test: ["CMD", "curl", "-fsS", "http://localhost:7700/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 20s

volumes:
  meili_data:
    driver: local

Verwenden Sie einen festen Tag wie v1.54.3, nicht latest: Ein erneuter Pull kann sonst eine inkompatible Version holen. Aktuelle Tags stehen auf Docker Hub.

Das Named Volume meili_data vermeidet die Berechtigungsprobleme eines nicht passend vorbereiteten Host-Verzeichnisses.

Der Healthcheck nutzt curl, das im offiziellen Image enthalten ist. Die früher oft gezeigte Variante mit wget --spider http://localhost:7700/health meldete im Test dauerhaft unhealthy: Das BusyBox-wget im Image löst localhost zuerst auf IPv6 (::1) auf, Meilisearch lauscht aber mit MEILI_HTTP_ADDR=0.0.0.0:7700 nur auf IPv4. MEILI_UPGRADE_DB bleibt im Normalbetrieb auf false und wird nur für Versionswechsel kurz eingeschaltet (Schritt 7).

Verifizieren: docker compose config (im Projektordner ausgeführt) gibt die aufgelöste Konfiguration ohne Fehler aus. Erscheint eine Warnung zu fehlenden Variablen, liegt die .env-Datei nicht im selben Verzeichnis.

Schritt 4: Container starten

Starten Sie den Stack im Hintergrund:

docker compose up -d

Docker zieht das Image (~101 MB komprimiert) von Docker Hub und startet den Container. Nach etwa 20 Sekunden sollte der Healthcheck greifen.

Status prüfen:

docker compose ps

Erwartete Ausgabe (nach dem start_period des Healthchecks):

NAME           IMAGE                            SERVICE        STATUS                   PORTS
meilisearch    getmeili/meilisearch:v1.54.3    meilisearch    Up 2 minutes (healthy)   0.0.0.0:7700->7700/tcp

Start-Log ansehen:

docker compose logs meilisearch

Im Log sollte u. a. folgendes erscheinen:

INFO  meilisearch: Server listening on: "0.0.0.0:7700"
INFO  meilisearch: Environment: "production"

Verifizieren: curl -s http://localhost:7700/health gibt {"status":"available"} zurück. Erscheint stattdessen Connection refused, ist MEILI_HTTP_ADDR=0.0.0.0:7700 nicht gesetzt oder der Container noch nicht vollständig gestartet, Logs prüfen.

Schritt 5: Dashboard öffnen und API testen

Meilisearch bringt ein eingebautes Mini-Dashboard mit, das ohne zusätzliche Installation direkt im Browser erreichbar ist.

Öffnen Sie im Browser: http://<server-ip>:7700

Nutzen Sie das Mini-Dashboard nur, wenn Ihre Betriebsart es bereitstellt. Für den Produktionsmodus dieser Anleitung verwenden Sie die API mit einem passenden API-Key.

Alternativ können Sie die API direkt per curl testen. Zuerst die Systemversion abfragen:

read -rsp "Meilisearch-Master-Key: " MEILI_MASTER_KEY; echo
curl -s http://localhost:7700/version \
  -H "Authorization: Bearer ${MEILI_MASTER_KEY}" | python3 -m json.tool

Einen Testindex mit Dokumenten anlegen (Master-Key als Bearer-Token):

curl -X POST http://localhost:7700/indexes/filme/documents \
  -H "Authorization: Bearer ${MEILI_MASTER_KEY}" \
  -H "Content-Type: application/json" \
  -d '[{"id":1,"titel":"Der Herr der Ringe"},{"id":2,"titel":"Das Schweigen der Lämmer"}]'

Suche mit Tippfehlertoleranz, Meilisearch korrigiert automatisch bis zu zwei Fehler bei Wörtern ab 9 Zeichen:

curl -s "http://localhost:7700/indexes/filme/search" \
  -H "Authorization: Bearer ${MEILI_MASTER_KEY}" \
  -H "Content-Type: application/json" \
  -d '{"q":"Herr der Rnge"}' | python3 -m json.tool

Warten Sie nach dem Import auf den Abschluss der zurückgegebenen Task. Danach findet die Suche trotz „Rnge“ den passenden Treffer; die Antwort enthält processingTimeMs.

Verifizieren: Die Such-Antwort enthält "hits":[{"id":1,"titel":"Der Herr der Ringe"}] und "processingTimeMs" liegt deutlich unter 50. Das Dashboard unter http://<server-ip>:7700 zeigt den Index „filme“ mit zwei Dokumenten.

Schritt 6: API-Keys für Anwendungen erstellen

Verwenden Sie in Anwendungen nicht den Master-Key. Fragen Sie die automatisch erzeugten API-Keys so ab:

curl -s http://localhost:7700/keys \
  -H "Authorization: Bearer ${MEILI_MASTER_KEY}" | python3 -m json.tool

Ein Search-Key darf nur die Indizes freigeben, deren Daten öffentlich sein sollen. Der Default Search Key erlaubt Suche in allen Indizes. Erstellen Sie für Frontends eingeschränkte Keys per POST /keys; veröffentlichen Sie nie den Master- oder Admin-Key.

Verifizieren: Die Antwort enthält mindestens zwei Einträge mit den Feldern "key", "actions" und "indexes". Der Search-Key hat "actions":["search"], der Admin-Key deutlich mehr Rechte.

Schritt 7: Backup und Updates

Backup per Dump

Meilisearch bietet zwei Sicherungsmethoden. Dumps sind versions-übergreifend portierbar und eignen sich für Migrationen:

curl -X POST http://localhost:7700/dumps \
  -H "Authorization: Bearer ${MEILI_MASTER_KEY}"

Die erzeugte .dump-Datei liegt im Container unter /meili_data/dumps, das über das Named Volume auf dem Host zugänglich ist:

docker volume inspect meilisearch_meili_data
# Mountpoint zeigt den Host-Pfad, z. B.:
# /var/lib/docker/volumes/meilisearch_meili_data/_data/

Für tägliche Snapshots setzen Sie MEILI_SCHEDULE_SNAPSHOT=86400 in .env und erstellen den Container neu. Die Compose-Datei muss die Variable an den Container weitergeben. Snapshots liegen unter /meili_data/snapshots und sind nicht für Versionsmigrationen geeignet. Verwenden Sie dafür Dumps. Ergänzend: 3-2-1-Backup-Strategie mit Restic, USB-Disk und S3-Cloud.

Update auf neue Version

Auch Minor-Updates können das Datenformat ändern. Bei Your database version (1.46.1) is incompatible with your current engine version (1.54.3) erlaubt MEILI_UPGRADE_DB=true die einmalige Migration beim Start. Die stabile Option heißt seit v1.51 --upgrade-db, zuvor --experimental-dumpless-upgrade.

cd /opt/meilisearch
# 1. Sicherheitskopie per Dump (siehe oben) anlegen
# 2. compose.yaml: image-Tag auf neue Version anpassen, z. B. v1.54.3
# 3. Upgrade beim Start einmalig erlauben
echo "MEILI_UPGRADE_DB=true" >> .env
docker compose pull
docker compose up -d
docker compose logs -f meilisearch   # warten, bis "listening on" erscheint
# 4. Zeile MEILI_UPGRADE_DB=true wieder aus der .env entfernen
sed -i '/^MEILI_UPGRADE_DB=/d' .env
docker compose up -d

Das Upgrade lässt sich nicht rückgängig machen; ein Zurück auf die alte Version gelingt nur über den vorher erstellten Dump. Im Test lief der Sprung von v1.46.1 auf v1.54.3 auf diese Weise ohne Datenverlust: Index, Dokumente und API-Keys waren danach unverändert vorhanden. Alternativ bleibt der klassische Weg: Dump erstellen, neues Volume mit der neuen Version starten und den Dump mit --import-dump einlesen. Wer experimentelle Funktionen nutzt, sollte vorher die Release Notes lesen: v1.51 hat mehrere experimentelle Optionen entfernt, v1.54 ändert die API der experimentellen Dynamic Search Rules.

Verifizieren: Nach dem Update zeigt docker compose ps den neuen Image-Tag und Status healthy. curl -s -H "Authorization: Bearer ${MEILI_MASTER_KEY}" http://localhost:7700/version gibt die neue Versionsnummer zurück.

Troubleshooting / Typische Fehler

„Connection refused“ auf Port 7700: MEILI_HTTP_ADDR=0.0.0.0:7700 fehlt in der compose.yaml. Meilisearch lauscht dann nur container-intern auf localhost:7700, Port-Mapping hat keinen Effekt. Variable ergänzen, Container mit docker compose up -d neu starten.
„A master key must be provided“: MEILI_ENV=production ist gesetzt, aber MEILI_MASTER_KEY fehlt in der .env-Datei oder die Datei liegt nicht im selben Verzeichnis wie compose.yaml. Prüfen Sie mit docker compose config, ob die Variable aufgelöst wird.
„The provided API key is invalid“: Der Master-Key ist kürzer als 16 Bytes. Bei Sonderzeichen kann die Byte-Länge von der Zeichenanzahl abweichen. Sicherer: openssl rand -hex 32 erzeugt stets einen 64-Zeichen-ASCII-Key.
Container bleibt bei „starting“ statt „healthy“ oder wird „unhealthy“: Der Healthcheck schlägt fehl. Häufigste Ursachen: MEILI_HTTP_ADDR fehlt, oder der Healthcheck nutzt noch wget mit localhost (siehe Schritt 3, ersetzen durch curl -fsS). docker compose logs meilisearch zeigt die genaue Fehlermeldung.
OOM-Kill auf kleinen VMs: Meilisearch nutzt standardmäßig 2/3 des verfügbaren RAMs für die Indexierung. Auf VMs mit wenig Arbeitsspeicher zu .env hinzufügen: MEILI_MAX_INDEXING_MEMORY=256Mb. Danach docker compose up -d ausführen.
„Address already in use“: Port 7700 ist belegt. Prüfen mit ss -tlnp | grep 7700. In compose.yaml den Host-Port ändern (z. B. 7701:7700), MEILI_HTTP_ADDR bleibt auf 0.0.0.0:7700 (Container-intern).
„Your database version (…) is incompatible with your current engine version“ nach einem Update: Das Volume stammt von einer älteren Version. Setzen Sie einmalig MEILI_UPGRADE_DB=true in der .env und starten Sie mit docker compose up -d neu (Ablauf in Schritt 7), oder spielen Sie einen Dump in ein neues Volume ein.
Datenverlust nach Major-Upgrade: Beim Upgrade zwischen Major-Versionen ist die LMDB-Datenbank nicht rückwärtskompatibel. Vor jedem Major-Upgrade per POST /dumps einen Dump erstellen und nach dem Upgrade importieren (POST /snapshots reicht hier nicht).

Häufige Fragen

Brauche ich PostgreSQL, Redis oder eine andere externe Datenbank?

Nein. Meilisearch speichert seine Daten in einer eingebetteten LMDB-Datenbank; PostgreSQL, Redis oder ein Suchcluster sind nicht erforderlich.

Wie aktiviere ich die KI-gestützte Hybridsuche?

Hybridsuche kombiniert klassische Volltextsuche mit semantischer Vektorsuche. Sie wird pro Index über die Einstellungs-API konfiguriert: PATCH /indexes/{uid}/settings mit einem embedders-Objekt, das den Embedding-Provider definiert (z. B. openAI, huggingFace, ollama). Für lokale Embeddings ohne Cloud-Abhängigkeit bietet sich Ollama an, eine Installationsanleitung finden Sie unter Ollama und Open WebUI mit Docker: eigenes lokales KI-Sprachmodell ohne Cloud betreiben.

Ist Meilisearch auf ARM-Hardware lauffähig?

Ja. Das offizielle Image getmeili/meilisearch unterstützt linux/amd64 und linux/arm64. Docker wählt beim Pull die passende Architektur, etwa für Raspberry Pi 4/5, Apple Silicon mit Docker Desktop oder AMD64-Server.

Wie erstelle ich eingeschränkte API-Keys für meine Anwendung?

Eigene Keys mit begrenzten Indizes, Aktionen und Ablaufdatum erstellen Sie per POST /keys mit dem Master-Key als Bearer-Token. Für Multi-Tenant-Szenarien unterstützt Meilisearch zusätzlich Tenant-Tokens, mit denen jeder Nutzer nur seine eigenen Daten sieht.

Was ist der Unterschied zwischen Dumps und Snapshots?

Dumps (POST /dumps) sind portable Exporte für Versionsmigrationen. Snapshots kopieren die Datenbank binär und sind für schnelle Wiederherstellung, nicht für einen Wechsel der Meilisearch-Version gedacht. Sichern Sie beide außerhalb des Servers.

Muss ich Meilisearch absichern, bevor es öffentlich erreichbar ist?

Ja. Meilisearch hat kein natives HTTPS. Nutzen Sie einen TLS-Proxy, damit Schlüssel nicht im Klartext übertragen werden. MEILI_ENV=production und ein starker Master-Key sind Pflicht. Ohne sie läuft Meilisearch im völlig offenen Entwicklungsmodus ohne jede Authentifizierung.

Fazit

Für einen sicheren Betrieb brauchen Sie einen festen Image-Tag, einen geschützten API-Zugang und externe Backups. Vor dem Versionswechsel erstellen Sie einen Dump und lesen die Release Notes. Öffentlich erreichbar darf die Instanz nur über HTTPS sein.

Weiterführende Anleitungen und Quellen

Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten, HTTPS-Termination vor Meilisearch
Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb, Sicherheits-Hardening für den Stack
Lokales RAG-System mit Qdrant und Embeddings selbst bauen, Vektorsuche als Ergänzung zu Meilisearch
Ollama und Open WebUI mit Docker: lokales KI-Sprachmodell ohne Cloud betreiben, Embedding-Provider für die Meilisearch-Hybridsuche

Offizielle Dokumentation: Meilisearch Docker Guide | Konfigurationsreferenz (Instance Options) | Docker Hub: getmeili/meilisearch | GitHub-Repository