Aproveite milhões de e-books, audiolivros, revistas e muito mais, com uma avaliação gratuita

Apenas $11.99 por mês após o período de teste gratuito. Cancele quando quiser.

Elasticsearch: Consumindo dados real-time com ELK
Elasticsearch: Consumindo dados real-time com ELK
Elasticsearch: Consumindo dados real-time com ELK
E-book297 páginas1 hora

Elasticsearch: Consumindo dados real-time com ELK

Nota: 0 de 5 estrelas

()

Ler a amostra

Sobre este e-book

Com o aumento massivo da produção de dados na atualidade, empresas como o Twitter, Facebook e Netflix precisam seguir modelos de estruturação formalizados para processar essas verdadeiras montanhas de dados, aproveitando-se de conceitos de computação distribuída. Dentre as novas tecnologias que permitem o processamento ou consulta de conjuntos enormes de dados textuais em tempo real está o Elasticsearch.

Neste livro, Alexandre Lourenço aborda a stack ELK (Elasticsearch, Logstash e Kibana), dissecando todos os seus aspectos. O objetivo é fornecer um método de se catalogar e efetuar buscas em grandes massas de informação por meio de interfaces REST que recebem ou provêm informações em formato JSON.
IdiomaPortuguês
Data de lançamento26 de fev. de 2016
ISBN9788555191695
Elasticsearch: Consumindo dados real-time com ELK
Ler a amostra

Relacionado a Elasticsearch

Ebooks relacionados

Avaliações de Elasticsearch

Nota: 0 de 5 estrelas
0 notas

0 avaliação0 avaliação

O que você achou?

Toque para dar uma nota

A avaliação deve ter pelo menos 10 palavras

    Pré-visualização do livro

    Elasticsearch - Alexandre Lourenço

    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

    Alexandre Eleutério Santos Lourenço

    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

    Logo do 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.

    Postman em ação

    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

    Está gostando da amostra?
    Página 1 de 1