Tutoriales de VPS
Elasticsearch 9 y Kibana: TLS privado, snapshots y recuperación
Instale Elasticsearch y Kibana 9.5.6 con Compose y Caddy. Proteja API y claves CA, limite acceso, controle heap y shards y compruebe snapshots externos con recuperación aislada.

Cuando búsquedas web, logs o filtros de productos superan las consultas LIKE, Elasticsearch ofrece índices invertidos, analizadores, relevancia, agregaciones, búsquedas geográficas y vectores. Kibana aporta exploración, visualización y administración.
La guía usa Ubuntu 24.04, Compose y Caddy, con TLS autenticado para Elasticsearch y puertos 9200/5601 solo en loopback. El ejemplo del 16 de septiembre de 2026 utilizaba Elasticsearch y Kibana 9.5.3. La versión y documentación oficial consultadas el 16 de noviembre usan 9.5.6. Para instalación nueva, seleccione ese parche revisado antes de descargar y mantenga ambos componentes alineados.
Conserve los datos de negocio autoritativos en PostgreSQL/MySQL u otra base principal e indexe lo necesario mediante aplicaciones, Logstash, Beats o CDC.
- Búsqueda completa de sitios, documentos, productos y conocimiento.
- Consulta centralizada de logs, agregaciones e investigaciones.
- Autocompletado, coincidencias aproximadas, sinónimos y relevancia.
- Análisis temporal de métricas, eventos y seguridad.
- Búsqueda híbrida de palabras y vectores con filtros.
Para logs con recursos limitados, Grafana Loki puede ser más ligero. Para agentes y reglas SIEM, consulte Wazuh. La amplitud de Elasticsearch exige más memoria, almacenamiento y mantenimiento.
| Arquitectura | Ventaja | Límite | Uso |
|---|---|---|---|
| Un nodo | Menor coste y diagnóstico sencillo | Fallo de host/disco interrumpe; sin redundancia | Desarrollo, herramientas e índices reconstruibles |
| Tres nodos en una VPS | Prueba configuración | Mismo dominio de fallo y competencia por RAM | Laboratorio |
| Tres nodos de datos independientes | Réplicas pueden tolerar un nodo caído | Planificación de capacidad, certificados y actualización | Búsqueda, logs y seguridad críticos |
Aquí se usa discovery.type=single-node. Configure réplicas 0 para no dejar réplicas sin asignar; eso no crea otra copia. Producción crítica necesita dominios independientes, votación de nodos master-eligible bien diseñada, réplicas y snapshots externos comprobados.
Planifique campos, analizadores, agregaciones, escritura máxima, concurrencia, retención y réplicas.
| Carga | VPS orientativa | Heap inicial | Condición |
|---|---|---|---|
| Desarrollo | 4 vCPU, 8GB RAM, 80GB SSD | 2GB | Poca concurrencia, índices reconstruibles |
| Búsqueda pequeña en producción | 8 vCPU, 16GB RAM, al menos 200GB NVMe | 4–6GB | Margen para Kibana y caché |
| Clúster crítico/logs | Al menos 3 hosts, 8 vCPU/16–32GB cada uno, NVMe independiente | Medido | Réplicas, ILM y snapshots separados |
El heap no debe superar el 50% de la memoria disponible del contenedor; uno menor puede beneficiar la caché del sistema. Tener 16GB no justifica -Xmx de 12GB: también consumen off-heap, Kibana, Docker y Linux.
Estime datos diarios × expansión del índice × días retenidos × (1 + réplicas) × margen:
每日原始数据 × 索引膨胀系数 × 保留天数 × (1 + 副本数) × 安全余量
La expansión depende de mapping, _source, analizadores y tipos. Mida datos reales y mantenga el disco por debajo de aproximadamente 70%–75%, sin esperar al bloqueo flood-stage.
| Puerto | Función | Exposición |
|---|---|---|
443/TCP | Kibana HTTPS | Caddy |
5601/TCP | Kibana HTTP | Solo 127.0.0.1 |
9200/TCP | API Elasticsearch HTTPS autenticada | Solo 127.0.0.1 |
9300/TCP | Transport entre nodos | Sin publicar |
La API no es una página administrativa para publicar a todo Internet. Use redes privadas o túneles restringidos, TLS y autenticación. Revise publicación Docker, seguridad del proveedor y la lista de exposición de middleware. Caddy puede necesitar también 80 para ACME HTTP y redirecciones; limite SSH.
Instale antes Docker Engine y Compose v2 con las instrucciones oficiales 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
Revise paquetes/reinicios y configure logs, salud y límites con la lista de Compose para producción.
El requisito Docker actual es 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
Ajústelo en el host. Investigue swap y memoria insuficiente; bootstrap.memory_lock=true y memlock no sustituyen 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
Genere contraseñas y tres claves estables de 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
Sustituya search.example.com por su dominio y configure DNS; publique AAAA solo con IPv6 operativo. Proteja .env. La generación sobrescribe el archivo y sirve solo para una instancia nueva: no regenere secretos existentes.
Seleccione el parche revisado antes del primer arranque:
cd /opt/elastic-stack
sed -i 's/^STACK_VERSION=.*/STACK_VERSION=9.5.6/' .env
chmod 600 .env
setup genera CA/certificados y configura la contraseña kibana_system cuando Elasticsearch responde. Cree /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 arrancar, inserte esta línea en setup inmediatamente después de ajustar permisos. Los contenedores comparten certificados y no deben poder leer la clave de firma ni sus archivos:
chmod 600 config/certs/ca/ca.key config/certs/ca.zip config/certs/certs.zip
Guarde material de firma cifrado por separado. Setup como root puede seguir utilizándolo y los procesos sin privilegios leen sus certificados 640. Antes de añadir nodos, diseñe también TLS transport: esta configuración HTTP de un nodo no resuelve un clúster completo.
Elasticsearch tiene límite 4GB/heap 2GB y Kibana otros 2GB. Reserve al menos 8GB en el host y más margen para servicios adicionales; ajuste mediante mediciones.
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
Cargue únicamente un .env fiable y revise versión/clúster:
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 suele indicar réplica sin destino en un nodo. Use number_of_replicas: 0 para esos índices; no desactive alarmas. Un primary rojo requiere otro diagnóstico.
Cree /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 con elastic y la contraseña conservada en .env. Deje 5601 privado. Caddy transmite HTTP y conexiones prolongadas; aplique HSTS a subdominios únicamente si todos admiten HTTPS.
elastic es superusuario, no credencial de aplicación. Este rol lee catalog-*:
PUT /_security/role/catalog_reader
{
"cluster": ["monitor"],
"indices": [
{
"names": ["catalog-*"],
"privileges": ["read", "view_index_metadata"]
}
]
}
Ejecute en Dev Tools y cree el usuario en Stack Management. El ejemplo concede también monitorización global del clúster; omítala si no hace falta.
Prefiera API keys con alcance y caducidad, guardadas en configuración restringida. Cree un catalog_writer separado con solo create_doc, index y permisos de mapping necesarios. No comparta elastic entre servicios. Pruebe solicitudes permitidas y denegación de otros índices.
En un nodo, empiece con un shard principal y ninguna 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 estricto evita crecimiento ilimitado e inferencias incorrectas, pero rechaza campos nuevos hasta actualizarlo. Templates afectan índices nuevos; los existentes necesitan ajustes propios o reindexación.
La recomendación general de 10–50GB y menos de 200 millones de documentos por shard es orientativa. Mida consultas y recuperación. En nodos independientes, añada réplicas y compruebe ubicación; aumentar réplicas en un host no crea HA.
No considere fiable un tar de /usr/share/elasticsearch/data ni del volumen esdata. Use Snapshot and Restore:
PUT /_snapshot/local_fs
{
"type": "fs",
"settings": {
"location": "/mnt/snapshots",
"compress": true
}
}
Verifique y cree snapshot:
POST /_snapshot/local_fs/_verify
PUT /_snapshot/local_fs/manual-2026-09-16?wait_for_completion=true
{
"include_global_state": true
}
La fecha del nombre es un identificador de ejemplo, no la fecha actual. Use nombres únicos y compruebe SUCCESS sin shards fallidos. Los snapshots funcionan en activo y deduplican segmentos inmutables.
/opt/elastic-stack/snapshots comparte el fallo de la VPS. Para copiar fuera, impida escrituras del repositorio o tome snapshot atómico del sistema de archivos; copiar mientras se modifica puede producir una copia inconsistente. En producción, prefiera repositorios S3/GCS/Azure y SLM. No edite archivos del repositorio.
Copie aparte y cifrados Compose, entorno, claves Kibana, certificados/configuración y plugins. El snapshot del clúster no conserva esos archivos del host.
Use un clúster aislado compatible y un repositorio completo registrado de solo lectura. Esta petición evita sobrescribir nombres y excluye estado global/seguridad:
POST /_snapshot/local_fs/YOUR_SNAPSHOT/_restore
{
"indices": "catalog-*",
"include_global_state": false,
"feature_states": ["none"],
"rename_pattern": "(.+)",
"rename_replacement": "restore-$1"
}
Sustituya el identificador y verifique documentos, consultas, mappings, aliases y salud. Un ensayo completo incluye objetos Kibana y recuperación de feature states de seguridad; esto puede reemplazar usuarios y credenciales, por lo que necesita acceso de emergencia. No pruebe recuperación destructiva en producción.
status, shards sin asignar y nodos.- Heap, frecuencia y pausas GC.
- Latencia de búsquedas/escrituras y rechazos.
- Documentos, tamaño de shards y crecimiento de campos.
- Disco/I/O y umbrales low/high/flood-stage.
- Disponibilidad Kibana, fallos de login y pruebas externas.
Use Prometheus y Grafana. green en un nodo indica asignación saludable, no redundancia o recuperación garantizadas.
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
Un nodo necesita parada. Lea notas, compruebe plugins y prepare snapshot compatible y probado. Elasticsearch no admite downgrade del nodo: normalmente hay que reconstruir vacío con versión anterior y restaurar su 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
Cambie STACK_VERSION en .env y mantenga Kibana alineado. Descargar la misma etiqueta no actualiza. Desde 8.x, llegue primero a la versión 8.19 admitida más reciente, utilice Upgrade Assistant y resuelva índices antiguos/cambios antes de seguir la ruta 9.x oficial.
Revise vm.max_map_count en el host:
sysctl vm.max_map_count
cat /etc/sysctl.d/99-elasticsearch.conf
El objetivo es 1048576; ejecute sudo sysctl --system y reinicie Elasticsearch.
cd /opt/elastic-stack
docker compose ps
docker compose logs --tail=200 setup es01 kibana
Compruebe que setup configuró kibana_system, que Kibana confía en ca.crt, versiones iguales y salud Elasticsearch.
Confíe en la CA de certs, no en un bypass -k permanente:
docker compose exec es01 curl -s \
--cacert config/certs/ca/ca.crt \
https://localhost:9200
missing authentication credentials sin cuenta demuestra acceso TLS/HTTP, no salud autenticada.
Revise _cat/shards. Si solo faltan réplicas del nodo único, ajuste number_of_replicas a 0 en templates e índices correspondientes. No quite réplicas de producción para colorear el indicador.
Resuelva primero presión flood-stage. Amplíe disco o elimine datos innecesarios; con nivel seguro, verifique desbloqueo automático o quite index.blocks.read_only_allow_delete siguiendo el procedimiento admitido. Solo quitar bloqueo no arregla disco lleno.
curl -I http://127.0.0.1:5601
sudo caddy validate --config /etc/caddy/Caddyfile
sudo journalctl -u caddy -n 100 --no-pager
Si loopback funciona, revise DNS, reglas 80/443 y la guía de acceso externo.
Para pruebas, 4 vCPU, 8GB RAM y 80GB SSD. Con Kibana, 4GB es escaso; producción pequeña suele necesitar 16GB/NVMe y medición real.
Decida según licencia, funciones, plugins, clientes y experiencia. OpenSearch tiene distribución y Dashboards propios; no mezcle paquetes o plugins.
La réplica configurada no tiene destino. Cero réplicas elimina esa condición y significa ausencia de redundancia.
Déjelo en 127.0.0.1; use VPN/red privada o túnel SSH, TLS, autenticación y permisos mínimos.
No. Use snapshots, almacene repositorios fuera y ensaye recuperación.
No dependa de ello. Restaure snapshot anterior compatible en un clúster vacío de la versión apropiada.