¿Para qué se utiliza Elasticsearch?

Elasticsearch es un motor de búsqueda y análisis distribuido utilizado para búsqueda de texto completo, análisis de registros, monitoreo de aplicaciones y análisis de datos en tiempo real. Se utiliza comúnmente para la búsqueda en sitios web, agregación de registros con la pila ELK e inteligencia empresarial.

¿Cómo verifico la salud del clúster de Elasticsearch?

Utilice el comando curl -X GET "localhost:9200/_cluster/health?pretty" para verificar el estado del clúster. El color verde indica que todos los shards están asignados, el amarillo significa que los réplicas no están asignados y el rojo señala que algunos shards primarios no están asignados.

¿Cuál es la diferencia entre una consulta y un filtro en Elasticsearch?

Las consultas calculan puntuaciones de relevancia y se utilizan para búsquedas de texto completo, mientras que los filtros son decisiones de sí/no que no asignan puntuación a los documentos. Los filtros son más rápidos y admiten caché, lo que los hace ideales para datos estructurados como rangos, términos y lógica booleana.

¿Cómo optimizar el rendimiento de Elasticsearch?

Las optimaciones clave incluyen un dimensionamiento adecuado de los shards (20-50 GB por shard), el uso de la API bulk para el indexado, la implementación de mappings correctos con los tipos de campo apropiados, la configuración de intervalos de actualización de índices y el uso de filtros en lugar de consultas cuando no se requiere scoring.

¿Qué es la pila ELK?

ELK son las siglas de Elasticsearch, Logstash y Kibana. Elasticsearch almacena y busca datos, Logstash recopila y procesa registros, y Kibana visualiza datos. Juntos, ofrecen una solución completa para la gestión y análisis de registros.

¿Cómo se respaldan los datos de Elasticsearch?

Utilice la API de instantáneas y restauración de Elasticsearch. Primero, registre un repositorio con PUT /_snapshot/my_backup; luego, cree instantáneas con PUT /_snapshot/my_backup/snapshot_1?wait_for_completion=true. Almacene las instantáneas en sistemas de archivos compartidos, S3, Azure o GCS.

Hoja de referencia de Elasticsearch: Comandos esenciales y consejos

Comandos de Elasticsearch para búsqueda, indexación y análisis

Índice

Elasticsearch es un potente motor de búsqueda y análisis distribuido construido sobre Apache Lucene. Esta hoja de referencia integral cubre los comandos esenciales, las mejores prácticas y referencias rápidas para trabajar con clústeres de Elasticsearch.

elasticsearch

Nota: La mayoría de los ejemplos de esta guía utilizan cURL para las solicitudes HTTP. Si eres nuevo en cURL o necesitas una referencia rápida para opciones avanzadas, consulta nuestra Hoja de referencia de cURL para técnicas detalladas de solicitudes HTTP desde la línea de comandos.

Gestión del Clúster

Verificar la salud del clúster

Todos los comandos de esta sección utilizan cURL para interactuar con la API REST de Elasticsearch. Puedes personalizar estas solicitudes con encabezados adicionales, autenticación y otras opciones según sea necesario.

# Comprobación básica de salud
curl -X GET "localhost:9200/_cluster/health?pretty"

# Salud detallada del clúster con información de particiones (shards)
curl -X GET "localhost:9200/_cluster/health?level=shards&pretty"

# Verificar información de nodos
curl -X GET "localhost:9200/_cat/nodes?v"

# Verificar la configuración del clúster
curl -X GET "localhost:9200/_cluster/settings?pretty"

Operaciones de nodo

# Listar todos los nodos
curl -X GET "localhost:9200/_cat/nodes?v&h=name,node.role,heap.percent,ram.percent,cpu,load_1m"

# Estadísticas del nodo
curl -X GET "localhost:9200/_nodes/stats?pretty"

# Hilos activos (resolución de problemas)
curl -X GET "localhost:9200/_nodes/hot_threads"

Gestión de Índices

Crear y eliminar índices

# Crear índice
curl -X PUT "localhost:9200/my_index?pretty"

# Crear índice con configuraciones
curl -X PUT "localhost:9200/my_index" -H 'Content-Type: application/json' -d'
{
  "settings": {
    "number_of_shards": 3,
    "number_of_replicas": 1
  }
}
'

# Eliminar índice
curl -X DELETE "localhost:9200/my_index?pretty"

# Listar todos los índices
curl -X GET "localhost:9200/_cat/indices?v"

# Estadísticas del índice
curl -X GET "localhost:9200/my_index/_stats?pretty"

Mapeos de índice

# Definir mapeo
curl -X PUT "localhost:9200/products" -H 'Content-Type: application/json' -d'
{
  "mappings": {
    "properties": {
      "name": { "type": "text" },
      "price": { "type": "float" },
      "created_at": { "type": "date" },
      "tags": { "type": "keyword" },
      "description": { 
        "type": "text",
        "analyzer": "english"
      }
    }
  }
}
'

# Obtener mapeo
curl -X GET "localhost:9200/products/_mapping?pretty"

# Actualizar mapeo (añadir campo)
curl -X PUT "localhost:9200/products/_mapping" -H 'Content-Type: application/json' -d'
{
  "properties": {
    "category": { "type": "keyword" }
  }
}
'

Plantillas de índice

# Crear plantilla de índice
curl -X PUT "localhost:9200/_index_template/logs_template" -H 'Content-Type: application/json' -d'
{
  "index_patterns": ["logs-*"],
  "template": {
    "settings": {
      "number_of_shards": 1
    },
    "mappings": {
      "properties": {
        "timestamp": { "type": "date" },
        "message": { "type": "text" },
        "level": { "type": "keyword" }
      }
    }
  }
}
'

# Listar plantillas
curl -X GET "localhost:9200/_index_template?pretty"

Operaciones de Documentos (CRUD)

Crear documentos

# Indexar documento con ID generado automáticamente
curl -X POST "localhost:9200/products/_doc?pretty" -H 'Content-Type: application/json' -d'
{
  "name": "Portátil",
  "price": 999.99,
  "tags": ["electrónica", "ordenadores"]
}
'

# Indexar documento con ID específico
curl -X PUT "localhost:9200/products/_doc/1?pretty" -H 'Content-Type: application/json' -d'
{
  "name": "Portátil",
  "price": 999.99
}
'

# Indexación masiva (bulk)
curl -X POST "localhost:9200/_bulk?pretty" -H 'Content-Type: application/json' -d'
{ "index": { "_index": "products", "_id": "1" }}
{ "name": "Portátil", "price": 999.99 }
{ "index": { "_index": "products", "_id": "2" }}
{ "name": "Ratón", "price": 29.99 }
'

Leer documentos

# Obtener documento por ID
curl -X GET "localhost:9200/products/_doc/1?pretty"

# Obtener múltiples documentos
curl -X GET "localhost:9200/_mget?pretty" -H 'Content-Type: application/json' -d'
{
  "docs": [
    { "_index": "products", "_id": "1" },
    { "_index": "products", "_id": "2" }
  ]
}
'

# Verificar si el documento existe
curl -I "localhost:9200/products/_doc/1"

Actualizar documentos

# Actualizar documento
curl -X POST "localhost:9200/products/_update/1?pretty" -H 'Content-Type: application/json' -d'
{
  "doc": {
    "price": 899.99
  }
}
'

# Actualizar con script
curl -X POST "localhost:9200/products/_update/1?pretty" -H 'Content-Type: application/json' -d'
{
  "script": {
    "source": "ctx._source.price *= params.discount",
    "params": {
      "discount": 0.9
    }
  }
}
'

# Upsert (actualizar o insertar)
curl -X POST "localhost:9200/products/_update/1?pretty" -H 'Content-Type: application/json' -d'
{
  "doc": {
    "price": 899.99
  },
  "doc_as_upsert": true
}
'

Eliminar documentos

# Eliminar por ID
curl -X DELETE "localhost:9200/products/_doc/1?pretty"

# Eliminar por consulta
curl -X POST "localhost:9200/products/_delete_by_query?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "match": {
      "name": "old"
    }
  }
}
'

Consultas de búsqueda

Búsqueda básica

# Coincidir con todo
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "match_all": {}
  }
}
'

# Consulta de coincidencia
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "match": {
      "name": "laptop"
    }
  }
}
'

# Consulta de coincidencia múltiple
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "multi_match": {
      "query": "laptop gaming",
      "fields": ["name", "description"]
    }
  }
}
'

Consultas a nivel de término

# Consulta de término (coincidencia exacta)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "term": {
      "tags": "electronics"
    }
  }
}
'

# Consulta de términos (múltiples valores)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "terms": {
      "tags": ["electronics", "computers"]
    }
  }
}
'

# Consulta de rango
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "range": {
      "price": {
        "gte": 100,
        "lte": 1000
      }
    }
  }
}
'

# Consulta de existencia
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "exists": {
      "field": "description"
    }
  }
}
'

Consultas booleanas

# Consulta bool (must, should, must_not, filter)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "bool": {
      "must": [
        { "match": { "name": "laptop" }}
      ],
      "filter": [
        { "range": { "price": { "gte": 500 }}}
      ],
      "should": [
        { "term": { "tags": "gaming" }}
      ],
      "must_not": [
        { "term": { "tags": "refurbished" }}
      ]
    }
  }
}
'

Búsqueda avanzada

# Consulta de comodín
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "wildcard": {
      "name": "lap*"
    }
  }
}
'

# Consulta difusa (tolerancia a errores tipográficos)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "fuzzy": {
      "name": {
        "value": "laptpo",
        "fuzziness": "AUTO"
      }
    }
  }
}
'

# Consulta de prefijo
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "prefix": {
      "name": "lap"
    }
  }
}
'

Agregaciones

Agregaciones métricas

# Promedio, suma, mínimo, máximo
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "avg_price": { "avg": { "field": "price" }},
    "max_price": { "max": { "field": "price" }},
    "min_price": { "min": { "field": "price" }},
    "total_sales": { "sum": { "field": "price" }}
  }
}
'

# Agregación de estadísticas
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "price_stats": {
      "stats": { "field": "price" }
    }
  }
}
'

Agregaciones de contenedores (buckets)

# Agregación de términos (agrupar por)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "popular_tags": {
      "terms": {
        "field": "tags",
        "size": 10
      }
    }
  }
}
'

# Agregación de rango
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "price_ranges": {
      "range": {
        "field": "price",
        "ranges": [
          { "to": 50 },
          { "from": 50, "to": 100 },
          { "from": 100 }
        ]
      }
    }
  }
}
'

# Histograma de fechas
curl -X GET "localhost:9200/logs/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "logs_over_time": {
      "date_histogram": {
        "field": "timestamp",
        "calendar_interval": "day"
      }
    }
  }
}
'

Agregaciones anidadas

# Agregaciones anidadas
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 0,
  "aggs": {
    "categories": {
      "terms": { "field": "category" },
      "aggs": {
        "avg_price": {
          "avg": { "field": "price" }
        }
      }
    }
  }
}
'

Ordenación y Paginación

# Ordenar por campo
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": { "match_all": {} },
  "sort": [
    { "price": { "order": "desc" }},
    { "_score": { "order": "desc" }}
  ]
}
'

# Paginación con from/size
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "from": 0,
  "size": 10,
  "query": { "match_all": {} }
}
'

# Search after (para paginación profunda)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "size": 10,
  "query": { "match_all": {} },
  "sort": [{ "price": "asc" }, { "_id": "asc" }],
  "search_after": [100, "product_123"]
}
'

Selección de campos y resaltado

# Seleccionar campos específicos
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": { "match_all": {} },
  "_source": ["name", "price"]
}
'

# Resaltado (highlighting)
curl -X GET "localhost:9200/products/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "match": { "description": "gaming laptop" }
  },
  "highlight": {
    "fields": {
      "description": {}
    }
  }
}
'

Alias de índice

# Crear alias
curl -X POST "localhost:9200/_aliases?pretty" -H 'Content-Type: application/json' -d'
{
  "actions": [
    { "add": { "index": "products_v1", "alias": "products" }}
  ]
}
'

# Cambiar alias a un nuevo índice (sin tiempo de inactividad)
curl -X POST "localhost:9200/_aliases?pretty" -H 'Content-Type: application/json' -d'
{
  "actions": [
    { "remove": { "index": "products_v1", "alias": "products" }},
    { "add": { "index": "products_v2", "alias": "products" }}
  ]
}
'

# Listar alias
curl -X GET "localhost:9200/_cat/aliases?v"

Reindexación

# Reindexar de un índice a otro
curl -X POST "localhost:9200/_reindex?pretty" -H 'Content-Type: application/json' -d'
{
  "source": {
    "index": "old_products"
  },
  "dest": {
    "index": "new_products"
  }
}
'

# Reindexar con consulta
curl -X POST "localhost:9200/_reindex?pretty" -H 'Content-Type: application/json' -d'
{
  "source": {
    "index": "products",
    "query": {
      "range": {
        "price": { "gte": 100 }
      }
    }
  },
  "dest": {
    "index": "expensive_products"
  }
}
'

Instantáneas y copias de seguridad

# Registrar repositorio de instantáneas
curl -X PUT "localhost:9200/_snapshot/my_backup?pretty" -H 'Content-Type: application/json' -d'
{
  "type": "fs",
  "settings": {
    "location": "/mount/backups/my_backup"
  }
}
'

# Crear instantánea
curl -X PUT "localhost:9200/_snapshot/my_backup/snapshot_1?wait_for_completion=true&pretty"

# Restaurar instantánea
curl -X POST "localhost:9200/_snapshot/my_backup/snapshot_1/_restore?pretty"

# Listar instantáneas
curl -X GET "localhost:9200/_snapshot/my_backup/_all?pretty"

# Eliminar instantánea
curl -X DELETE "localhost:9200/_snapshot/my_backup/snapshot_1?pretty"

Optimización de rendimiento

Configuración de índices

# Desactivar actualización (refresh) durante indexación masiva
curl -X PUT "localhost:9200/products/_settings?pretty" -H 'Content-Type: application/json' -d'
{
  "index": {
    "refresh_interval": "-1"
  }
}
'

# Reactivar después de indexación masiva
curl -X PUT "localhost:9200/products/_settings?pretty" -H 'Content-Type: application/json' -d'
{
  "index": {
    "refresh_interval": "1s"
  }
}
'

# Fusionar segmentos (optimizar)
curl -X POST "localhost:9200/products/_forcemerge?max_num_segments=1&pretty"

Limpieza de caché

# Limpiar todas las cachés
curl -X POST "localhost:9200/_cache/clear?pretty"

# Limpiar caché específica
curl -X POST "localhost:9200/products/_cache/clear?query=true&pretty"

Monitorización y resolución de problemas

# Tareas pendientes
curl -X GET "localhost:9200/_cat/pending_tasks?v"

# Estadísticas de pools de hilos
curl -X GET "localhost:9200/_cat/thread_pool?v"

# Información de segmentos
curl -X GET "localhost:9200/_cat/segments?v"

# Información de recuperación
curl -X GET "localhost:9200/_cat/recovery?v&h=index,stage,time"

# API de tareas
curl -X GET "localhost:9200/_tasks?detailed=true&pretty"

Ejemplos de cliente en Python

from elasticsearch import Elasticsearch

# Conectar a Elasticsearch
es = Elasticsearch(['http://localhost:9200'])

# Indexar documento
doc = {
    'name': 'Portátil',
    'price': 999.99,
    'tags': ['electrónica']
}
es.index(index='products', id=1, document=doc)

# Buscar
resp = es.search(index='products', query={'match': {'name': 'laptop'}})
for hit in resp['hits']['hits']:
    print(hit['_source'])

# Indexación masiva
from elasticsearch.helpers import bulk

actions = [
    {
        '_index': 'products',
        '_id': i,
        '_source': {'name': f'Producto {i}', 'price': i * 10}
    }
    for i in range(1000)
]
bulk(es, actions)

Ejemplos de cliente en JavaScript/Node.js

El cliente de JavaScript de Elasticsearch proporciona una forma segura de tipos para interactuar con su clúster. Para aplicaciones de producción, considere usar TypeScript para una mayor seguridad de tipos y autocompletado. Consulte nuestra Hoja de referencia de TypeScript para mejores prácticas sobre definiciones de tipos e interfaces.

const { Client } = require('@elastic/elasticsearch');
const client = new Client({ node: 'http://localhost:9200' });

// Indexar documento
async function indexDoc() {
  await client.index({
    index: 'products',
    id: 1,
    document: {
      name: 'Portátil',
      price: 999.99
    }
  });
}

// Buscar
async function search() {
  const result = await client.search({
    index: 'products',
    query: {
      match: { name: 'laptop' }
    }
  });
  console.log(result.hits.hits);
}

// Indexación masiva
async function bulkIndex() {
  const operations = [];
  for (let i = 0; i < 1000; i++) {
    operations.push({ index: { _index: 'products', _id: i } });
    operations.push({ name: `Producto ${i}`, price: i * 10 });
  }
  await client.bulk({ operations });
}

Ejemplo en TypeScript con tipado fuerte

import { Client } from '@elastic/elasticsearch';

interface Product {
  name: string;
  price: number;
  tags?: string[];
  created_at?: Date;
}

const client = new Client({ node: 'http://localhost:9200' });

async function indexProduct(product: Product, id: number): Promise<void> {
  await client.index<Product>({
    index: 'products',
    id: id.toString(),
    document: product
  });
}

async function searchProducts(query: string): Promise<Product[]> {
  const result = await client.search<Product>({
    index: 'products',
    query: {
      match: { name: query }
    }
  });
  
  return result.hits.hits.map(hit => hit._source as Product);
}

Mejores prácticas

Diseño de índices

Mantenga el tamaño de las particiones (shards) entre 20-50 GB para un rendimiento óptimo
Utilice la gestión del ciclo de vida de índices (ILM) para datos de series temporales
Diseñe los mapeos cuidadosamente antes de indexar datos
Utilice tipos de campo apropiados (keyword vs text, formatos de fecha)
Desactive _source para documentos grandes si no es necesario

Optimización de consultas

Utilice filtros en lugar de consultas cuando no se necesite puntuación
Prefiera consultas a nivel de término para datos estructurados
Utilice la consulta bool para combinar múltiples condiciones de forma eficiente
Implemente paginación con search_after para paginación profunda
Caché de filtros utilizados frecuentemente

Rendimiento de indexación

Utilice la API bulk para indexación por lotes (1000-5000 documentos por solicitud)
Desactive la actualización (refresh) durante operaciones masivas
Aumente index.refresh_interval durante indexación pesada
Utilice múltiples hilos/trabajadores para indexación paralela
Considere usar enrutamiento (routing) para una mejor distribución de particiones

Gestión del clúster

Monitoree la salud del clúster regularmente
Configure una configuración de réplicas adecuada
Utilice nodos maestros dedicados para clústeres grandes
Implemente una estrategia de copias de seguridad adecuada con instantáneas
Monitoree el uso de memoria JVM (mantener por debajo del 75%)

Seguridad

Habilite la autenticación y autorización (X-Pack Security)
Utilice HTTPS para despliegues de producción (configure cURL con las opciones --cacert, --cert, y --key para SSL/TLS)
Implemente un control de acceso basado en roles adecuado
Actualizaciones y parches de seguridad regulares
Encripte los datos en reposo y en tránsito

Casos de uso comunes

Búsqueda de texto completo

Elasticsearch sobresale en la búsqueda de texto completo con características como:

Puntuación de relevancia
Coincidencia difusa
Coincidencia de frases
Manejo de sinónimos
Soporte multilingüe Si está evaluando mantener la búsqueda dentro de Postgres o moverse a un motor de búsqueda dedicado, esta comparación de búsqueda de texto completo de PostgreSQL vs Elasticsearch detalla las compensaciones prácticas.

Análisis de registros (Stack ELK)

Recopilar registros con Logstash/Filebeat
Indexar y buscar registros en Elasticsearch
Visualizar con paneles de Kibana
Configurar alertas para anomalías

Búsqueda de comercio electrónico

Búsqueda de catálogo de productos
Navegación facetada con agregaciones
Autocompletado y sugerencias
Resultados de búsqueda personalizados

Monitorización del rendimiento de aplicaciones

Indexar métricas de la aplicación
Paneles de monitorización en tiempo real
Detección de anomalías
Análisis de tendencias de rendimiento

Enlaces útiles

Recursos oficiales de Elasticsearch

Hojas de referencia y guías relacionadas

Hoja de referencia de cURL - Esencial para dominar las solicitudes HTTP a la API REST de Elasticsearch
Hoja de referencia de TypeScript: Conceptos centrales y mejores prácticas - Construye aplicaciones de cliente Elasticsearch seguras de tipos