Aprende a Diseñar y Optimizar Mappings en Elasticsearch para Datos Estructurados

Elasticsearch es una potente base de datos distribuida de código abierto para búsquedas, análisis y almacenamiento de datos. En su núcleo, la forma en que Elasticsearch interpreta y almacena tus datos está definida por algo llamado mapping. Un mapping es como el esquema de una tabla en una base de datos relacional, pero con mucha más flexibilidad y capacidades de análisis.

Sin un mapping bien diseñado, tus búsquedas pueden ser ineficientes, irrelevantes o incluso imposibles. Este tutorial te guiará a través de los conceptos fundamentales, las mejores prácticas y técnicas avanzadas para diseñar y optimizar mappings en Elasticsearch.

💡 ¿Qué es un Mapping en Elasticsearch?

En Elasticsearch, un mapping es el proceso de definir cómo se almacena y se indexa un documento y sus campos. Describe los campos de un documento, su tipo de datos (por ejemplo, string, integer, date), y cómo deben ser procesados por los analizadores para la búsqueda.

Cuando indexas un documento, Elasticsearch intenta inferir el tipo de datos de cada campo (conocido como dynamic mapping). Si bien esto es útil para empezar rápidamente, para aplicaciones de producción y datos estructurados, es crucial definir tus mappings explícitamente. Esto te da control sobre:

• Tipos de datos: Asegura que los campos se traten como números, fechas, texto, etc.
• Analizadores: Define cómo el texto se tokeniza y normaliza para la búsqueda.
• Indexación: Controla si un campo es buscable y cómo.
• Formatos: Especifica formatos para fechas o números.

Tipos de Mappings

Existen dos tipos principales de mappings en Elasticsearch:

1. Dynamic Mapping: Elasticsearch intenta adivinar el tipo de datos de un campo cuando se indexa por primera vez. Esto es conveniente pero puede llevar a mappings subóptimos o incorrectos.
2. Explicit Mapping: Defines el esquema de tus documentos de antemano. Esta es la práctica recomendada para la mayoría de los casos de uso en producción.

🛠️ Creación de Mappings Explícitos

Para crear un mapping explícito, utilizas la API _mapping o lo defines al crear un índice. Vamos a ver un ejemplo básico. Imagina que queremos indexar documentos que representan productos.

PUT /productos
{
  "mappings": {
    "properties": {
      "nombre": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "descripcion": {
        "type": "text"
      },
      "precio": {
        "type": "float"
      },
      "stock": {
        "type": "integer"
      },
      "fecha_creacion": {
        "type": "date",
        "format": "yyyy/MM/dd HH:mm:ss||yyyy/MM/dd"
      },
      "categoria": {
        "type": "keyword"
      },
      "disponible": {
        "type": "boolean"
      }
    }
  }
}

En este ejemplo:

• nombre y descripcion son de tipo text porque queremos buscar dentro de su contenido. El campo nombre también tiene un subcampo keyword para búsquedas exactas (filtros, agregaciones).
• precio es float para números decimales.
• stock es integer para números enteros.
• fecha_creacion es date y especificamos múltiples formatos para que Elasticsearch pueda parsearlos correctamente.
• categoria es keyword porque queremos buscar coincidencias exactas y usarlo en agregaciones (facetas).
• disponible es boolean para valores verdadero/falso.

✅ Obtener un Mapping Existente

Puedes obtener el mapping actual de un índice con el siguiente comando:

GET /productos/_mapping

🎯 Tipos de Datos Fundamentales y su Uso

Elegir el tipo de datos correcto es crucial para el rendimiento y la funcionalidad. Aquí están algunos de los tipos más comunes:

Campos text vs keyword

Esta es una de las decisiones más importantes.

• text: El contenido se analiza. Esto significa que se divide en tokens (palabras individuales), se normaliza (se convierte a minúsculas, se eliminan stop words, etc.) y se indexa. Es ideal para búsquedas de texto completo (match query).
• keyword: El contenido se indexa tal cual, sin análisis. Ideal para búsquedas de igualdad (term query), filtros, ordenaciones (sort) y agregaciones (aggregations).

Es común mapear el mismo campo como text y keyword usando multi-fields. Esto permite buscar el campo de ambas maneras:

"nombre": {
  "type": "text",
  "fields": {
    "keyword": {
      "type": "keyword",
      "ignore_above": 256 
    }
  }
}

Aquí, nombre es text (para búsqueda de texto completo) y nombre.keyword es keyword (para filtros y agregaciones). ignore_above evita indexar cadenas muy largas como keywords, ahorrando espacio.

✨ Analizadores y Tokens

Los analizadores son los cerebros detrás de cómo Elasticsearch procesa el texto para la búsqueda. Un analizador es una combinación de:

1. Character filters: Limpian el texto (e.g., eliminan etiquetas HTML).
2. Tokenizer: Divide el texto en tokens (palabras).
3. Token filters: Modifican los tokens (e.g., lowercase, stemming, stop words).

Elasticsearch tiene analizadores predefinidos como standard, simple, whitespace, english, etc. También puedes crear analizadores personalizados.

Ejemplo de Analizador Personalizado

Supongamos que queremos un analizador para nombres de productos que elimine apóstrofes y convierta todo a minúsculas, además de usar un diccionario de sinónimos.

PUT /productos_v2
{
  "settings": {
    "analysis": {
      "char_filter": {
        "apóstrofe_filter": {
          "type": "mapping",
          "mappings": ["' => " ]
        }
      },
      "filter": {
        "sinonimos_filter": {
          "type": "synonym",
          "synonyms": [
            "usb, universal serial bus",
            "pc, ordenador personal"
          ]
        }
      },
      "analyzer": {
        "mi_analizador_producto": {
          "type": "custom",
          "char_filter": ["html_strip", "apóstrofe_filter"],
          "tokenizer": "standard",
          "filter": ["lowercase", "sinonimos_filter", "stop"]
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "nombre": {
        "type": "text",
        "analyzer": "mi_analizador_producto",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "descripcion": {
        "type": "text",
        "analyzer": "english"
      }
    }
  }
}

Aquí, nombre usa mi_analizador_producto que limpia apóstrofes, tokeniza, convierte a minúsculas, aplica sinónimos y elimina stop words. La descripcion usa el analizador english por defecto para un análisis más avanzado en inglés.

📈 Optimización de Mappings para el Rendimiento

Un mapping bien optimizado no solo mejora la relevancia de las búsquedas, sino también la velocidad de indexación y el uso del disco.

Reducir el Número de Campos Indexados

Cada campo indexado consume recursos (CPU, RAM, disco). Si no necesitas buscar en un campo o usarlo para agregaciones, puedes deshabilitar su indexación con "index": false.

"campo_solo_visualizacion": {
  "type": "text",
  "index": false 
}

El campo seguirá siendo almacenado en _source y podrás recuperarlo, pero no será buscable.

Deshabilitar _source (Con Cautela)

El campo _source almacena el documento JSON original. Deshabilitarlo ahorra espacio, pero significa que no podrás recuperar el documento original directamente, ni usar funciones como update o reindex.

PUT /indice_sin_source
{
  "mappings": {
    "_source": {
      "enabled": false
    },
    "properties": {
      "id": {"type": "keyword"}
    }
  }
}

Uso de Multi-fields Inteligentes

Como vimos con text y keyword, los multi-fields son muy potentes. Considera qué combinaciones son realmente necesarias. Por ejemplo, si tienes un campo ciudad, podrías querer:

• ciudad.text: Para búsquedas de texto completo (e.g., "nueva york").
• ciudad.keyword: Para filtros exactos y agregaciones (e.g., "New York").
• ciudad.lowercase: Para búsquedas exactas pero case-insensitive.

"ciudad": {
  "type": "text",
  "fields": {
    "keyword": {"type": "keyword"},
    "lowercase": {
      "type": "keyword",
      "normalizer": "lowercase_normalizer"
    }
  }
}

Para el lowercase_normalizer, necesitarías definirlo en settings:

"settings": {
  "analysis": {
    "normalizer": {
      "lowercase_normalizer": {
        "type": "custom",
        "char_filter": [],
        "token_filter": ["lowercase"]
      }
    }
  }
}

Campos object vs nested

Cuando tienes arrays de objetos, la elección entre object y nested es crucial.

• object: Elasticsearch aplana los objetos en el array. Esto puede romper la correlación entre los campos del mismo objeto.

  Por ejemplo, si tienes "tags": [{"nombre": "rojo", "tipo": "color"}, {"nombre": "grande", "tipo": "tamaño"}] Una búsqueda para nombre:rojo AND tipo:tamaño podría encontrar el documento, incluso si rojo y tamaño provienen de objetos diferentes.

• nested: Trata cada objeto en el array como un documento oculto e independiente. Esto mantiene la correlación y permite búsquedas precisas en arrays de objetos.

"etiquetas": {
"type": "nested",
"properties": {
"nombre": {"type": "keyword"},
"tipo": {"type": "keyword"}
}
}

Luego, para buscar, usarías una `nested query`:

GET /productos/_search
{
"query": {
"nested": {
"path": "etiquetas",
"query": {
"bool": {
"must": [
{ "match": { "etiquetas.nombre": "rojo" } },
{ "match": { "etiquetas.tipo": "color" } }
]
}
}
}
}
}

<div class="callout note">📌 <strong>Nota:</strong> Los campos `nested` aumentan el uso de memoria y disco debido a la indexación de documentos ocultos. Úsalos solo cuando la correlación de campos en arrays de objetos sea fundamental.</div>

Plantillas Dinámicas (Dynamic Templates)

Las plantillas dinámicas te permiten aplicar mappings específicos a campos que aún no existen, basándose en su nombre, tipo o ruta. Son muy útiles para estandarizar cómo se mapean nuevos campos.

Por ejemplo, mapear todas las cadenas que terminan en _id como keyword:

PUT /logs
{
  "mappings": {
    "dynamic_templates": [
      {
        "string_as_keyword": {
          "match_mapping_type": "string",
          "match":   "*_id",
          "mapping": {
            "type": "keyword"
          }
        }
      }
    ]
  }
}

📊 Escenarios Comunes y Soluciones de Mappings

Aquí hay algunos escenarios comunes y cómo los mappings pueden ayudar:

1. Búsqueda de Texto Completo y Filtrado Exacto: Usa multi-fields text y keyword.
2. Fechas y Rangos: Define el type: date y usa el formato adecuado. Para rangos, Elasticsearch puede inferirlos o puedes usar range queries.
3. Datos Geoespaciales: Utiliza geo_point o geo_shape para coordenadas o formas geográficas.

"ubicacion": {
"type": "geo_point"
}

4. Búsqueda en Objetos Anidados: Usa nested para arrays de objetos.

🚧 Buenas Prácticas y Consideraciones Finales

• Planifica tus Mappings: Antes de indexar grandes volúmenes de datos, define tus mappings explícitamente. Cambiar un mapping más tarde es costoso (reindexación).
• Monitorea el Tamaño del Índice: Mappings complejos o demasiados campos indexados pueden hinchar el tamaño del índice y ralentizar las operaciones.
• Usa Alias: En lugar de apuntar directamente a un índice (productos_v1), usa un alias (productos). Cuando necesites cambiar el mapping, crea productos_v2 con el nuevo mapping, reindexa los datos de productos_v1 a productos_v2, y luego actualiza el alias para que apunte a productos_v2. Esto permite un tiempo de inactividad mínimo.

• Evita el field_data en Campos text: Para ordenaciones y agregaciones en campos text, Elasticsearch debe cargar el field_data en memoria, lo cual es costoso. Si necesitas ordenar o agregar un campo de texto, mapea un subcampo keyword o text con un analizador que produzca un único token por valor.

POST /_reindex
{
  "source": {
    "index": "productos_v1"
  },
  "dest": {
    "index": "productos_v2"
  }
}

Diseñar y optimizar tus mappings es una habilidad fundamental para cualquier usuario de Elasticsearch. Al comprender cómo los datos se almacenan y se procesan, puedes crear soluciones de búsqueda más eficientes, precisas y escalables.