Curso completo de Elasticsearch

Elasticsearch
Implementando búsquedas de
datos eficientes y escalables
Cool... bonsai cool
Curso de capacitación - Mercadolibre SRL Julio 2014

¿Quiénes somos?
Fernando A. Rodriguez
(Desarrolador Sr, SYI)
Federico A. Ocampo
(Supervisor, Buyingflow)
Curso de Capacitación - Julio 2014

● Introducir al mundo de los motores de búsquedas y
sus desafíos.
● Aprender las características centrales de
Elasticsearch (y Lucene)...
● ...y cómo utilizarlas para encarar estos desafíos.
● Todo esto teniendo en cuenta los requerimientos de
performance y escalabilidad de Mercadolibre
Objetivos

● Introducción
● Capa distribuida
● E/S de datos
● Búsquedas básicas
● Lucene
● Búsquedas avanzadas
● Analyzers
● Mapping
● Relevancia (Scoring)
● Aggregations
● Integración
● Puesta en Producción
● Funcionalidades
avanzadas
Agenda
Día 1 Día 2

Búsquedas
Las búsquedas son la principal interfaz
para la obtención de información en la
actualidad.

Búsquedas: Motores conocidos

Pero las búsquedas tienen sus
desafíos...
Búsquedas: desafíos

?
?

Existen muchos productos y herramientas para
implementar búsquedas de texto...
Búsquedas: herramientas
● Bases de datos relacionales (SQL)
● Bases No relacionales (MongoDB)
● Soluciones Ad-Hoc ("te lo hago en bash")
● Motores de búsqueda full-text-search (Solr)
... y Elasticsearch

Introducción a
Elasticsearch

¿Qué es Elasticsearch?
Es un motor de búsqueda, orientado a
documentos, basado en Apache Lucene

● Creado por Shay “Kimchy” Banon en el 2010:
“...ElasticSearch itself was born out of my frustration with the fact that there isn’t really
a good, open source, solution for distributed search engine out there”
● Mantenido por él hasta la creación de Elasticsearch.com
(http://elasticsearch.com/) en 2012
● Actualmente desarrollado por la empresa, bajo licencia
Apache 2 (muy flexible).
● La última versión a la fecha es la 1.3.2 (Requiere Java 7.x)
Breve reseña histórica

● Orientado a documentos
○ JSON's, Basado en Apache Lucene
● Libre de schemas
○ Aunque permite definirlos de ser necesario
● Distribuido
○ Escala dinámicamente, implementa HA
● Multi-Tenant
○ Permite operar sobre múltiples índices a la vez
● Centrado en API's
○ Expone casi todas sus funcionalidades vía APIs REST
¿Qué características tiene?

● Búsquedas no estructuradas
○ Todos los items que contengan la palabra “curso”.
● Búsquedas estructuradas
○ Items “oro” vendidos por el user “X” en Marzo.
● Aggregations / Facetas
○ Promedio de precios de los items de la categoría “C”.
● Combinaciones de todo lo anterior
○ Promedio de precios de los items vendidos en Abril de
los usuarios “X” e “Y” en la categoría “C”.
● … y todo en tiempo “casi” real!
¿Y qué puede hacer?

# Crear un documento
curl -XPOST "http://localhost:9200/items/item/MLA1" -d '{
"title" : "Condensador de flujo XT-2000"
}'
# Obtener un documento por ID
curl -XGET "http://localhost:9200/items/item/1
# Buscar un documento por texto
curl -XGET "http://localhost:9200/items/_search?q=Condensador"
# Borrar por ID
curl -XDELETE "http://localhost:9200/items/1"
Una muestra gratis :¬)

Todo muy lindo pero.. ¿quién lo usa?

● Sistema distribuido
○ Implementa la lógica de coordinación de los nodos
de un cluster y el mantenimiento de sus datos
● Motor de búsqueda
○ Proporciona las funcionalidades de indexación y
búsqueda de documentos.
Componentes principales
Elasticsearch se compone de dos capas principales
bien definidas y desacopladas:
... veamos como funciona la primera

Sistema
distribuido

¿Qué esperamos en Meli de un sistema distribuido?
● Performance
● Escalabilidad
● Alta disponibilidad
● Tolerancia a fallos
Sistema distribuido: introducción

Sistema distribuido: glosario
Cluster Nodos Indices Tipos
Conjunto de
instancias de ES
que comparten
mismo nombre
(cluster.name)
Instancia de
Elasticsearch
Colección de varios
documentos
(objeto JSON), no
necesariamente de
igual estructura.
Comparable a
esquemas de bases
de datos
No confundir con
índices de bases de
datos
Colección de varios
documentos de
similar estructura
Comparable a
tablas de bases de
datos

Sistema distribuido: Ejemplo
Cluster: springfield
Indice: usuario
Tipo: preguntas
NODO 1NODO ES
USUARIO
preguntas
{...}
compras
{...}
USUARIO
Preguntas
Compras

Sistema distribuido: más sobre shards
● Partición de la información.
● Puede ser Primario (read/write) o Réplica (read-only).
● Un nodo puede administrar 1 o más shards.
● La cantidad de shards primarios son definidos al crear el
índice y luego no se puede modificar
● Proveen alta disponibilidad y performance.
● Instancias de lucene independientes entre sí .

Sistema distribuido: Ejemplo shard
NODO 1Usuario
homero
homero
lisa
moe
bart
bart
bart
bart
Pregunta
p1
p2
p3
p4
p5
p6
p7
p8
1 shard
NODO 1Usuario
homero
homero
lisa
moe
Pregunta
p1
p2
p3
p4
2 shards
Usuario
bart
bart
bart
bart
Pregunta
p5
p6
p7
p8

NODO 2
Shard 1
(primario)
Shard 0
(replica)
NODO 1
Shard 0
(primario)
Shard 1
(replica)
curl -XPUT localhost:9200/test -d '{
"index" : {
"number_of_shards" : 2,
"number_of_replicas" : 1
}
}'
Sistema distribuido: shards y réplicas

Agregando un nodo...
NODO 2
Shard 1
(primario)
Shard 0
(replica)
NODO 1
Shard 0
(primario)
Shard 1
(replica)
NODO 3

NODO 2
Shard 1
(primario)
Shard 0
(replica)
NODO 1
Shard 0
(primario)
Shard 1
(replica)
NODO 3
Shard 0
(replica)
...se balancea el cluster automáticamente.

NODO 2
Shard 1
(primario)
NODO 1
Shard 0
(primario)
Shard 1
(replica)
NODO 3
Shard 0
(replica)
...se balancea el cluster automáticamente.

Ante la caida de un nodo...
NODO 2
Shard 1
(primario)
NODO 1
Shard 0
(primario)
Shard 1
(replica)
NODO 3
Shard 0
(replica)

NODO 1
... se regeneran los shard faltantes
NODO 2
Shard 1
(primario)
Shard 0
(primario)
NODO 3
Shard 0
(replica)
Shard 1
(replica)

NODO 2NODO 1
Vamos a experimentar un poco
con los shards...
Sistema distribuido: simulación

Data In / Out

{
"id": "MLA464468956",
"title": "Departamento 3 Ambientes En Alquiler - Claypole R",
"price": 5000,
"geolocation": {
"latitude": -34.56854,
"longitude": -58.4678583,
},
"pictures": [
{"url": "http://img2.mlstatic.com/s_MLA_v_O_f_447_062013.jpg"},
{"url": "http://img2.mlstatic.com/s_MLA_v_O_f_534_062014.jpg"}
],
"date_created": "2013-06-12T18:46:00.000Z",
}
● Los documentos se representan en formato JSON
● Cada campo contiene información de cierto tipo.
Estructura de datos

● ES agrega su propia Metadata a los documentos
Campo
_id
_type
_source
_all
_timestamp
_ttl
_size
Default
enabled
enabled
disabled
disabled
disabled
Descripción
ID interno del documento
Tipo de documento
Guarda el doc original indexado
Indexa todos los valores de todos los campos
del documento.
timestamp asociado al documento
define una fecha de expiración (opcional)
almacena el tamaño del _source
descomprimido
Estructura de datos

● Tipos básicos
○ String, number, boolean
● Tipos complejos
○ Array, Object
● Tipos extendidos
○ Datetime, binary (base 64), ip, geo_point, multi-filed...
...más detalles cuando veamos Mapping
ES soporta los tipos de datos propios de JSON y otros
tipos derivados, propios del sistema:
Tipos de datos

Primero necesitamos un índice...
curl -XPUT ‘localhost:9200/items’ -d '{
"settings" : {
...
},
"mappings" : {
...
}
}'
... aunque si no lo creamos, ES lo hace por nosotros usando
una configuración por defecto.
Nombre del índice
Configuraciones opcionales
Insertando datos: Index API

Luego agregamos la información...
curl -XPUT 'localhost:9200/items/item/MLA123' -d '{
"id" : "MLA-123"
"title" : "Delorean modelo '85, joya nunca taxi",
"kmts" : 325000
"seller": "MACFLY_1980"
}'
nombre
tipooperación
HTTP REST
nombre
índice ID documento
documento JSON
a indexar

Podemos dejar que ES defina el ID automáticamente...
curl -XPOST 'localhost:9200/items/item' -d '{
"id" : "MLA-123"
"title" : "Delorean modelo '85, joya nunca taxi",
"kmts" : 325000
}'
nombre
tipooperación
HTTP REST
nombre
índice
documento JSON
a indexar

... obteniendo como respuesta:
{
"ok" : true,
"_index" : "items",
"_type" : "item",
"_id" : "MLA123",
"_version" : 1
}
nombre del índice
nombre del tipo
id del documento
versión del cocumento
● 201 (CREATED): Se creó un nuevo documento
● 200 (OK): Se actualizó un documento existente

Ejecución distribuida:
1. Se genera el request a un
nodo dado.
NODO 1
Shard 1
(primario)
Shard 0
(replica)
Shard 1
(replica)
NODO 2
Shard 0
(primario)
1.
3.
2.
$curl -XPUT ... Cliente
2. El server lee el valor de
routing (por defecto el
_id) y determina en cuál
shard primario (Shard 1)
se indexa el documento
3. Una vez indexado el
documento en el shard
primario, se propaga a
las réplicas

● Permite obtener un documento dado su tipo y ID
curl -XGET 'localhost:9200/items/item/MLA1234'
nombre
tipooperación
HTTP REST
nombre
índice ID documento
● La operación GET se realiza en tiempo real
○ En el momento en que se indexa un documento, está
inmediatamente disponible para ser obtenido vía GET
Obteniendo datos: Get API

... obteniendo como respuesta:
{
"exists" : true,
"_index" : "items",
"_type" : "item",
"_id" : "MLA1234",
"_version" : 1
"_source" : {
"id" : "MLA1234"
"title" : "Delorean...",
"kmts" : 325000,
}
}
nombre del índice
nombre del tipo
id del documento
versión del cocumento
● 200 (CREATED): Si el documento existe
● 404 (NOT FOUND): Si no existe
contenido del
documento

● También pueden obtenerse ciertos campos específicos.
○ Permitir reducir tráfico de red en GETs de documentos grandes.
{
...
"_id" : "MLA1234",
"_fields" : {
"seller_id": 123136,
"item_id": “MLA1234”,
...
}
}
contenido del
campo
curl -XGET 'localhost:9200/items/item/MLA1234?
_source_include=*id&_source_exclude=*picture

1. Se genera el request
routing (por defecto el _id)
y determina en qué shard
se encuentra el documento
(Shard 1).
Luego el nodo receptor
realizar un round-robin
entre todos los shards
primarios y réplicas
3. Se accede finalmente al
shard y se obtiene el
documento.
NODO 1
Shard 1
(primario)
Shard 0
(replica)
Shard 1
(replica)
NODO 2
Shard 0
(primario)
1.
2.
3
.
$curl -XGET ... Cliente

● Si solamente se quiere saber si existe el documento
○ Evita el overhead de transferir el JSON.
curl -XHEAD 'localhost:9200/items/item/MLA1234'
● Si solamente quiere obtenerse el _source
○ Sin metadatos extra
curl -XGET 'localhost:9200/items/item/MLA1234/_source'

● Elimina un documento dado del índice
○ La operación consiste en un borrado lógico. Cuando Elasticsearch lo
determina, procede a borrar los datos físicamente del sistema.
curl -XDELETE 'localhost:9200/items/item/MLA1234'
● Respuestas:
○ 200 (CREATED): Si se borró el documento
○ 404 (NOT_FOUND): Si no se encontró el documento
Eliminando datos: Delete API

routing (por defecto el
_id) y determina en qué
shard primario (Shard 1)
se encuenta el documento
3. Una vez borrado el
documento en el shard
primario, se propaga la
operación en las réplicas
NODO 1
Shard 1
(primario)
Shard 0
(replica)
Shard 1
(replica)
NODO 2
Shard 0
(primario)
1.
3.
2.
$curl -XDELETE
... Cliente
Eliminando datos: Delete API

● Todo documento está versionado
○ Se utiliza para controlar la concurrencia de forma "optimista",
permitiendo ejecutar de forma transaccional las operaciones
○ Ejemplo: read-then-write o write-then-read.
● La versión se asigna al crearse un documento (_version)
○ Por defecto tiene un valor '1' pero puede definirse explícitamente.
○ Por ejemplo si dicho valor viniese desde una base de datos.
● Cada operación de escritura incrementa el valor en 1.
○ Incluye PUT, POST, DELETE
Implementando Optimistic Locking...
Versionado de documentos

● Todas las escrituras retornan una nueva versión
○ La versión del documento luego de ser modificado
● Toda escritura puede recibir una versión
○ Esta es la versión sobre la cual se espera operar.
○ Si este valor no es igual a la versión actual del documento, la
operación falla.
curl -XPUT 'localhost:9200/items/item/MLB2?version=1'
curl -XDELETE 'localhost:9200/items/item/MLB2?version=1'
Versionado de documentos

● Es posible actualizar solo una parte de un documento
○ Internamente ejecuta un get-and-put (reduce el tráfico entre nodos).
○ Reintenta si hubo un conflicto de versiones entre el GET y el PUT.
curl -XPUT 'localhost:9200/items/item/MLA2/_update' -d {
"doc": {
"title": "Dolar blue",
"price": 13.45
}
}
● Los campos que no son objetos se sobreescriben
● Los campos de tipo objeto se mergean recursivamente
Otras operaciones: Update

● Se pueden obtener N documentos juntos por ID
○ Esto evita múltiples rountrips al server
○ Puede hacerse a cualquier nivel (base, índice, tipo)
curl -XPUT 'localhost:9200/documentos/_mget' -d {
"docs": {
{
"_type": "Item",
"_id": "MLA1234"
},{
"_type": "Question",
"_id": 35246
}
}
}
Otras operaciones: Multi-get

● Permite realizar múltiples operaciones en un solo request
○ Esto evita múltiples rountrips al server
○ El cluster conoce a qué shards debe acceder en casa operación.
○ El end-point REST es /_bulk
{ "delete" : { "_index" : "items", "_type" : "item", "_id" : "MLA1" } }n
{ "index" : { "_index" : "items", "_type" : "item", "_id" : "MLA2" } }n
{ "id" : "MLA2", "title" : "La pierna izquierda de Messi" , price: 100000}n
.
.
{ "create" : { "_index" : "items", "_type" : "item", "_id" : "MLA3" } }n
{ "id" : "MLA3", "title" : "La mano izquierda de Ginobili", price: 20000 }n
Operación a realizar
Cuerpo del documento
(opcional)
Todas las líneas deben terminar
en un "retorno de carro"
Otras operaciones: Bulk

● Contiene una respuesta individual para cada operación.
● Se garantiza el orden entre operaciones y respuestas
○ la respuesta de la 3era operación está en 3er lugar
● Si falla una operación, el resto no se ve afectado.
○ A tener en cuenta en caso de consumir mensajes de una cola.
● Cada respuesta incluye los conocidos datos de _index,
_type y _id y por supuesto el contenido del documento o
un descriptor de "error".
Formato de respuesta:
¡es mucho más rápido que request individuales!
Otras operaciones: Bulk

Search API
(Búsquedas básicas)

Hasta ahora no dijimos nada de búsquedas en ES....
● Elasticsearch provee una API muy poderosa para todo lo
que es el proceso de búsqueda: Search API
● Permite realizar desde simples búsquedas de texto hasta
implementar muchas de las funcionalidades que proveen
los grandes buscadores (Google, Mercadolibre... :¬)
...¿y qué funcionalidades son esas?
Búsquedas de texto: Search API

● Relevancia (Scoring)
○ Define qué tan importante es un documento en un conjunto de resultados
● Spellchecker
○ Permite interpretar una búsqueda aunque tenga errores ortográficos
● Soporte multi-lenguaje
○ Permite interpretar búsquedas en diferentes idiomas
● Autocomplete
○ Predice la búsqueda en base a las primeras palabras ingresadas y ofrece
posibles alternativas comunes.
...y todo de manera eficiente, por supuesto
Algunas funcionalidades importantes:

● Ejecutando una búsqueda simple (todo los campos):
curl -XGET 'localhost:9200/items/_search?q=sony'
{
"took" : 5,
"timed_out" : false,
"_shards" : {
"total" : 5,
"successful" : 5,
"failed" : 0
},
...
}
tiempo insumido (ms)
'true' si dió timeout
shards involucrados
(exitosos y fallidos)
● Header de la respuesta:

"hits":{
"total":1,
"max_score":0.3125,
"hits":[
{
"_index":"items",
"_type":"item",
"_id":"MLA123",
"_score":0.3125,
"_source":{
"id":"MLA123",
"title":"Cámara Sony HD"
}
}
]
total de resultados
los resultados de la
primer "página"
fuente del
documento
● Cuerpo de la respuesta:

2. El server determina en
qué shards (primario o
réplica) se encuentran los
documentos (search)
3. Finalmente reunen los
datos de los shards
correspondientes (reduce)
NODO 1
Shard 1
(primario)
Shard 0
(replica)
Shard 1
(replica)
NODO 2
Shard 0
(primario)
1.
3.
2.
Cliente

También permite búsquedas complejas
curl -XGET 'localhost:9200/items/_search?q=sony+OR+nikon'
● Búsquedas booleanas
curl -XGET 'localhost:9200/items/_search?q=price:[10+TO+*]'
● Búsquedas por rango
● ...y mas (búsquedas difusas, expansión de frases, filtros, etc)
¿pero queremos todo en una línea?

Search+Routing
(Ruteando datos)

● Por defecto, los documentos se distribuyen
uniformemente entre todos los shards.
● Luego las búsquedas se ejecutan en todos los shards
relevantes (y posiblemente nodos).
Index
Shard 1 Shard 3
Shard 4 ... Shard N
Shard 2
Cliente
Redireccionando datos: Routing
curl -XGET localhost:9200/users/user/_search -d '{...}'

● Al indexar podemos indicar un valor de _routing el cual
determina a qué shard acceder directamente.
curl -XPUT localhost:9200/users/user/1?routing=MLB -d '{...}'
Cliente
Index
Shard 1 Shard 3
Shard 4 ... Shard N
Shard 2

● Al buscar, si aplicamos routing accedemos sólo a él shard
(primario o réplica) que contiene la información relevante
curl -XGET localhost:9200/users/user/_search?routing=MLB -d '{...}'
Cliente
Index
Shard 1 Shard 3
Shard 4 ... Shard N
Shard 2

● Esto mejora notablemente la performance de las
búsquedas e indexaciones.

Query DSL
(Búsquedas complejas)

● Permite la creación de Queries complejas.
● Se basa en la composición de queries.
Búsquedas complejas: Query DSL

Queries
Filtros
{
"query": {
"filtered": {
"query": {
"match": {"title":"iphone 4s"}
},
"filter": {
"term": {"status": "active"}
}
}
}
}
Búsquedas complejas: Query DSL
Formato:

Es él término utilizado para la búsqueda de texto
{
“match” : {“titulo” : “Star Wars 25”}
}
● Maneja correctamente los tipos de datos (número, boolean, etc) y el
análisis de strings, si se requiere (lo veremos más adelante)
Búsquedas complejas: Match Query

Porcentaje mínimo de "matcheo"
● Cada token es "concatenado" por una bool query
{
“match” : {
“text” : {
“type” : “boolean”,
“query” : “lannister saludos”,
“min_should_match” : “30%”
}
}
}

● Búsquedas de frases dentro de un string
● Parámetro opcional: slop
○ Cantidad de palabras entre dos términos que e
permiten no matchear
{
“match” : {
“text” : {
“type” : “phrase”,
“query” : “Argentina salió campeón”,
“slop” : “1”
}
}
}
Buscando frases...

● Igual a búsqueda por frase pero utilizando prefijos para
el último término.
● Parámetro opcional: max_expansion
○ Especifica cantidad de términos a expandir.
{
“match” : {
“text” : {
“type” : “phrase_prefix”,
“query” : “Argentina salió”,
"max_expansion" : 100
}
}
}
Buscando frases por prefijo

{
"multi_match" : {
"fields" : ["titulo","descripcion","atributo.*"],
"query" : “Item de testeo”,
}
}
Permite buscar en varios campos
● Admite expresiones regulares en los nombres de campos

● Compone queries y es compuesta a su vez
● Tipos
○ should, must y must_not
● Parámetros opcionales
○ minimun_shoud_match
○ disable_coord
Implementa operaciones booleanas entre resultados.
Búsquedas complejas: Bool Query

{
"bool" : {
"must" : [
{"match" : {"tipo" : "cerveza"}},
{"match" : {"tamaño" : 250}}
],
"must_not" : [
{"match" : {"marca" : "quilmes"}}
]
}
}
Búsquedas complejas: Bool Query

● Búsquedas por rangos
○ Númericos / Fechas
○ Strings (por orden lexicográfico)
● Parámetros
○ gt (mayor) / gte (mayor o igual)
○ lt (menor) / lte (menor o igual)
{
"range" : {
"precio" : {
"gte": 100,
"lt": 150
}
}
}
Búsquedas complejas: Range Query

Devuelve todos los documentos
● Generalmente en combinación con otros filtros
{
"match_all" : { }
}
Búsquedas complejas: Match_all Query

● Term query
○ Búsqueda sobre campo sin parsear
○ Similar match, debe usarse este último
● Prefix/Wildcard query
○ Búsqueda parcial sobre campo sin parsear
● Fuzzy query
○ Búsqueda difusa sobre campo sin parsear
○ Bastante lento y consume muchos recursos
● Regexp query
○ Poco performante
Búsquedas complejas: otras queries

Query Filters
(Optimizando búsquedas)

● Varios tipos
○ term,bool,and,or,not,range,geo_distance,...
● Pueden usarse en
○ filtered query
○ constant_score query
○ aggregations
● ¡Cacheable! (super rápido)
Búsquedas complejas: Filtros

Queries Filters
Búsquedas por texto y términos Sólo términos (responde a la
pregunta si/no)
Con relevancias Sin relevancia
Rápido (según query) Muy Rápido
Sin caching Cacheable
Siempre debería usarse "Filters" excepto cuando
se precisa relevancia.
Queries vs Filters

"filtered":{
"query":{ ...query de búsqueda... },
"filter":{
"and":[
{"term": {"listing":"silver"}},
{"term": {"seller": 76060303}}
]
}
}
Composición de
query y filters...
Queries vs Filters

{
"from" : 10, "size" : 30,
"query" : {
"filtered" : {
"filter" : {
"term" : {
"seller_id" : "76060303"
}
}
}
},
"sort" : [ {
"start_time" : {
"order" : "desc",
"missing" : "_last"
}
}]
}
paginado
Ordenamiento
Ordenamiento y paginado

Lucene
(Muy breve introducción)

¿En qué capítulos de la serie Game of Thrones se
menciona al personaje Jon "Snow"?
● ¡Fácil! Busco en todos los diálogos de todos los capítulos
hasta encontrar el texto buscado (Grep).
● El tiempo total es lineal a la cantidad de palabras
● La cantidad de palabras puede ser gigante.
...¿y entonces?
Breve introducción a Lucene

¡Índices invertidos!
● Se toma palabra por palabra de todos los diálogos y se
arma un diccionario de tipo <palabra, [capítulos]>
● Se ordenan las claves alfabéticamente
● Luego para buscar basta con hacer búsqueda binaria en la
cantidad de claves (muchas menos operaciones)

Índices invertidos:
Términos Frecuencia Documentos (ids)
Rob 3 1,2,3
John 1 5
Arya 2 1,4
Ned 1 3
● Implementa una estructura muy eficiente.
● Permite definir relevancia en base a la frecuencia
de aparición de un término (entre e intra docs.)

Apache Lucene implementa estos índices.
● Cada shard de Elasticsearch es una instancia de Lucene
● Por tanto un índice invertido de los datos indexados
● Es ésta librería la que provee las funcionalidades de
análisis y búsqueda de texto libre que ya veremos.
"Apache Lucene is a free/open source information
retrieval software library"

Analyzers
(Análisis y procesamiento de texto)

¿Qué hace Google con mi texto de búsqueda?
● No todo lo que buscamos se usa en los resultados.
○ "Haciendo un buscador" busca "haciendo" y "buscador" (sin "un")
● Ni todo es igual de importante
○ "Elasticsearch, el mejor de todos" prioriza "Elasticsearch" y "mejor"
● Ni tienen que ser las mismas palabras las que se buscan.
○ "Haciendo un buscador" puede buscar "hacer" y "buscador"
...para determinar qué se busca y qué no
existen diversas técnicas
Análisis de texto: Analyzers

● Tokenizing
○ Dividir el texto en términos significativos ("la casa" => ["la", "casa"])
● Stopwords
○ Ignorar los términos comunes de cada lenguaje (Ej: artículos)
● Ignorar 'capitalización'
○ No diferenciar mayúsculas de minúsculas.
● Ignorar caracteres especiales
○ No diferenciar caracteres especiales de su versión original (Ej: ã => a)
● Stemming
○ Transformar una palabra a su "raíz" (Ej: jugando => jugar).
● Sinónimos
○ Incluir en una búsqueda a los sinónimos (Ej: triunfar => ganar).
Técnicas generales de procesamiento de texto:

"A la grande le puse Cúca"
A la grande pusele Cúca
Tokenizing
a la grande pusele cúca
grande puse cúca
grande puse cuca
ignore-case filters
stopwords filters
ignore special chars filters

● Tokenizer
○ Divide el texto en términos (tokens) en base a reglas definidas,
generando una cadena de tokens (token stream).
○ Por ejemplo: keyword, whitespace, standard, regex, etc...
● Token Filter
○ Actua sobre un token stream modificándolo y/o creando nuevos tokens.
○ Por ejemplo: asciifolding, lowercase, stopword, ngram, etc...
○ Opera en cadena (pipelining): la salida de un filter es la entrada de otro.
Un Analyzer está compuesto de:
Análisis con ES: anatomía de un Analyzer
...Elasticsearch provee tokenizers prearmados y
permite generar nuevos personalizados

● Análisis en la indexación:
IndexTokenizer FilterFilterFilter
Texto
entrada
Tokens
salida
● Análisis en la búsqueda:
SearchTokenizer FilterFilterFilter
query
"match":"la ola"
query
"match":"ola"

● Tokenizers: "Masche te quita-lo-bailado"
Tokenizer Descripción Ejemplo
keyword genera un solo token "Masche te quita-lo-bailado"
whitespace separa por espacios [“Masche”, “te”,”quita-lo-bailado”]
standard basado en gramática [“Masche”, “te”,”quita”, “lo”,
“bailado”]
URL / email diferencia urls y emails ["Mail", "elastic@girl.com"]
Custom plug-in ...

● Filters: "Elástico"
Filter Descripción Ejemplo
lowercase Ignora capitalización "elástico"
asciifolding reemplaza caracteres especiales "Elastico"
NGrams Genera N-Gramas del token.
Útil para mutilenguaje y
autcomplete. (ej: n=2)
["El", "la", "as", "st"...]
stemmer /
snowball
Filtros algorítmicos. Especializados
en un lenguaje
["elastico"," elast"]
hspell stemming basado en diccionarios ["elastico"," elastica"]

Mapping
(Configurando los tipos de datos)

● Los datos indexados son obtenidos de documentos y campos
● El mapeo define como serán manipulados esos documentos
○ ¿Cómo deben ser indexados?
○ ¿Cuáles son los tipos de datos de los campos?
○ ¿Cómo manejar los tipos de datos objeto?
○ ¿Qué relación hay entre los diferentes tipos de documentos?
○ ¿Cómo manipular la metadata?
○ Definir la relevancia de los campos / documentos
Mapping: ¿Qué es?

● Principio de "Schema-less"
○ Sólo configurar cuando es necesario
● Tipos de datos
○ Los infiere de los tipos de datos básicos de JSON (boolean, string, etc.)
Mapping: mapeo dinámico
Es el mapeo que Elasticsearch aplica por defecto

● Tipos de datos que lo requieren (no-nativos de Json)
○ Fechas
○ Geolocalización
● Boosting
○ Cuando deseo realizar boosting de un documento / campo
● Análisis de texto
○ Búsquedas específicas
○ Adaptaciones de idioma
● Funcionalidades que lo requieren
○ Aggregations (Facets)
○ Highlighting
¿Cuando debería definir un mapeo?
Mapping: configuración

● En la creación del indice...
Los mapeos pueden definirse de dos formas:
$curl -XPOST localhost:9200/test -d '{
"settings" : { … },
"mappings" : {
"item" : {
"properties" : {
"listing_type" : {
"type" : "string",
"index" : "not_analyzed"
}
}
}
}
}'

● Mediante PUT a API de Mapping
Cuidado: los cambios en un mapping existente no se aplican hacia atrás
$ curl -XPUT 'http://localhost:9200/users/item/_mapping' -d '
{
"item" : {
"properties" : {
"listing_type" : {
"type" : "string",
"index" : "not_analyzed"
}
}
}
}'
Los mapeos pueden definirse de dos formas:

● Tipos de datos (pueden ser de un único tipo o array)
Tipo Descripción
string, integer, long, float, double,
date, boolean
Los clásicos...
root-object / object Objeto padre
nested Similar a object, difiere en la forma que se
almacena internamente
multi_field Permite configurar un campo de múltiples tipos
ip Dirección ipv4
geo_point Representa un punto de geo localización (lat,long)
attachment Archivo binario parseable

● Parametros extras
Tipo Descripción
boost Grado de relevancia
include_in_all Si el campo será incluido en el campo _all
null_value Valor por defecto del campo
store Si el valor del campo será almacenado (además del
indexado)
index_name Nombre con el que será indexado el campo

● Utilizar Strings como tipo de dato para campos de texto
Tipo Descripción
index Define si el campo será buscable:
● analyzed: buscable y analizado
● not_analyzed: buscable, pero no analizado
● no: No buscable
analyzer, search_analyzer,
index_analyzer
Define analyzer a utilizarse al buscar/indexar
Mapping: campos de tipo texto

● Puede ser float, double, integer, long, short o byte
Tipo Descripción
ignore_malformed Ignora mal formateados. Por defecto en "false"
Mapping: campos de tipo numérico

● Representados por Strings con formato específico
Tipo Descripción
format
Define el formato de la fecha. Existen varios predefinidos
(por defecto ISO8601) pero tambien soporta
personalizados
ignore_malformed Ignora mal formateados. Por defecto en "false"
Mapping: campos de tipo fecha

Mapeos: Campos de tipo objeto
Tipo Descripción
properties
Atributo(s) del objeto, puede ser del tipo "core" o a su vez
otro objeto
dynamic
Por defecto en "true". Permite agregar dinámicamente
nuevos atributos al objeto (principio de "schema-less")
enabled Ignora el campo (no se indexa)
path Especifica cómo se guardará (y se accederá) el documento.
include_in_all Los atributos heredan la configuración de este objeto
● Permite crear campos de tipos de datos compuestos

{
"mensaje" : {
"type" : "object",
"properties" : {
"usuario" : {
"type" : "object",
"dynamic" : false,
"properties" : {
"nombre" : {"type" : "string"},
"apellido" : {"type" : "string"}
"id" : {"type" : "string", "index" : "not_analyzed"}
}
},
"texto" : {"type" : "string"}
}
}
}
Mapping: campos de tipo objeto

● Generalmente utilizado para parsear un mismo campo
"string" con diferentes analyzers
● Útil para realizar facetado / clasificación diferenciandolo
de las queries comunes
● También para soporte multi-lenguaje
○ Permite aplicar analyzers específicos para distintos lenguajes.
Mapping: Multi-fields
Permite indexar un mismo campo de diferentes formas

"item" : {
"properties" : {
"titulo" : {
"type" : "multi_field"
"fields" : {
"titulo" : { "type" : "string",
"index" : "not_analyzed" }
"espanol" : { "type" : "string",
"analyzer" : "custom_es" },
"portugues" : { "type" : "string",
"analyzer" : "custom_pt" }
}
}
}
}
Mapping: Multi-fields

Scoring
(Dando relevancia a los resultados)

Scoring: introducción
¿Qué tan importante es dar relevancia a los
resultados de las búsquedas?...

...básicamente determina qué queremos mostrar primero
a los usuarios, en base a sus preferencias...

... o las nuestras

¿Cómo se determina la posición de un resultado?
● Algoritmos
○ Procesan información de la frecuencia de aparición de los términos
buscados en los documentos encontrados.
● Boosting
○ Operación para dar "peso" a ciertos documentos o campos, en base a
requerimientos funcionales que los algoritmos no tienen en cuenta:
temporalidad, tipos de documentos, etc.

● Term Frequency (TF)
○ Frecuencia de aparición de un término (token) en un documento.
○ Mayor frecuencia => mayor relevancia
● Inverted Document Frequency (IDF)
○ Frecuencia de aparición de un término en toda la colección de docs.
○ Mayor frecuencia => menor relevancia.
● Algoritmo TF-IDF
○ Por cada término se calcula el TF. Luego este valor se pondera con la
relevancia IDF.
Scoring: algoritmos
...veamos como lo implementa Elasticsearch

● Algoritmo implementado por
Lucene para scoring.
● Implementación de TF-IDF.
● Incorpora normalización y
boosting.
● Se ejecuta en cada búsqueda de
texto libre (match)
Scoring: algoritmos
Lucene Similarity:
"hits":{
"total":1,
"max_score":0.3125,
"hits":[
{
"_index":"items",
"_type":"item",
"_id":"MLA123",
"_score":0.3125,
"_source":{
"id":"MLA123",
"title":"Cámara Sony HD"
}
}
]

● A mayor cantidad de ocurrencias de un término en un
documento, mayor relevancia (score).
Scoring: Lucene Similarity
"...MercadoLibre realizó su primera
Developer Conference basadas en
sus APIs donde se presentaron....
MercadoLibre anunció hoy que los
desarrolladores de software podrán
tener acceso a las APIs..."
"...Hace mucho tiempo que se pedía
que MercadoLibre desarrolle una API
para realizar consultas a la pagina de
manera mas sencilla, a que hasta
hace un tiempo solo teníamos XML y
dolor de cabeza..."
>
Ejemplo: buscando "API":
Documento 1: Documento 2:

● Términos poco frecuentes entre los documentos aportan
mayor peso a la relevancia total.
Ejemplo: buscando "Mercadolibre APIs Conference":
"...MercadoLibre realizó
su primera Developer
Conference donde se
presentaron las
novedades sobre....
"...Hace mucho tiempo
que se pedía que
MercadoLibre
desarrolle unas APIs
para realizar..."
>
"...Las APIs de
MercadoLibre son
una plataforma ideal
para desarrollar
aplicaciones..."
,..,
Documento 1: Documento 2: Documento N:

● A mayor cantidad de términos de búsqueda en un
documento, mayor relevancia.
"...MercadoLibre realizó su primera
Developer Conference basadas en
sus APIs donde se presentaron....
La empresa anunció hoy que los
desarrolladores de software podrán
tener acceso.."
"...Las oportunidades ahora son
ilimitadas, podremos integrar
grandes retailers a MercadoLibre,
desarrollar soluciones logísticas,
entre otras opciones. En definitiva,
seguiremos trabajando para..."
>
Ejemplo: buscando "Mercadolibre API":
Documento 1: Documento 2:

● Campos "cortos" tienen más relevancia que los "largos".
"MercadoLibre realizó su
primera Developer
Conference en San Pablo"
"Podremos integrar grandes
retailers a MercadoLibre,
desarrollar soluciones logísticas,
entre otras opciones. En
definitiva, seguiremos trabajando
para..."
>
Ejemplo: buscando "Mercadolibre":
Título de Documento 1: Cuerpo de Documento 2:

¿Por qué aplicar boosting?
● Si bien Lucene hace un excelente trabajo de scoring, hay
variables que estos algoritmos no contemplan.
● Los aspectos de lógica de negocio que determinan la
relevancia de un documento, requieren que ésta se
modifique mediante el boosting.
● Ejemplos de esto son:
○ distintos tipos de documentos (ej: videos, imágenes).
○ relevancia afectada por variables de dominio (ej: ventas)
Scoring: boosting

¿Cuándo y cómo se aplica el boosting?
● En tiempo de indexación:
○ Cuando consideramos que cierto documento será siempre más
importante que otros (Ej: la home-page de un sitio).
○ Es más performante ya que no requiere cálculos extra.
○ Si se quiere modificar, requiere reindexar el documento.
● En tiempo de búsqueda (recomendado):
○ Permite variar la relevancia de un documento según variables del
dominio (ej: fecha de búsqueda vs fecha de publicación)
○ Requiere calcular el score en el momento.
○ Puede variarse con solo modificar la búsqueda.
Scoring: boosting

Scoring: boosting en indexación
● A nivel de documento utilizando _boost
curl -XPOST 'localhost:9200/users/user/dakota' -d '{
"_boost" : 5.0
...
}'
● A nivel de campo mediante mapping
curl -XPOST 'localhost:9200/users/user/_mapping -d '{
"user": {
"properties":{
"nickname": {"type":"string","boost": 2.0},
"email": {"type":"string","boost": 1.5},
...
}
}
}'

Scoring: boosting en búsqueda
● Toda query permite modificar la relevancia de sus
resultados mediante el parámetro boost
"bool" : {
"should" : [
{
"match": {
"site": {
"query": "Alamaula"
}
}
},
{
"match": {
"site": {
"query": "Mercadolibre"
"boost": 1.5
}
}
}
]
}

Scoring: boosting en búsqueda
● También es posible definir un cálculo de scoring
personalizado utilizando Scripts
● El lenguaje utilizado es MVEL (muy eficiente)
"custom_score": {
"query": { ...búsqueda de empleados... },
"script":
"_score * (doc['puesto'].value == 'capo'? 1.2 : 1)"
}
score calculado por Lucene
para la query ejecutada
atributo del documento

Ejemplos de boosting: blog de reviews
Scoring: boosting
Se tiene un blog de tecnología, donde se publican periódicamente reviews de
productos. Las reviews pueden ser artículos de texto (largos), con título y
contenido, o videos, con una descripción (corta) asociada.
El buscador del site debe priorizar los artículos por sobre los videos. Si un texto se
encuentra en el título de un artículo, éste es más importante que si se encontrase
en el cuerpo del mismo.
Los artículos más recientes deben ser más relevantes que otros más viejos.
Así mismo, al listarse todos los productos evaluados, se debe priorizar aquellos
sobre los cuales se hayan generado mayor cantidad de artículos y/o videos.

Ejemplos de boosting: blog de reviews
Scoring: boosting
1. Las descripciones de los videos tendrán mayor scoring que los artículos de
texto por ser más cortas: boost a los artículos.
2. Entre los artículos, los títulos tendrán más relevancia por ser más cortos.
3. Para dar importancia a los artículos más recientes se debe verificar la fecha
de publicación: boost por script en base a "cercanía" con fecha actual.
4. Si un producto es muy referenciado entre todos los documentos baja su
relevancia: boost por cantidad de referencias.

Scoring: custom_filters_score
● Si el boost depende de valores exactos, podemos
aprovechar la eficiencia de los filtros.
"custom_filters_score": {
"query": { ...búsqueda realizada... },
"filters": [
{
"filter": {
"term": {
"puesto": "capo"
}
},
"boost": 1.2
}
]
}

Aggregations
(estadísticas de los resultados)

Aggregations: introducción
● Proveen contadores con resultados de las búsquedas
● Proveen información para análisis estadístico
● Guían al usuario hacia filtros más específicos
¿Para qué sirve?

● Usado para realizar herramientas de análisis y dashboards
http://demo.kibana.org/

Cambio precio
de 200 a 150
Upgrade a
gold_premium
envios gratis2da republicación
arrastra ventas y
visitas Evento x día

Aggregations: elementos
● Buckets
○ Documentos que cumplen una determinada condición
○ Equivalente a GROUP BY de SQL
○ Ej: Artículos agrupados por categoría
● Metrics
○ Funciones matemáticas aplicadas sobre los buckets
○ Equivalente en SQL: COUNT, AVG, SUM, MAX, etc
○ Ej: Precio promedio

Aggregations: añadiendo complejidad
● Combinación de ambos
○ Un caso común es utilizar una combinación entre buckets y metrics
○ Ej: Calcular el precio promedio por categoría
● Composición de buckets
○ Es posible definir buckets dentro de buckets permitiendo agrupar por
más de un críterio
○ Ej: Calcular el precio promedio por categoría, listing type y si tiene free
shipping

Aggregations: ejemplo
Request:
{
"aggs": {
"categoria": {
"terms": { "field": "category_id" },
"aggs": {
"tipo_publicacion" : {
"terms" : { "field" : "listing_type_id"},
"aggs" : {
"prom_precio" : { "avg": { "field": "price"} },
"min_precio" : { "min": { "field": "price"} },
"max_precio" : { "max": { "field": "price"} }
}
}
}
}
}
}
Nombre
Buckets
Metrics

Aggregations: ejemplo
Response
aggregations: {
categoria: {
buckets: [
{
key: MLA34370
doc_count: 19
tipo_publicacion: {
buckets: [
{
key: bronze
doc_count: 16
prom_precio: {value: 175.125}
min_precio: {value: 49}
max_precio: {value: 350}
},
…
}

Aggregations: scope
● Mismo scope que la query (defecto)
○ Las aggregations se aplican sobre los resultados de la búsqueda
● Global
○ Las aggregations se aplican sobre el total los datos (no de la búsqueda)
● Filter bucket
○ Las aggregations se aplican sobre los resultados de la búsqueda + filtro
especifico dado

Aggregations: tipos
● Term
○ Devuelve los n términos más frecuentes
● Stats
○ Información estádistica de los resultados (máximo, mínimo, media,
variancia, desviación estandard, etc)
● Percentiles
○ Genera los percentiles sobre un campo numérico y calcula la frecuencia
● Range / Date / histogram
○ Permite definir rangos y devuelve la frecuencia
● geo distance
○ Dado un punto y rangos de distancia dados, devuelve la cantidad de
ocurrencias

Integración
(Conectando sistemas externos)

● Se comunican mediante el protocolo propio del sistema
○ Protocolo binario vía TCP, mas eficiente que JSON/HTTP.
● "Conocen" el cluster y actúan como un nodo más.
○ No almacenan información.
Integración: clientes
... existen dos categorías de clientes
Aparte del protocolo HTTP se pueden implementar
clientes nativos de Elasticsearch

● Cliente "liviano"
○ No se integra con el cluster (no se ejecuta node_discovery)
○ Se crea y destruye rápidamente. Ideal para múltiples threads
● Ejecuta requests en modo round-robin
○ Requiere que se defina una lista de nodos con los que comunicarse.
○ Si algún nodo se diese de baja, da timeout y continúa con otro.
Transport Client
Nodo 1
Cliente
Nodo 3
... Nodo N
Nodo 2
Nodo 4

● Nodo del cluster
○ No almacena información, pero a todo efecto es un nodo más.
○ Al crearse el cluster lo reconoce y asigna un nombre (node discovery)
● Conoce tablas de ruteo y estado del cluster
○ Accede directamente a los shards que tienen la info (si se hace routing)
○ Permite ejecutar acciones ante la caída de nodos o pérdida de info.
Node Client
Cluster
Nodo 1
Cliente
Nodo 3
... Nodo N
Nodo 2
Nodo 4

Integración: Rivers
● Complementos que ejecutan pulling de información (o
reciben un push) y la indexan en el cluster.
● Automatizan las operaciones de toma de datos + bulk
¿Que son?
● Wikipedia
● Twitter
● RabbitMQ
● Dropbox
Algunos ejemplos

Producción
(Configuración y recomendaciones)

● Manual
○ Bajar, descomprimir y configurar.
● Automatizado
○ Cheff (http://www.opscode.com/chef)
○ Puppet (http://www.puppetlabs.com/)
○ Paquetes Debian
● ... a la Melicloud
○ Incluir ES como parte del repositorio con sus configuraciones base.
○ Cada nuevo deploy sobreescribe las configuraciones
○ Los cambios aplican a todos los servers por igual.
Producción: instalación
... vamos a centrarnos en el último

LICENSE.txt
├── NOTICE.txt
├── README.textile
├── bin
│ ├── elasticsearch
│ ├── elasticsearch.in.sh
│ └── plugin
├── config
│ ├── elasticsearch.yml
│ └── logging.yml
├── data
│ └── elasticsearch
├── lib
│ ├── elasticsearch-x.y.z.jar
│ ├── ...
│ └──
└── logs
├── elasticsearch.log
└── elasticsearch_index_search_slowlog.log
● Archivos de la distribución

● Directorios principales
Nombre Descripción
bin binarios de ejecución. Contiene el archivo
"elasticsearch.in.sh" donde puede definirse el
Heap.
config archivos de configuración (ES y logging)
data datos almacenados por cluster
lib librerías utilizadas, incluyendo ES.
logs Logs de la aplicación. Incluye detalle de operaciones
"lentas"

Producción: configuración
● No cambiar, a menos que sea necesario
○ La configuración por defecto está pensada para un buen rendimiento.
● Misma configuración para todos los nodos
○ No configurar servers por separado para uso diario.
○ Puede ser necesario para mantenimiento.
● Preferir configuración por API por sobre archivo.
○ Mantener en archivo la configuración que aplica siempre.
Algunas premisas importantes sobre configuración
... ante la duda, consulte a su experto en
Elasticsearch más cercano

● Configuración principal de un cluster/nodo
Nombre Descripción
cluster.name
Nombre del cluster. En base a él se unen los nodos, con
lo que debe ser único.
node.name Nombre del nodo. ES asigna valores por defecto
path.data
Ubicación de los datos. Configurar siempre fuera del
directorio de instalación de ES.
path.logs Ubicación de los logs (ej: /usr/local/log)

● Sistema distribuido: detección de nodos
Nombre Descripción
discovery.zen.
minimum_master_nodes
Mínima cantidad de Masters. Conviene definir
N/2+1 donde N es la cantidad de masters elegibles.
discovery.zen.ping.
multicast.enabled
Descubrimiento de nodos vía multicast. En
producción debe estar deshabilitado (false).
discovery.zen.ping.
unicast.hosts
Lista de posibles masters a consultar para descubrir
el cluster. Basta con que uno de los nodos
pertenezca al cluster para integrarse.

● Sistema distribuido: recupero
Nombre Descripción
gateway.
recover_after_nodes
Cantidad mínima de nodos necesaria para
recuperar el cluster luego de reinicio de todos los
nodos. Mayor número implica reuso de datos
locales y menor transferencias de shards
gateway.
recover_after_time
Cantidad de minutos a esperar otros nodos una vez
que se levantaron los N nodos anteriores.

Producción: memoria
● Definir la variable de ambiente ES_HEAP_SIZE
○ Define el tamaño máximo y mínimo (iguales) de la memoria reservada
para ejecutar Elasticsearch.
● Idealmente definirla como 1/2 de la memoria total.
○ La otra mitad también es aprovechada por ES, ya que se utiliza para
cache del filesystem
● Nunca reservar más de 30GB de espacio
○ La JVM realiza compresión de punteros (64 a 32 bits)
● Definir configuraciones extra para evitar swapping
○ Ver comentarios en elasticsearch.yml
Definiendo el tamaño del Heap

● Aggregations
○ Cargan en memoria los valores de los campos referenciados.
○ No facetar por campos analized o con muchos valores posibles.
● Filtros y Ordenamiento
○ Cargan en memoria los valores de los campos referenciados.
○ Puede monitorearse con la API de Stats.
● Lucene
○ Aunque muy optimizado, carga diccionario invertido en memoria.
○ Afecta sólo cuando hay muchos shards ejecutando en un mismo nodo.
Principales "usuarios" de la memoria

● Surge cuando la JVM no tiene más memoria disponible
● Puede generar inestabilidad en el clusters
○ Las APIs de monitoreo pueden no informar problemas.
○ Algunas operaciones pueden seguir ejecutándose normalmente.
● Es necesario tomar medidas
○ Ver logs. Elasticsearch informa cuando ocurrió un error de este tipo.
○ Ampliar memoria (siempre bajo las recomendaciones previas).
○ Agregar nodos.
En caso de una OutOfMemoryException

Producción: file descriptors
● Puede ser necesario aumentar este valor.
○ El valor por defecto de los SO's suele ser muy bajo.
● Setear en 64K, o 32K si está restringido.
○ Las instancias del Melicloud ya vienen con un número elevado.
● Para monitorear este valor:
Cantidad de descriptores de archivos (y sockets)
abiertos por el proceso, permitidos por el SO
curl 'localhost:9200/_nodes/process?pretty'

Producción: dimensionamiento
● No hay recetas mágicas.
○ Cada instalación es diferente.
○ Depende de la infraestructura, los datos y las queries.
¿Cómo dimensionar un cluster?
● Es posible determinar el máximo tamaño de un shard
a. Comenzar con 1 nodo y 1 shard (sin réplicas).
b. Indexar información y mirar métricas.
c. Cuando el nodo está sobrecargado (aumento de tiempos, GC, etc),
obtener la cantidad total de documentos indexados.
d. Asumir el 50~60% de esa cantidad como capacidad del nodo.

Producción: configuraciones extras
● Deshabilitar creación de índices automática.
○ Obliga a que todo índice sea creado vía la API correspondiente
○ Setear action.auto_create_index en false
● Deshabilitar borrado de índices masivo.
○ Evita que pueda ejecutarse un DELETE sobre la raíz de índices.
○ Setear action.disable_delete_all_indices en true
● Deshabilitar sharding reallocation al reiniciar cluster
○ cluster.routing.allocation.disable_allocation
○ cluster.routing.allocation.disable_replica_allocation
Algunos tips importantes a tener en cuenta

Producción: hardware
● Nodos "large" o "medium" sobre "small"
○ Preferible tener menos nodos más potentes que muchos poco potentes
● Toda la memoria que sea posible
○ En especial si se hace uso intensivo de facetado y ordenamiento
○ La memoria que no use ES, será aprovechada por el file system cache
○ Los filtros también podrán cachear más documentos.
● CPU y Cores: Más es mejor.
○ Una instancia utiliza concurrencia intensivamente
○ Puede ocupar todos los cores disponibles.
○ Mayor velocidad de CPU ayuda a indexación y búsqueda.
¿Qué infraestructura se recomienda?

Producción: monitoreo
● Cluster Health:
○ Semáforo indicador del estado del cluster
○ Verde: los shards primarios y las réplicas están inicializadas.
○ Amarillo: todos los shards primarios están iniciados pero faltan réplicas.
○ Rojo: faltan shards primarios y réplicas (falta información)
● Cluster Info/Stats:
○ Info: información estática del cluster que no varía.
○ Stats: información del cluster que varía con el tiempo.
○ Cubren todos los aspectos de SO, JVM, Red, etc.
...existen plugins para todas estas APIs
Todo en ES puede monitorearse vía APIs...
... ¡y debe monitorearse!

● BigDesk
○ Permite monitorear todos los aspectos de ejecución de cada nodo.
● Elasticsearch-Head
○ Permite visualizar la topología y el comportamiento de los shards.
○ Permite navegar la información y generar queries libres o prearmadas.
● Paramedic:
○ Monitor de ejecución de todo el cluster en una sola pantalla.
● Elasticsearch HQ
○ Monitor y administrador del sistema (excelente interfaz)
... y hay muchos más en el site
Los plugins más recomendados:

curl -XGET localhost:9200/_cat/master
3oPXD3WEQJulGc4OYkGZeQ mac-host 10.10.32.237 The Angel
curl -XGET localhost:9200/_cat/indices?h=h,i,p,dc,fm,ss
yellow brasil_2014 5 20 0b 102.7kb
curl -XGET localhost:9200/_cat/
=^.^=
/_cat/allocation
/_cat/shards
...
¿Y si quiero/necesito usar curl? ¡CAT API!

Bonus Track
(algunas funcionalidades avanzadas)

Bonus Track: percolation
● En lugar de indexar documentos y buscarlos con queries...
● ... almacenamos queries y las "filtramos" con documentos.
Búscando búsquedas... ¿lo qué?
curl -XPUT localhost:9200/users/.percolator/usuario-trucho -d '{
"query" : {
"boolean" : {
"must" : [
{ "term" : { "reputation" : "5_red" }},
{ "range" : { "negative_calif" : { "gt" : "3" }}}
]
}
}
}'

Bonus Track: percolation
● Sin indexarlos
Luego percolamos los documentos
curl -X POST localhost:9200/user/user/_percolate -d '{
"doc": {"reputation" : "5_red","negative_calif" : 23}
}'
{ "ok" : true, "matches" : ["usuario-trucho"]}
curl -X POST localhost:9200/user/user/?percolate=* -d '{
"reputation" : "5_red","negative_calif" : 23
}'
● Al indexarlos
● Resultado

curl -XPUT 'localhost:9200/_snapshot/fs_backup' -d '{
"type" : "fs",
"settings": {
"location": "/es/backups",
}
}'
Bonus Track: snapshots
● Primero se crea un repositorio indicando el tipo.
Desde ES 1.x es posible salvar el estado del cluster
nombre del repo
tipo de repositorio

Bonus Track: snapshots
● Luego se genera el snapshot (x def. para todos los índices)
curl -XPUT localhost:9200/_snapshot/fs_backup/2014 -d '{
"indices": "indice_1, indice_n"
}'
curl -XPOST "localhost:9200/_snapshot/fs_backup/2014" -d '{
"indices": "indice_*"
}'
● Y luego se recupera cuando es necesario (previo cierre)

Bonus Track: geo locations
● Una vez seteado el mapping correcto, indexamos la info
Elasticsearch permite buscar zonas geográficas
curl -XPUT 'localhost:9200/restaurant/desc/1' -d '{
"desc" : {
"location" : { "lat" : 41.12, "lon" : -71.34 }
}
}'
se admiten varios formatos
(ej: "lat,long")

Bonus Track: geo locations
● Búsqueda por geo_box (región rectangular)
geo_bbox" : {
"location" : {
"top_left" : { "lat" : 40.73, "lon" : -74.1 },
"bottom_right" : { "lat" : 40.717, "lon" : -73.99 }
}
}
● Por geo_distance (región circular)
"geo_distance" : {
"distance" : "400km"
"location" : { "lat" : 40.73, "lon" : -74.1 }
}

Bonus Track: scan
● Para iterar sobre una gran cantidad de resultados
● Permite generar un "cursor" sobre una búsqueda
○ Permite definir el tiempo en que permanece abierto
○ Y la cantidad de registros por scan a obtener
● Luego ES genera un token para cada Scan iniciado.
curl -XGET 'localhost:9200/_search?search_type=scan&scroll=10m&size=50' -d '{
"query" : { "match_all" : {}}
}'
curl -XGET 'localhost:9200/scroll?scroll=10m' -d
'c2NhbjsxOjBLMzdpWEtqU2IyZHlmVURPeFJOZnc7MzowSzM3aVhLalNiMmR5ZlVET3hSTmZ3OzU
6MEszN2lYS2pTYjJkeWZVRE94Uk5mdzsyOjBLMzdpWEtqU2IyZHlmVURPeFJOZnc7NDowSzM3aVh
LalNiMmR5ZlVET3hSTmZ3Ow=='

¿?

Recursos
● Libro oficial de ES
○ http://www.elasticsearch.org/guide/en/elasticsearch/guide/current/
● Advanced Scoring en ES
○ http://jontai.me/blog/2013/01/advanced-scoring-in-elasticsearch/
● Pre-Flight checks (setup para producción)
○ http://www.elasticsearch.org/webinars/elasticsearch-pre-flight-checklist
● DSL Explained
○ http://www.slideshare.net/clintongormley/terms-of-endearment-the-
elasticsearch-query-dsl-explained
● Foro de ES en español
○ https://groups.google.com/forum/#!forum/elasticsearch-es
Algunas páginas interesantes:

Curso completo de Elasticsearch

Más contenido relacionado

La actualidad más candente

Similar a Curso completo de Elasticsearch

Curso completo de Elasticsearch