Tutoriais de VPS
Elasticsearch 9 e Kibana: TLS privado, snapshots e recuperação
Implante Elasticsearch e Kibana 9.5.6 com Compose e Caddy. Proteja API e chaves CA, limite acesso, controle heap e shards e teste snapshots externos com recuperação isolada.

Quando buscas no site, logs ou filtros de produtos ultrapassam consultas LIKE, Elasticsearch oferece índices invertidos, analisadores, relevância, agregações, consultas geográficas e vetores. Kibana fornece exploração, visualização e administração.
O guia usa Ubuntu 24.04, Compose e Caddy, com TLS autenticado no Elasticsearch e 9200/5601 apenas no loopback. O exemplo de 16 de setembro de 2026 usava Elasticsearch e Kibana 9.5.3. A versão e documentação oficial consultadas em 16 de novembro usam 9.5.6. Para instalação nova, selecione esse patch antes de baixar e mantenha os componentes na mesma versão.
Mantenha os dados de negócio autoritativos no PostgreSQL/MySQL ou outro banco principal. Indexe o necessário por aplicativos, Logstash, Beats ou CDC.
- Busca completa de sites, documentos, produtos e conhecimento.
- Consulta centralizada de logs, agregações e investigação.
- Autocompletar, correspondência aproximada, sinônimos e relevância.
- Análise temporal de métricas, eventos e segurança.
- Busca híbrida de palavras e vetores com filtros.
Para logs com poucos recursos, Grafana Loki pode ser mais leve. Para agentes e regras SIEM, veja Wazuh. A amplitude do Elasticsearch exige mais memória, armazenamento e manutenção.
| Arquitetura | Vantagem | Limitação | Uso |
|---|---|---|---|
| Um nó | Menor custo e diagnóstico simples | Falha de host/disco interrompe; sem redundância | Desenvolvimento, ferramentas e índices reconstruíveis |
| Três nós na mesma VPS | Testa configuração | Mesmo domínio de falha e disputa por RAM | Laboratório |
| Três nós de dados independentes | Réplicas podem tolerar um nó indisponível | Planejar capacidade, certificados e atualização | Busca, logs e segurança críticos |
Aqui é usado discovery.type=single-node. Configure réplicas 0 para evitar réplicas sem destino; isso não cria outra cópia. Serviços críticos precisam de domínios independentes, votação master-eligible bem planejada, réplicas e snapshots externos testados.
Planeje campos, analisadores, agregações, pico de gravação, concorrência, retenção e réplicas.
| Carga | VPS sugerida | Heap inicial | Premissa |
|---|---|---|---|
| Desenvolvimento | 4 vCPU, 8GB RAM, SSD de 80GB | 2GB | Baixa concorrência, índices reconstruíveis |
| Busca pequena em produção | 8 vCPU, 16GB RAM, pelo menos 200GB NVMe | 4–6GB | Folga para Kibana e cache |
| Cluster crítico/logs | Pelo menos 3 hosts, 8 vCPU/16–32GB cada, NVMe independente | Medido | Réplicas, ILM e snapshots separados |
Heap não deve superar 50% da memória disponível no contêiner; menor heap pode beneficiar o cache. Ter 16GB não justifica -Xmx de 12GB: off-heap, Kibana, Docker e Linux também consomem memória.
Estime dados diários × expansão do índice × dias retidos × (1 + réplicas) × margem:
每日原始数据 × 索引膨胀系数 × 保留天数 × (1 + 副本数) × 安全余量
A expansão depende de mapping, _source, analisadores e tipos. Meça dados reais e mantenha disco abaixo de cerca de 70%–75%, sem esperar pelo bloqueio flood-stage.
| Porta | Função | Exposição |
|---|---|---|
443/TCP | Kibana HTTPS | Caddy |
5601/TCP | Kibana HTTP | Apenas 127.0.0.1 |
9200/TCP | API Elasticsearch HTTPS autenticada | Apenas 127.0.0.1 |
9300/TCP | Transport entre nós | Sem publicação |
A API não é uma página administrativa para expor a toda a internet. Use redes privadas ou túneis restritos, TLS e autenticação. Confira Docker, regras do provedor e a lista de exposição de middleware. Caddy pode precisar também de 80 para ACME HTTP e redirecionamento; restrinja SSH.
Instale antes Docker Engine e Compose v2 pelas instruções oficiais Ubuntu:
sudo apt update
sudo apt full-upgrade -y
sudo apt install -y ca-certificates curl openssl caddy jq
docker --version
docker compose version
sudo systemctl enable --now caddy
Avalie pacotes/reinicializações e configure logs, saúde e limites com a lista de Compose para produção.
O requisito Docker atual é vm.max_map_count=1048576:
printf 'vm.max_map_count=1048576\n' | \
sudo tee /etc/sysctl.d/99-elasticsearch.conf >/dev/null
sudo sysctl --system
sysctl vm.max_map_count
Ajuste no host. Investigue swap e falta de memória; bootstrap.memory_lock=true e memlock não substituem RAM.
sudo install -d -m 0750 -o "$USER" -g "$USER" /opt/elastic-stack
cd /opt/elastic-stack
sudo install -d -m 0770 -o 1000 -g 0 snapshots
umask 077
Gere senhas e três chaves estáveis do Kibana:
ELASTIC_PASSWORD="$(openssl rand -hex 32)"
KIBANA_PASSWORD="$(openssl rand -hex 32)"
SECURITY_KEY="$(openssl rand -hex 32)"
SAVED_OBJECTS_KEY="$(openssl rand -hex 32)"
REPORTING_KEY="$(openssl rand -hex 32)"
{
printf 'STACK_VERSION=9.5.3\n'
printf 'CLUSTER_NAME=vps-search\n'
printf 'ELASTIC_PASSWORD=%s\n' "$ELASTIC_PASSWORD"
printf 'KIBANA_PASSWORD=%s\n' "$KIBANA_PASSWORD"
printf 'KIBANA_HOST=search.example.com\n'
printf 'XPACK_SECURITY_KEY=%s\n' "$SECURITY_KEY"
printf 'XPACK_SAVED_OBJECTS_KEY=%s\n' "$SAVED_OBJECTS_KEY"
printf 'XPACK_REPORTING_KEY=%s\n' "$REPORTING_KEY"
} > .env
chmod 600 .env
Troque search.example.com pelo domínio e configure DNS; publique AAAA somente com IPv6 funcionando. Proteja .env. A geração sobrescreve o arquivo e serve para instância nova; não gere novamente segredos existentes.
Selecione o patch revisado antes de iniciar:
cd /opt/elastic-stack
sed -i 's/^STACK_VERSION=.*/STACK_VERSION=9.5.6/' .env
chmod 600 .env
setup gera CA/certificados e configura a senha kibana_system quando Elasticsearch responde. Crie /opt/elastic-stack/compose.yml:
services:
setup:
image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
user: "0"
volumes:
- certs:/usr/share/elasticsearch/config/certs
environment:
ELASTIC_PASSWORD: ${ELASTIC_PASSWORD}
KIBANA_PASSWORD: ${KIBANA_PASSWORD}
command: >
bash -c '
test -n "$${ELASTIC_PASSWORD}" || { echo "ELASTIC_PASSWORD is empty"; exit 1; };
test -n "$${KIBANA_PASSWORD}" || { echo "KIBANA_PASSWORD is empty"; exit 1; };
if [ ! -f config/certs/ca.zip ]; then
bin/elasticsearch-certutil ca --silent --pem -out config/certs/ca.zip;
unzip config/certs/ca.zip -d config/certs;
fi;
if [ ! -f config/certs/certs.zip ]; then
printf "instances:\n - name: es01\n dns:\n - es01\n - localhost\n ip:\n - 127.0.0.1\n" > config/certs/instances.yml;
bin/elasticsearch-certutil cert --silent --pem
-out config/certs/certs.zip
--in config/certs/instances.yml
--ca-cert config/certs/ca/ca.crt
--ca-key config/certs/ca/ca.key;
unzip config/certs/certs.zip -d config/certs;
fi;
chown -R root:root config/certs;
find config/certs -type d -exec chmod 750 {} \;;
find config/certs -type f -exec chmod 640 {} \;;
until curl -s --cacert config/certs/ca/ca.crt https://es01:9200 |
grep -q "missing authentication credentials"; do sleep 10; done;
until curl -s -X POST --cacert config/certs/ca/ca.crt
-u "elastic:$${ELASTIC_PASSWORD}"
-H "Content-Type: application/json"
https://es01:9200/_security/user/kibana_system/_password
-d "{\"password\":\"$${KIBANA_PASSWORD}\"}" |
grep -q "^{}"; do sleep 10; done;
touch config/certs/.setup-complete;
'
healthcheck:
test: ["CMD-SHELL", "test -f config/certs/ca/ca.crt"]
interval: 2s
timeout: 5s
retries: 60
es01:
image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
container_name: es01
restart: unless-stopped
depends_on:
setup:
condition: service_healthy
ports:
- "127.0.0.1:9200:9200"
volumes:
- certs:/usr/share/elasticsearch/config/certs:ro
- esdata:/usr/share/elasticsearch/data
- ./snapshots:/mnt/snapshots
environment:
node.name: es01
cluster.name: ${CLUSTER_NAME}
discovery.type: single-node
ELASTIC_PASSWORD: ${ELASTIC_PASSWORD}
bootstrap.memory_lock: "true"
xpack.security.enabled: "true"
xpack.security.http.ssl.enabled: "true"
xpack.security.http.ssl.key: certs/es01/es01.key
xpack.security.http.ssl.certificate: certs/es01/es01.crt
xpack.security.http.ssl.certificate_authorities: certs/ca/ca.crt
path.repo: /mnt/snapshots
ES_JAVA_OPTS: -Xms2g -Xmx2g
mem_limit: 4g
ulimits:
memlock:
soft: -1
hard: -1
nofile:
soft: 65535
hard: 65535
healthcheck:
test:
- CMD-SHELL
- curl -s --cacert config/certs/ca/ca.crt https://localhost:9200 | grep -q "missing authentication credentials"
interval: 10s
timeout: 10s
retries: 60
start_period: 60s
logging:
driver: json-file
options:
max-size: 10m
max-file: "5"
kibana:
image: docker.elastic.co/kibana/kibana:${STACK_VERSION}
container_name: kibana
restart: unless-stopped
depends_on:
setup:
condition: service_completed_successfully
es01:
condition: service_healthy
ports:
- "127.0.0.1:5601:5601"
volumes:
- certs:/usr/share/kibana/config/certs:ro
- kibanadata:/usr/share/kibana/data
environment:
SERVER_NAME: kibana
SERVER_PUBLICBASEURL: https://${KIBANA_HOST}
ELASTICSEARCH_HOSTS: '["https://es01:9200"]'
ELASTICSEARCH_USERNAME: kibana_system
ELASTICSEARCH_PASSWORD: ${KIBANA_PASSWORD}
ELASTICSEARCH_SSL_CERTIFICATEAUTHORITIES: config/certs/ca/ca.crt
XPACK_SECURITY_ENCRYPTIONKEY: ${XPACK_SECURITY_KEY}
XPACK_ENCRYPTEDSAVEDOBJECTS_ENCRYPTIONKEY: ${XPACK_SAVED_OBJECTS_KEY}
XPACK_REPORTING_ENCRYPTIONKEY: ${XPACK_REPORTING_KEY}
mem_limit: 2g
healthcheck:
test:
- CMD-SHELL
- curl -s -I http://localhost:5601 | grep -q "HTTP/1.1 302"
interval: 10s
timeout: 10s
retries: 60
start_period: 60s
logging:
driver: json-file
options:
max-size: 10m
max-file: "5"
volumes:
certs:
esdata:
kibanadata:
Antes de iniciar, insira esta linha no setup logo após os comandos de permissões. Os contêineres compartilham certificados e não devem ler a chave de assinatura nem seus arquivos:
chmod 600 config/certs/ca/ca.key config/certs/ca.zip config/certs/certs.zip
Guarde material de assinatura criptografado separadamente. Setup como root continua usando-o e os processos sem privilégios leem os certificados 640. Antes de adicionar nós, planeje também TLS transport: essa configuração HTTP de um nó não cobre um cluster completo.
Elasticsearch tem limite de 4GB/heap 2GB e Kibana outros 2GB. Reserve pelo menos 8GB no host e mais folga para outros serviços. Ajuste por medições.
cd /opt/elastic-stack
docker compose config --quiet
docker compose pull
docker compose up -d
docker compose ps
docker compose logs --tail=100 setup es01 kibana
Carregue apenas um .env confiável e confira versão/cluster:
set -a
. /opt/elastic-stack/.env
set +a
docker compose exec es01 curl -s \
--cacert config/certs/ca/ca.crt \
-u "elastic:$ELASTIC_PASSWORD" \
https://localhost:9200 | jq
docker compose exec es01 curl -s \
--cacert config/certs/ca/ca.crt \
-u "elastic:$ELASTIC_PASSWORD" \
'https://localhost:9200/_cluster/health?pretty'
yellow costuma indicar réplica sem destino no nó único. Use number_of_replicas: 0 para esses índices; não desligue alarmes. Primary vermelho precisa de outro diagnóstico.
Crie /etc/caddy/Caddyfile:
search.example.com {
encode zstd gzip
reverse_proxy 127.0.0.1:5601
header {
Strict-Transport-Security "max-age=31536000; includeSubDomains"
X-Content-Type-Options "nosniff"
Referrer-Policy "strict-origin-when-cross-origin"
}
}
sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy
sudo journalctl -u caddy -n 50 --no-pager
Abra https://search.example.com com elastic e a senha preservada em .env. Mantenha 5601 privado. Caddy trata HTTP e conexões prolongadas; aplique HSTS a subdomínios somente se todos suportarem HTTPS.
elastic é superusuário, não credencial de aplicativo. Este papel lê catalog-*:
PUT /_security/role/catalog_reader
{
"cluster": ["monitor"],
"indices": [
{
"names": ["catalog-*"],
"privileges": ["read", "view_index_metadata"]
}
]
}
Execute no Dev Tools e crie o usuário em Stack Management. O exemplo também permite monitorar o cluster inteiro; omita esse privilégio se desnecessário.
Prefira API keys com escopo e validade, guardadas em configuração restrita. Crie catalog_writer separado com apenas create_doc, index e permissões de mapping necessárias. Não compartilhe elastic entre serviços. Teste acesso permitido e negação a outros índices.
Em um nó, comece com um shard primário e nenhuma réplica:
PUT /_index_template/catalog_template
{
"index_patterns": ["catalog-*"],
"template": {
"settings": {
"number_of_shards": 1,
"number_of_replicas": 0,
"refresh_interval": "5s"
},
"mappings": {
"dynamic": "strict",
"properties": {
"title": { "type": "text" },
"sku": { "type": "keyword" },
"price": { "type": "scaled_float", "scaling_factor": 100 },
"updated_at": { "type": "date" }
}
}
}
}
Mapping estrito evita crescimento ilimitado e inferências erradas, mas rejeita campos novos até atualizar. Templates afetam índices novos; os existentes precisam de ajustes próprios ou reindexação.
A recomendação geral de 10–50GB e menos de 200 milhões de documentos por shard é orientativa. Meça consultas e restauração. Em nós independentes, adicione réplicas e confira localização; aumentar réplicas no mesmo host não cria HA.
Não considere confiável um tar de /usr/share/elasticsearch/data nem do volume esdata. Use Snapshot and Restore:
PUT /_snapshot/local_fs
{
"type": "fs",
"settings": {
"location": "/mnt/snapshots",
"compress": true
}
}
Verifique e crie snapshot:
POST /_snapshot/local_fs/_verify
PUT /_snapshot/local_fs/manual-2026-09-16?wait_for_completion=true
{
"include_global_state": true
}
A data no nome é um identificador de exemplo, não a data atual. Use nomes únicos e confirme SUCCESS sem shards falhos. Snapshots funcionam com cluster ativo e deduplicam segmentos imutáveis.
/opt/elastic-stack/snapshots compartilha a falha da VPS. Para copiar externamente, suspenda escritas do repositório ou faça snapshot atômico do sistema de arquivos; copiar durante alterações pode gerar uma cópia inconsistente. Em produção, prefira S3/GCS/Azure e SLM. Não edite arquivos do repositório.
Copie separadamente e criptografados Compose, ambiente, chaves Kibana, certificados/configurações e plugins. O snapshot do cluster não preserva esses arquivos do host.
Use um cluster isolado compatível e repositório completo registrado somente para leitura. A requisição evita sobrescrever nomes e exclui estado global/segurança:
POST /_snapshot/local_fs/YOUR_SNAPSHOT/_restore
{
"indices": "catalog-*",
"include_global_state": false,
"feature_states": ["none"],
"rename_pattern": "(.+)",
"rename_replacement": "restore-$1"
}
Troque o identificador e confira documentos, consultas, mappings, aliases e saúde. Um ensaio completo inclui objetos Kibana e feature states de segurança; isso pode substituir usuários e credenciais, então preserve acesso emergencial. Não teste recuperação destrutiva em produção.
status, shards não atribuídos e nós.- Heap, frequência e pausas GC.
- Latência de busca/gravação e rejeições.
- Documentos, tamanho de shards e crescimento de campos.
- Disco/I/O e limites low/high/flood-stage.
- Kibana, falhas de login e testes externos.
Use Prometheus e Grafana. green no nó único indica alocação saudável, não redundância ou recuperação garantida.
GET /_cluster/health
GET /_cat/nodes?v&h=name,heap.percent,ram.percent,cpu,load_1m,disk.used_percent
GET /_cat/indices?v&s=store.size:desc
GET /_cat/shards?v&s=store:desc
GET /_cluster/allocation/explain
Um nó exige parada. Leia notas, confira plugins e prepare snapshot compatível testado. Elasticsearch não suporta downgrade do nó: normalmente é preciso cluster vazio na versão anterior e restaurar seu snapshot anterior.
cd /opt/elastic-stack
set -a
. ./.env
set +a
docker compose exec es01 curl -s \
--cacert config/certs/ca/ca.crt \
-u "elastic:$ELASTIC_PASSWORD" \
'https://localhost:9200/_cluster/health?pretty'
docker compose pull
docker compose up -d
docker compose ps
docker compose logs --tail=100 es01 kibana
Altere STACK_VERSION em .env e mantenha Kibana alinhado. Baixar a mesma tag não atualiza. De 8.x, chegue primeiro à versão 8.19 suportada mais recente, use Upgrade Assistant e resolva índices antigos e mudanças antes do caminho 9.x oficial.
Confira vm.max_map_count no host:
sysctl vm.max_map_count
cat /etc/sysctl.d/99-elasticsearch.conf
O alvo é 1048576; execute sudo sysctl --system e reinicie Elasticsearch.
cd /opt/elastic-stack
docker compose ps
docker compose logs --tail=200 setup es01 kibana
Confira se setup definiu kibana_system, se Kibana confia em ca.crt, versões iguais e saúde Elasticsearch.
Confie na CA de certs, não em bypass -k permanente:
docker compose exec es01 curl -s \
--cacert config/certs/ca/ca.crt \
https://localhost:9200
missing authentication credentials sem conta indica acesso TLS/HTTP, não saúde autenticada.
Confira _cat/shards. Se faltam somente réplicas do nó único, ajuste number_of_replicas para 0 em templates e índices correspondentes. Não retire réplicas de produção só para mudar a cor.
Resolva primeiro flood-stage. Amplie disco ou exclua dados desnecessários; com nível seguro, confirme remoção automática ou remova index.blocks.read_only_allow_delete pelo procedimento suportado. Só retirar bloqueio não resolve disco cheio.
curl -I http://127.0.0.1:5601
sudo caddy validate --config /etc/caddy/Caddyfile
sudo journalctl -u caddy -n 100 --no-pager
Se loopback funciona, confira DNS, regras 80/443 e o guia de acesso externo.
Para testes, 4 vCPU, 8GB RAM e SSD de 80GB. Com Kibana, 4GB é pouco; produção pequena costuma precisar de 16GB/NVMe e carga medida.
Escolha por licença, recursos, plugins, clientes e experiência. OpenSearch tem distribuição e Dashboards próprios; não misture pacotes ou plugins.
A réplica configurada não tem destino. Zero réplicas elimina essa condição e significa ausência de redundância.
Mantenha em 127.0.0.1; use VPN/rede privada ou túnel SSH, TLS, autenticação e privilégio mínimo.
Não. Use snapshots, mantenha repositórios externos e ensaie restauração.
Não dependa disso. Restaure snapshot anterior compatível em cluster vazio da versão apropriada.