Elasticsearch: Consumindo dados real-time com ELK

Sumário

Agradecimentos

Sobre o autor

Prefácio

1. Introdução

2. Dissecando a ELK – Logstash

3. Dissecando a ELK - Elasticsearch

4. Dissecando a ELK – Kibana

5. Elasticsearch avançado

6. Administrando um cluster Elasticsearch

7. Considerações finais

Agradecimentos

Agradeço a Deus pela minha vida e por tudo que possuo, e a meus pais, Maria Odete Santos Lourenço e Eleutério da Silva Lourenço, que me suportaram e proporcionaram a base que me permitiu chegar onde estou hoje. Sem vocês, eu não seria nada! Agradeço também a minha irmã Lucebiane Santos Lourenço e minha namorada Ana Carolina Fernandes do Sim, cujo apoio e carinho são fundamentais na minha vida.

Agradeço aos leitores do meu blog (http://alexandreesl.com), por me acompanharem nas minhas aventuras no mundo da Tecnologia. Ter um blog é uma experiência muito gratificante, que pretendo continuar por muitos anos.

Agradeço a meus colegas e ex-colegas de trabalho, Victor Jabur, Élio Capelati, Cláudio Dias Marins e Cristiano Sanchez, cujo apoio foi fundamental para este e muitos outros projetos na minha carreira!

Agradeço ao pessoal da Casa do Código, em especial ao Paulo Silveira, a Vivian Matsui e Adriano Almeida, cujo suporte me ajudou a escrever este livro. Desejo-lhes muita sorte e felicidade!

Por fim, agradeço a você, leitor, por depositar a sua confiança em mim ao adquirir este livro. Espero que eu possa cumprir as suas expectativas e fornecer uma boa fonte de informações sobre o indexador Elasticsearch e a stack ELK.

Sobre o autor

Figura -1.1: Alexandre Eleutério Santos Lourenço

Alexandre Eleutério Santos Lourenço é Arquiteto de Software, com bacharel em Ciência da Computação pela Pontifícia Universidade Católica de São Paulo (PUC-SP). Possui grande experiência na linguagem Java, com a qual trabalha desde 2003.

Como arquiteto, tem contato com diversas tecnologias, frameworks e linguagens, como Java, Python, C#, C/C++, Angularjs, HTML5, Apache Cordova, Spring, EJB, Hadoop, Spark e, é claro, ELK.

Apaixonado por tecnologia, filmes, seriados e games, possui o blog Tecnologia Explicada (Technology Explained), onde publica artigos sobre os mais diversos assuntos do gênero. Também possui alguns artigos publicados no site americano Developer Zone (https://dzone.com).

Prefácio

A explosão dos dados

Vivemos em um mundo dominado por dados. Nunca foram produzidos tantos dados, de maneira tão rápida. Além disso, nunca se produziram tantos dados de maneira não estruturada, ou seja, que não seguem um modelo de estruturação formalizado, por meio do uso dos conhecidos schemas, como um XSD ou uma tabela em um banco de dados tradicional.

Para termos uma ideia do tamanho da massa de dados que temos em mãos, basta vermos os números de empresas como Twitter, Facebook e Netflix. Tais empresas processam milhões de dados por dia - em 2011, por exemplo, o Twitter publicou em seu blog que seus usuários alcançaram a marca de 200 milhões de tweets por dia! - e precisam de novos modelos para processar essas verdadeiras montanhas de dados, aproveitando-se de conceitos de computação distribuída.

Seguindo esses conceitos, diversas tecnologias foram criadas, como hadoop, spark, splunk, bancos NOSQL etc. Neste livro, abordaremos uma dessas novas ferramentas que permitem o processamento (consulta) de conjuntos massivos de dados textuais em tempo real, o Elasticsearch.

Para quem se destina este livro?

Este livro se destina a desenvolvedores que desejam ampliar seus conhecimentos em Elasticsearch e seu ferramental relacionado, cujos casos de uso discutiremos no decorrer do livro. Para melhor aproveitar o livro, o leitor deve possuir algum conhecimento em REST e JSON, visto que as principais interfaces que temos disponíveis para interagir com um cluster Elasticsearch se utilizam desses padrões de comunicação e formato de mensagens. Conhecimento básico da linguagem Java também pode auxiliar no entendimento.

Como devo estudar?

No decorrer do livro, em alguns capítulos teremos hands-on e outros tipos de atividades práticas. Todo o código-fonte dessas atividades se encontra em meu repositório. Se o leitor desejar obter uma referência rápida:

https://github.com/alexandreesl/livro-elasticsearch.git

Convido o leitor a entrar também no Fórum da Casa do Código:

http://forum.casadocodigo.com.br

Capítulo 1

Introdução

1.1 Conhecendo o Elasticsearch

Figura 1.1: Logo do Elasticsearch

O Elasticsearch foi criado por Shay Banon em 2010. Baseado no Apache Lucene, um servidor de busca e indexação textual, o objetivo do Elasticsearch é fornecer um método de se catalogar e efetuar buscas em grandes massas de informação por meio de interfaces REST que recebem/provêm informações em formato JSON.

Para entendermos as vantagens de se utilizar um indexador para nossas informações, vamos começar com um exemplo bastante simples. Imagine que temos uma API REST que implementa um CRUD (Create, Read, Update e Delete) de clientes. Usaremos o Spring Boot para subir nossa API. Com o intuito de não tirar o nosso foco do assunto principal, vamos mockar os dados em vez de utilizar um banco de dados, por questão de simplicidade.

Para começar, vamos criar nossa classe de domínio:

public class Cliente

{

private long

id;

private

String nome;

private

String email;

//getters e setters omitidos

  }

A seguir, criamos as classes Application e ApplicationConfig, responsáveis por configurar e inicializar o REST. Não se preocupe se você não conhecer o Spring Boot, você pode encontrar a API pronta dentro do meu repositório (https://github.com/alexandreesl/livro-Elasticsearch.git), na pasta Capitulo 1.

Veja a Application.java:

@SpringBootApplication public class Application

{

public static void main(String[] args)

{

        SpringApplication.run(Application.class, args);

    }

}

Veja a ApplicationConfig.java:

public class ApplicationConfig

{

@Named

static class JerseyConfig extends ResourceConfig

{

public JerseyConfig()

{

this.packages(br.com.alexandreesl.handson.rest

);

        }

    }

}

Por fim, criamos a classe ClienteRestService, que executa o CRUD de cadastro de clientes. Vamos começar pelo método de listagem de todos os clientes, bem como a criação da lista de clientes mockados:

@Named @Path(/) public class ClienteRestService

{

private static final

Logger logger = LogManager.getLogger(ClienteRestService.class.getName());

private static Map clientes = new

HashMap();

private static long

contadorErroCaotico;

static

{

        Cliente cliente1 =

new

Cliente();

        cliente1.setId(

1

);

        cliente1.setNome(

Cliente 1

);

        cliente1.setEmail(

customer1@gmail.com

);

        Cliente cliente2 =

new

Cliente();

        cliente2.setId(

2

);

        cliente2.setNome(

Cliente 2

);

        cliente2.setEmail(

customer2@gmail.com

);

        Cliente cliente3 =

new

Cliente();

        cliente3.setId(

3

);

        cliente3.setNome(

Cliente 3

);

        cliente3.setEmail(

customer3@gmail.com

);

        Cliente cliente4 =

new

Cliente();

        cliente4.setId(

4

);

        cliente4.setNome(

Cliente 4

);

        cliente4.setEmail(

customer4@gmail.com

);

        Cliente cliente5 =

new

Cliente();

        cliente5.setId(

5

);

        cliente5.setNome(

Cliente 5

);

        cliente5.setEmail(

customer5@gmail.com

);

        clientes.put(cliente1.getId(), cliente1);

        clientes.put(cliente2.getId(), cliente2);

        clientes.put(cliente3.getId(), cliente3);

        clientes.put(cliente4.getId(), cliente4);

        clientes.put(cliente5.getId(), cliente5);

    }

@GET

@Produces

(MediaType.APPLICATION_JSON)

public Collection getClientes()

{

            logger.info(

Foram buscados + clientes.values().size() + clientes

);

return

clientes.values();

    }

@GET

@Path(cliente

)

@Produces

(MediaType.APPLICATION_JSON)

public Cliente getCliente(@QueryParam(id) long id)

{

        Cliente cli =

null

;

for

(Cliente c : clientes.values()) {

if

(c.getId() == id)

                cli = c;

        }

        logger.info(

foi buscado o cliente

+ cli.getNome());

return

cli;

    }

//restante da classe omitida

A seguir, criamos os métodos para criação e alteração de clientes:

@POST

@Consumes

(MediaType.APPLICATION_JSON)

public void addCliente(Cliente cliente)

{

        logger.warn(

O cliente + cliente.getId() + foi inserido!

);

        clientes.put(cliente.getId(), cliente);

    }

@PUT

@Consumes

(MediaType.APPLICATION_JSON)

public void mergeCliente(Cliente cliente)

{

        contadorErroCaotico++;

if ((contadorErroCaotico) % 7 == 0

) {

throw new RuntimeException(Ocorreu um erro caótico!

);

        }

        logger.info(

O cliente + cliente.getId() + foi alterado!

);

        Cliente temp = clientes.get(cliente.getId());

        temp.setNome(cliente.getNome());

        temp.setEmail(cliente.getEmail());

    }

E por fim, o método para exclusão de clientes:

@DELETE

public void deleteCliente(@QueryParam(id) long id)

{

        logger.info(

O cliente + id + foi excluido!

);

        clientes.remove(id);

    }

Para testarmos a API, sugiro que você utilize o Postman (https://www.getpostman.com). Com uma interface gráfica simples, é uma ótima forma de se testar APIs REST.

Figura 1.2: Postman em ação

Outra forma de testar as chamadas é a partir do comando linux/unix curl. Para simplificar as instruções, vamos usar