Guía Completa para Configurar un Cluster de Elasticsearch
Despliega y escala clusters de Elasticsearch en producción. Cubre roles de nodos, sharding, index templates, mapping, ILM, snapshots, seguridad y tuning.
Introducción
Elasticsearch es un motor distribuido de búsqueda y analítica que se usa para búsqueda de texto completo, filtrado estructurado, agregaciones de analítica y búsqueda vectorial. Un solo nodo en tu portátil funciona bien para desarrollo, pero producción es otro problema: necesitas quórum para que el cluster no sufra split-brain, suficientes nodos para que las réplicas tengan dónde vivir, seguridad activada y un plan para cuando los índices superen al hardware.
Esta guía recorre una instalación real de producción de 3 nodos en Elasticsearch 8.x: roles de nodos, estrategia de sharding, index templates, mapping, gestión del ciclo de vida, snapshots y el tuning que mantiene un cluster sano bajo carga. Cada sección termina con cómo verificar que el paso funcionó — una configuración que “debería estar bien” es cómo los clusters acaban en rojo a las 2 de la mañana.
Si solo necesitas búsqueda sobre un cluster ya existente, ve directo a la guía de Full-Text Search. Esta trata sobre operar el cluster en sí.
Prerequisitos
Antes de tocar elasticsearch.yml, prepara el host — la mayoría de fallos “misteriosos” de Elasticsearch son ajustes del SO, no bugs de Elasticsearch:
vm.max_map_count >= 262144en Linux (sysctl -w vm.max_map_count=262144y déjalo permanente en/etc/sysctl.conf). Elasticsearch mapea sus índices a memoria; con el 65530 por defecto falla o no supera los bootstrap checks cuandobootstrap.memory_lockestá activo.- File descriptors: sube el límite a 65535 para el usuario de elasticsearch (cada shard mantiene archivos abiertos).
- RAM: el heap debe ser el 50% de la RAM, con tope de ~31GB (umbral de compressed oops). Un nodo con 16GB de RAM lleva
-Xms8g -Xmx8g. - Sin swap: deshabilita swap o activa
bootstrap.memory_lock: true— una JVM swappeada convierte consultas de milisegundos en segundos. - Java: no hace falta — Elasticsearch 8 trae su propio JDK. No instales un JDK del sistema salvo que tengas una razón.
- Disco: SSD para datos calientes. Calcula el tamaño de los índices más ~50% de margen para merges, más espacio para el repositorio de snapshots.
Para experimentos locales basta un contenedor Docker de un nodo. Para un cluster de prueba de 3 nodos, lanza tres contenedores en una red Docker dedicada — misma configuración que abajo. El repo companion trae un docker-compose.yml listo para justo eso, con el TLS ya cableado: es la forma más rápida de ver la salida de bootstrap, los enrollment tokens y _cluster/health en green antes de tocar hosts reales.
Arquitectura del Cluster
Cada nodo cumple uno o varios roles. Los roles que asignes deciden dónde viven los datos, quién toma decisiones del cluster y quién responde las consultas:
# elasticsearch.yml — ejemplos de roles
# Nodo master-eligible — gestiona el estado del cluster (qué shard va dónde)
node.roles: [master]
# Nodo data — almacena shards, ejecuta CRUD y búsqueda
node.roles: [data]
# Nodo solo coordinating — enruta peticiones, agrega resultados
node.roles: []
# Nodo ingest — pre-procesa documentos antes de indexar
node.roles: [data, ingest]
# Tiers hot/warm/cold para datos time-series
node.roles: [data_hot] # datos recientes, SSD rápido
node.roles: [data_warm] # datos más viejos, discos más baratos
node.roles: [data_cold] # raramente consultados, storage más barato
Dos decisiones son las que más pesan:
¿Cuántos nodos master-eligible? Siempre un número impar — 3 en la práctica. La elección de master necesita quórum (2 de 3), así que un cluster de 3 masters sobrevive a que uno caiga sin riesgo de que dos masters se elijan a sí mismos (split-brain, que corrompe el estado del cluster). En clusters pequeños, los masters pueden doblar como nodos data.
¿Roles dedicados o compartidos? Por debajo de ~10 nodos o unos pocos TB, master+data en el mismo nodo vale. Más allá, dedica 3 nodos pequeños solo a node.roles: [master] — los masters apenas hacen I/O, con 2 vCPU / 4GB de RAM cada uno basta, y aislarlos evita que la indexación pesada desestabilice las elecciones.
# Nodo 1 — master + data (clusters pequeños, los 3 nodos idénticos)
cluster.name: prod-es-cluster
node.name: node-1
node.roles: [master, data, ingest]
# Solo contenedores/desarrollo — en producción bindea la interfaz privada
network.host: 0.0.0.0
discovery.seed_hosts: ["node-1", "node-2", "node-3"]
# SOLO BOOTSTRAP — se usa una vez cuando el cluster se forma por primera vez.
# Elimínalo o coméntalo tras el arranque inicial; un valor viejo al
# reiniciar es una forma clásica de romper un cluster existente.
cluster.initial_master_nodes: ["node-1", "node-2", "node-3"]
xpack.security.enabled: true
La topología que produce:
Los clusters más grandes se ven igual con 3 masters dedicados alimentando N nodos data — los masters se mantienen idénticos, solo añades node.roles: [master] y apuntas los discovery.seed_hosts de los nodos data hacia ellos.
Bootstrap de Seguridad
Elasticsearch 8 activa la seguridad por defecto — ya no hay “activarlo luego”. En el primer nodo:
- Arranca Elasticsearch; imprime en stdout una contraseña autogenerada para el usuario
elasticy un enrollment token. Guárdalos. - Verifica:
curl -u elastic:<password> https://localhost:9200 -kdebería devolver la info del cluster por HTTPS. - Añade nodos con enrollment tokens —
GET /_security/enrollment/nodeen el primer nodo imprime un token; ponxpack.security.enrollment.enabled: trueen los nodos nuevos y arráncalos con--enrollment-token <token>. Esto configura el TLS de transporte automáticamente. - Crea usuarios de aplicación en Kibana o vía
_security/user— nunca dejes que las apps conecten comoelastic.
Saltarse el TLS entre nodos en un cluster multi-nodo no es opción en ES 8: el TLS de transporte es obligatorio cuando la seguridad está activa, y es la razón de que exista el flujo de enrollment — hacerlo a mano implica generar las CA y los certificados de cada nodo por tu cuenta.
Sharding y Réplicas
Cada índice se divide en shards primarios; cada primario puede tener copias réplica en otros nodos. Dos restricciones duras mandan en los números:
- El número de shards primarios se fija al crear el índice y no se puede cambiar sin reindexar (o con las APIs
shrink/splitcon restricciones). Si lo calculas a la baja, reindexarás antes de lo que te gustaría. - Las réplicas hacen dos trabajos: disponibilidad (una réplica asciende cuando muere el nodo de su primario) y throughput de lectura (las búsquedas golpean primarios y réplicas por igual). Cuestan disco y tiempo de indexación — cada escritura llega a todas las copias.
# Crear un índice con 3 primarios y 1 réplica — 6 copias de shard en total
PUT /products
{
"settings": {
"index": {
"number_of_shards": 3,
"number_of_replicas": 1
}
}
}
El tamaño de los shards es un equilibrio. Los shards pequeños desperdician heap (cada uno lleva un overhead fijo — la guía de Elastic habla de un máximo de unos cientos de shards por GB de heap); los grandes ralentizan la recuperación y hacen las búsquedas seriales. Apunta a 10–50GB por shard:
| Tamaño de Índice | Shards | Razonamiento |
|---|---|---|
| < 1GB | 1 | Sin beneficio del sharding |
| 1-10GB | 1-2 | Un shard lo gestiona bien |
| 10-50GB | 3-5 | Búsqueda en paralelo entre shards |
| 50-200GB | 5-10 | Máx 50GB por shard |
| > 200GB | 10-20 | Dividir por tiempo o categoría |
Para datos time-series (logs, métricas) no pre-dividas índices estáticos enormes — deja que ILM haga rollover a índices nuevos cuando alcancen un umbral de tamaño.
Las réplicas son el único ajuste que se puede cambiar en un índice en vivo — sin reindexar:
PUT /products/_settings
{
"number_of_replicas": 2
}
Verifica con GET /_cat/shards/products?v — deberías ver cada réplica de primario en un nodo distinto. Si una réplica cae en el mismo nodo que su primario, las reglas de cluster.routing.allocation están mal o te falta un nodo data. Para estrategia de particionado más allá de un cluster, mira la guía de Database Sharding.
Index Templates
Los valores por defecto de índice en elasticsearch.yml se eliminaron en Elasticsearch 8 — el template es donde viven ahora los settings de índice. Un template aplica settings, mappings y aliases a todo índice que coincida con un patrón de nombre, así logs-2026.10.20 hereda la misma forma que el logs-2026.10.21 de mañana sin trabajo manual:
PUT /_index_template/logs
{
"index_patterns": ["logs-*"],
"template": {
"settings": {
"number_of_shards": 3,
"number_of_replicas": 1,
"index.refresh_interval": "5s",
"index.lifecycle.name": "logs-policy"
},
"mappings": {
"properties": {
"@timestamp": { "type": "date" },
"level": { "type": "keyword" },
"message": { "type": "text" },
"service": { "type": "keyword" },
"host": { "type": "keyword" }
}
}
},
"priority": 100
}
El campo priority resuelve conflictos cuando varios templates coinciden — gana el más alto. index.lifecycle.name conecta los índices nuevos directamente con la política ILM de abajo.
Mapping
El mapping es el schema de Elasticsearch: decide qué campos son buscables como texto completo, cuáles son keywords de coincidencia exacta y cuáles son fechas, números u objetos anidados. El dynamic mapping adivina los tipos a partir del primer documento que ve — cómodo para prototipar, arriesgado en producción, donde un solo campo mal tipado ("price": "19.99" como texto) rompe las consultas hasta que reindexas.
Regla de producción: mapping explícito para los campos que consultas, dynamic: strict o runtime para el resto:
PUT /products
{
"mappings": {
"properties": {
"name": {
"type": "text",
"analyzer": "standard",
"fields": {
"keyword": { "type": "keyword", "ignore_above": 256 }
}
},
"price": { "type": "scaled_float", "scaling_factor": 100 },
"in_stock": { "type": "boolean" },
"created_at": { "type": "date" },
"tags": { "type": "keyword" },
"description": {
"type": "text",
"analyzer": "english"
},
"metadata": { "type": "object", "enabled": false }
}
}
}
Dos patrones que merece la pena robar:
- Multi-fields (
name+name.keyword):textpara búsqueda con relevancia,keywordpara coincidencias exactas, ordenación y agregaciones — obtienes ambos de un mismo campo. scaled_floatpara dinero: guarda19.99como el entero1999, evitando los artefactos de redondeo de float en agregaciones."enabled": falseenmetadata: no indexa nada, lo almacena en_source— la forma barata de aceptar payloads arbitrarios sin explosión de mappings.
dynamic: strict rechaza documentos con campos no mapeados — genial para pillar bugs de productores temprano, doloroso si los schemas de upstream cambian sin aviso. "dynamic": "runtime" es el punto medio: los campos no mapeados son consultables en tiempo de búsqueda sin indexarse.
Los dynamic templates siguen ganándose su sitio para mapping por convención — todo campo *_at como date, todo string como keyword:
PUT /products
{
"mappings": {
"dynamic_templates": [
{
"strings_as_keyword": {
"match_mapping_type": "string",
"mapping": { "type": "keyword" }
}
},
{
"dates_default": {
"match": ".*_at",
"mapping": { "type": "date" }
}
}
]
}
}
Index Lifecycle Management (ILM)
Los índices time-series crecen para siempre salvo que algo los jubile. ILM automatiza todo el arco: hot (escritura intensa) → warm (mayormente lectura, reducido) → cold (storage barato) → delete:
PUT /_ilm/policy/logs-policy
{
"policy": {
"phases": {
"hot": {
"actions": {
"rollover": {
"max_age": "7d",
"max_primary_shard_size": "50gb"
},
"set_priority": { "priority": 100 }
}
},
"warm": {
"min_age": "30d",
"actions": {
"shrink": { "number_of_shards": 1 },
"forcemerge": { "max_num_segments": 1 },
"set_priority": { "priority": 50 }
}
},
"cold": {
"min_age": "90d",
"actions": {
"set_priority": { "priority": 0 },
"allocate": { "require": { "data": "cold" } }
}
},
"delete": {
"min_age": "365d",
"actions": { "delete": {} }
}
}
}
}
Cómo se comporta con datos reales:
- hot: el rollover crea un índice nuevo cuando el actual llega a 7 días o 50GB por shard primario — así los shards individuales se mantienen en la banda sana de 10–50GB en vez de que un índice crezca a terabytes.
- warm:
shrinkconsolida 3 primarios en 1 (los índices son mayormente lectura a estas alturas, menos shards = menos overhead) yforcemergea un segmento hace las búsquedas rápidas. - cold:
allocatemueve los shards a nodosdata_coldsi los tienes; omite la acción si no. Ojo: la acciónfreezeantigua está deprecated en ES 8 — los searchable snapshots son la forma moderna de mantener datos fríos consultables a bajo coste. - delete: corte duro a un año. Ajusta según tus necesidades de cumplimiento.
Para conectarlo: adjunta index.lifecycle.name: "logs-policy" en el index template, escribe contra un alias (logs-write) que el rollover gestiona, y apunta los lectores a logs-*. Comprueba el progreso con GET /logs-*/_ilm/explain — índices atascados en una fase significan que la política o la salud del cluster necesitan atención.
Snapshots y Backups
Las réplicas protegen contra caídas de nodos — no contra un DELETE /*, corrupción o una migración de mapping mala. Los snapshots son el único backup real. Capturan un índice en un punto del tiempo hacia un repositorio: sistema de archivos compartido (fs), S3, GCS o Azure Storage.
# Registrar un repositorio — filesystem para self-hosted, S3 en cloud
PUT /_snapshot/backup_repo
{
"type": "fs",
"settings": {
"location": "/mnt/backups/elasticsearch",
"compress": true
}
}
# Hacer un snapshot
PUT /_snapshot/backup_repo/snapshot_2026_01_01?wait_for_completion=true
{
"indices": "products,orders",
"ignore_unavailable": true
}
# Restaurar con otro nombre para verificar o hacer rollback
POST /_snapshot/backup_repo/snapshot_2026_01_01/_restore
{
"indices": "products",
"rename_pattern": "products",
"rename_replacement": "restored_products"
}
Dos reglas operativas: los snapshots son incrementales y baratos, así que ejecútalos programados (SLM — _slm/policy) en vez de ad hoc; y un backup que no has restaurado es un rumor — restaura en un cluster de prueba o en un índice renombrado periódicamente para demostrar que el pipeline funciona.
Salud del Cluster y Monitoreo
Los comandos del día a día para el estado del cluster:
GET /_cluster/health # green/yellow/red + conteo de nodos y shards
GET /_cluster/stats # CPU/heap/disco/docs de todo el cluster
GET /_nodes/info # roles, JVM y SO por nodo
GET /products/_stats # docs, tamaño, tasas de búsqueda/indexación por índice
GET /_cat/shards/products?v # dónde vive cada shard
GET /_cat/shards?v&h=index,shard,prirep,state,unassigned.reason # qué falló y por qué
GET /_cluster/health es lo primero a ejecutar cuando algo huele mal:
- green — todos los shards asignados, normal.
- yellow — todos los primarios asignados pero faltan réplicas. Normalmente un nodo caído o pocos nodos data; no es pérdida de datos, pero la disponibilidad está degradada.
- red — al menos un shard primario sin asignar: esos datos no están disponibles. Busca la razón en la columna
unassigned.reason— disk watermark, réplica que falta o reglas de asignación.
Para monitoreo continuo, envía esto a lo que ya uses — exporter de Prometheus, Metricbeat/Elastic Agent o un cron sobre _cluster/health que pague cuando el estado no sea green. Alerta con unassigned_shards > 0 y status != green antes de que los usuarios noten consultas lentas.
Las métricas que merecen dashboard: presión de heap por nodo (GET /_nodes/stats/jvm), uso de disco contra los watermarks, percentiles de latencia de búsqueda e indexación, peticiones rechazadas en thread pools y crecimiento del número de índices. Un heap rondando el 75% entre ciclos de GC o un crecimiento sostenido de búsquedas rechazadas es el cluster diciéndote que se quedó pequeño — escúchalo antes de que se ponga rojo.
Tuning de Producción
La mayoría de los valores por defecto de Elasticsearch son sensatos; estos son los ajustes que de verdad mueven la aguja en producción:
# elasticsearch.yml — tuning a nivel de sistema
# Evita que la JVM sea swappeada
bootstrap.memory_lock: true
# (Opcional) los thread pools se auto-dimensionan a tu CPU en ES 8 —
# solo sobreescribe con evidencia medida de colas rechazadas.
# thread_pool.search.size: 50
# thread_pool.search.queue_size: 1000
# Disk watermarks — deja un buffer real, no aceptes los defaults a ciegas
cluster.routing.allocation.disk.watermark.low: 85%
cluster.routing.allocation.disk.watermark.high: 90%
cluster.routing.allocation.disk.watermark.flood_stage: 95%
Qué tocar de verdad, y por qué:
- Heap de JVM (en
jvm.options, no enelasticsearch.yml):-Xms16g -Xmx16g— mismo valor en ambos, 50% de la RAM, nunca por encima de ~31GB. Cruzar el umbral de compressed oops hace que un heap de 32GB rinda peor que uno de 31GB. - Disk watermarks: al 85% Elasticsearch deja de asignar shards nuevos al nodo, al 90% intenta sacar shards de él, al 95% (flood_stage) pone todos los índices del nodo en solo lectura. Un cluster en rojo por
flood_stagesuele ser un agujero de monitoreo, no un bug de Elasticsearch. index.refresh_interval: ajústalo por índice o en templates (ej.5sbajo carga de escritura,30sdurante reindexación masiva) — es un setting de índice, no de nodo. El default de 1s quema CPU re-ejecutando búsquedas por shard cada segundo.- Circuit breakers (
indices.breaker.*): guardarraíles, no tuning. Deja los defaults; un cluster que necesita breakers más laxos tiene un problema de consultas.
La indexación bulk es donde vive el throughput. Indexar documento a documento es 10–100x más lento porque cada petición paga el transporte completo y el overhead de commit:
POST /_bulk
{ "index": { "_index": "products", "_id": "1" } }
{ "name": "Widget", "price": 9.99 }
{ "index": { "_index": "products", "_id": "2" } }
{ "name": "Gadget", "price": 19.99 }
{ "update": { "_index": "products", "_id": "3" } }
{ "doc": { "price": 14.99 } }
from elasticsearch import Elasticsearch, helpers
es = Elasticsearch("http://localhost:9200")
actions = [
{"_index": "products", "_id": i, "_source": {"name": f"Product {i}", "price": i * 1.99}}
for i in range(10000)
]
helpers.bulk(es, actions, chunk_size=1000, request_timeout=60)
El punto dulce suele ser 5–15MB por petición bulk — mide con tus datos; demasiado grande y las peticiones encolan, demasiado pequeño y vuelves al overhead por documento. Durante la reindexación masiva, pon refresh_interval: -1 (o 30s) y number_of_replicas: 0, y restaura ambos al terminar.
Actualizaciones Rolling y Reinicios
Elasticsearch maneja upgrades rolling de forma nativa — para eso están las réplicas. La secuencia segura por nodo:
- Desactiva la asignación de shards:
PUT /_cluster/settingscon"persistent": {"cluster.routing.allocation.enable": "primaries"}. Evita que el cluster reubique shards mientras reinicias nodos. - Para el nodo, actualiza el paquete, arráncalo.
- Espera a que
GET /_cluster/healthmuestre el nodo reincorporado. - Repite por nodo, luego reactiva la asignación con
"enable": "all"y espera a green.
Para un reinicio simple (sin cambio de versión) aplica la misma secuencia menos el upgrade. Saltarse el paso de desactivar asignación convierte cada reinicio en una tormenta de minutos de relocación de shards — el cluster “se auto-cura” copiando terabytes que no necesitaba mover.
Buenas Prácticas
- Usa siempre 3 nodos master-eligible — el quórum sobrevive a una caída sin split-brain
- Mantén el tamaño de shard en la banda 10–50GB — shards pequeños desperdician heap, los grandes ralentizan la recuperación
- Usa mapping explícito — el dynamic mapping adivina los tipos una vez y te quedas con ellos hasta reindexar
- Pon
bootstrap.memory_lock: true— pero solo después de configurarvm.max_map_county el swap; memory_lock sin los prerequisitos de SO falla los bootstrap checks - Usa ILM para datos time-series — el rollover le gana a planear conteos de shards para índices que nunca dimensionarás bien
- Usa index templates, no settings de índice a nivel nodo — los defaults
index.*enelasticsearch.ymlno existen en ES 8 - Trata los snapshots como el único backup — la replicación es disponibilidad, no recuperabilidad
- Bulk para escrituras batch — fragmenta a 5–15MB, baja el refresh_interval durante reindexación masiva
- Monitorea
unassigned_shards— un yellow silencioso se vuelve rojo con la siguiente caída de nodo - Usa tiers hot/warm/cold cuando los datos envejecen — los nodos cold pueden costar una fracción de los hot
- Escribe contra un alias, lee contra un patrón — permite que el rollover de ILM y la reindexación cambien índices de forma invisible
Solución de Problemas
Los escenarios que te despiertan, y cómo trabajarlos:
- Cluster en rojo — primarios sin asignar: lee
unassigned.reasondeGET /_cat/shards?v&h=index,shard,prirep,state,unassigned.reason.NODE_LEFTsignifica nodo ausente (devuélvelo);ALLOCATION_FAILEDcon mensajes de disco son los watermarks — libera espacio o súbelos temporalmente, luegoPOST /_cluster/reroute?retry_failed=truepara limpiar las asignaciones atascadas. - Yellow con
unassigned_shardssubiendo: pocos nodos data para el conteo de réplicas, o reglas de asignación que excluyen los nodos que quedan. Si el nodo no vuelve, bajanumber_of_replicastemporalmente para que el cluster pase a green, y arregla luego el número de nodos. - “master not discovered yet” en logs: los nodos no se alcanzan entre sí — verifica que
discovery.seed_hostsresuelve y que el puerto 9300 está abierto entre ellos. Si el cluster ya se formó, revisa también que nadie dejócluster.initial_master_nodesconfigurado en un nodo reiniciado. - Índices bloqueados en solo lectura tras llenar el disco: es
flood_stagehaciendo su trabajo. Libera disco por debajo del watermark alto, luego desbloquea a mano:PUT /*/_settings {"index.blocks.read_only_allow_delete": null}. - OOM /
circuit_breaking_exception: una consulta o agregación superó el request breaker — el cluster se salvó a sí mismo. La solución no es subir el breaker, es encontrar la consulta: revisa_tasksbuscando al culpable, mirafielddataen campos text o agregaciones sobre terms de alta cardinalidad, y mueve la carga a camposkeyword.
Errores Comunes
- Over-sharding — cientos de shards pequeños queman heap en overhead; la regla de ~20 shards por GB de heap te mantiene honesto
- Dejar
cluster.initial_master_nodesconfigurado — es solo para bootstrap; un valor viejo al reiniciar puede partir el cluster - Dynamic mapping en producción — un campo
pricemapeado como texto rompe las agregaciones hasta que reindexas - Heap por encima de 31GB — los compressed oops se desactivan y el heap mayor rinde peor
- Sin política ILM — los índices crecen hasta que flood_stage deja todo en solo lectura
- Sin snapshots — descubrir que la replicación no es un backup pasa exactamente una vez
- Un solo nodo en producción — sin réplicas no hay alta disponibilidad ni reinicios rolling
- Reinicios sin desactivar la asignación — tormentas de relocación de shards autoinfligidas
network.host: 0.0.0.0fuera de contenedores — bindea Elasticsearch a todas las interfaces incluidas las públicas; en producción bindea la interfaz privada- Reenrutar shards a mano —
cluster/rerouteenmascara la causa raíz; la columna unassigned.reason existe por algo - Ignorar la explosión de índices — miles de índices pequeños por día llevan overhead cada uno; ILM rollover a índices por tamaño, no por fecha, cuando el volumen lo permite
Ver También
- Elasticsearch: Tune for indexing speed — referencia oficial de tuning detrás de la guía de bulk y refresh-interval
- Index Lifecycle Management — docs oficiales de ILM: fases, acciones y mecánica de rollover
- Size your shards — guía oficial de dimensionado de shards detrás de la regla de 10–50GB
- Recursos companion —
elasticsearch.yml,docker-compose.ymlde 3 nodos, política ILM e index template descargables
Preguntas frecuentes
¿Cuántos shards debería usar?
Apunta a 10–50GB por shard. Un índice de 100GB cae en 3–5 primarios; por debajo de 1GB usa un solo shard — los shards extra solo añaden overhead. Los primarios no se pueden cambiar sin reindexar, así que planea con antelación o deja que el rollover de ILM dimensione los índices por ti en datos time-series.
¿Puedo correr Elasticsearch en un solo nodo?
Para desarrollo y cargas diminutas, sí — pon discovery.type: single-node y acepta que las réplicas no se pueden asignar (el health en yellow es normal). En producción un solo nodo significa sin réplicas, sin alta disponibilidad y downtime en cada reinicio. Tres nodos es el mínimo real.
¿Cuánta RAM necesita un nodo de Elasticsearch?
El mínimo útil es 8GB en total: 4GB de heap, 4GB para la caché de página del SO de Lucene — la velocidad de búsqueda vive en esa caché, no en el heap. Los nodos data realistas de producción llevan 32–64GB de RAM, y duplicar RAM suele ganarle a duplicar heap porque alimenta la caché.
¿Debo usar Elasticsearch u OpenSearch?
OpenSearch es el fork Apache 2.0 de Elasticsearch 7.10, mantenido por AWS. Elige Elasticsearch por las funciones más recientes y el X-Pack incluido (seguridad, ILM, monitoreo gratis); elige OpenSearch si la pureza de licencia importa más que la actualidad. Las APIs siguen siendo compatibles para uso común, pero las funciones divergen más en cada release — no planees migrar a la ligera.
¿Cómo hago reindex sin downtime?
Escribe a través de un alias. Apunta products a products_v1, crea products_v2 con el mapping nuevo, POST /_reindex del viejo al nuevo, y luego cambia el alias atómicamente:
POST /_aliases
{
"actions": [
{ "remove": { "index": "products_v1", "alias": "products" } },
{ "add": { "index": "products_v2", "alias": "products" } }
]
}
Las lecturas nunca ven el cambio. Mantén el índice viejo hasta que el nuevo demuestre que funciona, luego haz snapshot y bórralo.
¿Qué versión de Elasticsearch debería instalar?
El último minor de 8.x. Los upgrades de major pasan por el último minor del major anterior (8 → 9 exige el último 8.x primero), así que mantenerte al día abarata los upgrades. Si sigues en 7.x, subir a 8.x es el momento de adoptar la seguridad por enrollment y dejar los settings de índice a nivel nodo — no existen en 8.
¿La replicación de Elasticsearch es un backup?
No. Las réplicas protegen contra caídas de nodos — copian borrados y corrupción con la misma fidelidad que los datos. Si alguien ejecuta DELETE /products o una migración mala corrompe el índice, cada réplica guarda el mismo daño. Los snapshots a un repositorio separado son el backup; las réplicas son disponibilidad.
¿Cómo escalo el cluster más adelante?
Añadiendo nodos data — eso es lo que significa escalar horizontal aquí. Los nodos nuevos se unen vía discovery.seed_hosts, los shards se rebalancean solos y las búsquedas se reparten por la capacidad extra. Añade nodos cuando la presión de heap se mantenga alta o el conteo de shards se acerque al techo de ~20 por GB de heap; añade una réplica cuando necesites throughput de lectura, no más almacenamiento.
Recursos Relacionados
Guía Completa de Sharding de Bases de Datos
Domina el sharding: shard keys, estrategias de partición, consistent hashing, consultas cross-shard, resharding, Vitess y Citus.
GuideBúsqueda de Texto Completo: Implementa Búsqueda que Funciona
Guía práctica de búsqueda de texto completo: tsvector de PostgreSQL, indexación en Elasticsearch, diseño de consultas, ajuste de relevancia y construcción de búsqueda confiable con autocompletado, faceting y tolerancia a errores.
RecipeCómo usar agregaciones de Elasticsearch (con ejemplos)
Usá agregaciones de Elasticsearch para búsqueda facetada, métricas y análisis de series temporales. Ejemplos de terms, date_histogram, range y composite.
GuideGuía Completa de Kafka Stream Processing
Construye pipelines de eventos en tiempo real con Kafka: producers, consumers, Kafka Streams, Connect, schema registry y patrones.
GuideGuía Completa de Replicación en PostgreSQL
Configura y opera la replicación de PostgreSQL en producción: streaming y replicación lógica, commit síncrono, failover con Patroni y monitorización del lag.
GuideDesnormalización: espacio por velocidad de lectura
Guía práctica de desnormalización de bases de datos: cuándo cambiar almacenamiento por rendimiento de lectura y mantener datos consistentes.