Anda di halaman 1dari 50

UNIVERSIDAD MAYOR DE SAN SIMON

FACULTAD DE CIENCIAS Y TECNOLOGIA


DIRECCIÓN DE POSGRADO

“CÓMO MEJORAR EL SSI CON EL USO DE


ELASTICSEARCH EN SPRING”

TRABAJO FINAL PRESENTADO PARA OBTENER EL CERTIFICADO


DE DIPLOMADO EXPERTO EN DESARROLLO DE APLICACIONES
EMPRESARIALES VERSIÓN I
.

POSTULANTE: Mejia Callizaya Juan Pablo


TUTOR : Ing. Edson Ariel Terceros Torrico

Cochabamba – Bolivia
2018
2
Dedicatoria
A Dios por la fe y fortaleza, a mis padres Gabino y
Emiliana por el apoyo y a mi esposa Daniela por
toda la comprensión y paciencia al estar a mi lado
en esta etapa de mi vida.

3
4
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

TABLA DE CONTENIDOS

RESUMEN ..................................................................................................................................... 11

INTRODUCCION ........................................................................................................................... 13

1 GENERALIDADES ..................................................................................................................... 15

1.1 Antecedentes Generales ..................................................................................................... 15

1.2 Antecedentes Específicos ................................................................................................... 15

2 METODOLOGIA ......................................................................................................................... 15

3 ELASTICSEARCH...................................................................................................................... 16

3.1 Conceptos de Elasticsearch ................................................................................................ 16

3.2 Características de Elasticsearch ......................................................................................... 17

3.2.1 Datos en tiempo real .................................................................................................... 17

3.2.2 Distribuido y escalable horizontalmente ...................................................................... 17

3.2.3 Alta disponibilidad ........................................................................................................ 18

3.2.4 Multitenencia (Multi-tenancy) ....................................................................................... 18

3.2.5 Búsquedas Full-Text .................................................................................................... 18

3.2.6 Búsquedas Fuzzy ......................................................................................................... 19

3.2.7 Búsqueda Avanzada DSL ............................................................................................ 19

3.2.8 Orientado a documentos .............................................................................................. 19

3.2.9 Gestión de conflictos .................................................................................................... 19

3.2.10 Sin esquemas ............................................................................................................. 19

3.2.11 API RESTFUL ............................................................................................................ 20

3.2.12 Persistencia a nivel de operación .............................................................................. 21

3.2.13 Velocidad .................................................................................................................... 21

5
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

3.2.14 Código abierto ............................................................................................................ 21

3.2.15 Multiplataforma ........................................................................................................... 21

3.3 Arquitectura de Elasticsearch ............................................................................................. 21

3.3.1 Clúster .......................................................................................................................... 21

Tabla 1- Comparación Elasticsearch con base de datos relacional (Elasticsearch indexing,


2015) ...................................................................................................................................... 22

3.3.2 Nodo ............................................................................................................................. 22

3.3.3 Índice ............................................................................................................................ 22

3.3.4 Tipo ............................................................................................................................... 23

3.3.5 Mapping ........................................................................................................................ 24

3.3.6 Documento ................................................................................................................... 24

3.3.7 Fragmentos y réplicas .................................................................................................. 24

3.4 Casos de uso de Elasticsearch ........................................................................................... 25

3.5 Caso de estudio: Sistema SSI ............................................................................................ 25

3.6 Instalación, configuración de Elasticsearch para dar soporte a SSI .................................. 26

3.6.1 Crear indice .................................................................................................................. 28

3.6.2 Crear documento .......................................................................................................... 28

3.7 Integración Elasticsearch con Spring .................................................................................. 31

3.7.1 Spring Data ................................................................................................................... 31

3.7.2 Dependencias en Maven ............................................................................................. 31

3.7.3 Definiendo la configuración en Java ............................................................................ 33

3.7.4 Definición de interfaces del repositorio ........................................................................ 35

3.7.5 Definición del servicio................................................................................................... 36

3.7.6 Mapping ........................................................................................................................ 40

6
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

3.7.7 Indexando Documentos ............................................................................................... 44

3.7.8 Consultas ...................................................................................................................... 45

3.7.9 Actualizar y Eliminar documentos ................................................................................ 46

3.8 Kibana .................................................................................................................................. 46

4 CONCLUSIONES ....................................................................................................................... 49

5 BIBLIOGRAFÍA ........................................................................................................................... 50

7
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

8
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

TABLA DE CUADROS, GRÁFICOS Y FIGURAS

Tabla 1- Comparación Elasticsearch con base de datos relacional 22

Figura 1- Logo de Elasticsearch 16

Figura 2 - URI de un documento en Elasticsearch 20

Figura 3- Familia Elastic 47

Figura 4-Captura de Kibana Dev tools 48

Figura 5- Ejemplo de Visualizaciones 48

9
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

10
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

RESUMEN

Esta monografía de investigación y análisis se centra en el estudio de las características de


Elasticsearch, además de poner en práctica la implementación en el caso de estudio SSI
Sistema de Seguridad Industrial.

Se realizó una revisión bibliográfica que era relevante para los puntos de investigación que
fueron muy útiles al integrar Elasticsearch con Spring.

Cada uno de los temas fue expuesto de manera detallada, pero limitando la información
únicamente con la relación directa con el tema de investigación, de forma que se obtuvo una
comprensión clara de los puntos que se tratan.

Gracias a la puesta de campo con ejemplos claros en la integración de Spring con Elasticsearch
las empresas podrán implementar en su aplicación empresarial tomando como principio esta
investigación.

Se realizaron ejemplos de código fuente donde se observará cómo implementar paso a paso y
qué modificaciones realizar para integrar Elasticsearch, así se puede apoyar que no es muy
complejo realizar dicha integración.

Esta monografía se plantea como un estudio que puede otorgar la pauta para realizar otros
estudios relacionados con este tema, ya que Elasticsearch tiene funcionalidades avanzadas
para optimizar mucho mejor la aplicación empresarial.

11
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

12
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

INTRODUCCION

Para mejorar el proyecto SSI Sistema de Seguridad Industrial desarrollado en java en el


framework Spring por el grupo “the walking bugs” turno mañana, se realizará la investigación en
un ejemplo completo y real de las características de Elasticsearch.

De esta investigación se beneficiará la comunidad informática ya que ayudará a implementar


Elasticsearch para aplicaciones empresariales y lo tomen en cuenta como un punto de partida.

Técnicamente pondremos en práctica los conocimientos de base de datos nosql.


Económicamente las personas o empresas que implementen Elasticsearch en sus proyectos se
beneficiaran de tener un software robusto, código abierto y sin costo.

Los cambios que se realizarán en el proyecto SSI solo se aplicarán en el módulo de accidentes,
no se implementara clúster o características avanzadas de Elasticsearch que incluyan gran
cantidad de servidores.

El enfoque de esta monografía es de investigación, revisión bibliográfica y con ejemplos


prácticos para conocer las características y la arquitectura de Elasticsearch con las empresas
que actualmente están haciendo uso. También se pondrá en práctica con el caso de estudio
SSI Sistema de Seguridad Industrial desde la instalación, configuración e integración con el
modulo Spring data con Elasticsearch.

El resultado de la siguiente monografía ayudara a las personas interesadas en implementar


Elasticsearch para sus aplicaciones empresariales lo tomen en cuenta como un mecanismo
desde un principio y sea un punto de partida.

13
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

14
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

1 GENERALIDADES

1.1 Antecedentes Generales

Elasticsearch es una base de datos nosql, motor de búsqueda y análisis de texto completo
altamente escalable y de código abierto. Le permite almacenar, buscar y analizar grandes
volúmenes de datos de forma rápida y casi en tiempo real. Elasticsearch ofrece formas de
ampliar las capacidades de búsqueda mediante el uso de API y consultas DSL. Hay clientes
disponibles para que se puedan usar con numerosos lenguajes de programación, como Java,
Ruby, PHP, JavaScript y otros.

1.2 Antecedentes Específicos

Elasticsearch en aplicaciones empresariales hechas en java, existe un framework que se llama


Spring, que tiene su propio módulo Spring data para integrar ambas tecnologías y aprovechar al
máximo las funcionalidades que tiene Elasticsearch.

En esta monografía se hará estudio de Elasticsearch desde sus conceptos, características,


arquitectura y casos de usos en la actualidad. Ademas se hará la aplicación práctica en la
integración del proyecto SSI Sistema de Seguridad Industrial desarrollado en el framework
Spring con Elasticsearch.

2 METODOLOGIA

Para el presente trabajo se utilizarán los siguientes métodos de investigación:

● Método Bibliográfico, debido a que se realizará la lectura y compilación de libros


relacionados al tema de estudio.
● Método Analítico, debido a que se procederá a revisar y analizar ordenadamente
documentos relacionados al tema de estudio.
● Método Empírico o de Campo, debido a que se utilizarán ejemplos de aplicación o
experiencias observadas en el caso de estudio SSI Sistema de seguridad Industrial del
grupo “The Walking Bugs” turno mañana.

15
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

3 ELASTICSEARCH

Figura 1- Logo de Elasticsearch (Elastic, 2018)

3.1 Conceptos de Elasticsearch

Elasticsearch es un motor de análisis y búsqueda de texto completo altamente escalable. Le


permite almacenar, buscar y analizar grandes volúmenes de datos de forma rápida y casi en
tiempo real. Generalmente se usa para impulsar las aplicaciones que tienen características y
requisitos de búsqueda complejos según (Elastic, 2018, p. getting started).

Elasticsearch es un motor de búsqueda distribuida de texto completo y un motor analítico que


está construido sobre Lucene, una biblioteca de motores de búsqueda escrita en Java, y
también es una base para solr. Tras su primer lanzamiento en 2010, Elasticsearch ha sido
ampliamente adoptado por organizaciones grandes y pequeñas, incluida la NASA, Wikipedia, y
GitHub, para diferentes casos de uso. Los últimos lanzamientos de Elasticsearch se centra más
en la capacidad de recuperación, lo que genera confianza en los usuarios pueden utilizar
Elasticsearch como una herramienta de almacenamiento de datos, aparte de usarlo como un
motor de búsqueda de texto completo. Elasticsearch oculta todas las complejidades de
principiantes, que permite que todos sean productivos muy rápidamente con solo aprender lo
básico según (Bharvi, Rafał, Marek, & Saurabh, 2017, p. 51).

Elasticsearch es un motor de búsqueda de texto completo de código abierto y una herramienta


de análisis de datos desarrollada en Java y escalable basada en Apache Lucene. Se produce
una enorme escala de datos en todo momento en el mundo actual de las tecnologías de la
información, como ser en las redes sociales, en los sitios para compartir videos, en las
medianas y grandes empresas que brindan servicios en comunicación, salud, seguridad y otras

16
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

áreas. Aquí estamos hablando de un océano de información de datos, y llamamos a este


océano brevemente como big data en el mundo de la tecnología de la información. Una parte
importante de este mundo de big data es desestructurada, dispersa e insignificante cuando está
aislada según (Elasticsearch indexing, 2015).

Por lo tanto, acorde a los conceptos mencionados se concluye que Elasticsearch es un motor
de búsqueda orientado a documentos JSON estructurados sin esquemas, desarrollado en JAVA
de código abierto, una de las principales características es que nos permite tener una
arquitectura distribuida, escalable y de alta disponibilidad.

Las búsquedas soportan multi-idioma, geolocalización, autocompletado y sugerencias dichas


características son ideales para los proyectos en donde se trabaja con big data. Además que
posee un motor de búsqueda distribuido en tiempo real.

3.2 Características de Elasticsearch

Las características de Elasticsearch nos permiten proveer a las aplicaciones empresariales


datos en tiempo real, distribuido y escalable horizontal, una alta disponibilidad, búsquedas
avanzadas DSL, orientado a documentos, sin esquemas, código abierto y multiplataforma.

3.2.1 Datos en tiempo real

Según (Elastic, 2018, p. basic_concepts) Elasticsearch es una plataforma de búsqueda casi en


tiempo real. Lo que esto significa es que hay una ligera latencia (normalmente un segundo)
desde el momento en que indexas un documento hasta el momento en que se puede buscar.

Por lo tanto, Elasticsearch permite disponer en tiempo real de los últimos cambios realizados
sobre los datos.

3.2.2 Distribuido y escalable horizontalmente

Según (Bharvi, Rafał, Marek, & Saurabh, 2017, p. 52) Elasticsearch se distribuye desde el
primer día, y ha sido diseñado para escalar horizontalmente y no verticalmente. Se puede
comenzar con un clúster Elasticsearch de un solo nodo en su computadora portátil y puede
escalar ese clúster a cientos o miles de nodos sin preocuparse sobre las complejidades internas
que vienen con la computación distribuida, Almacenamiento de documentos distribuidos, y
búsquedas.

17
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

Entonces Elasticsearch está preparado para escalar horizontalmente. Con Elasticsearch es


posible empezar con una solución pequeña e ir creciendo a medida que crece nuestras
necesidades. En la medida en que se necesite más capacidad simplemente habrá que añadir
más nodos y dejar que el clúster se reorganice para aprovecharse por sí solo del hardware
extra.

3.2.3 Alta disponibilidad

Según (Bharvi, Rafał, Marek, & Saurabh, 2017, p. 52) La replicación de datos significa tener
múltiples copias de datos en su clúster. Esta característica permite a los usuarios crear
altamente clústeres disponibles manteniendo más de una copia de datos. Solo se

necesita emitir un comando simple, y crea automáticamente copias redundantes de los datos
para proporcionar mayores disponibilidades y evitar pérdida de datos en caso de fallo de la
máquina.

Además, que los clústeres de Elasticsearch son flexibles, estos son capaces de detectar y
eliminar nodos que estén fallando y reorganizarse a sí mismos para asegurar que los datos
estén a salvo y permanezcan accesibles.

3.2.4 Multitenencia (Multi-tenancy)

Un clúster de Elasticsearch puede alojar múltiples índices, que podrán ser consultados de
manera independiente o en grupo. Además, asignando alias a los índices, permite añadir
índices al vuelo de manera transparente para la aplicación

3.2.5 Búsquedas de texto completo

Para buscar dentro de los campos de texto completo y los documentos más relevantes,
Elasticsearcch utiliza el algoritmo de similitud estándar que se conoce como frecuencia /
inversa frecuencia del documento TF/IDF, que toma en cuenta los siguientes factores:

• Frecuencia de término, frecuencia que aparece el término en el campo. Cuanto más a


menudo, más relevante.
• Frecuencia de documento inverso, con qué frecuencia aparece el termino en el índice.
• Norma de longitud del campo, cuanto más largo sea, menos probable es que las palabras
en el campo sean relevantes.

18
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

3.2.6 Búsquedas difusa

La búsqueda difusa utiliza la similitud basada en la distancia de edición Levenshtein.

La búsqueda difusa genera términos coincidentes que se encuentran dentro de la distancia de


edición máxima especificada en fuzziness y luego verifica el término en el diccionario para
averiguar cuál de esos términos generados existe realmente en el índice. La consulta final
utiliza hasta max_expansions de términos coincidentes.

3.2.7 Búsqueda Avanzada DSL

Según (Bharvi, Rafał, Marek, & Saurabh, 2017, p. 52) Las consultas DSL (domain-specific
language) es una interfaz JSON proporcionada por Elasticsearch para exponer el poder de
Lucene para escribir y leer consultas de una manera muy fácil. Gracias a la consulta DSL, los
desarrolladores que no conocen la sintaxis de consulta de Lucene

También puede comenzar a escribir consultas complejas en Elasticsearch.

3.2.8 Orientado a documentos

Las entidades se almacenan en Elasticsearch como documentos JSON estructurados. Todos


los campos son indexados por defecto y todos los índices pueden ser usados en una misma
consulta.

3.2.9 Gestión de conflictos

Elasticsearch provee mecanismos para asegurar que los datos nunca se pierdan debido
a cambios simultáneos sobre un mismo documento realizados por diferentes procesos.

3.2.10 Sin esquemas

Según (Bharvi, Rafał, Marek, & Saurabh, 2017, pp. 53-54) Sin esquemas significa que no tienes
que crear un esquema con nombres de campo y tipos de datos antes de indexar los datos en
Elasticsearch. Aunque es uno de los conceptos más incomprendidos, esta es una de las
mayores ventajas que hemos visto en muchas organizaciones, especialmente en los sectores
de comercio electrónico donde es difícil definir el esquema por adelantado en algunos casos.
Cuando envíes tu primer documento a Elasticsearch, hace todo lo posible para analizar cada
campo en el documento y crea un esquema en sí. La próxima vez, si envía otro documento con

19
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

un tipo de datos diferente para el mismo campo, se descartará el documento. Por lo tanto,
Elasticsearch no es completamente sin esquemas, pero es el comportamiento dinámico de
crear un esquema es muy útil.

Entonces se entiende que Elasticsearch permite trabajar sin esquemas que definan la
estructura de los datos. Simplemente pasándole un documento JSON intentará detectar la
estructura de los datos, indexarlos y hacer que sean accesibles para las búsquedas.

3.2.11 API RESTFUL

Según (Bharvi, Rafał, Marek, & Saurabh, 2017, p. 52) Elasticsearch se basa en la arquitectura
REST y proporciona puntos finales de la API para no solo realizar operaciones CRUD sobre
llamadas API HTTP, también permitir que los usuarios realicen monitoreo de clústeres y tareas
utilizando API REST. Los puntos finales REST también permiten a los usuarios hacer cambios a
los grupos e índices de configuración de forma dinámica, en lugar de hacerlo manualmente las
actualizaciones de configuración a todos los nodos en un clúster, editando el archivo
elasticsearch.yml y reiniciando el nodo. Esto es posible porque cada recurso (índice,
documento, nodo, etc.) en Elasticsearch es accesible a través de un simple URI como se
muestra en la figura.

Figura 2 - URI de un documento en Elasticsearch (Bharvi, Rafał, Marek, & Saurabh, 2017)

20
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

3.2.12 Persistencia a nivel de operación

Elasticsearch vela por la seguridad de los datos. Todos los cambios que se realizan sobre los
documentos se almacenan en logs de transacciones en múltiples nodos del clúster para
minimizar las pérdidas de información.

3.2.13 Velocidad

Elasticsearch puede ejecutar consultas complejas extremadamente rápido. También almacena


casi todas las consultas estructuradas comúnmente utilizadas como filtro para el conjunto de
resultados y las ejecuta solo una vez. Para cada otra solicitud que contiene un filtro en caché,
comprueba el resultado de la caché. Esto ahorra el tiempo de análisis y ejecución de la consulta
mejorando la velocidad.

3.2.14 Código abierto

Es código abierto y está bajo la licencia Apache 2. Permite descargar, usar y modificar el
código.

3.2.15 Multiplataforma

Puede utilizarse en diversos entornos o sistemas operativos como Windows, Mac Os y las
distintas distribuciones GNU Linux como Ubuntu o Debian.

3.3 Arquitectura de Elasticsearch

La arquitectura de Elasticsearch está compuesta por clúster, nodos, índices, tipo, mapping,
documento, fragmentos y replicas que mantienen toda la información de manera distribuida e
indexada.

En la tabla 1 se hace una comparación de Elasticsearch con una base de datos relacional.

3.3.1 Clúster

Un clúster es una colección de uno o más nodos (servidores) que, en conjunto, conservan sus
datos completos y proporcionan capacidades de búsqueda e indexación en todos los nodos. Un
clúster se identifica con un nombre único que, de forma predeterminada, es "elasticsearch".
Este nombre es importante porque un nodo solo puede ser parte de un clúster si el nodo está
configurado para unirse al clúster por su nombre según (Elastic, 2018, p. basic_concepts).

21
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

Elasticsearch Base de datos Relacional

Index Database

Type Table

Document Row

Mapping Schema

query DSL Sql

Fields columns

Tabla 1- Comparación Elasticsearch con base de datos relacional (Elasticsearch indexing,


2015)

3.3.2 Nodo

Una sola instancia de Elasticsearch ejecutándose en una máquina según según (Bharvi, Rafał,
Marek, & Saurabh, 2017, p. 55).

Un nodo es un único servidor que forma parte de su clúster, almacena sus datos y participa en
las capacidades de búsqueda e indexación del clúster. Al igual que un clúster, un nodo se
identifica con un nombre que, de forma predeterminada, es un identificador universal único
aleatorio (UUID) que se asigna al nodo en el inicio. Puede definir cualquier nombre de nodo que
desee si no desea el valor predeterminado. Este nombre es importante para fines de
administración en los que desea identificar qué servidores de su red corresponden a qué nodos
en su grupo de Elasticsearch según (Elastic, 2018, p. basic_concepts).

3.3.3 Índice

De acuerdo con (Elastic, 2018, p. basic_concepts) un índice es una colección de documentos


que tienen características similares. Por ejemplo, puede tener un índice para datos de
empleados, otro índice para un catálogo de accidentes y otro índice para datos de causas de
accidente. Un índice se identifica con un nombre (que debe estar todo en minúsculas) y este

22
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

nombre se usa para referirse al índice cuando se realizan operaciones de indexación,


búsqueda, actualización y eliminación en los documentos que contiene.

En un solo clúster, puede definir tantos índices como desee.

3.3.4 Tipo

Según (Gupta, 2015) Esto es similar a una tabla en una base de datos relacional tradicional.
Contiene una lista de Campos, que se definen para cada documento. Un tipo es una
segregación lógica de indices, cuya interpretación y la semántica depende totalmente de los
desarrolladores. Por ejemplo, tu tiene datos sobre el mundo y usted pone todos sus datos en un
índice. En este índice, usted puede definir un tipo para datos de continente, otro tipo para datos
de país y un Tercer tipo para datos por región. Los tipos se utilizan con una API de mapeo;
especifica el Tipo de su campo. Un ejemplo de mapeo de tipos es el siguiente:

"usuario": {

"properties": {

"nombre": {

"type": "string"

},

"edad": {

"type": "integer"

},

"fecha_nacimiento”: {

"type": "date"

},

"balance_banco": {

"type": "float"

23
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

3.3.5 Mapping

Es similar al esquema de una base de datos, describe los campos de un documento, como
debe ser indexado.

3.3.6 Documento

De acuerdo con (Elastic, 2018, p. basic_concepts) un documento es una unidad básica de


información que puede ser indexada. Por ejemplo, puede tener un documento para un solo
empleado, otro documento para un solo accidente y otro para un solo causa. Este documento
se expresa en JSON (Notación de objetos de JavaScript), que es un formato de intercambio de
datos de Internet ubicuo.

Según (Bharvi, Rafał, Marek, & Saurabh, 2017, p. 55), el documento es un objeto JSON que
contiene los datos reales en pares de valores clave.

Por lo tanto, un documento es una unidad básica de información que puede ser indexado.

3.3.7 Fragmentos y réplicas

Según (Elastic, 2018, p. basic_concepts) Elasticsearch ofrece la capacidad de subdividir su


índice en varias partes llamadas fragmentos. Cuando crea un índice, simplemente puede definir
el número de fragmentos que desea. Cada fragmento es en sí mismo un "índice"
completamente funcional e independiente que se puede alojar en cualquier nodo del clúster.

La fragmentación es importante por dos principales razones:

• Te permite dividir y escalar horizontalmente tu volumen de contenido.


• Le permite distribuir y paralelizar operaciones entre fragmentos (potencialmente en múltiples
nodos), lo que aumenta el rendimiento y rendimiento.

24
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

Elasticsearch gestiona completamente la mecánica de cómo se distribuye un fragmento y


también la forma en que sus documentos se agregan a las solicitudes de búsqueda y son
transparentes para usted como usuario.

De forma predeterminada, a cada índice en Elasticsearch se le asignan 5 fragmentos primarios


y 1 réplica, lo que significa que, si tiene al menos dos nodos en su grupo, su índice tendrá 5
fragmentos primarios y otros 5 fragmentos de réplica (1 réplica completa) para un total de 10
fragmentos por índice.

Por lo tanto, un índice puede almacenar una gran cantidad de datos que puede exceder los
límites de hardware de un solo nodo.

3.4 Casos de uso de Elasticsearch

Son muchas organizaciones importantes que están utilizando en la actualidad Elasticsearch,


entre ellas tenemos Tesco, Linkedin, Foursquare, Facebook, Netflix, Dell, Ebay, Wikipedia, The
Guardian, New York Times, Salesforce, Docker, Orange, Groupon, Eventbrite, Mozilla, Quora,
Github y muchos otros.

Un caso práctico es cuando Dell implementó usar Elasticsearch para apoyar la búsqueda de
comercio electrónico para más de 60 países en más de 21 idiomas. El equipo de búsqueda de
Dell tiene 30 miembros. Han visto la importancia de la búsqueda avanzada ya que las
expectativas de compra del consumidor se centraron más en la gratificación instantánea.
Ofrecer exactamente el resultado que un consumidor busca comprar los mantiene
continuamente innovando, expandiendo las capacidades de relevancia y personalización de la
plataforma.

3.5 Caso de estudio: Sistema SSI

Para trabajar con un ejemplo completo y real de aplicación con Elasticsearch se utilizará el
sistema de seguridad industrial SSI, que fue desarrollado en el diplomado con el fin de disminuir
la incidencia de accidentes en las empresas constructoras, con los objetivos de registrar el
manual de funciones para controlar el cumplimiento laboral, registrar asignación de equipos y
maquinaria al personal, registrar incidencias de accidentes dentro de la empresa, generar
reportes que ayuden a la correcta toma de decisiones.

25
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

El sistema fue construido en dos partes el API REST en el lenguaje java con el framework
Spring y el frontend con Angular.

Por lo tanto, la mejora que se realizará y aportará será en el modulo de accidentes con la
integración de Elasticsearch para aprovechar todas las características que nos ofrece.

3.6 Instalación, configuración de Elasticsearch para dar soporte a SSI

La instalación y configuración de Elasticsearch en el sistema operativo Ubuntu, se requiere


tener instalado java y seguir los pasos de la documentación oficial, para interactuar como crear
índice, un documento u otra acción se realiza mediante el API REST.

Según (Elastic, 2018, p. installation) Elasticsearch requiere al menos Java 8. Específicamente al


redactar esta monografía, se recomienda que se use la versión 1.8.0_131 de Oracle JDK. La
instalación de Java varía de una plataforma a otra, por lo que no entraremos en esos detalles.
La documentación de instalación recomendada de Oracle se puede encontrar en el sitio web de
Oracle. Basta con decir que, antes de instalar Elasticsearch, primero se debe comprobar la
versión de Java ejecutando el siguiente comando.

java -version

echo $JAVA_HOME

Para la instalación se mostrará los pasos para el sistema operativo GNU Linux Ubuntu Server
16.04 LTS.

Continuando con la instalación según (Elastic, 2018, p. installation), una vez que tengamos Java
configurado, podemos descargar y ejecutar Elasticsearch. Los binarios están disponibles en
www.elastic.co/downloads. Puede elegir entre un archivo zip o tar, un paquete DEB o RPM, o
un paquete de instalación de Windows MSI para este proyecto descargaremos la opción de
comprimido tar de Elasticsearch 6.4.2.

curl -L -O https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-6.4.2.tar.gz

Descomprimir el archivo descargado.


tar -xvf elasticsearch-6.4.2.tar.gz

26
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

A continuación, creará un montón de archivos y carpetas en su directorio actual. Luego


entramos en el directorio bin de la siguiente manera y ejecutamos Elasticsearch:
cd elasticsearch-6.4.2/bin

./elasticsearch

Se puede anular el nombre del clúster o del nodo. Esto se puede hacer desde la línea de
comandos al iniciar Elasticsearch de la siguiente manera:
./elasticsearch -Ecluster.name=my_cluster -Enode.name=my_node

También tenga en cuenta la línea marcada http con información sobre la dirección HTTP
(127.0.0.1) y el puerto (9200) desde donde se puede acceder a nuestro nodo. De forma
predeterminada, Elasticsearch utiliza el puerto 9200 para proporcionar acceso a su API REST.
Este puerto es configurable si es necesario.
Ahora que tenemos nuestro nodo (y clúster) en funcionamiento, el siguiente paso es entender
cómo interactuar con él. Elasticsearch proporciona una API REST muy completa y potente que
puede utilizar para interactuar con su clúster.
Para comprobar el estado nos será útil el siguiente comando

$ curl -XGET http://localhost:9200/

Respuesta esperada

{
"ok": true,
"status": 200,
"name": "BTA",
"version": {
"number": "0.90.2",
"snapshot_build": false,
"lucene_version": "4.3.1"
},

27
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

"tagline": "You Know, for Search"


}

3.6.1 Crear indice

Comencemos por crear nuestro primer índice y darle un nombre a este índice, que es ssi en
este caso. Después de ejecutar el siguiente comando, un índice con cinco fragmentos y una
réplica:

Se creara un índice con el nombre de “ssi” de la siguiente manera siguiendo los pasos según
(Elastic, 2018, p. _create_an_index)

$ curl -XPUT 'http://localhost:9200/ssi'

al igual si es necesario realizar la eliminación del índice “ssi”

$ curl -XDELETE 'http://localhost:9200/ssi'

Para ver los índices actuales nos será útil el siguiente comando

$ curl -XGET 'http://localhost:9200/cat/indices?v'

3.6.2 Crear documento

Lo siguiente será trabajar con el mapping, el mapeo no es necesario definirlo previamente, pero
es aconsejable para ciertas propiedades sino queremos que Elasticsearch tome valores por
defecto o haga suposiciones, a continuación, insertamos los documentos. Cada documento
tiene un identificativo que deberemos asignarle y para indexar básicamente proporcionamos un
JSON con las propiedades del documento. Elasticsearch se encargará de indicarlo para que
una búsqueda posterior se ejecute rápidamente.

Para el caso práctico se hará el mapping de un accidente como se muestra a continuación.

28
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

$ curl -XPUT 'http://localhost:9200/ssi/accidentes/_mapping' -d '{


titulo{type:string }}'

posterior se verificará si se actualizo correctamente

$ curl -XGET 'http://localhost:9200/ssi/accidentes/_mapping'

Según (Elastic, 2018, p. index_and_query_a_document) lo siguiente será crear un documento


muy importante al indexar el ID es opcional sino se especifica genera un ID aleatorio y luego se
utilizará para indexar el documento.

$ curl -XPOST "http://localhost:9200/ssi/accidentes/1" -d '{ "titulo" : "Accidente 1" }'

u otra alternativa

$ curl -XPOST 'localhost:9200/ssi/accidentes?' -d '{ "titulo" : "Accidente 1" }'

al igual para actualizar el documento

$ curl -XPUT 'http://localhost:9200/ssi/accidentes/1' -d '


{
titulo: "Accidente 1 modificado",
}'

donde la posible respuesta sea la siguiente

{
"ok": true,
"_index": "ssi",
"_type": "accidentes",
"_id": "1",
"_version": 1
}

29
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

otra manera de actualizar seria

$ curl -XPOST 'localhost:9200/ssi/accidentes/1/_update?' -d'


{
"titulo": "Accidente 1 modificado post"
}'

Al igual para recuperar un específico documento por el ID

$ curl -XGET 'localhost:9200/ssi/accidentes/1'

las características más importantes son las búsquedas un ejemplo de ello sería el siguiente:

$ curl -XGET 'localhost:9200/ssi/_search?p=accidente'

como también de la siguiente manera

$ curl -XGET 'localhost:9200/ssi/accidentes/_search' -d '


{
query: {
range: {
sendDate: {
from: "20180715T18:00:00",
to: "20180715T18:00:15"
}
}
}
}'

30
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

3.7 Integración Elasticsearch con Spring

Exploramos los conceptos básicos de Spring Data con Elasticsearch de una manera práctica y
centrada en el código aplicando al proyecto SSI Sistema de seguridad Industrial. Mostraremos
cómo indexar, buscar y consultar Elasticsearch en Spring utilizando Spring Data, este módulo
de Spring es útil para interactuar con el motor de búsqueda de código abierto basado en
Lucene.

Aunque Elasticsearch no tiene esquemas, puede usar asignaciones para decir el tipo de campo.
Cuando un documento está indexado, sus campos se procesan según sus tipos. Por ejemplo,
un campo de texto se convertirá en token y se filtra según las reglas de mapeo. También puede
crear filtros y tokenizadores propios.

3.7.1 Spring Data

Según (Team, 2018), El proyecto Spring Data Elasticsearch aplica los conceptos básicos de
Spring al desarrollar soluciones utilizando Elasticsearch. Tiene un template que es una
abstracción de alto nivel para almacenar, consultar, clasificar y realizar búsquedas de
documentos.

Por lo tanto, Spring Data ayuda a evitar el código repetitivo. Por ejemplo, si definimos una
interfaz de repositorio que implemente la interfaz ElasticsearchRepository proporcionada por
Spring Data Elasticsearch, las operaciones de CRUD para la clase de documento
correspondiente estarán disponibles de forma predeterminada. Además, simplemente al
declarar métodos con nombres en un formato predefinido, las implementaciones de métodos se
generan y no es necesario escribir una implementación de la interfaz del repositorio.

Para tener más información sobre el uso de Spring Data recomendamos revisar la
documentación oficial http://projects.spring.io/spring-data/ .

3.7.2 Dependencias en Maven

Spring Data Elasticsearch proporciona una API de Java para el motor de búsqueda. Para
usarlo, necesitamos agregar una nueva dependencia al pom.xml entre los tags
“dependencies”:

31
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-elasticsearch</artifactId>
<version>${spring-data-elasticsearch.version}</version>
</dependency>
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>${elasticsearch.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-elasticsearch</artifactId>
<version>3.0.8.RELEASE</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>transport</artifactId>
<version>${elasticsearch.version}</version>
</dependency>
<dependency>
<groupId>net.java.dev.jna</groupId>

32
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

<artifactId>jna</artifactId>
<version>${jna.version}</version>
<scope>test</scope>
</dependency>
</dependencies>

3.7.3 Definiendo la configuración en Java

Exploremos ahora la configuración Spring de nuestra capa de persistencia aquí:

package com.dh.spring5webapp;
import java.net.InetAddress;
import java.net.UnknownHostException;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import
org.springframework.data.elasticsearch.repository.config.EnableElasticsearchReposit
ories;
@Configuration
@EnableElasticsearchRepositories(basePackages =

33
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

"com.dh.spring5webapp.repositories")
@ComponentScan(basePackages = { "com.dh.spring5webapp.services" })
public class ElasticConfig {

@Value("${elasticsearch.home:/home/danita/ELK/elasticsearch-6.3.2}")
private String elasticsearchHome;

@Value("${elasticsearch.cluster.name:elasticsearch}")
private String clusterName;

@Bean
public Client client() {
TransportClient client = null;
try {
final Settings elasticsearchSettings = Settings.builder()
.put("client.transport.sniff", true)
.put("path.home", elasticsearchHome)
.put("cluster.name", clusterName).build();
client = new PreBuiltTransportClient(elasticsearchSettings);
client.addTransportAddress(new
InetSocketTransportAddress(InetAddress.getByName("127.0.0.1"), 9300));
} catch (UnknownHostException e) {
e.printStackTrace();
}
return client;
}

34
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

@Bean
public ElasticsearchOperations elasticsearchTemplate() {
return new ElasticsearchTemplate(client());
}
}

Tenga en cuenta que estamos utilizando una anotación de estilo de habilitación Spring estándar
@EnableElasticsearchRepositories para escanear el paquete proporcionado para los
repositorios de Spring Data.

También proporcionamos el directorio de instalación de Elasticsearch usando "path.home" Si


el nombre del clúster no es "elasticsearch", necesitamos proporcionarlo usando "cluster.name"
por defecto normalmente es Elasticsearch Finalmente, también estamos configurando un
ElasticsearchOperations bean como nuestro cliente para trabajar contra el servidor de
Elasticsearch.

3.7.4 Definición de interfaces del repositorio

A continuación, debemos extender una de las interfaces de repositorio proporcionadas,


reemplazando los tipos genéricos con nuestro documento real y los tipos de clave primaria.
Tenga en cuenta que ElasticsearchRepository extiende PagingAndSortingRepository, que
proporciona compatibilidad integrada para paginación y clasificación.

package com.dh.spring5webapp.repositories;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.annotations.Query;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.stereotype.Repository;
import com.dh.spring5webapp.model.Accidente;

35
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

@Repository
public interface AccidenteRepository
extends ElasticsearchRepository<Accidente, String> {
Page<Accidente> findByEmpleadosNombre(String nombre, Pageable pageable);

@Query("{\"bool\": {\"must\": [{\"match\": {\"empleados.nombre\": \"?0\"}}]}}")


Page<Accidente> findByEmpleadosNombreUsingCustomQuery(String nombre,
Pageable pageable);

@Query("{\"bool\": {\"must\": {\"match_all\": {}}, \"filter\": {\"term\": {\"tags\": \"?0\" }}}}")


Page<Accidente> findByFilteredTagQuery(String tag, Pageable pageable);

@Query("{\"bool\": {\"must\": {\"match\": {\"empleados.nombre\": \"?0\"}}, \"filter\": {\"term\":


{\"tags\": \"?1\" }}}}")
Page<Accidente> findByEmpleadosNombreAndFilteredTagQuery(String nombre, String
tag, Pageable pageable);
}

Tomamos en cuenta que agregamos dos métodos personalizados. Con el método


findByEmpleadosNombre, el repositorio creará una implementación basada en el nombre del
método. El algoritmo de resolución determinará que necesita acceder a la propiedad del
empleado y luego buscará la propiedad del nombre de cada elemento. El segundo método,
findByEmpleadoNombreUsingCustomQuery, utiliza una consulta booleana Elasticsearch,
definida mediante la anotación @Query, que requiere una concordancia estricta entre el
nombre del empleado y el argumento del nombre proporcionado.

3.7.5 Definición del servicio

Primeramente, definimos la interface AccidenteService

package com.dh.spring5webapp.services;

36
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

import java.util.Optional;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import com.dh.spring5webapp.model.Accidente;

public interface AccidenteService {


Accidente save(Accidente accidente);

Optional<Accidente> findOne(String id);

Iterable<Accidente> findAll();

Page<Accidente> findByEmpleadoNombre(String nombre, Pageable pageable);

Page<Accidente> findByEmpleadoNombreUsingCustomQuery(String nombre,


Pageable pageable);

Page<Accidente> findByFilteredTagQuery(String tag, Pageable pageable);

Page<Accidente> findByEmpleadosNombreAndFilteredTagQuery(String
nombre, String tag, Pageable pageable);

long count();

void delete(Accidente accidente);


}

37
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

Definición de la implementación

package com.dh.spring5webapp.services;

import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

import com.dh.spring5webapp.model.Accidente;
import com.dh.spring5webapp.repositories.AccidenteRepository;

@Service
public class AccidenteServiceImpl implements AccidenteService {

private final AccidenteRepository accidenteRepository;

@Autowired
public AccidenteServiceImpl(AccidenteRepository accidenteRepository) {
this.accidenteRepository = accidenteRepository;
}

@Override
public Accidente save(Accidente accidente) {
return accidenteRepository.save(accidente);
}

38
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

@Override
public Optional<Accidente> findOne(String id) {
return accidenteRepository.findById(id);
}

@Override
public Iterable<Accidente> findAll() {
return accidenteRepository.findAll();
}

@Override
public Page<Accidente> findByEmpleadoNombre(String nombre, Pageable
pageable) {
return accidenteRepository.findByEmpleadosNombre(nombre, pageable);
}

@Override
public Page<Accidente> findByEmpleadoNombreUsingCustomQuery(String
nombre, Pageable pageable) {
return
accidenteRepository.findByEmpleadosNombreUsingCustomQuery(nombre,
pageable);
}

@Override
public Page<Accidente> findByFilteredTagQuery(String tag, Pageable pageable)
{

39
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

return accidenteRepository.findByFilteredTagQuery(tag, pageable);


}

@Override
public Page<Accidente> findByEmpleadosNombreAndFilteredTagQuery(String
nombre, String tag, Pageable pageable) {
return
accidenteRepository.findByEmpleadosNombreAndFilteredTagQuery(nombre, tag,
pageable);
}

@Override
public long count() {
return accidenteRepository.count();
}

@Override
public void delete(Accidente accidente) {
accidenteRepository.delete(accidente);
}
}

3.7.6 Mapping

Definamos ahora nuestra primera entidad, un documento llamado Accidente con un Id

package com.dh.spring5webapp.model;

import static

40
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

org.springframework.data.elasticsearch.annotations.FieldType.Keyword;
import static org.springframework.data.elasticsearch.annotations.FieldType.Nested;
import static org.springframework.data.elasticsearch.annotations.FieldType.Text;

import java.util.Arrays;
import java.util.List;

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.InnerField;
import org.springframework.data.elasticsearch.annotations.MultiField;

@Document(indexName = "ssi", type = "accidente")


public class Accidente {

@Id
private String id;

@MultiField(mainField = @Field(type = Text, fielddata = true), otherFields = {


@InnerField(suffix = "verbatim", type = Keyword) })
private String titulo;

@Field(type = Nested, includeInParent = true)


private List<Empleado> empleados;

@Field(type = Keyword)

41
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

private String[] tags;

public Accidente() {
}

public Accidente(String titulo) {


this.titulo = titulo;
}

public String getId() {


return id;
}

public void setId(String id) {


this.id = id;
}

public String getTitulo() {


return titulo;
}

public void setTitle(String titulo) {


this.titulo = titulo;
}

public List<Empleado> getEmpleados() {


return empleados;

42
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

public void setEmpleados(List<Empleado> empleados) {


this.empleados = empleados;
}

public String[] getTags() {


return tags;
}

public void setTags(String... tags) {


this.tags = tags;
}

@Override
public String toString() {
return "Accidente{" + "id='" + id + '\'' + ", titulo='" + titulo + '\'' + ", empleados=" +
empleados + ", tags=" + Arrays.toString(tags) + '}';
}
}

y al igual Empleado que es un simple bean

package com.dh.spring5webapp.model;
public class Empleado {
private String nombre;
public Empleado() {
}

43
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

public Empleado(String nombre) {


this.nombre = nombre;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
@Override
public String toString() {
return "Empleado{" + "nombre='" + nombre + '\'' + '}';
}
}

Tenga en cuenta que en la anotación @Document, indicamos que las instancias de esta clase
se deben almacenar en Elasticsearch en un índice llamado "ssi", y con un tipo de documento
de "accidente". Los documentos con muchos tipos diferentes se pueden almacenar en el
mismo índice. También observe que el campo de empleados está marcado como
FieldType.Nested. Esto nos permite definir la clase Empleado por separado, pero tener las
instancias individuales de empleado incrustadas en un documento Accidente cuando está
indexado en Elasticsearch.

3.7.7 Indexando Documentos

Un vistazo rápido a un ejemplo para indexar un accidente con dos empleados que participaron:

@GET
@Path("/test-elk")
public Accidente getAccidentById() {
Accidente accidente = new Accidente("Accidente ELK 1");

44
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

accidente.setEmpleados(asList(new Empleado("Juan Mejia"),


new Empleado("Valentin Laime")));
accidenteService.save(accidente);
return (accidente);
}

3.7.8 Consultas

El método basado en el nombre de consulta. La clase de repositorio que definimos


anteriormente tenía un método findByEmpleadoNombre, que podemos usar para buscar
accidentes por nombre de empleado:

String nombreBuscar = "Juan Mejia";


Page<Accidente> accidentePorEmpleadoNombre
= accidenteService.findByEmpleadoNombre(nombreBuscar,
PageRequest.of(0, 10));

Al llamar a findByEmpleadoNombre con un objeto PageRequest, obtenemos la primera página


de resultados (la numeración de las páginas se basa en cero), y esa página contiene como
mucho 10 accidentes.

Existen dos formas de definir consultas personalizadas para los repositorios Spring Data
Elasticsearch. Una forma es usar la anotación @Query, como se demostró en la sección 3.7.4.
Otra opción es usar un generador para la creación de consultas personalizadas. Por ejemplo,
podríamos buscar accidentes que tengan la palabra "accidente" en el título construyendo una
consulta con NativeSearchQueryBuilder:

SearchQuery searchQuery = new NativeSearchQueryBuilder()


.withFilter(regexpQuery("titulo", ".*accidente.*"))
.build();
List<Accidente> accidentes = elasticsearchTemplate.queryForList(searchQuery,
Accidente.class);

45
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

3.7.9 Actualizar y Eliminar documentos

Para actualizar o eliminar un documento, primero tenemos que recuperar ese documento.

String accidenteTitulo = "accidente";


SearchQuery searchQuery = new NativeSearchQueryBuilder()
.withQuery(matchQuery("titulo",accidenteTitulo).minimumShouldMatch("75%"))
.build();
List<Accidente> accidentes = elasticsearchTemplate.queryForList(searchQuery,
Accidente.class);

Ahora, para actualizar el título del artículo, podemos modificar el documento y usar la API de
guardado:

accidente.setTitle("Titulo accidente modificado");


accidenteService.save(accidente);

Para eliminar un documento puedes utilizar el método de eliminación:

accidenteService.delete(accidente);

3.8 Kibana

Kibana facilita la comprensión de grandes volúmenes de datos. Su sencilla interfaz basada en


navegador le permite crear y compartir rápidamente dashboards y visualizaciones dinámicas
que muestran cambios en las consultas de Elasticsearch en tiempo real.

Según (Elastic, 2018) Kibana es una plataforma de análisis y visualización de código abierto
diseñada para trabajar con Elasticsearch. Se utiliza Kibana para buscar, ver e interactuar con
los datos almacenados en los índices de Elasticsearch. Se puede realizar fácilmente análisis de
datos avanzados y visualizar sus datos en una variedad de cuadros, tablas y mapas.

Según (Gupta, 2015, pág. 46), Kibana es una herramienta que forma parte de la familia de ELK,
que consta de Elasticsearch, Logstash, y Kibana. Está construido y desarrollado por Elastic.

46
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

Kibana es una plataforma de visualización que es construido sobre Elasticsearch y aprovecha


las funcionalidades de Elasticsearch.

Para entender mejor a Kibana, echemos un vistazo a la siguiente figura:

Figura 3- Familia Elastic (Gupta, 2015)

Configurar Kibana es muy sencillo. Se puede instalar Kibana y comenzar a explorar sus índices
de Elasticsearch en minutos, sin necesidad de código ni infraestructura adicional.

Para practicar las consultas a la API de Elasticsearch se tiene la opción de “Dev Tools” como se
observa en la figura 4.

Además se puede generar distintas visualizaciones como mostramos en la figura 5.

Las cuales nos permite compartir ya sea el dashboard o la visualización como un <iframe>, el
cual lo podemos integrar a nuestros proyectos usando simple HTML.

47
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

Figura 4-Captura de Kibana Dev tools (Elastic, 2018)

Figura 5- Ejemplo de Visualizaciones (Elastic, 2018)

48
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

4 CONCLUSIONES

La presente monografía se ha dedicado a la investigación y análisis de las características e


integración de Elasticsearch con Spring aplicando al caso de estudio SSI Sistema de Seguridad
Industrial.

• Elasticsearch es un motor de análisis y búsqueda de texto completo altamente escalable.


Permite almacenar, buscar y analizar grandes volúmenes de datos de forma rápida y casi
en tiempo real.
• Las características de Elasticsearch provee a las aplicaciones empresariales datos en
tiempo real, distribuido, escalable, de una alta disponibilidad, búsquedas avanzadas DSL,
orientado a documentos, sin esquemas, código abierto y multiplataforma.
• La arquitectura de Elasticsearch está compuesta por cluster, nodos, índices, mapping,
documentos, fragmentos y replicas que mantienen toda la información de manera distribuida
e indexada.
• Son muchas organizaciones importantes que están utilizando en la actualidad Elasticsearch
• La instalación y configuración de Elasticsearch en el sistema operativo Ubuntu, se requiere
tener instalado java y seguir los pasos de la documentación oficial, para interactuar como
crear índice, un documento u otra acción se realiza mediante el API REST.
• Se aplicaron los conceptos básicos de Spring Data con Elasticsearch de una manera
práctica y centrada en el código, al proyecto SSI Sistema de seguridad Industrial. Para
indexar, buscar y consultar datos en Elasticsearch con Spring utilizando Spring Data, este
módulo de Spring es útil para interactuar con el motor de búsqueda de código abierto
basado en Lucene
• Kibana facilita la comprensión de grandes volúmenes de datos. Su sencilla interfaz basada
en navegador le permite crear y compartir rápidamente dashboards y visualizaciones
dinámicas que muestran cambios en las consultas de Elasticsearch en tiempo real.

Se recomienda a toda persona interesada que desarrolle una aplicación empresarial en java
considerar el uso de Elasticsearch para obtener todos los beneficios que nos ofrece.

49
Mejora de SSI con el uso de Elasticsearch en Spring – Juan Pablo Mejia

5 BIBLIOGRAFÍA

Bharvi, D., Rafał, K., Marek, R., & Saurabh, C. (2017). Elasticsearch: A Complete Guide. Packt
Publishing.

Elastic. (2018, 10 1). Elasticsearch Reference 6.4. Retrieved from https://www.elastic.co/

Elasticsearch indexing. (2015). Publishing Ltd.

Gupta, Y. (2015). Kibana Essentials. Packt Publishing.

RADU, G., MATTHEW, H. L., & ROY , R. (2016). Elasticsearch in action. Manning Publications
Co.

Team, B. C. (2018, 09 10). Spring Data Elasticsearch. Retrieved from


https://docs.spring.io/spring-data/elasticsearch/docs/3.0.10.RELEASE/reference/html/

50

Anda mungkin juga menyukai