Meilisearch · 21 min read · Oct 26, 2025

Come installare e configurare Meilisearch su Debian 12

Meilisearch è un motore di ricerca open-source scritto in linguaggio Rust. Essendo scritto in Rust richiede meno risorse per funzionare e può essere eseguito utilizzando un singolo file binario da riga di comando. Il processo di installazione è più semplice rispetto agli altri motori di ricerca e richiede meno passaggi. Le sue caratteristiche includono il fuzzy matching e l’indicizzazione senza schema. Viene fornito con un’interfaccia web per scopi dimostrativi. Può essere integrato in varie applicazioni web attraverso diverse librerie disponibili in più linguaggi come JavaScript, Python, PHP, Ruby, ecc.

In questo tutorial, imparerai come installare Meilisearch in produzione su un server Debian 12 e usarlo per eseguire diverse ricerche semplici.

Prerequisiti

  • Un server che esegue Debian 12 con un minimo di 2GB di RAM.

  • Un utente non root con privilegi sudo.

  • Il Firewall semplice (UFW) è abilitato e in esecuzione.

  • Un Nome di Dominio Completo (FQDN) come meilisearch.example.com che punta al tuo server. Questo è utile se desideri servire Meilisearch tramite SSL utilizzando un server proxy.

  • Tutto è aggiornato. $ sudo apt update && sudo apt upgrade

  • Alcuni pacchetti essenziali sono richiesti per il tutorial. Alcuni di questi potrebbero già essere installati sul tuo server. $ sudo apt install curl wget nano software-properties-common dirmngr apt-transport-https ca-certificates lsb-release debian-archive-keyring gnupg2 ufw unzip -y

Passo 1 - Configurare il Firewall

Il primo passo prima di installare qualsiasi pacchetto è configurare il firewall per consentire le connessioni HTTP e HTTPS.

Controlla lo stato del firewall.

$ sudo ufw status

Dovresti vedere qualcosa di simile al seguente.

Status: active

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

Consenti le porte HTTP e HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Controlla di nuovo lo stato per confermare.

$ 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)

Passo 2 - Installare Meilisearch

Ci sono diversi modi per installare Meilisearch. Utilizzeremo il metodo più semplice che prevede la copia del file binario sul nostro server.

Installa Meilisearch.

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

Rendi il binario eseguibile.

$ chmod +x meilisearch

In questo momento il binario è utilizzabile solo dalla directory in cui lo hai scaricato. Per poterlo utilizzare da qualsiasi parte, sposta il file binario nella directory /usr/local/bin.

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

Conferma che Meilisearch è installato e funzionante correttamente.

$ meilisearch --version
meilisearch 1.7.6

Passo 3 - Creare un utente di sistema per Meilisearch

Eseguire Meilisearch come root può creare problemi di sicurezza. Per evitarli, crea un utente di sistema per eseguire Meilisearch.

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

Passo 4 - Configurare Meilisearch

Prima di procedere, dobbiamo creare una chiave master che Meilisearch utilizza per il processo di autenticazione. Puoi utilizzare l’utilità da riga di comando OpenSSL per crearla. Esegui il seguente comando per creare una chiave master lunga 30 caratteri. Puoi scegliere qualsiasi lunghezza per la tua chiave master. Più lunga è, meglio è.

$ openssl rand -hex 30

Dovresti ricevere un output simile con una chiave lunga 30 caratteri. Copia questo valore perché ne avremo bisogno nei passaggi successivi.

65ed5fc15848f7ceb8e646d4928fcf79f494cec239a2874cacd118e42611

Prendi l’ultimo file di configurazione dal repository GitHub di Meilisearch e copialo nella directory /etc.

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

Aprilo per la modifica.

$ sudo nano /etc/meilisearch.toml

Aggiorna le seguenti righe nel file per configurare il percorso del database, il percorso del dump, la directory degli snapshot e l’ambiente di lavoro, e aggiungi la chiave master che hai generato prima per l’autenticazione.

I valori aggiornati nel file di configurazione dovrebbero apparire come segue.

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

Meilisearch raccoglie dati regolari in modo anonimo. Dovresti disabilitarlo utilizzando la seguente opzione. Decommentalo per disattivare la telemetria di Meilisearch.

no_analytics = true

Per impostazione predefinita, Meilisearch utilizza non più di due terzi della RAM disponibile sul tuo sistema. Puoi controllare questo decommentando e impostando la seguente variabile. Puoi anche specificare il valore come numero esatto di byte per essere preciso e accurato.

max_indexing_memory = "1 GiB"

Meilisearch utilizza non più della metà dei core CPU disponibili. Puoi, tuttavia, controllare questo valore decommentando e impostando la seguente variabile.

max_indexing_threads = 1

Impostare questo valore superiore al numero di core CPU della macchina dirà a Meilisearch di utilizzare il numero massimo di core disponibili.

Un’altra impostazione che dovresti conoscere è la quantità massima di payload che Meilisearch può gestire. Il valore predefinito è impostato a 100MB. Puoi cambiarlo configurando la seguente variabile.

http_payload_size_limit = "100 MB"

Una volta terminato, salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Passo 5 - Creare directory e dare permessi

Crea le directory in cui Meilisearch memorizzerà il suo database, i dump del database e gli snapshot.

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

Imposta il proprietario e il gruppo su queste directory all’utente di sistema che abbiamo creato per Meilisearch.

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

Imposta il proprietario e il gruppo sul file binario di Meilisearch.

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

Imposta i permessi appropriati sulla directory.

$ sudo chmod 750 /var/lib/meilisearch

Passo 6 - Eseguire Meilisearch come servizio

Per rendere Meilisearch disponibile in ogni momento per le richieste di ricerca, è meglio eseguirlo come servizio di sistema. Per questo, dobbiamo creare un file di servizio per esso.

Crea e apri /etc/systemd/system/meilisearch.service per la modifica.

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

Incolla il seguente codice in esso.

[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

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Abilita il servizio.

$ sudo systemctl enable meilisearch

Avvia il servizio Meilisearch.

$ sudo systemctl start meilisearch

Controlla lo stato del servizio

$ sudo systemctl status meilisearch

Dovresti ricevere un output simile.

? 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 è installato e in esecuzione. Esponiamo il servizio all’esterno utilizzando il server Nginx come reverse proxy e utilizziamo Let’s Encrypt per servirlo tramite SSL.

Passo 7 - Installare Nginx

Debian 12 viene fornito con una versione più vecchia di Nginx. Devi scaricare il repository ufficiale di Nginx per installare l’ultima versione.

Importa la chiave di firma di Nginx.

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

Aggiungi il repository per la versione principale di Nginx.

$ 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

Aggiorna i repository di sistema.

$ sudo apt update

Installa Nginx.

$ sudo apt install nginx

Verifica l’installazione. Sui sistemi Debian, il seguente comando funzionerà solo con sudo.

$ sudo nginx -v
nginx version: nginx/1.25.5

Avvia il server Nginx.

$ sudo systemctl start nginx

Controlla lo stato del servizio.

$ 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.

Passo 8 - Installare SSL

Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot utilizzando il repository di Debian o scaricare l’ultima versione utilizzando lo strumento Snapd. Useremo la versione Snapd.

Debian 12 non viene fornito con Snapd installato. Installa il pacchetto Snapd.

$ sudo apt install -y snapd

Esegui i seguenti comandi per assicurarti che la tua versione di Snapd sia aggiornata.

$ sudo snap install core && sudo snap refresh core

Installa Certbot.

$ sudo snap install --classic certbot

Usa il seguente comando per assicurarti che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.

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

Verifica se Certbot funziona correttamente.

$ certbot --version
certbot 2.10.0

Esegui il seguente comando per generare un certificato SSL.

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

Il comando sopra scaricherà un certificato nella directory /etc/letsencrypt/live/meilisearch.example.com sul tuo server.

Genera un certificato Diffie-Hellman group.

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

Controlla l’elenco dei timer di systemd. Certbot installa e avvia automaticamente un timer per il rinnovo.

$ sudo systemctl list-timers

Troverai snap.certbot.renew.service come uno dei servizi programmati per l’esecuzione.

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

Fai un dry run del processo per controllare se il rinnovo SSL funziona correttamente.

$ sudo certbot renew --dry-run

Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.

Passo 9 - Configurare Nginx

Apri il file /etc/nginx/nginx.conf per la modifica.

$ sudo nano /etc/nginx/nginx.conf

Aggiungi la seguente riga prima della riga include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size 64;

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Crea e apri il file /etc/nginx/conf.d/meilisearch.conf per la modifica.

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

Incolla il seguente codice in esso. Sostituisci meilisearch.example.com con il tuo nome di dominio.

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;
}

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Verifica la tua configurazione Nginx.

$ sudo nginx -t

Riavvia il server Nginx.

$ sudo systemctl restart nginx

Meilisearch è ora in esecuzione e disponibile tramite l’URL https://meilisearch.example.com. Dovresti vedere il seguente testo quando apri l’URL.

{"status":"Meilisearch is running"}

Questo URL può essere utilizzato solo per la ricerca tramite la riga di comando. Se desideri accedere a Meilisearch tramite un frontend, dovrai integrarlo con un altro CMS o software per farlo funzionare, il cui scopo è al di fuori di questo tutorial. Meilisearch viene fornito con un’interfaccia frontend integrata, ma funziona solo se lo stai utilizzando per scopi di sviluppo. Puoi cambiare l’ambiente dell’istanza in development nel file di configurazione e riavviare Meilisearch per attivare l’interfaccia. Dovrebbe apparire simile al seguente.

Dashboard di ricerca in sviluppo di Meilisearch

Per un ambiente di produzione, dovrai integrare Meilisearch con un altro CMS.

Iniziamo a usarlo per indicizzare alcuni documenti e utilizzarlo per la ricerca.

Passo 10 - Caricamento di dati di esempio in Meilisearch

Il progetto Meilisearch fornisce un file di film in formato JSON di esempio con i dati estratti da The Movie Database (TMDB). Scarica il file.

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

Puoi eseguire il comando tail per vedere una parte dei dati. Dovrebbe apparire simile al seguente.

$ tail -n 3 movies.json

{"id":460070,"title":"J.T. LeRoy","overview":"Una giovane donna di nome Savannah Knoop trascorre sei anni fingendo di essere uno scrittore transgender di nome JT Leroy, la persona letteraria inventata di sua cognata.","genres":["Drama"],"poster":"https://image.tmdb.org/t/p/w500/43ffZhMCWQhzMneGP4kDWoPV48X.jpg","release_date":1556236800},
{"id":460071,"title":"Lizzie","overview":"Massachusetts, 1892. Una donna non sposata di 32 anni e un emarginato sociale, Lizzie vive una vita claustrofobica sotto il freddo e dominante controllo di suo padre. Quando Bridget Sullivan, una giovane cameriera, viene a lavorare per la famiglia, Lizzie trova uno spirito affine e gentile, e una segreta intimità sboccia presto in un piano malvagio.","genres":["Crime","Drama","Thriller"],"poster":"https://image.tmdb.org/t/p/w500/z2iuBcwznen3kC9z4LeOzBSz1BB.jpg","release_date":1536883200}
]

Come puoi vedere, ogni singolo elemento contiene un id, un titolo, un link all’immagine del poster, una panoramica del film, una data di rilascio e un elenco di generi. La data di rilascio è nel formato EPOCH.

Carichiamo i dati in Meilisearch utilizzando curl tramite una richiesta HTTP POST.

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

Esaminiamo gli argomenti del comando:

  • -X POST - specifica che stiamo eseguendo una richiesta HTTP POST e inviando dati.
  • -H Content-Type - specifica il tipo di contenuto del file.
  • -H Authorization: Bearer - serve a passare la chiave master con le tue richieste.
  • –data-binary - specifica il file da includere.

Qui stiamo creando un nuovo indice Meilisearch nella posizione /indexes/movies/documents. Dovresti ricevere un output simile che ti dice che la richiesta è stata messa in coda. Meilisearch elabora tutte le richieste in modo asincrono.

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

Puoi anche eseguire il comando sopra sostituendo l’URL http://localhost:7700 con https://meilisearch.example.com e funzionerà allo stesso modo. Puoi farlo per tutti i comandi in questo tutorial, ma per semplicità rimarremo all’URL http://localhost:7700.

Esegui il seguente comando per controllare lo stato della richiesta.

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

Dovresti ricevere un output simile.

{"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"}

Questo ci dice che il compito è stato completato e il database dei film è ora completamente indicizzato e pronto per l’uso.

Passo 11 - Utilizzare chiavi limitate per la ricerca

C’è uno strumento di cui abbiamo bisogno che aiuta con la formattazione JSON leggibile da riga di comando. Si chiama jq. Esegui il seguente comando per installarlo.

$ sudo apt install -y jq

Anche se abbiamo aggiunto la chiave master al file di configurazione, dovrai passarla di nuovo con ogni richiesta. Prima di procedere, abbiamo bisogno di una chiave più ristretta che abiliti la modalità di sola lettura. Meiliserch crea una chiave di sola lettura predefinita per impostazione predefinita. Prendiamola.

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

Dovresti vedere un output simile.

{
  "results": [
    {
      "name": "Default Search API Key",
      "description": "Usala per cercare dal 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": "Usala per qualsiasi cosa che non sia un'operazione di ricerca. Attenzione! Non esporlo su un frontend pubblico",
      "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
}

D’ora in poi, utilizzeremo la Default Search API key per eseguire ricerche.

Passo 12 - Ricerca nei dati di esempio

Ci sono due modi per cercare utilizzando Meilisearch, puoi utilizzare l’API tramite la riga di comando o utilizzare l’interfaccia web. L’interfaccia web è piuttosto limitata e funziona solo se utilizzi Meilisearch in un ambiente di sviluppo, e l’API è il modo raccomandato per utilizzare Meilisearch. Poiché abbiamo configurato la nostra ricerca per la produzione, utilizzeremo solo il metodo della riga di comando.

Cercare tramite l’API è come caricare dati tramite richiesta HTTP POST. Fai una richiesta all’endpoint /search dell’API. Ad esempio, cerchiamo eventuali film con la parola saint in esso.

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

Dovresti ricevere un output formattato in JSON simile al seguente.

{
  "hits": [
    {
      "id": 25248,
      "title": "Saint Ralph",
      "overview": "Questa commedia/dramma canadese, ambientata a Hamilton, Ontario nel 1954, è una dolce e - a volte - goffa storia che diventa sempre più toccante man mano che i minuti passano. È la storia fittizia di un ragazzo di 9 anni, Ralph (Adam Butcher), che vive segretamente da solo mentre sua madre vedova e ospedalizzata rimane immersa in un coma. Spesso nei guai con Padre Fitzpatrick (Gordon Pinsent), il preside della sua scuola cattolica maschile, Ralph è considerato una sorta di barzelletta tra i coetanei fino a quando non decide di compiere un miracolo che potrebbe salvare sua madre, ovvero vincere la Maratona di Boston. Allenato da un giovane prete e ex corridore, Padre Hibbert (Campbell Scott), il cui cinismo è stato sollevato dalla pura speranza del ragazzo, Ralph si applica alla sua improbabile missione, respingendo i detrattori e ricevendo aiuto lungo un percorso molto impegnativo da vari alleati e amici.",
      "genres": [
        "Comedy",
        "Drama"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/3MdWgqUunIBWnc7mYi2dtZrD54Y.jpg",
      "release_date": 1123200000
    },
    {
      "id": 26894,
      "title": "Saint Sinner",
      "overview": "Nel 1815 un monaco, Tomas Alcala, inavvertitamente scatenò due succubi femminili, Munkar e Nakir, su un 21° secolo ignaro. È scelto da Dio per viaggiare attraverso i secoli e fermare la furia dei demoni.",
      "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": "Un ex giocatore d'azzardo viene attirato di nuovo nel gioco da un investigatore di frodi assicurative veterano.",
      "genres": [
        "Comedy"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/kN4Vur1SccouDR0k3tmJXJHdrXw.jpg",
      "release_date": 1264723200
    },
  ...

Per testare la funzionalità di fuzzy matching di Meilisearch in cui parole simili possono essere utilizzate per trovare la ricerca esatta. Questo è utile nel caso tu faccia un errore di battitura e ti aspetti comunque il risultato corretto.

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

Qui, abbiamo scritto male saint come seint e Meilisearch restituirà comunque voci con la parola saint.

{
  "hits": [
    {
      "id": 10105,
      "title": "Saints and Soldiers",
      "overview": "Cinque soldati americani che combattono in Europa durante la Seconda Guerra Mondiale lottano per tornare nel territorio alleato dopo essere stati separati dalle forze statunitensi durante il storico Massacro di Malmedy.",
      "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": "Questa commedia/dramma canadese, ambientata a Hamilton, Ontario nel 1954, è una dolce e - a volte - goffa storia che diventa sempre più toccante man mano che i minuti passano. È la storia fittizia di un ragazzo di 9 anni, Ralph (Adam Butcher), che vive segretamente da solo mentre sua madre vedova e ospedalizzata rimane immersa in un coma. Spesso nei guai con Padre Fitzpatrick (Gordon Pinsent), il preside della sua scuola cattolica maschile, Ralph è considerato una sorta di barzelletta tra i coetanei fino a quando non decide di compiere un miracolo che potrebbe salvare sua madre, ovvero vincere la Maratona di Boston. Allenato da un giovane prete e ex corridore, Padre Hibbert (Campbell Scott), il cui cinismo è stato sollevato dalla pura speranza del ragazzo, Ralph si applica alla sua improbabile missione, respingendo i detrattori e ricevendo aiuto lungo un percorso molto impegnativo da vari alleati e amici.",
      "genres": [
        "Comedy",
        "Drama"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/3MdWgqUunIBWnc7mYi2dtZrD54Y.jpg",
      "release_date": 1123200000
    },
    {
      "id": 26894,
      "title": "Saint Sinner",
      "overview": "Nel 1815 un monaco, Tomas Alcala, inavvertitamente scatenò due succubi femminili, Munkar e Nakir, su un 21° secolo ignaro. È scelto da Dio per viaggiare attraverso i secoli e fermare la furia dei demoni.",
      "genres": [
        "Fantasy",
        "Horror",
        "Science Fiction",
        "TV Movie"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/cxljKsfUI6PVFPIgPvsesUWHai4.jpg",
      "release_date": 1035590400
    },
 …

Passo 13 - Ottimizzazione del ranking della ricerca e filtraggio dei dati

I motori di ricerca possono restituire risultati migliori se sanno come classificare o dare importanza a determinati risultati in base all’importanza di un particolare campo. Meilisearch ha un insieme predefinito di regole di bias che puoi configurare per migliorare i tuoi risultati di ricerca.

Ma prima, dobbiamo controllare le regole di ranking impostate da Meilisearch.

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

Riceverai il seguente output.

["words","typo","proximity","attribute","sort","exactness"]
  1. words - i risultati sono ordinati in base al numero decrescente di termini corrispondenti.
  2. typo - i risultati sono ordinati in base al numero crescente di errori di battitura. Meno query di errore di battitura vengono restituite in cima.
  3. proximity - i risultati sono ordinati in base alla distanza crescente tra i termini corrispondenti.
  4. attribute - i risultati sono ordinati in base all’ordine di ranking degli attributi.
  5. sort - i risultati sono ordinati in base ai parametri decisi al momento della query.
  6. exactness - i risultati sono ordinati in base alla somiglianza delle parole corrispondenti con le parole della query.

Puoi leggere di più sulla rilevanza nella documentazione ufficiale di Meilisearch.

Esegui il seguente comando per cambiare l’ordine delle regole di bias.

$ 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"
  ]'

Ora filtriamo i risultati della ricerca. Prima, chiediamo a Meilisearch di utilizzare solo determinati attributi per eseguire la ricerca e lasciare da parte gli attributi privi di significato come id.

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

Qui, stiamo eseguendo una ricerca utilizzando solo gli attributi title, overview e genres che daranno risultati migliori.

Successivamente, possiamo formattare i nostri risultati di ricerca per visualizzare solo determinati attributi mentre nascondiamo gli altri.

$ 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"
      ]'

Questo mostrerà solo gli attributi che abbiamo incluso nella nostra query con i risultati.

Infine, puoi anche fornire un elenco di attributi da filtrare o ordinare. Questo include sia il filtraggio quantitativo utilizzando operatori matematici come < o > e il filtraggio attraverso l’inclusione in un insieme specificato. Questo è anche chiamato ricerca facettata.

$ 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"
      ]
  }'

Possiamo combinare tutte queste regole per eseguire una query come la seguente.

$ 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

Qui stiamo cercando tutti i film nel genere Horror dal più recente al più vecchio contenente la parola house nel titolo. Dovresti ricevere un output simile.

{
  "hits": [
    {
      "id": 440559,
      "title": "Housesitters",
      "overview": "Angie e Izzy ottengono un lavoro di housesitting che sembra troppo bello per essere vero. 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 è incentrato su Holly la cui madre ha ucciso sua sorella e suo padre quando aveva sette anni. 20 anni dopo e lentamente perdendo la presa sulla differenza tra realtà e incubi, incontra un sensitivo famoso che afferma di essere destinato ad aiutarla.",
      "genres": [
        "Horror"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/ohHxS7PIRQb9O6KTrDtqYshYGts.jpg",
      "release_date": 1504828800
    },
    {
      "id": 392703,
      "title": "House of Darkness",
      "overview": "Ispirato a eventi veri, il thriller soprannaturale 'House of Darkness' racconta il misterioso caso di una famiglia di San Francisco che ha affermato che una forza oscura era responsabile degli eventi tragici che si sono svolti. Cercando di salvare il loro matrimonio in difficoltà Kelly (Sara Fletcher, 'Adulthood'), suo marito Brian (Gunner Wright, 'J. Edgar') e la loro figlia Sarah (Mykayla Sohn, 'The Chosen') si trasferiscono in una fattoria rurale in cerca di serenità. Senza saperlo, quasi ogni famiglia che ha vissuto nella casa ha subito qualche forma di tragedia, risalente a quasi 100 anni. Poco dopo il loro arrivo, Kelly inizia a percepire che il comportamento di suo marito sta diventando sempre più strano e violento. Kelly scopre anche che le voci che sente echeggiare nei corridoi non provengono da sua figlia. Saranno Kelly e la sua famiglia le prossime vittime delle forze oscure nella casa?",
      "genres": [
        "Horror",
        "Thriller",
        "TV Movie"
      ],
      "poster": "https://image.tmdb.org/t/p/w500/ueQM9RsT0HLL2RuuiLmD07j8lKB.jpg",
      "release_date": 1460851200
    },
…

Passo 14 - Conclusione

Hai finito di installare e configurare Meilisearch in un ambiente di produzione su un server Debian 12. Hai anche eseguito alcune ricerche di base e imparato come migliorare i risultati di ricerca attraverso il ranking e il filtraggio. Se hai domande, postale nei commenti qui sotto.

Share: X/Twitter LinkedIn
#Meilisearch

Ricevi i nuovi post nella tua casella di posta.

Nessuno spam. Disiscriviti in qualsiasi momento.