HowtoForge

Wie man Meilisearch unter Debian 12 installiert und konfiguriert

von ·

Meilisearch ist eine Open-Source-Suchmaschine, die in der Sprache Rust geschrieben wurde. Da sie in Rust geschrieben ist, benötigt sie weniger Ressourcen und kann mit einer einzigen Kommandozeilen-Binärdatei ausgeführt werden. Der Installationsprozess ist einfacher als bei den anderen Suchmaschinen und erfordert weniger Schritte. Zu den Funktionen gehören Fuzzy Matching und schemafreie Indizierung. Sie wird mit einem Web-Frontend für Demozwecke geliefert. Sie kann über verschiedene Bibliotheken, die in unterschiedlichen Sprachen wie JavaScript, Python, PHP, Ruby usw. verfügbar sind, in verschiedene Webanwendungen integriert werden.

In diesem Tutorium lernst du, wie du Meilisearch auf einem Debian 12-Server in der Produktion installierst und verschiedene einfache Suchen damit durchführst.

Voraussetzungen

  • Ein Server mit Debian 12 und mindestens 2 GB RAM.
  • Ein Nicht-Root-Benutzer mit sudo-Rechten.
  • Die Unkomplizierte Firewall (UFW) ist aktiviert und läuft.
  • Ein Fully Qualified Domain Name (FQDN) wie meilisearch.example.com, der auf deinen Server zeigt. Dies ist von Vorteil, wenn du Meilisearch über SSL mit einem Proxy-Server bedienen willst.
  • Alles ist auf dem neuesten Stand. 
    $ sudo apt update && sudo apt upgrade
  • Für das Tutorial werden ein paar wichtige Pakete benötigt. Einige davon sind vielleicht schon auf deinem Server installiert. 
    $ sudo apt install curl wget nano software-properties-common dirmngr apt-transport-https ca-certificates lsb-release debian-archive-keyring gnupg2 ufw unzip -y

Schritt 1 – Firewall konfigurieren

Der erste Schritt vor der Installation der Pakete besteht darin, die Firewall so zu konfigurieren, dass sie HTTP- und HTTPS-Verbindungen zulässt.

Überprüfe den Status der Firewall.

$ sudo ufw status

Du solltest etwas wie das Folgende sehen.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Erlaube HTTP- und HTTPs-Ports.

$ sudo ufw allow http
$ sudo ufw allow https

Überprüfe den Status zur Bestätigung noch einmal.

$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443/tcp                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443/tcp (v6)               ALLOW       Anywhere (v6)

Schritt 2 – Installiere Meilisearch

Es gibt mehrere Möglichkeiten, Meilisearch zu installieren. Wir werden die einfachste Methode verwenden, bei der wir die Binärdatei auf unseren Server kopieren.

Installiere Meilisearch.

$ curl -L https://install.meilisearch.com | sh

Mache die Binärdatei ausführbar.

$ chmod +x meilisearch

Im Moment ist die Binärdatei nur von dem Verzeichnis aus nutzbar, in das du sie heruntergeladen hast. Um sie von überall aus nutzen zu können, verschiebe die Binärdatei in das Verzeichnis /usr/local/bin.

$ sudo mv ./meilisearch /usr/local/bin/

Überprüfe, ob Meilisearch installiert ist und ordnungsgemäß läuft.

$ meilisearch --version
meilisearch 1.7.6

Schritt 3 – Erstelle einen Systembenutzer für Meilisearch

Wenn du Meilisearch als root ausführst, kann das zu Sicherheitsproblemen führen. Um diese zu vermeiden, erstelle einen Systembenutzer für Meilisearch.

$ sudo useradd -d /var/lib/meilisearch -b /bin/false -m -r meilisearch

Schritt 4 – Meilisearch konfigurieren

Bevor wir weitermachen, müssen wir einen Hauptschlüssel erstellen, den Meilisearch für den Authentifizierungsprozess verwendet. Du kannst ihn mit dem OpenSSL-Kommandozeilenprogramm erstellen. Führe den folgenden Befehl aus, um einen 30 Zeichen langen Hauptschlüssel zu erstellen. Du kannst eine beliebige Länge für deinen Hauptschlüssel wählen. Je länger, desto besser.

$ openssl rand -hex 30

Mit einem 30-Zeichen langen Schlüssel solltest du eine ähnliche Ausgabe erhalten. Kopiere diesen Wert, denn wir werden ihn in den nächsten Schritten brauchen.

65ed5fc15848f7ceb8e646d4928fcf79f494cec239a2874cacd118e42611

Hol dir die neueste Konfigurationsdatei aus dem Meilisearch GitHub Repository und kopiere sie in das Verzeichnis /etc.

$ sudo sh -c 'curl https://raw.githubusercontent.com/meilisearch/meilisearch/latest/config.toml > /etc/meilisearch.toml'

Öffne sie zum Bearbeiten.

$ sudo nano /etc/meilisearch.toml

Aktualisiere die folgenden Zeilen in der Datei, um den Datenbankpfad, den Dump-Pfad, das Snapshot-Verzeichnis und die Arbeitsumgebung zu konfigurieren, und füge den Hauptschlüssel hinzu, den du zuvor für die Authentifizierung erzeugt hast.

Die aktualisierten Werte in der Konfigurationsdatei sollten wie folgt aussehen.

env = "production"
master_key = "173e95f077590ed33dad89247247be8d8ce8b6722ccc87829aaefe3207be"
db_path = "/var/lib/meilisearch/data"
dump_dir = "/var/lib/meilisearch/dumps"
snapshot_dir = "/var/lib/meilisearch/snapshots"

Meilisearch sammelt regelmäßig anonymisierte Daten. Du solltest sie mit der folgenden Option deaktivieren. Deaktiviere sie, um die Telemetrie von Meilisearch zu deaktivieren.

no_analytics = true

Standardmäßig verwendet Meilisearch nicht mehr als zwei Drittel des verfügbaren Arbeitsspeichers auf deinem System. Du kannst dies steuern, indem du die folgende Variable auskommentierst und setzt. Du kannst den Wert auch als exakte Anzahl von Bytes angeben, um präzise und genau zu sein.

max_indexing_memory = "1 GiB"

Meilisearch nutzt nicht mehr als die Hälfte der verfügbaren CPU-Kerne. Du kannst diesen Wert jedoch steuern, indem du die folgende Variable auskommentierst und setzt.

max_indexing_threads = 1

Wenn du diesen Wert auf mehr als die Anzahl der CPU-Kerne des Rechners setzt, wird Meilisearch die maximale Anzahl der verfügbaren Kerne verwenden.

Eine weitere Einstellung, die du kennen solltest, ist die Menge der maximalen Nutzlast, die Meilisearch aufnehmen kann. Der Standardwert ist auf 100 MB eingestellt. Du kannst ihn ändern, indem du die folgende Variable einstellst.

http_payload_size_limit = "100 MB"

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Schritt 5 – Verzeichnisse erstellen und Berechtigungen erteilen

Erstelle die Verzeichnisse, in denen Meilisearch seine Datenbank, Datenbank-Dumps und Snapshots speichern wird.

$ sudo mkdir /var/lib/meilisearch/dumps -p
$ sudo mkdir /var/lib/meilisearch/snapshots

Setze den Besitzer und die Gruppe für diese Verzeichnisse auf den Systembenutzer, den wir für Meilisearch angelegt haben.

$ sudo chown -R meilisearch:meilisearch /var/lib/meilisearch

Setze den Besitzer und die Gruppe für die Meilisearch-Binärdatei.

$ sudo chown meilisearch:meilisearch /usr/local/bin/meilisearch

Setze die richtigen Berechtigungen für das Verzeichnis.

$ sudo chmod 750 /var/lib/meilisearch

Schritt 6 – Meilisearch als Dienst ausführen

Damit Meilisearch jederzeit für Suchanfragen zur Verfügung steht, ist es besser, es als Systemdienst laufen zu lassen. Dazu müssen wir eine Servicedatei dafür erstellen.

Erstelle und öffne /etc/systemd/system/meilisearch.service zum Bearbeiten.

$ sudo nano /etc/systemd/system/meilisearch.service

Füge den folgenden Code in die Datei ein.

[Unit]
Description=Meilisearch
After=systemd-user-sessions.service

[Service]
Type=simple
WorkingDirectory=/var/lib/meilisearch
ExecStart=/usr/local/bin/meilisearch --config-file-path /etc/meilisearch.toml
User=meilisearch
Group=meilisearch

[Install]
WantedBy=multi-user.target

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Aktiviere den Dienst.

$ sudo systemctl enable meilisearch

Starte den Meilisearch-Dienst.

$ sudo systemctl start meilisearch

Überprüfe den Status des Dienstes

$ sudo systemctl status meilisearch

Du solltest eine ähnliche Ausgabe erhalten.

? meilisearch.service - Meilisearch
     Loaded: loaded (/etc/systemd/system/meilisearch.service; enabled; preset: enabled)
     Active: active (running) since Fri 2024-05-03 03:02:53 UTC; 5s ago
   Main PID: 1008 (meilisearch)
      Tasks: 6 (limit: 2251)
     Memory: 23.0M
        CPU: 10ms
     CGroup: /system.slice/meilisearch.service
             ??1008 /usr/local/bin/meilisearch --config-file-path /etc/meilisearch.toml

May 03 03:02:53 meilisearch meilisearch[1008]: Commit date:                "unknown"
May 03 03:02:53 meilisearch meilisearch[1008]: Package version:        "1.7.6"
May 03 03:02:53 meilisearch meilisearch[1008]: Anonymous telemetry:        "Disabled"
May 03 03:02:53 meilisearch meilisearch[1008]: A master key has been set. Requests to Meilisearch won't be authorized unless you provide an authentication key.
May 03 03:02:53 meilisearch meilisearch[1008]: Check out Meilisearch Cloud!        https://www.meilisearch.com/cloud?utm_campaign=oss&utm_source=engine&utm_medium=cli
May 03 03:02:53 meilisearch meilisearch[1008]: Documentation:                        https://www.meilisearch.com/docs
May 03 03:02:53 meilisearch meilisearch[1008]: Source code:                        https://github.com/meilisearch/meilisearch
May 03 03:02:53 meilisearch meilisearch[1008]: Discord:                        https://discord.meilisearch.com
May 03 03:02:53 meilisearch meilisearch[1008]: 2024-05-03T03:02:53.891366Z  INFO actix_server::builder: starting 2 workers
May 03 03:02:53 meilisearch meilisearch[1008]: 2024-05-03T03:02:53.891396Z  INFO actix_server::server: Actix runtime found; starting in Actix runtime

Meilisearch ist installiert und läuft. Wir stellen den Dienst nach außen dar, indem wir den Nginx-Server als Reverse-Proxy verwenden und Let’s Encrypt für die SSL-Verbindung nutzen.

Schritt 7 – Nginx installieren

Debian 12 wird mit einer älteren Version von Nginx ausgeliefert. Du musst das offizielle Nginx-Repository herunterladen, um die neueste Version zu installieren.

Importiere den Signierschlüssel von Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
    | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Füge das Repository für die Mainline-Version von Nginx hinzu.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] \
http://nginx.org/packages/mainline/debian `lsb_release -cs` nginx" \
    | sudo tee /etc/apt/sources.list.d/nginx.list

Aktualisiere die System-Repositories.

$ sudo apt update

Installiere Nginx.

$ sudo apt install nginx

Überprüfe die Installation. Auf Debian-Systemen funktioniert der folgende Befehl nur mit sudo.

$ sudo nginx -v
nginx version: nginx/1.25.5

Starte den Nginx-Server.

$ sudo systemctl start nginx

Überprüfe den Status des Dienstes.

$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
     Loaded: loaded (/lib/systemd/system/nginx.service; enabled; preset: enabled)
     Active: active (running) since Fri 2024-05-03 03:04:02 UTC; 5s ago
       Docs: https://nginx.org/en/docs/
    Process: 1699 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 1700 (nginx)
      Tasks: 3 (limit: 2251)
     Memory: 2.9M
        CPU: 7ms
     CGroup: /system.slice/nginx.service
             ??1700 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??1701 "nginx: worker process"
             ??1702 "nginx: worker process"

May 03 03:04:02 meilisearch systemd[1]: Starting nginx.service - nginx - high performance web server...
May 03 03:04:02 meilisearch systemd[1]: Started nginx.service - nginx - high performance web server.

Schritt 8 – SSL installieren

Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Debian installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Bei Debian 12 ist Snapd noch nicht installiert. Installiere das Snapd-Paket.

$ sudo apt install -y snapd

Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core && sudo snap refresh core

Installiere Certbot.

$ sudo snap install --classic certbot

Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Überprüfe, ob Certbot richtig funktioniert.

$ certbot --version
certbot 2.10.0

Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d meilisearch.example.com

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/meilisearch.example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Überprüfe die Liste der systemd-Timer. Certbot installiert und startet automatisch einen Timer für die Erneuerung.

$ sudo systemctl list-timers

Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.

NEXT                        LEFT           LAST                        PASSED    UNIT                        ACTIVATES                   ---------------------------------------------------------------------------------------------------------------------------------------  
Fri 2024-05-03 17:17:15 UTC 14h left      Fri 2024-05-03 02:54:42 UTC 11min ago apt-daily.timer              apt-daily.service
Fri 2024-05-03 06:42:20 UTC 3h 36min left Fri 2024-05-03 02:54:42 UTC 11min ago apt-daily-upgrade.timer      apt-daily-upgrade.service
Fri 2024-05-03 10:39:00 UTC 7h left       -                           -         snap.certbot.renew.timer     snap.certbot.renew.service

Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.

Schritt 9 – Nginx konfigurieren

Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.

$ sudo nano /etc/nginx/nginx.conf

Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.

server_names_hash_bucket_size 64;

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Erstelle und öffne die Datei /etc/nginx/conf.d/meilisearch.conf zum Bearbeiten.

$ sudo nano /etc/nginx/conf.d/meilisearch.conf

Füge den folgenden Code in die Datei ein. Ersetze meilisearch.example.com durch deinen Domainnamen.

server {

    listen 443 ssl;
    listen [::]:443 ssl;

    http2 on;
    http3 on;
    quic_retry on;

    server_name meilisearch.example.com;

    access_log  /var/log/nginx/meilisearch.access.log;
    error_log   /var/log/nginx/meilisearch.error.log;

    ssl_certificate      /etc/letsencrypt/live/meilisearch.example.com/fullchain.pem;
    ssl_certificate_key  /etc/letsencrypt/live/meilisearch.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/meilisearch.example.com/chain.pem;

    ssl_session_timeout  5m;
    ssl_session_cache shared:MozSSL:10m;
    ssl_session_tickets off;
    ssl_early_data on;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
    ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_dhparam /etc/ssl/certs/dhparam.pem;

    location / {
        proxy_pass http://localhost:7700;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
# enforce HTTPS
server {
    listen 80;
    listen [::]:80;
    server_name  meilisearch.example.com;
    return 301   https://$host$request_uri;
}

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Überprüfe deine Nginx-Konfiguration.

$ sudo nginx -t

Starte den Nginx-Server neu.

$ sudo systemctl restart nginx

Meilisearch läuft jetzt und ist über die URL https://meilisearch.example.com erreichbar. Du solltest den folgenden Text sehen, wenn du die URL öffnest.

{"status":"Meilisearch is running"}

Diese URL kann nur für die Suche über die Kommandozeile verwendet werden. Wenn du über ein Frontend auf Meilisearch zugreifen willst, musst du es in ein anderes CMS oder eine andere Software integrieren, damit es funktioniert, was den Rahmen dieses Tutorials sprengen würde. Meilisearch wird mit einer eingebauten Frontend-Schnittstelle ausgeliefert, aber das funktioniert nur, wenn du es für Entwicklungszwecke verwendest. Du kannst die Umgebung der Instanz in der Konfigurationsdatei auf development ändern und Meilisearch neu starten, um die Schnittstelle zu aktivieren. Sie sollte ungefähr so aussehen wie die folgende.

Meilisearch Entwicklung Suche Dashboard

Für eine Produktionsumgebung musst du Meilisearch in ein anderes CMS integrieren.

Beginnen wir damit, einige Dokumente zu indizieren und für die Suche zu verwenden.

Schritt 10 – Beispieldaten in Meilisearch laden

Das Meilisearch-Projekt stellt eine JSON-formatierte Beispieldatei mit den Daten aus der Filmdatenbank (TMDB) bereit. Lade die Datei herunter.

$ wget https://www.meilisearch.com/movies.json

Du kannst den Befehl tail ausführen, um einen Teil der Daten zu sehen. Er sollte wie der folgende aussehen.

$ tail -n 3 movies.json

{"id":460070,"title":"J.T. LeRoy","overview":"A young woman named Savannah Knoop spends six years pretending to be a transgender writer named JT Leroy, the made-up literary persona of her sister-in-law.","genres":["Drama"],"poster":"https://image.tmdb.org/t/p/w500/43ffZhMCWQhzMneGP4kDWoPV48X.jpg","release_date":1556236800},
{"id":460071,"title":"Lizzie","overview":"Massachusetts, 1892. An unmarried woman of 32 and a social outcast, Lizzie lives a claustrophobic life under her father's cold and domineering control. When Bridget Sullivan, a young maid, comes to work for the family, Lizzie finds a sympathetic, kindred spirit, and a secret intimacy soon blossoms into a wicked plan.","genres":["Crime","Drama","Thriller"],"poster":"https://image.tmdb.org/t/p/w500/z2iuBcwznen3kC9z4LeOzBSz1BB.jpg","release_date":1536883200}
]

Wie du siehst, enthält jeder einzelne Eintrag eine ID, einen Titel, einen Link zum Posterbild, eine Übersicht über den Film, ein Veröffentlichungsdatum und eine Liste der Genres. Das Veröffentlichungsdatum ist im EPOCH-Format.

Wir laden die Daten mit curl über eine HTTP POST-Anfrage in Meilisearch.

$ curl \
  -X POST 'http://localhost:7700/indexes/movies/documents' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer 65ed5fc15848f7ceb8e646d4928fcf79f494cec239a2874cacd118e42611' \
  --data-binary @movies.json

Gehen wir die Befehlsargumente durch:

  • -X POST – gibt an, dass wir eine HTTP POST-Anfrage durchführen und Daten senden.
  • -H Content-Type – gibt den Inhaltstyp der Datei an.
  • -H Authorization: Bearer – gibt an, dass du den Hauptschlüssel mit deinen Anfragen übermitteln sollst.
  • –data-binary – gibt die Datei an, die eingebunden werden soll.

Hier erstellen wir einen neuen Meilisearch-Index unter /indexes/movies/documents. Du solltest eine ähnliche Ausgabe erhalten, die dir mitteilt, dass die Anfrage in die Warteschlange gestellt wurde. Meilisearch verarbeitet alle Anfragen asynchron.

{"taskUid":0,"indexUid":"movies","status":"enqueued","type":"documentAdditionOrUpdate","enqueuedAt":"2024-05-03T03:12:55.599798591Z"}

Du kannst den obigen Befehl auch ausführen, indem du die URL http://localhost:7700 durch https://meilisearch.example.com ersetzt, dann funktioniert er genauso. Du kannst dies für alle Befehle in diesem Lehrgang tun, aber der Einfachheit halber bleiben wir bei der URL http://localhost:7700.

Führe den folgenden Befehl aus, um den Status der Anfrage zu überprüfen.

$ curl -X GET 'http://localhost:7700/indexes/movies/tasks/0'

Du solltest eine ähnliche Ausgabe erhalten.

{"uid":0,"indexUid":"movies","status":"succeeded","type":"documentAddition","details":{"receivedDocuments":19547,"indexedDocuments":19546},"duration":"PT29.866920116S","enqueuedAt":"2024-05-03T03:13:18.233702815Z","startedAt":"2024-05-03T03:19:45.370142371Z","finishedAt":"2024-05-03T03:20:05.108395540Z"}

Dies zeigt uns, dass die Aufgabe abgeschlossen ist und die Filmdatenbank nun vollständig indiziert und einsatzbereit ist.

Schritt 11 – Begrenzte Schlüssel für die Suche verwenden

Es gibt ein Tool, das uns bei der lesbaren JSON-Formatierung in der Kommandozeile hilft. Es heißt jq. Führe den folgenden Befehl aus, um es zu installieren.

$ sudo apt install -y jq

Auch wenn wir den Hauptschlüssel in die Konfigurationsdatei aufgenommen haben, musst du ihn bei jeder Anfrage erneut übergeben. Bevor wir weitermachen, brauchen wir einen eingeschränkten Schlüssel, der den Nur-Lese-Modus aktiviert. Meiliserch erstellt standardmäßig einen Nur-Lese-Schlüssel. Holen wir ihn uns.

$ curl -X GET 'http://localhost:7700/keys' -H 'Authorization: Bearer 65ed5fc15848f7ceb8e646d4928fcf79f494cec239a2874cacd118e42611' | jq

Du solltest eine ähnliche Ausgabe sehen.

{
  "results": [
    {
      "name": "Default Search API Key",
      "description": "Use it to search from the frontend",
      "key": "591e51d2f6700ead7ba134a7aed0966d72e2022e43847caf48df3e4800c9279a",
      "uid": "d004073b-b813-4016-82cb-7995df5149f6",
      "actions": [
        "search"
      ],
      "indexes": [
        "*"
      ],
      "expiresAt": null,
      "createdAt": "2024-05-03T03:02:53.887256411Z",
      "updatedAt": "2024-05-03T03:02:53.887256411Z"
    },
    {
      "name": "Default Admin API Key",
      "description": "Use it for anything that is not a search operation. Caution! Do not expose it on a public frontend",
      "key": "0f3cdcfe5d9a56273d6c708f068a82382a97b629b70f4962f969687b5e327196",
      "uid": "b4fc2f96-4347-4750-9ba6-2da73c26e2bd",
      "actions": [
        "*"
      ],
      "indexes": [
        "*"
      ],
      "expiresAt": null,
      "createdAt": "2024-05-03T03:02:53.886580786Z",
      "updatedAt": "2024-05-03T03:02:53.886580786Z"
    }
  ],
  "offset": 0,
  "limit": 20,
  "total": 2
}

Von nun an werden wir den Standard-Such-API-Schlüssel verwenden, um Suchen durchzuführen.

Schritt 12 – Durchsuchen von Beispieldaten

Es gibt zwei Möglichkeiten, mit Meilisearch zu suchen: Du kannst entweder die API über die Kommandozeile oder das Webinterface nutzen. Die Weboberfläche ist ziemlich eingeschränkt und funktioniert nur, wenn du Meilisearch in einer Entwicklungsumgebung verwendest; die API ist der empfohlene Weg, um Meilisearch zu nutzen. Da wir unsere Suche für die Produktion konfiguriert haben, werden wir nur die Kommandozeilenmethode verwenden.

Die Suche über die API ist wie das Hochladen von Daten per HTTP POST-Anfrage. Du stellst eine Anfrage an den Endpunkt /search der API. Wir suchen zum Beispiel nach allen Filmen, die das Wort saint enthalten.

$ curl \
  -X POST 'http://localhost:7700/indexes/movies/search' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer 591e51d2f6700ead7ba134a7aed0966d72e2022e43847caf48df3e4800c9279a' \
  --data-binary '{ "q": "saint" }' | jq

Du solltest eine Ausgabe erhalten, die in JSON formatiert ist, wie die folgende.

{
  "hits": [
    {
      "id": 25248,
      "title": "Saint Ralph",
      "overview": "This Canadian made comedy/drama, set in Hamilton, Ontario in 1954, is a sweet and - at times - goofy story that becomes increasingly poignant as the minutes tick by.  It's the fictional tale of a wayward 9th grader, Ralph (Adam Butcher), who is secretly living on his own while his widowed, hospitalized mother remains immersed in a coma. Frequently in trouble with Father Fitzpatrick (Gordon Pinsent), the principal of his all-boys, Catholic school, Ralph is considered something of a joke among peers until he decides to pull off a miracle that could save his mother, i.e., winning the Boston Marathon.  Coached by a younger priest and former runner, Father Hibbert (Campbell Scott), whose cynicism has been lifted by the boy's pure hope, Ralph applies himself to his unlikely mission, fending off naysayers and getting help along a very challenging path from sundry allies and friends.",
      "genres": [
        "Comedy",
        "Drama"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/3MdWgqUunIBWnc7mYi2dtZrD54Y.jpg",
      "release_date": 1123200000
    },
    {
      "id": 26894,
      "title": "Saint Sinner",
      "overview": "In 1815 a monk, Tomas Alcala, unwittingly unleashes two female succubi, Munkar and Nakir, upon an unsuspecting 21st century. He is chosen by God to travel through the centuries and stop the demons' rampage.",
      "genres": [
        "Fantasy",
        "Horror",
        "Science Fiction",
        "TV Movie"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/cxljKsfUI6PVFPIgPvsesUWHai4.jpg",
      "release_date": 1035590400
    },
    {
      "id": 27023,
      "title": "Saint John of Las Vegas",
      "overview": "An ex-gambler is lured back into the game by a veteran insurance-fraud investigator.",
      "genres": [
        "Comedy"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/kN4Vur1SccouDR0k3tmJXJHdrXw.jpg",
      "release_date": 1264723200
    },
  ...

Um die Fuzzy-Matching-Funktion von Meilisearch zu testen, bei der ähnlich klingende Wörter verwendet werden können, um die genaue Suche zu finden. Das ist hilfreich, wenn du einen Tippfehler machst und trotzdem das richtige Ergebnis erwartest.

$ curl \
  -X POST 'http://localhost:7700/indexes/movies/search' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer 591e51d2f6700ead7ba134a7aed0966d72e2022e43847caf48df3e4800c9279a' \
  --data-binary '{ "q": "seint" }' | jq

Hier haben wir saint als seint falsch geschrieben und Meilisearch wird trotzdem Einträge mit dem Wort saint zurückgeben.

{
  "hits": [
    {
      "id": 10105,
      "title": "Saints and Soldiers",
      "overview": "Five American soldiers fighting in Europe during World War II struggle to return to Allied territory after being separated from U.S. forces during the historic Malmedy Massacre.",
      "genres": [
        "War",
        "Drama",
        "Action",
        "Adventure",
        "History"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/efhqxap8fLi4v1GEXVvakey0z3S.jpg",
      "release_date": 1063238400
    },
    {
      "id": 25248,
      "title": "Saint Ralph",
      "overview": "This Canadian made comedy/drama, set in Hamilton, Ontario in 1954, is a sweet and - at times - goofy story that becomes increasingly poignant as the minutes tick by.  It's the fictional tale of a wayward 9th grader, Ralph (Adam Butcher), who is secretly living on his own while his widowed, hospitalized mother remains immersed in a coma. Frequently in trouble with Father Fitzpatrick (Gordon Pinsent), the principal of his all-boys, Catholic school, Ralph is considered something of a joke among peers until he decides to pull off a miracle that could save his mother, i.e., winning the Boston Marathon.  Coached by a younger priest and former runner, Father Hibbert (Campbell Scott), whose cynicism has been lifted by the boy's pure hope, Ralph applies himself to his unlikely mission, fending off naysayers and getting help along a very challenging path from sundry allies and friends.",
      "genres": [
        "Comedy",
        "Drama"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/3MdWgqUunIBWnc7mYi2dtZrD54Y.jpg",
      "release_date": 1123200000
    },
    {
      "id": 26894,
      "title": "Saint Sinner",
      "overview": "In 1815 a monk, Tomas Alcala, unwittingly unleashes two female succubi, Munkar and Nakir, upon an unsuspecting 21st century. He is chosen by God to travel through the centuries and stop the demons' rampage.",
      "genres": [
        "Fantasy",
        "Horror",
        "Science Fiction",
        "TV Movie"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/cxljKsfUI6PVFPIgPvsesUWHai4.jpg",
      "release_date": 1035590400
    },
 …

Schritt 13 – Tuning des Suchrankings und Filtern der Daten

Suchmaschinen können bessere Ergebnisse liefern, wenn sie wissen, wie sie bestimmte Ergebnisse nach der Wichtigkeit eines bestimmten Feldes einstufen oder gewichten können. Meilisearch hat eine Reihe von Standardregeln, die du konfigurieren kannst, um deine Suchergebnisse zu verbessern.

Aber zuerst müssen wir die von Meilisearch eingestellten Rangordnungsregeln überprüfen.

$ curl -X GET 'http://localhost:7700/indexes/movies/settings/ranking-rules' -H 'Authorization: Bearer 0f3cdcfe5d9a56273d6c708f068a82382a97b629b70f4962f969687b5e327196'

Du wirst die folgende Ausgabe erhalten.

["words","typo","proximity","attribute","sort","exactness"]
  1. Wörter – die Ergebnisse werden nach abnehmender Anzahl der übereinstimmenden Begriffe sortiert.
  2. typo – die Ergebnisse werden nach zunehmender Anzahl von Tippfehlern sortiert. Weniger Tippfehler-Abfragen werden ganz oben angezeigt.
  3. Proximity – Die Ergebnisse werden nach dem Abstand zwischen den übereinstimmenden Begriffen sortiert.
  4. Attribut – die Ergebnisse werden nach der Rangfolge der Attribute sortiert.
  5. Sortieren – Die Ergebnisse werden nach den Parametern sortiert, die bei der Abfrage festgelegt wurden.
  6. Exaktheit – die Ergebnisse werden nach der Ähnlichkeit der übereinstimmenden Wörter mit den Suchbegriffen sortiert.

Du kannst mehr über Relevanz in der offiziellen Meilisearch-Dokumentation lesen.

Gib den folgenden Befehl ein, um die Reihenfolge der Bias-Regeln zu ändern.

$ curl \
  -X POST 'http://localhost:7700/indexes/movies/settings/ranking-rules' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer 0f3cdcfe5d9a56273d6c708f068a82382a97b629b70f4962f969687b5e327196' \
  --data-binary '[
      "words",
      "typo",
      "proximity",
      "release_date:asc",
      "attribute",
      "sort",
      "exactness",
      "rank:desc"
  ]'

Nun wollen wir die Suchergebnisse filtern. Zunächst bitten wir Meilisearch, nur bestimmte Attribute für die Suche zu verwenden und die bedeutungslosen Attribute wie id wegzulassen.

$ curl \
  -X POST 'http://localhost:7700/indexes/movies/settings' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer 0f3cdcfe5d9a56273d6c708f068a82382a97b629b70f4962f969687b5e327196' \
  --data-binary '{
      "searchableAttributes": [
          "title",
          "overview",
          "genres"
      ]
  }'

Hier führen wir eine Suche nur mit den Attributen title, overview und genres durch, die bessere Ergebnisse liefert.

Als Nächstes können wir unsere Suchergebnisse so formatieren, dass nur bestimmte Attribute angezeigt und die anderen ausgeblendet werden.

$ curl \
  -X POST 'http://localhost:7700/indexes/movies/settings/displayedAttributes' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer 0f3cdcfe5d9a56273d6c708f068a82382a97b629b70f4962f969687b5e327196' \
  --data-binary '[
          "title",
          "overview",
          "genres",
          "release_date"
      ]'

Dann werden nur die Attribute angezeigt, die wir in unserer Abfrage mit den Ergebnissen angegeben haben.

Schließlich kannst du auch eine Liste von Attributen angeben, die gefiltert oder sortiert werden sollen. Dies umfasst sowohl die quantitative Filterung mit mathematischen Operatoren wie < oder > als auch die Filterung durch Aufnahme in eine bestimmte Menge. Dies wird auch als Facettensuche bezeichnet.

$ curl \
  -X PATCH 'http://localhost:7700/indexes/movies/settings' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer 0f3cdcfe5d9a56273d6c708f068a82382a97b629b70f4962f969687b5e327196' \
  --data-binary '{
      "filterableAttributes": [
          "genres",
          "release_date"
      ],
      "sortableAttributes": [
          "release_date"
      ]
  }'

Wir können alle diese Regeln kombinieren, um eine Abfrage wie die folgende durchzuführen.

$ curl \
  -X POST 'http://localhost:7700/indexes/movies/search' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer 591e51d2f6700ead7ba134a7aed0966d72e2022e43847caf48df3e4800c9279a' \
  --data-binary '{ "q": "house", "sort": ["release_date:desc"], "filter": "genres = Horror" }' | jq

Hier suchen wir nach allen Filmen des Horrorgenres, von den neuesten bis zu den ältesten, die das Wort house im Titel enthalten. Du solltest eine ähnliche Ausgabe erhalten.

{
  "hits": [
    {
      "id": 440559,
      "title": "Housesitters",
      "overview": "Angie and Izzy get a housesitting gig that seems too good to be true. Gruesome supernatural hijinks ensue.",
      "genres": [
        "Comedy",
        "Horror"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/9Gnu0PBdYzyd7ZkO74XK0xCH0iY.jpg",
      "release_date": 1524873600
    },
    {
      "id": 449550,
      "title": "Housewife",
      "overview": "Housewife is centered on Holly whose mother murdered her sister and father when she was seven. 20 years later and slowly losing her grip on the difference between reality and nightmares, she runs into a celebrity psychic who claims that he is destined to help her.",
      "genres": [
        "Horror"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/ohHxS7PIRQb9O6KTrDtqYshYGts.jpg",
      "release_date": 1504828800
    },
    {
      "id": 392703,
      "title": "House of Darkness",
      "overview": "Inspired by true events, the supernatural thriller \"House of Darkness\" recounts the mysterious case of a San Francisco family who claimed that a dark force was responsible for the tragic events that unfolded.  Trying to save their struggling marriage Kelly (Sara Fletcher, \"Adulthood\"), her husband Brian (Gunner Wright, \"J. Edgar\") and their daughter Sarah (Mykayla Sohn, \"The Chosen\") move to a rural farmhouse in search of some serenity. Unbeknownst to them, nearly every family that has lived in the house has suffered some form of tragedy, dating back nearly 100 years. Shortly after their arrival, Kelly begins to sense that her husband’s behavior is growing increasingly strange and violent. Kelly also comes to discover the voices she’s hearing echoing through the halls, are not coming from her daughter. Will Kelly and her family be the next victims of the dark forces in the house?",
      "genres": [
        "Horror",
        "Thriller",
        "TV Movie"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/ueQM9RsT0HLL2RuuiLmD07j8lKB.jpg",
      "release_date": 1460851200
    },
…

Schritt 14 – Fazit

Du hast die Installation und Konfiguration von Meilisearch in einer Produktionsumgebung auf einem Debian 12 Server abgeschlossen. Du hast auch einige grundlegende Suchen durchgeführt und gelernt, wie du die Suchergebnisse durch Ranking und Filterung verbessern kannst. Wenn du Fragen hast, schreibe sie unten in die Kommentare.

Das könnte dich auch interessieren …