Como instalar e configurar o Meilisearch no Debian 12
Nesta página
- Pré-requisitos
- Passo 1 - Configurar Firewall
- Passo 2 - Instale o Meilisearch
- Passo 3 - Crie um usuário de sistema para Meilisearch
- Passo 4 - Configurar Meilisearch
- Passo 5 – Crie diretórios e conceda permissões
- Passo 6 – Execute o Meilisearch como um serviço
- Etapa 7 - Instale o Nginx
- Passo 8 – Instalar SSL
- Etapa 9 – Configurar o Nginx
- Passo 10 - Carregando dados de amostra no Meilisearch
- Passo 11 - Use chaves limitadas para pesquisa
- Passo 12 - Pesquisando Dados de Amostra
- Etapa 13 - Ajustando a classificação de pesquisa e filtragem de dados
- Passo 14 – Conclusão
Meilisearch é um mecanismo de busca de código aberto escrito na linguagem Rust. Ser escrito usando Rust requer menos recursos para ser executado e pode ser executado usando um único binário de linha de comando. O processo de instalação é mais simples que os motores de busca alternativos e requer menos etapas. Seus recursos incluem correspondência difusa e indexação sem esquema. Ele vem com uma interface web para fins de demonstração. Ele pode ser integrado a diversas aplicações web por meio de diversas bibliotecas disponíveis em diversas linguagens como JavaScript, Python, PHP, Ruby, etc.
Neste tutorial, você aprenderá como instalar o Meilisearch em produção em um servidor Debian 12 e utilizá-lo para realizar diversas pesquisas simples.
Pré-requisitos
Um servidor rodando Debian 12 com no mínimo 2 GB de RAM.
Um usuário não root com privilégios sudo.
O Firewall descomplicado (UFW) está habilitado e em execução.
Um nome de domínio totalmente qualificado (FQDN) como meilisearch.example.com apontando para o seu servidor. Isso é benéfico se você deseja servir Meilisearch via SSL usando um servidor proxy.
Tudo está atualizado.
$ sudo apt update && sudo apt upgrade
Alguns pacotes essenciais são necessários para o tutorial. Alguns deles já podem estar instalados em seu servidor.
$ 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 - Configurar Firewall
A primeira etapa antes de instalar qualquer pacote é configurar o firewall para permitir conexões HTTP e HTTPS.
Verifique o status do firewall.
$ sudo ufw status
Você deverá ver algo como o seguinte.
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
Permitir portas HTTP e HTTPs.
$ sudo ufw allow http
$ sudo ufw allow https
Verifique o status novamente para confirmar.
$ 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 - Instale o Meilisearch
Existem várias maneiras de instalar o Meilisearch. Usaremos o método mais simples que envolve copiar o arquivo binário para nosso servidor.
Instale o Meilisearch.
$ curl -L https://install.meilisearch.com | sh
Torne o binário executável.
$ chmod +x meilisearch
No momento, o binário só pode ser usado no diretório onde você o baixou. Para poder usá-lo de qualquer lugar, mova o arquivo binário para o diretório /usr/local/bin.
$ sudo mv ./meilisearch /usr/local/bin/
Confirme se o Meilisearch está instalado e funcionando corretamente.
$ meilisearch --version
meilisearch 1.7.6
Passo 3 - Crie um usuário de sistema para Meilisearch
Executar o Meilisearch como root pode criar problemas de segurança. Para evitá-los, crie um usuário de sistema para executar o Meilisearch.
$ sudo useradd -d /var/lib/meilisearch -b /bin/false -m -r meilisearch
Passo 4 - Configurar Meilisearch
Antes de prosseguir, precisamos criar uma chave mestra que o Meilisearch usa para o processo de autenticação. Você pode usar o utilitário de linha de comando OpenSSL para criá-lo. Execute o seguinte comando para criar uma chave mestra de 30 caracteres. Você pode escolher qualquer comprimento para sua chave mestra. Quanto mais tempo, melhor.
$ openssl rand -hex 30
Você deve receber uma saída semelhante com uma chave de 30 caracteres. Copie este valor porque precisaremos dele nas próximas etapas.
65ed5fc15848f7ceb8e646d4928fcf79f494cec239a2874cacd118e42611
Pegue o arquivo de configuração mais recente do repositório Meilisearch GitHub e copie-o para o diretório /etc.
$ sudo sh -c 'curl https://raw.githubusercontent.com/meilisearch/meilisearch/latest/config.toml > /etc/meilisearch.toml'
Abra-o para edição.
$ sudo nano /etc/meilisearch.toml
Atualize as linhas a seguir no arquivo para configurar o caminho do banco de dados, o caminho de despejo, o diretório de snapshots e o ambiente de trabalho e adicione a chave mestra que você gerou antes para autenticação.
Os valores atualizados no arquivo de configuração devem ser semelhantes aos seguintes.
env = "production"
master_key = "173e95f077590ed33dad89247247be8d8ce8b6722ccc87829aaefe3207be"
db_path = "/var/lib/meilisearch/data"
dump_dir = "/var/lib/meilisearch/dumps"
snapshot_dir = "/var/lib/meilisearch/snapshots"
Meilisearch coleta dados regulares de forma anônima. Você deve desativá-lo usando a seguinte opção. Remova o comentário para desativar a telemetria do Meilisearch.
no_analytics = true
Por padrão, o Meilisearch não usa mais do que dois terços da RAM disponível no seu sistema. Você pode controlar isso removendo o comentário e definindo a seguinte variável. Você também pode especificar o valor como o número exato de bytes para ser preciso e exato.
max_indexing_memory = "1 GiB"
Meilisearch não usa mais da metade dos núcleos de CPU disponíveis. Você pode, no entanto, controlar esse valor removendo o comentário e definindo a seguinte variável.
max_indexing_threads = 1
Definir este valor acima do número de núcleos de CPU da máquina instruirá o Meilisearch a usar o número máximo de núcleos disponíveis.
Mais uma configuração que você deve saber é a quantidade de carga útil máxima que o Meilisearch pode suportar. O valor padrão é definido em 100 MB. Você pode alterá-lo configurando a seguinte variável.
http_payload_size_limit = "100 MB"
Quando terminar, salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.
Passo 5 – Crie diretórios e conceda permissões
Crie os diretórios onde o Meilisearch armazenará seu banco de dados, dumps de banco de dados e instantâneos.
$ sudo mkdir /var/lib/meilisearch/dumps -p
$ sudo mkdir /var/lib/meilisearch/snapshots
Defina o proprietário e o grupo nesses diretórios para o usuário do sistema que criamos para o Meilisearch.
$ sudo chown -R meilisearch:meilisearch /var/lib/meilisearch
Defina o proprietário e o grupo no arquivo binário Meilisearch.
$ sudo chown meilisearch:meilisearch /usr/local/bin/meilisearch
Defina as permissões adequadas no diretório.
$ sudo chmod 750 /var/lib/meilisearch
Passo 6 – Execute o Meilisearch como um serviço
Para que o Meilisearch esteja sempre disponível para solicitações de pesquisa, é melhor executá-lo como um serviço do sistema. Para isso, precisamos criar um arquivo de serviço para ele.
Crie e abra /etc/systemd/system/meilisearch.service para edição.
$ sudo nano /etc/systemd/system/meilisearch.service
Cole o seguinte código nele.
[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
Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.
Habilite o serviço.
$ sudo systemctl enable meilisearch
Inicie o serviço Meilisearch.
$ sudo systemctl start meilisearch
Verifique o status do serviço
$ sudo systemctl status meilisearch
Você deve receber uma saída semelhante.
? 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 está instalado e funcionando. Vamos expor o serviço para o exterior usando o servidor Nginx como proxy reverso e usar o Let's Encrypt para servi-lo por SSL.
Etapa 7 - Instale o Nginx
O Debian 12 vem com uma versão mais antiga do Nginx. Você precisa baixar o repositório oficial do Nginx para instalar a versão mais recente.
Importe a chave de assinatura do Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Adicione o repositório para a versão principal do 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
Atualize os repositórios do sistema.
$ sudo apt update
Instale o Nginx.
$ sudo apt install nginx
Verifique a instalação. Em sistemas Debian, o comando a seguir funcionará apenas com sudo.
$ sudo nginx -v
nginx version: nginx/1.25.5
Inicie o servidor Nginx.
$ sudo systemctl start nginx
Verifique o status do serviço.
$ 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 – Instalar SSL
Precisamos instalar o Certbot para gerar o certificado SSL. Você pode instalar o Certbot usando o repositório Debian ou obter a versão mais recente usando a ferramenta Snapd. Estaremos usando a versão Snapd.
O Debian 12 não vem com o Snapd instalado. Instale o pacote Snapd.
$ sudo apt install -y snapd
Execute os seguintes comandos para garantir que sua versão do Snapd esteja atualizada.
$ sudo snap install core && sudo snap refresh core
Instale o Certbot.
$ sudo snap install --classic certbot
Use o comando a seguir para garantir que o comando Certbot possa ser executado criando um link simbólico para o diretório /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Verifique se o Certbot está funcionando corretamente.
$ certbot --version
certbot 2.10.0
Execute o seguinte comando para gerar um certificado SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email -d meilisearch.example.com
O comando acima fará download de um certificado para o diretório /etc/letsencrypt/live/meilisearch.example.com em seu servidor.
Gere um certificado do grupo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Verifique a lista de temporizadores do systemd. O Certbot instala e inicia automaticamente um cronômetro para fins de renovação.
$ sudo systemctl list-timers
Você encontrará snap.certbot.renew.service como um dos serviços programados para execução.
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
Faça uma simulação do processo para verificar se a renovação do SSL está funcionando bem.
$ sudo certbot renew --dry-run
Se você não encontrar erros, está tudo pronto. Seu certificado será renovado automaticamente.
Etapa 9 – Configurar o Nginx
Abra o arquivo /etc/nginx/nginx.conf para edição.
$ sudo nano /etc/nginx/nginx.conf
Adicione a seguinte linha antes da linha include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.
Crie e abra o arquivo /etc/nginx/conf.d/meilisearch.conf para edição.
$ sudo nano /etc/nginx/conf.d/meilisearch.conf
Cole o seguinte código nele. Substitua meilisearch.example.com pelo seu nome de domínio.
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;
}
Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.
Verifique sua configuração do Nginx.
$ sudo nginx -t
Reinicie o servidor Nginx.
$ sudo systemctl restart nginx
Meilisearch agora está em execução e disponível através do URL https://meilisearch.example.com. Você deverá ver o seguinte texto ao abrir o URL.
{"status":"Meilisearch is running"}
Este URL só pode ser usado para pesquisa por meio da linha de comando. Se quiser acessar o Meilisearch através de um frontend, você precisará integrá-lo a outro CMS ou software para fazê-lo funcionar, cujo escopo está fora deste tutorial. O Meilisearch vem com uma interface frontend integrada, mas funciona apenas se você a estiver usando para fins de desenvolvimento. Você pode alterar o ambiente da instância para development no arquivo de configuração e reiniciar o Meilisearch para ativar a interface. Deve ser algo parecido com o seguinte.
Para um ambiente de produção, você precisará integrar o Meilisearch com outro CMS.
Vamos começar a usá-lo para indexar alguns documentos e para pesquisas.
Passo 10 - Carregando dados de amostra no Meilisearch
O projeto Meilisearch fornece um exemplo de arquivo de filme formatado em JSON com os dados retirados do The Movie Database (TMDB). Baixe o arquivo.
$ wget https://www.meilisearch.com/movies.json
Você pode executar o comando tail para ver uma parte dos dados. Deve ser semelhante ao seguinte.
$ 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}
]
Como você pode ver, cada entrada individual contém um ID, um título, um link para a imagem do pôster, uma visão geral do filme, uma data de lançamento e uma lista de gêneros. A data de lançamento está no formato EPOCH.
Vamos carregar os dados no Meilisearch usando curl por meio de uma solicitação HTTP POST.
$ curl \
-X POST 'http://localhost:7700/indexes/movies/documents' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer 65ed5fc15848f7ceb8e646d4928fcf79f494cec239a2874cacd118e42611' \
--data-binary @movies.json
Vamos examinar os argumentos do comando:
- -X POST
- especifica que estamos executando uma solicitação HTTP POST e enviando dados. - -H Content-Type - especifica o tipo de conteúdo do arquivo.
- -H Autorização: Portador - é passar a chave mestra com suas solicitações.
- --data-binary - especifica o arquivo a ser incluído.
Aqui estamos criando um novo índice Meilisearch no local /indexes/movies/documents. Você deverá receber uma saída semelhante informando que a solicitação foi enfileirada. Meilisearch processa todas as solicitações de forma assíncrona.
{"taskUid":0,"indexUid":"movies","status":"enqueued","type":"documentAdditionOrUpdate","enqueuedAt":"2024-05-03T03:12:55.599798591Z"}
Você também pode executar o comando acima substituindo o URL http://localhost:7700 por https://meilisearch.example.com e funcionará da mesma maneira. Você pode fazer isso para todos os comandos deste tutorial, mas para simplificar, usaremos a URL http://localhost:7700.
Execute o seguinte comando para verificar o status da solicitação.
$ curl -X GET 'http://localhost:7700/indexes/movies/tasks/0'
Você deve receber uma saída semelhante.
{"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"}
Isso nos diz que a tarefa foi concluída e o banco de dados de filmes está totalmente indexado e pronto para uso.
Passo 11 – Use chaves limitadas para pesquisa
Precisamos de uma ferramenta que ajuda com a formatação JSON de linha de comando legível. É chamado jq. Execute o seguinte comando para instalá-lo.
$ sudo apt install -y jq
Embora tenhamos adicionado a chave mestra ao arquivo de configuração, você precisará passá-la novamente a cada solicitação. Antes de prosseguir, precisamos de uma chave mais restrita que habilite o modo somente leitura. Meiliserch cria uma chave somente leitura padrão. Vamos agarrá-lo.
$ curl -X GET 'http://localhost:7700/keys' -H 'Authorization: Bearer 65ed5fc15848f7ceb8e646d4928fcf79f494cec239a2874cacd118e42611' | jq
Você deverá ver uma saída semelhante.
{
"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
}
De agora em diante, usaremos a chave da API de pesquisa padrão para realizar pesquisas.
Passo 12 - Pesquisando Dados de Amostra
Existem duas maneiras de pesquisar usando o Meilisearch: você pode usar a API por meio da linha de comando ou usar a interface web. A interface web é bastante limitada e só funciona se você usar o Meilisearch em um ambiente de desenvolvimento, e a API é a forma recomendada de usar o Meilisearch. Como configuramos nossa busca para produção, usaremos apenas o método de linha de comando.
Pesquisar por meio da API é como fazer upload de dados por meio de solicitação HTTP POST. Você faz uma solicitação ao endpoint /search da API. Por exemplo, vamos procurar qualquer filme que contenha a palavra santo.
$ curl \
-X POST 'http://localhost:7700/indexes/movies/search' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer 591e51d2f6700ead7ba134a7aed0966d72e2022e43847caf48df3e4800c9279a' \
--data-binary '{ "q": "saint" }' | jq
Você deverá receber uma saída formatada em JSON como a seguir.
{
"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
},
...
Para testar o recurso de correspondência difusa do Meilisearch, no qual palavras com sons semelhantes podem ser usadas para encontrar a pesquisa exata. Isso é útil caso você cometa um erro de digitação e ainda espere o resultado correto.
$ curl \
-X POST 'http://localhost:7700/indexes/movies/search' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer 591e51d2f6700ead7ba134a7aed0966d72e2022e43847caf48df3e4800c9279a' \
--data-binary '{ "q": "seint" }' | jq
Aqui, escrevemos saint incorretamente como seint e o Meilisearch ainda retornará entradas com a palavra saint.
{
"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
},
…
Etapa 13 - Ajustando a classificação de pesquisa e filtragem de dados
Os motores de busca podem retornar melhores resultados se souberem classificar ou dar importância a determinados resultados com base na importância de um determinado campo. Meilisearch possui um conjunto padrão de regras de preconceito que você pode configurar para melhorar seus resultados de pesquisa.
Mas primeiro precisamos verificar as regras de classificação definidas pela Meilisearch.
$ curl -X GET 'http://localhost:7700/indexes/movies/settings/ranking-rules' -H 'Authorization: Bearer 0f3cdcfe5d9a56273d6c708f068a82382a97b629b70f4962f969687b5e327196'
Você obterá a seguinte saída.
["words","typo","proximity","attribute","sort","exactness"]
- palavras - os resultados são classificados diminuindo o número de termos correspondentes.
- erro de digitação - os resultados são classificados aumentando o número de erros de digitação. Menos consultas de erro de digitação são retornadas na parte superior.
- proximidade - os resultados são classificados aumentando a distância entre os termos correspondentes.
- atributo - os resultados são classificados por ordem de classificação de atributos.
- sort - os resultados são classificados de acordo com os parâmetros decididos no momento da consulta.
- exatidão - os resultados são classificados pela semelhança das palavras correspondentes com as palavras da consulta.
Você pode ler mais sobre relevância na documentação oficial do Meilisearch.
Emita o comando a seguir para alterar a ordem das regras de polarização.
$ 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"
]'
Agora vamos filtrar os resultados da pesquisa. Primeiro, vamos pedir ao Meilisearch para usar apenas determinados atributos para realizar a pesquisa e deixar de lado os atributos sem sentido como 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"
]
}'
Aqui estamos realizando uma busca apenas utilizando os atributos title, overview e genres que darão melhores resultados.
A seguir, podemos formatar nossos resultados de pesquisa para exibir apenas determinados atributos e ocultar outros.
$ 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"
]'
Isso mostrará apenas os atributos que incluímos em nossa consulta com os resultados.
Finalmente, você também pode fornecer uma lista de atributos a serem filtrados ou classificados. Isso inclui filtragem quantitativa usando operadores matemáticos como < ou > e filtragem por inclusão em um conjunto especificado. Isso também é chamado de pesquisa facetada.
$ 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"
]
}'
Podemos combinar todas essas regras para realizar uma consulta como a seguinte.
$ 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
Aqui procuramos todos os filmes do gênero Terror, do mais novo ao mais antigo, contendo a palavra casa no título. Você deve receber uma saída semelhante.
{
"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
},
…
Passo 14 – Conclusão
Você concluiu a instalação e configuração do Meilisearch em um ambiente de produção em um servidor Debian 12. Você também realizou algumas pesquisas básicas e aprendeu como melhorar os resultados da pesquisa por meio de classificação e filtragem. Se você tiver alguma dúvida, poste-a nos comentários abaixo.