Instalación de Elasticsearch: Guía Completa de Configuración del Motor de Búsqueda y Análisis

Elasticsearch es un motor de búsqueda y análisis distribuido y RESTful construido sobre Apache Lucene, diseñado para manejar volúmenes masivos de datos con capacidades de búsqueda en tiempo casi real. Como el corazón del Elastic Stack (anteriormente ELK Stack), Elasticsearch impulsa desde la búsqueda simple de sitios hasta análisis complejos de logs, inteligencia empresarial y análisis de seguridad. Esta guía completa proporciona instrucciones detalladas para instalar, configurar y optimizar Elasticsearch para uso en producción.

Introducción

En el paisaje moderno de datos, la capacidad de buscar, analizar y visualizar grandes volúmenes de datos rápidamente es crucial para el éxito empresarial. Elasticsearch aborda esta necesidad proporcionando una plataforma poderosa y escalable para búsqueda de texto completo, análisis de datos estructurados y gestión de datos de series temporales.

¿Qué Hace Poderoso a Elasticsearch?

Búsqueda de Texto Completo: Capacidades de búsqueda avanzadas con puntuación de relevancia, coincidencia difusa y soporte de consultas complejas permiten experiencias de búsqueda sofisticadas comparables a los principales motores de búsqueda.

Casi Tiempo Real: Los documentos se vuelven buscables en segundos después de la indexación, permitiendo análisis en tiempo real y paneles de monitoreo.

Arquitectura Distribuida: Escalamiento horizontal a través de múltiples nodos proporciona alta disponibilidad y la capacidad de manejar petabytes de datos.

Documentos JSON Sin Esquema: Almacenar y buscar documentos JSON complejos y anidados sin esquemas predefinidos, adaptándose dinámicamente a tu estructura de datos.

API RESTful: API simple basada en HTTP hace que la integración con cualquier lenguaje de programación sea directa.

Agregaciones Poderosas: Operaciones complejas de análisis, estadísticas y agrupación rivalizan con las herramientas tradicionales de inteligencia empresarial.

Casos de Uso Comunes

  • Búsqueda de Aplicaciones: Impulsar características de búsqueda de sitios web y aplicaciones con ajuste de relevancia
  • Análisis de Datos de Logs y Eventos: Centralizar y analizar logs de sistemas distribuidos
  • Análisis de Seguridad: Detectar amenazas y anomalías en datos de eventos de seguridad
  • Análisis Empresarial: Analizar métricas empresariales y generar perspectivas de datos operacionales
  • Monitoreo y Observabilidad: Rastrear rendimiento del sistema y métricas de aplicaciones
  • Búsqueda de Productos E-commerce: Implementar búsqueda facetada con filtros y recomendaciones
  • Análisis Geoespacial: Buscar y analizar datos basados en ubicación

Esta guía se centra en la instalación de Elasticsearch lista para producción con seguridad, optimización de rendimiento y mejores prácticas.

Requisitos Previos

Elasticsearch tiene requisitos específicos que deben cumplirse antes de la instalación.

Requisitos del Sistema

Requisitos Mínimos (Desarrollo/Pruebas):

  • Servidor Linux (Ubuntu 20.04+, Debian 11+, CentOS 8+, Rocky Linux 8+)
  • 2 núcleos CPU
  • 4GB RAM
  • 20GB espacio en disco
  • Java 11 o superior (OpenJDK u Oracle JDK)

Recomendado para Producción:

  • 4+ núcleos CPU (8+ para cargas de trabajo pesadas)
  • 16GB+ RAM (32GB+ recomendado)
  • Almacenamiento SSD con 100GB+ espacio disponible
  • Nodos Elasticsearch dedicados (no compartidos con aplicaciones)
  • Múltiples nodos para alta disponibilidad (3+ nodos recomendados)

Planificación de Memoria

Elasticsearch es intensivo en memoria. Sigue estas pautas:

Memoria Heap:

  • Establecer al 50% de RAM disponible (máximo 32GB por nodo)
  • Nunca exceder 32GB de heap (punteros comprimidos deshabilitados sobre 32GB)
  • Reservar RAM restante para caché del sistema de archivos Lucene

Ejemplo de Cálculo:

  • Servidor con 64GB RAM: Establecer heap a 31GB, dejando 33GB para SO y caché de archivos
  • Servidor con 16GB RAM: Establecer heap a 8GB, dejando 8GB para SO y caché de archivos

Requisitos de Almacenamiento

Planificación de Almacenamiento:

  • Calcular tamaño de datos esperado: tasa de ingesta diaria × días de retención × 1.25 (sobrecarga)
  • Usar SSDs para producción (mejora de rendimiento 10x+ sobre HDDs)
  • Planificar 20-30% de espacio libre en disco para fusiones y optimización

Ejemplo de Cálculo:

  • Ingesta diaria: 50GB
  • Retención: 30 días
  • Almacenamiento requerido: 50GB × 30 × 1.25 = 1,875GB (~2TB)

Requisitos de Red

  • Puerto 9200 (API HTTP) accesible desde aplicaciones cliente
  • Puerto 9300 (Capa de transporte) para comunicación entre nodos
  • Red de baja latencia para clusters multi-nodo
  • Firewall configurado para restringir acceso externo

Prerrequisitos de Software

  • Java Development Kit (JDK) 11 o superior
  • Acceso root o sudo
  • Curl o wget para pruebas
  • Editor de texto (vim, nano, etc.)

Instalación

Método 1: Instalación de Repositorio de Paquetes (Recomendado)

Usar repositorios oficiales de Elasticsearch garantiza que recibas actualizaciones y parches de seguridad.

Instalación Ubuntu/Debian

Paso 1: Importar Clave GPG de Elasticsearch

wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg

Paso 2: Agregar Repositorio de Elasticsearch

sudo apt install -y apt-transport-https

echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list

Paso 3: Actualizar Índice de Paquetes

sudo apt update

Paso 4: Instalar Elasticsearch

sudo apt install -y elasticsearch

La instalación generará una contraseña aleatoria para el superusuario elastic y un token de inscripción. Guárdalos de forma segura:

--------------------------- Security autoconfiguration information ----------------------------

Authentication and authorization are enabled.
TLS for the transport and HTTP layers is enabled and configured.

The generated password for the elastic built-in superuser is: ABC123xyz789==

If this node should join an existing cluster, you can reconfigure this with
'/usr/share/elasticsearch/bin/elasticsearch-reconfigure-node --enrollment-token <token-here>'
after creating an enrollment token on your existing cluster.

You can complete the following actions at any time:

Reset the password of the elastic built-in superuser with
'/usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic'.

Generate an enrollment token for Kibana instances with
'/usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana'.

Generate an enrollment token for Elasticsearch nodes with
'/usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s node'.
---------------------------------------------------------------------------------------------------

Paso 5: Configurar Sistema para Iniciar Elasticsearch

sudo systemctl daemon-reload
sudo systemctl enable elasticsearch
sudo systemctl start elasticsearch

Instalación CentOS/Rocky Linux

Paso 1: Importar Clave GPG de Elasticsearch

sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

Paso 2: Crear Archivo de Repositorio

sudo tee /etc/yum.repos.d/elasticsearch.repo << 'EOF'
[elasticsearch]
name=Elasticsearch repository for 8.x packages
baseurl=https://artifacts.elastic.co/packages/8.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md
EOF

Paso 3: Instalar Elasticsearch

sudo dnf install -y elasticsearch

Paso 4: Habilitar e Iniciar Servicio

sudo systemctl daemon-reload
sudo systemctl enable elasticsearch
sudo systemctl start elasticsearch

Método 2: Instalación Manual de Archivo

Para instalaciones personalizadas o entornos no estándar:

Descargar y Extraer

# Descargar Elasticsearch (verificar https://www.elastic.co/downloads/elasticsearch para última versión)
cd /tmp
wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-8.11.0-linux-x86_64.tar.gz

# Extraer
sudo tar -xzf elasticsearch-8.11.0-linux-x86_64.tar.gz -C /opt/
sudo mv /opt/elasticsearch-8.11.0 /opt/elasticsearch

# Crear usuario elasticsearch
sudo useradd -r -s /bin/false elasticsearch

# Establecer propiedad
sudo chown -R elasticsearch:elasticsearch /opt/elasticsearch

Crear Servicio Systemd

Crear /etc/systemd/system/elasticsearch.service:

[Unit]
Description=Elasticsearch
Documentation=https://www.elastic.co
Wants=network-online.target
After=network-online.target

[Service]
Type=notify
RuntimeDirectory=elasticsearch
PrivateTmp=true
Environment=ES_HOME=/opt/elasticsearch
Environment=ES_PATH_CONF=/opt/elasticsearch/config
Environment=PID_DIR=/var/run/elasticsearch
Environment=ES_SD_NOTIFY=true
WorkingDirectory=/opt/elasticsearch

User=elasticsearch
Group=elasticsearch

ExecStart=/opt/elasticsearch/bin/elasticsearch

StandardOutput=journal
StandardError=inherit

LimitNOFILE=65535
LimitNPROC=4096
LimitAS=infinity
LimitFSIZE=infinity

TimeoutStopSec=0

KillMode=process
KillSignal=SIGTERM

SendSIGKILL=no
SuccessExitStatus=143

[Install]
WantedBy=multi-user.target

Habilitar e iniciar:

sudo systemctl daemon-reload
sudo systemctl enable elasticsearch
sudo systemctl start elasticsearch

Método 3: Instalación Docker

Para entornos contenerizados:

# Crear red
docker network create elastic

# Ejecutar Elasticsearch
docker run -d \
  --name elasticsearch \
  --net elastic \
  -p 9200:9200 \
  -p 9300:9300 \
  -e "discovery.type=single-node" \
  -e "ES_JAVA_OPTS=-Xms2g -Xmx2g" \
  -v es-data:/usr/share/elasticsearch/data \
  docker.elastic.co/elasticsearch/elasticsearch:8.11.0

# Obtener contraseña generada
docker logs elasticsearch | grep "Password for the elastic user"

Verificación Post-Instalación

# Verificar estado del servicio
sudo systemctl status elasticsearch

# Esperar que Elasticsearch inicie (puede tomar 30-60 segundos)
sleep 30

# Probar conexión (usar contraseña generada)
curl -k -u elastic:YOUR_GENERATED_PASSWORD https://localhost:9200

# La salida esperada muestra información del cluster

Configuración

La configuración de Elasticsearch se gestiona principalmente a través de elasticsearch.yml y opciones JVM.

Archivo de Configuración Principal

Ubicación: /etc/elasticsearch/elasticsearch.yml (instalación de paquete) o /opt/elasticsearch/config/elasticsearch.yml (instalación manual)

Configuraciones Esenciales

Configuración de Cluster y Nodo

# Nombre del cluster (todos los nodos en el cluster deben tener el mismo nombre)
cluster.name: production-cluster

# Nombre del nodo (único para cada nodo)
node.name: es-node-1

# Roles del nodo (master, data, ingest, ml, etc.)
node.roles: [master, data, ingest]

# Configuración de red
network.host: 0.0.0.0
http.port: 9200
transport.port: 9300

# Configuración de descubrimiento (para nodo único)
discovery.type: single-node

# Configuración de descubrimiento (para cluster multi-nodo)
# discovery.seed_hosts: ["es-node-1", "es-node-2", "es-node-3"]
# cluster.initial_master_nodes: ["es-node-1", "es-node-2", "es-node-3"]

Configuración de Rutas

# Directorio de datos (puede especificar múltiples para múltiples discos)
path.data: /var/lib/elasticsearch

# Directorio de logs
path.logs: /var/log/elasticsearch

Configuraciones de Memoria

# Bloquear memoria para evitar swapping
bootstrap.memory_lock: true

Configuración de Seguridad (Elasticsearch 8.x)

Elasticsearch 8.x habilita seguridad por defecto:

# Características de seguridad
xpack.security.enabled: true
xpack.security.enrollment.enabled: true

# SSL/TLS para HTTP
xpack.security.http.ssl.enabled: true
xpack.security.http.ssl.keystore.path: certs/http.p12

# SSL/TLS para capa de transporte
xpack.security.transport.ssl.enabled: true
xpack.security.transport.ssl.verification_mode: certificate
xpack.security.transport.ssl.keystore.path: certs/transport.p12
xpack.security.transport.ssl.truststore.path: certs/transport.p12

Configuración de Tamaño de Heap JVM

Editar /etc/elasticsearch/jvm.options o /etc/elasticsearch/jvm.options.d/custom.options:

# Establecer tamaño de heap (50% de RAM, máx 32GB)
-Xms8g
-Xmx8g

# Para producción con 32GB+ RAM
-Xms31g
-Xmx31g

Reglas Importantes:

  • Establecer Xms y Xmx al mismo valor
  • No exceder 32GB (punteros comprimidos deshabilitados sobre esto)
  • Establecer al 50% de RAM disponible
  • Dejar RAM restante para caché del sistema de archivos

Configuración del Sistema

Deshabilitar Swapping

El swapping degrada severamente el rendimiento de Elasticsearch.

Método 1: Deshabilitar Swap Completamente

sudo swapoff -a

# Hacer permanente
sudo sed -i '/ swap / s/^/#/' /etc/fstab

Método 2: Configurar Swappiness

sudo sysctl -w vm.swappiness=1
echo "vm.swappiness=1" | sudo tee -a /etc/sysctl.conf

Aumentar Descriptores de Archivo

# Verificar límites actuales
ulimit -n

# Establecer para usuario elasticsearch
sudo tee -a /etc/security/limits.conf << EOF
elasticsearch soft nofile 65536
elasticsearch hard nofile 65536
elasticsearch soft nproc 4096
elasticsearch hard nproc 4096
elasticsearch soft memlock unlimited
elasticsearch hard memlock unlimited
EOF

Para servicios systemd, los límites ya están configurados en el archivo de servicio.

Configuraciones de Memoria Virtual

# Aumentar conteo de mapas de memoria virtual
sudo sysctl -w vm.max_map_count=262144

# Hacer permanente
echo "vm.max_map_count=262144" | sudo tee -a /etc/sysctl.conf

Configuración de Firewall

UFW (Ubuntu/Debian)

# Permitir desde servidores de aplicaciones específicos
sudo ufw allow from 192.168.1.0/24 to any port 9200 proto tcp

# Permitir comunicación entre nodos (para clusters)
sudo ufw allow from 192.168.1.0/24 to any port 9300 proto tcp

# Recargar firewall
sudo ufw reload

firewalld (CentOS/Rocky)

# Crear zona para Elasticsearch
sudo firewall-cmd --permanent --new-zone=elasticsearch
sudo firewall-cmd --permanent --zone=elasticsearch --add-source=192.168.1.0/24
sudo firewall-cmd --permanent --zone=elasticsearch --add-port=9200/tcp
sudo firewall-cmd --permanent --zone=elasticsearch --add-port=9300/tcp

# Recargar firewall
sudo firewall-cmd --reload

Configuración de Seguridad

Restablecer Contraseña del Usuario Elastic

# Restablecer contraseña para superusuario elastic
sudo /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic -i

# O auto-generar
sudo /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic

Crear Usuarios Adicionales

# Crear usuario con rol específico
sudo /usr/share/elasticsearch/bin/elasticsearch-users useradd myuser -r superuser

# Crear usuario con rol personalizado
sudo /usr/share/elasticsearch/bin/elasticsearch-users useradd readonly_user -r viewer

Deshabilitar Seguridad (No Recomendado para Producción)

Solo para desarrollo/pruebas:

Editar /etc/elasticsearch/elasticsearch.yml:

xpack.security.enabled: false
xpack.security.enrollment.enabled: false
xpack.security.http.ssl.enabled: false
xpack.security.transport.ssl.enabled: false

Reiniciar Elasticsearch:

sudo systemctl restart elasticsearch

Ajuste de Rendimiento

Configuraciones a Nivel de Índice

Crear índice con configuraciones óptimas:

curl -k -u elastic:password -X PUT "https://localhost:9200/myindex" -H 'Content-Type: application/json' -d'
{
  "settings": {
    "number_of_shards": 3,
    "number_of_replicas": 1,
    "refresh_interval": "30s",
    "index.codec": "best_compression"
  }
}
'

Configuración de Thread Pool

Agregar a elasticsearch.yml:

thread_pool:
  write:
    queue_size: 1000
  search:
    queue_size: 1000

Reiniciar Elasticsearch

Después de cambios de configuración:

sudo systemctl restart elasticsearch

# Verificar inicio
sudo journalctl -u elasticsearch -f

Ejemplos Prácticos

Ejemplo 1: Creación y Consulta de Índice

Crear Índice:

curl -k -u elastic:password -X PUT "https://localhost:9200/products" -H 'Content-Type: application/json' -d'
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 0
  },
  "mappings": {
    "properties": {
      "name": { "type": "text" },
      "description": { "type": "text" },
      "price": { "type": "float" },
      "category": { "type": "keyword" },
      "created_at": { "type": "date" }
    }
  }
}
'

Indexar Documentos:

# Indexar documento único
curl -k -u elastic:password -X POST "https://localhost:9200/products/_doc/1" -H 'Content-Type: application/json' -d'
{
  "name": "Laptop Pro 15",
  "description": "High performance laptop with 16GB RAM",
  "price": 1299.99,
  "category": "Electronics",
  "created_at": "2024-01-15"
}
'

# Indexación masiva
curl -k -u elastic:password -X POST "https://localhost:9200/products/_bulk" -H 'Content-Type: application/json' -d'
{"index":{"_id":"2"}}
{"name":"Wireless Mouse","description":"Ergonomic wireless mouse","price":29.99,"category":"Electronics","created_at":"2024-01-16"}
{"index":{"_id":"3"}}
{"name":"USB-C Cable","description":"High speed USB-C charging cable","price":12.99,"category":"Accessories","created_at":"2024-01-17"}
'

Buscar Documentos:

# Búsqueda simple
curl -k -u elastic:password -X GET "https://localhost:9200/products/_search?q=laptop"

# Búsqueda compleja con query DSL
curl -k -u elastic:password -X GET "https://localhost:9200/products/_search" -H 'Content-Type: application/json' -d'
{
  "query": {
    "bool": {
      "must": [
        { "match": { "description": "wireless" } }
      ],
      "filter": [
        { "range": { "price": { "lte": 50 } } }
      ]
    }
  },
  "sort": [
    { "price": { "order": "asc" } }
  ]
}
'

Ejemplo 2: Ingesta y Análisis de Logs

Crear Índice de Logs con Patrón de Fecha:

curl -k -u elastic:password -X PUT "https://localhost:9200/logs-2024.01.15" -H 'Content-Type: application/json' -d'
{
  "settings": {
    "number_of_shards": 2,
    "number_of_replicas": 1
  },
  "mappings": {
    "properties": {
      "timestamp": { "type": "date" },
      "level": { "type": "keyword" },
      "message": { "type": "text" },
      "service": { "type": "keyword" },
      "host": { "type": "keyword" },
      "response_time": { "type": "integer" }
    }
  }
}
'

Indexar Entradas de Log:

curl -k -u elastic:password -X POST "https://localhost:9200/logs-2024.01.15/_bulk" -H 'Content-Type: application/json' -d'
{"index":{}}
{"timestamp":"2024-01-15T10:00:00","level":"INFO","message":"User logged in","service":"auth","host":"web-1","response_time":45}
{"index":{}}
{"timestamp":"2024-01-15T10:01:00","level":"ERROR","message":"Database connection failed","service":"api","host":"web-2","response_time":5000}
{"index":{}}
{"timestamp":"2024-01-15T10:02:00","level":"WARN","message":"High memory usage detected","service":"monitor","host":"web-1","response_time":120}
'

Analizar Logs:

# Contar errores por servicio
curl -k -u elastic:password -X GET "https://localhost:9200/logs-*/_search" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "query": {
    "term": { "level": "ERROR" }
  },
  "aggs": {
    "errors_by_service": {
      "terms": { "field": "service" }
    }
  }
}
'

# Tiempo de respuesta promedio por hora
curl -k -u elastic:password -X GET "https://localhost:9200/logs-*/_search" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "response_times": {
      "date_histogram": {
        "field": "timestamp",
        "calendar_interval": "hour"
      },
      "aggs": {
        "avg_response": {
          "avg": { "field": "response_time" }
        }
      }
    }
  }
}
'

Ejemplo 3: Búsqueda de Texto Completo con Relevancia

Crear Índice de Artículos:

curl -k -u elastic:password -X PUT "https://localhost:9200/articles" -H 'Content-Type: application/json' -d'
{
  "settings": {
    "analysis": {
      "analyzer": {
        "english_analyzer": {
          "type": "standard",
          "stopwords": "_english_"
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "title": {
        "type": "text",
        "analyzer": "english_analyzer",
        "boost": 2.0
      },
      "content": {
        "type": "text",
        "analyzer": "english_analyzer"
      },
      "tags": { "type": "keyword" },
      "author": { "type": "keyword" },
      "published_date": { "type": "date" }
    }
  }
}
'

Buscar con Resaltado:

curl -k -u elastic:password -X GET "https://localhost:9200/articles/_search" -H 'Content-Type: application/json' -d'
{
  "query": {
    "multi_match": {
      "query": "elasticsearch performance",
      "fields": ["title^2", "content"],
      "type": "best_fields"
    }
  },
  "highlight": {
    "fields": {
      "title": {},
      "content": {}
    }
  },
  "size": 10
}
'

Ejemplo 4: Agregaciones y Análisis

Ejemplo de Análisis de Ventas:

# Consulta de agregación compleja
curl -k -u elastic:password -X GET "https://localhost:9200/sales/_search" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "sales_over_time": {
      "date_histogram": {
        "field": "sale_date",
        "calendar_interval": "month"
      },
      "aggs": {
        "total_revenue": {
          "sum": { "field": "amount" }
        },
        "average_sale": {
          "avg": { "field": "amount" }
        },
        "top_products": {
          "terms": {
            "field": "product_name",
            "size": 5
          },
          "aggs": {
            "product_revenue": {
              "sum": { "field": "amount" }
            }
          }
        }
      }
    }
  }
}
'

Ejemplo 5: Integración con Python

Usando Cliente Python de Elasticsearch:

from elasticsearch import Elasticsearch
from datetime import datetime

# Conectar a Elasticsearch
es = Elasticsearch(
    ['https://localhost:9200'],
    basic_auth=('elastic', 'your_password'),
    verify_certs=False
)

# Indexar documento
doc = {
    'title': 'Elasticsearch Guide',
    'content': 'Learn how to use Elasticsearch effectively',
    'author': 'John Doe',
    'published_date': datetime.now(),
    'tags': ['elasticsearch', 'search', 'tutorial']
}

response = es.index(index='articles', document=doc)
print(f"Indexed document ID: {response['_id']}")

# Buscar documentos
search_query = {
    'query': {
        'match': {
            'content': 'elasticsearch'
        }
    }
}

results = es.search(index='articles', body=search_query)
print(f"Found {results['hits']['total']['value']} results")

for hit in results['hits']['hits']:
    print(f"- {hit['_source']['title']}")

# Agregación
agg_query = {
    'size': 0,
    'aggs': {
        'tags_count': {
            'terms': {
                'field': 'tags',
                'size': 10
            }
        }
    }
}

agg_results = es.search(index='articles', body=agg_query)
for bucket in agg_results['aggregations']['tags_count']['buckets']:
    print(f"{bucket['key']}: {bucket['doc_count']}")

Verificación

Verificaciones Básicas de Salud

# Salud del cluster
curl -k -u elastic:password "https://localhost:9200/_cluster/health?pretty"

# Información del nodo
curl -k -u elastic:password "https://localhost:9200/_nodes?pretty"

# Estadísticas del cluster
curl -k -u elastic:password "https://localhost:9200/_cluster/stats?pretty"

# Información de índice
curl -k -u elastic:password "https://localhost:9200/_cat/indices?v"

# Estadísticas del nodo
curl -k -u elastic:password "https://localhost:9200/_cat/nodes?v"

Pruebas de Rendimiento

# Instalar esrally (herramienta de benchmarking de Elasticsearch)
pip3 install esrally

# Ejecutar benchmark
esrally race --track=geonames --target-hosts=localhost:9200 --client-options="basic_auth_user:'elastic',basic_auth_password:'password',verify_certs:false"

Monitorear Uso de Recursos

# Verificar uso de heap JVM
curl -k -u elastic:password "https://localhost:9200/_cat/nodes?v&h=name,heap.percent,heap.current,heap.max,ram.percent,ram.current,ram.max"

# Verificar uso de disco
curl -k -u elastic:password "https://localhost:9200/_cat/allocation?v"

# Verificar thread pools
curl -k -u elastic:password "https://localhost:9200/_cat/thread_pool?v&h=node_name,name,active,queue,rejected,completed"

Solución de Problemas

Problema 1: Elasticsearch No Inicia

Síntoma: El servicio falla al iniciar

Solución:

# Verificar logs
sudo journalctl -u elasticsearch -n 100 --no-pager

# Problemas comunes y soluciones:

# 1. Memoria insuficiente
# Verificar memoria disponible
free -h
# Reducir tamaño de heap en /etc/elasticsearch/jvm.options

# 2. Puerto ya en uso
sudo ss -tlnp | grep 9200
# Matar proceso o cambiar puerto en elasticsearch.yml

# 3. Problemas de permisos
sudo chown -R elasticsearch:elasticsearch /var/lib/elasticsearch
sudo chown -R elasticsearch:elasticsearch /var/log/elasticsearch
sudo chown -R elasticsearch:elasticsearch /etc/elasticsearch

# 4. vm.max_map_count muy bajo
sudo sysctl -w vm.max_map_count=262144

Problema 2: Alto Uso de Memoria

Síntoma: Elasticsearch consumiendo demasiada memoria o experimentando errores OOM

Solución:

# Verificar uso actual de heap
curl -k -u elastic:password "https://localhost:9200/_nodes/stats/jvm?pretty"

# Reducir tamaño de heap si es muy alto
sudo nano /etc/elasticsearch/jvm.options
# Establecer valores apropiados:
# -Xms8g
# -Xmx8g

# Limpiar caché de field data
curl -k -u elastic:password -X POST "https://localhost:9200/_cache/clear?fielddata=true"

# Verificar fugas de memoria
curl -k -u elastic:password "https://localhost:9200/_nodes/stats/indices/fielddata?fields=*&pretty"

# Reiniciar servicio
sudo systemctl restart elasticsearch

Problema 3: Consultas Lentas

Síntoma: Consultas de búsqueda tomando mucho tiempo

Solución:

# Habilitar slow log
curl -k -u elastic:password -X PUT "https://localhost:9200/myindex/_settings" -H 'Content-Type: application/json' -d'
{
  "index.search.slowlog.threshold.query.warn": "10s",
  "index.search.slowlog.threshold.query.info": "5s",
  "index.search.slowlog.threshold.fetch.warn": "1s",
  "index.indexing.slowlog.threshold.index.warn": "10s"
}
'

# Verificar slow log
sudo tail -f /var/log/elasticsearch/*_index_search_slowlog.log

# Optimizar índice
curl -k -u elastic:password -X POST "https://localhost:9200/myindex/_forcemerge?max_num_segments=1"

# Verificar perfil de consulta
# Agregar "profile": true a tu consulta de búsqueda

Problema 4: Problemas de Espacio en Disco

Síntoma: Cluster entrando en modo solo lectura o rechazando escrituras

Solución:

# Verificar uso de disco
curl -k -u elastic:password "https://localhost:9200/_cat/allocation?v"

# Eliminar bloqueo de solo lectura
curl -k -u elastic:password -X PUT "https://localhost:9200/_all/_settings" -H 'Content-Type: application/json' -d'
{
  "index.blocks.read_only_allow_delete": null
}
'

# Eliminar índices antiguos
curl -k -u elastic:password -X DELETE "https://localhost:9200/logs-2023.*"

# Reducir conteo de réplicas
curl -k -u elastic:password -X PUT "https://localhost:9200/myindex/_settings" -H 'Content-Type: application/json' -d'
{
  "number_of_replicas": 0
}
'

# Aumentar umbrales de watermark de disco
curl -k -u elastic:password -X PUT "https://localhost:9200/_cluster/settings" -H 'Content-Type: application/json' -d'
{
  "persistent": {
    "cluster.routing.allocation.disk.watermark.low": "90%",
    "cluster.routing.allocation.disk.watermark.high": "95%"
  }
}
'

Problema 5: Conexión Rechazada

Síntoma: No se puede conectar a Elasticsearch

Solución:

# Verificar si el servicio está ejecutándose
sudo systemctl status elasticsearch

# Verificar puertos en escucha
sudo ss -tlnp | grep 9200

# Verificar configuración network.host
sudo grep "network.host" /etc/elasticsearch/elasticsearch.yml

# Deshabilitar temporalmente firewall para pruebas
sudo ufw disable  # Ubuntu
sudo systemctl stop firewalld  # CentOS

# Probar conexión local
curl -k -u elastic:password https://localhost:9200

# Verificar problemas de certificado SSL
curl -v -k -u elastic:password https://localhost:9200

Problema 6: Fallos de Autenticación

Síntoma: Errores 401 No Autorizado

Solución:

# Restablecer contraseña de elastic
sudo /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic

# Probar con nueva contraseña
curl -k -u elastic:NEW_PASSWORD https://localhost:9200

# Verificar si la seguridad está habilitada
sudo grep "xpack.security.enabled" /etc/elasticsearch/elasticsearch.yml

# Deshabilitar temporalmente seguridad (solo desarrollo)
# Editar /etc/elasticsearch/elasticsearch.yml:
# xpack.security.enabled: false
# sudo systemctl restart elasticsearch

Mejores Prácticas

Mejores Prácticas de Gestión de Índices

  1. Usar Index Lifecycle Management (ILM):
curl -k -u elastic:password -X PUT "https://localhost:9200/_ilm/policy/logs_policy" -H 'Content-Type: application/json' -d'
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover": {
            "max_size": "50GB",
            "max_age": "1d"
          }
        }
      },
      "warm": {
        "min_age": "7d",
        "actions": {
          "shrink": {
            "number_of_shards": 1
          },
          "forcemerge": {
            "max_num_segments": 1
          }
        }
      },
      "delete": {
        "min_age": "30d",
        "actions": {
          "delete": {}
        }
      }
    }
  }
}
'

  1. Dimensionamiento Apropiado de Shards:

    • Tamaño objetivo de shard: 10-50GB
    • Evitar demasiados shards pequeños (sobrecarga)
    • Evitar muy pocos shards grandes (distribución pobre)

  2. Deshabilitar Réplicas Durante Indexación Masiva:

curl -k -u elastic:password -X PUT "https://localhost:9200/myindex/_settings" -H 'Content-Type: application/json' -d'
{
  "number_of_replicas": 0,
  "refresh_interval": "-1"
}
'

# Después de que la indexación masiva se complete
curl -k -u elastic:password -X PUT "https://localhost:9200/myindex/_settings" -H 'Content-Type: application/json' -d'
{
  "number_of_replicas": 1,
  "refresh_interval": "1s"
}
'

Mejores Prácticas de Seguridad

  1. Siempre Habilitar Seguridad en Producción
  2. Usar Control de Acceso Basado en Roles (RBAC)
  3. Habilitar Registro de Auditoría:
xpack.security.audit.enabled: true
  1. Usar TLS/SSL para Todas las Conexiones
  2. Actualizar Contraseñas Regularmente
  3. Implementar Segmentación de Red
  4. Restringir Acceso Anónimo

Mejores Prácticas de Rendimiento

  1. Optimizar Mappings:

    • Usar tipos de campo apropiados
    • Deshabilitar indexación para campos que no buscas
    • Usar filtrado de _source para documentos grandes

  2. Operaciones Masivas:

    • Usar API bulk para indexar múltiples documentos
    • Tamaño de bulk óptimo: 5-15MB

  3. Optimización de Consultas:

    • Usar filtros en lugar de consultas cuando sea posible (cacheable)
    • Evitar consultas wildcard en grandes conjuntos de datos
    • Usar filtrado de _source para retornar solo campos necesarios

  4. Monitorear y Alertar:

    • Configurar monitoreo de salud del cluster
    • Alertar sobre uso alto de heap (>75%)
    • Monitorear espacio en disco
    • Rastrear rendimiento de consultas

Mejores Prácticas de Respaldo

  1. Configurar Repositorio de Snapshots:
# Crear directorio de respaldo
sudo mkdir -p /backup/elasticsearch
sudo chown elasticsearch:elasticsearch /backup/elasticsearch

# Registrar repositorio de snapshot
curl -k -u elastic:password -X PUT "https://localhost:9200/_snapshot/my_backup" -H 'Content-Type: application/json' -d'
{
  "type": "fs",
  "settings": {
    "location": "/backup/elasticsearch",
    "compress": true
  }
}
'

# Crear snapshot
curl -k -u elastic:password -X PUT "https://localhost:9200/_snapshot/my_backup/snapshot_1?wait_for_completion=true"

# Restaurar snapshot
curl -k -u elastic:password -X POST "https://localhost:9200/_snapshot/my_backup/snapshot_1/_restore"
  1. Script de Respaldo Automatizado:
#!/bin/bash
DATE=$(date +%Y%m%d_%H%M%S)
SNAPSHOT_NAME="snapshot_$DATE"

curl -k -u elastic:password -X PUT "https://localhost:9200/_snapshot/my_backup/$SNAPSHOT_NAME?wait_for_completion=false"

# Programar con cron
# 0 2 * * * /usr/local/bin/elasticsearch-backup.sh

Mejores Prácticas de Monitoreo

  1. Métricas Clave a Monitorear:

    • Estado del cluster (verde, amarillo, rojo)
    • Uso de heap JVM
    • Espacio en disco
    • Uso de CPU
    • Latencia de consultas
    • Tasa de indexación
    • Tasa de búsqueda

  2. Usar Características de Monitoreo de Elasticsearch:

    • Habilitar monitoreo en Kibana
    • Usar Metricbeat para métricas del sistema
    • Configurar alertas para condiciones críticas

Conclusión

Elasticsearch es un motor de búsqueda y análisis poderoso que, cuando se instala y configura adecuadamente, proporciona un rendimiento y escalabilidad excepcionales para una amplia gama de casos de uso. Esta guía completa te ha llevado a través del proceso completo de configurar una instalación de Elasticsearch lista para producción.

Conclusiones Clave:

Instalación: Ya sea usando gestores de paquetes, instalación manual o Docker, asegúrate de seguir las mejores prácticas de seguridad desde el inicio, incluyendo habilitar autenticación y encriptación TLS/SSL.

Configuración: La asignación adecuada de memoria, el ajuste del sistema y las configuraciones de índice son críticas para el rendimiento óptimo. Recuerda la regla del 50% de heap y nunca exceder 32GB por nodo.

Seguridad: Elasticsearch 8.x habilita seguridad por defecto, lo cual es esencial para despliegues en producción. Siempre usa contraseñas fuertes, control de acceso basado en roles y restricciones de red.

Rendimiento: Optimiza el dimensionamiento de shards, usa mappings apropiados, aprovecha las operaciones masivas e implementa gestión del ciclo de vida de índices para un alto rendimiento sostenido.

Monitoreo: El monitoreo regular de la salud del cluster, uso de recursos y rendimiento de consultas ayuda a identificar problemas antes de que impacten a los usuarios.

Respaldos: Implementa estrategias automatizadas de snapshots para proteger contra pérdida de datos y habilitar recuperación ante desastres.

La versatilidad de Elasticsearch lo hace adecuado para todo, desde búsquedas simples de sitios web hasta análisis complejos de logs e inteligencia empresarial. Siguiendo las mejores prácticas descritas en esta guía, has establecido una base sólida para aprovechar el potencial completo de Elasticsearch.

A medida que tus datos crecen y los requisitos evolucionan, Elasticsearch escala contigo a través de clustering, optimización de índices y características avanzadas. Continúa aprendiendo sobre el rico ecosistema de Elasticsearch, incluyendo Kibana para visualización, Logstash para procesamiento de datos y Beats para envío de datos.

Tu instalación de Elasticsearch ahora está lista para impulsar experiencias de búsqueda rápidas y relevantes y entregar perspectivas accionables de tus datos. Monitorea, optimiza e itera sobre tu configuración a medida que aprendas qué funciona mejor para tus casos de uso específicos.

¡Bienvenido al mundo de búsqueda y análisis potentes y escalables con Elasticsearch!