DEV Community: Alex Salgado

Como Configurar e Testar Políticas ILM no Elasticsearch

Alex Salgado — Fri, 02 Aug 2024 12:52:39 +0000

Introdução

Gerenciar dados de forma eficiente é crucial, especialmente em sistemas que lidam com grandes volumes de informações. O Elasticsearch, uma poderosa ferramenta de busca e análise, oferece o recurso de políticas de gerenciamento de ciclo de vida de índices (ILM) para ajudar a gerenciar como os dados são armazenados, movidos e excluídos ao longo do tempo. Isso não só otimiza a performance, mas também ajuda a reduzir os custos de armazenamento. Imagine uma empresa que coleta dados de sensores IoT: inicialmente, os dados precisam ser acessados rapidamente, mas com o tempo, podem ser movidos para um armazenamento mais barato antes de serem excluídos após um período.

Passo 1: Configurar a Política ILM

1.1 Definindo a Política ILM

Primeiro, precisamos criar uma política ILM chamada my_ilm_policy. Esta política divide o ciclo de vida dos dados em três fases:

Fase "hot": Aqui, os dados são escritos inicialmente. Configuramos para fazer o rollover (criar um novo índice) quando o índice atinge 50 GB ou 30 dias de idade.
Fase "warm": Após 30 dias, os dados são movidos para nós de dados "warm", que são mais baratos, mas ainda relativamente rápidos.
Fase "delete": Após 90 dias, os dados são excluídos para liberar espaço.

Comando:

PUT /_ilm/policy/my_ilm_policy
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover": {
            "max_size": "50gb",
            "max_age": "30d"
          }
        }
      },
      "warm": {
        "min_age": "30d",
        "actions": {
          "allocate": {
            "require": {
              "data": "warm"
            }
          }
        }
      },
      "delete": {
        "min_age": "90d",
        "actions": {
          "delete": {}
        }
      }
    }
  }
}

1.2 Criar o Índice Inicial e Associar o Alias

Agora, criamos o primeiro índice (my_index-000001) e associamos a ele um alias chamado my_alias. O alias é um apelido para o índice, facilitando a referência a ele. Também aplicamos a política ILM my_ilm_policy ao índice.

Comando:

PUT /my_index-000001
{
  "settings": {
    "index": {
      "lifecycle": {
        "name": "my_ilm_policy",
        "rollover_alias": "my_alias"
      }
    }
  },
  "aliases": {
    "my_alias": {}
  }
}

Passo 2: Verificar o Índice de Gravação e sua Saúde

2.1 Verificar o Índice de Gravação

Para garantir que estamos gravando no índice correto, verificamos qual índice está associado ao alias my_alias.

Comando:

GET /_alias/my_alias

2.2 Verificar a Saúde do Índice de Gravação

Para garantir que o índice está funcionando corretamente, verificamos sua saúde.

Comando:

GET /_cluster/health/my_index-000001

Passo 3: Realizar o Rollover Manualmente

3.1 Forçar o Rollover do Índice

Se quisermos forçar a criação de um novo índice de gravação manualmente (sem esperar pelos critérios de tamanho ou idade), usamos o comando abaixo. Isso cria um novo índice (por exemplo, my_index-000002) e o associa ao alias my_alias.

Comando:

POST /my_alias/_rollover

Passo 4: Verificar o Novo Índice de Gravação e sua Saúde

4.1 Identificar o Novo Índice de Gravação

Depois de realizar o rollover, verificamos novamente qual índice está associado ao alias my_alias e está sendo usado para gravar novos dados.

Comando:

GET /_alias/my_alias

4.2 Verificar a Saúde do Novo Índice de Gravação

Verificamos a saúde do novo índice de gravação (por exemplo, my_index-000002) para garantir que ele está funcionando corretamente.

Comando:

GET /_cluster/health/my_index-000002

Passo 5: Verificar Remoção do Alias de Índices Antigos na Fase "warm"

5.1 Verificar a Configuração do Alias Após a Mudança de Fase

Depois que o índice original se move para a fase "warm", verificamos se ele foi removido do alias my_alias. Isso deve acontecer automaticamente conforme nossa política ILM.

Comando:

GET /_alias/my_alias

Resumo

Configurar a política ILM para gerenciar como e quando os índices são movidos ou excluídos.
Criar o primeiro índice e associar um alias a ele.
Verificar qual índice está sendo usado para gravação e sua saúde.
Forçar a criação de um novo índice de gravação manualmente.
Verificar o novo índice de gravação e garantir que ele está saudável.
Verificar se o índice antigo foi removido do alias quando se move para uma fase de dados menos importante.

Esses passos ajudam a garantir que seus dados estão sendo gerenciados de forma eficiente e que você sempre está escrevendo em um índice saudável e atualizado.

Referências

Usando Consultas de Percolação do Elasticsearch, Netflix Aperfeiçoa Buscas Reversas Eficientemente

Alex Salgado — Fri, 10 May 2024 14:00:27 +0000

Você já ouviu falar de buscas de percolação, buscas reversas? Olha esse case da NetFlix usando Elasticsearch.

🎥🍿 No mais recente artigo do Netflix Tech Blog, a equipe técnica descreve como transformaram os desafios de notificações personalizadas em uma solução eficiente que economiza tempo e recursos. Utilizando buscas reversas, a Netflix pode agora identificar rapidamente quais consultas são satisfeitas por um novo documento, como a adição de um filme, e notificar automaticamente os funcionários sobre atualizações relevantes.

Esta abordagem não só melhora a eficiência interna mas também abre novas possibilidades para personalizar a experiência do usuário final. 🎥🍿

O que é uma busca reversa?

Normalmente, quando você faz uma busca na internet ou em um banco de dados, você tem uma pergunta ou critério específico e está procurando por respostas ou itens que correspondam a esse critério. Por exemplo, se você pesquisar "filmes de comédia" em um site de streaming, você está procurando por filmes que se encaixem na categoria de comédia.

A busca reversa é o oposto disso. Em vez de você ter a pergunta e procurar por respostas, você tem uma "resposta" e está procurando por todas as perguntas ou critérios que essa resposta satisfaz. Por exemplo, se um novo filme de comédia é adicionado ao catálogo, a busca reversa encontra todas as buscas salvas que deveriam incluir esse filme, como "filmes de comédia" ou "novos lançamentos".

Como a Netflix usa isso?

A Netflix usa essa técnica para enviar notificações personalizadas. Eles usaram o exemplo de uma funcionária da Netflix, chamada Tiffany, que é responsável por supervisionar vários filmes. Ela pode querer ser notificada sobre coisas específicas, como "filmes sendo filmados na Cidade do México que ainda não têm um diretor designado".

Ela não está inscrita para receber atualizações de filmes específicos, mas sim para tipos de atualizações que correspondem a certos critérios. Então, quando um filme é atualizado e agora se encaixa nos critérios de uma das buscas de Tiffany, ela recebe uma notificação automaticamente.

O que são consultas de percolação?

Para fazer isso de forma eficiente, a Netflix usa algo chamado "consultas de percolação" do Elasticsearch. Isso permite que a Netflix não apenas guarde as consultas de busca como se fossem documentos num índice, mas também verifique rapidamente novos filmes contra essas consultas para ver quais consultas eles satisfazem.

Por que isso é útil?

Esse método é super eficiente porque evita que a Netflix tenha que refazer todas as buscas salvas toda vez que um filme é atualizado para ver se ele agora se encaixa em alguma das buscas. Em vez disso, eles podem rapidamente verificar o filme contra as consultas salvas e ver quais notificações precisam ser enviadas. Isso economiza muitos recursos e tempo, tornando o sistema de notificação rápido e eficiente.

Quer saber mais sobre como isso funciona e as implicações dessa tecnologia? Leia o artigo completo no Netflix Tech Blog! (https://netflixtechblog.com/reverse-searching-netflixs-federated-graph-222ac5d23576)

Referências:

[IoT - Drones] Visualizando os dados com o Kibana - Episódio FINAL

Alex Salgado — Thu, 16 Feb 2023 21:17:42 +0000

Como um bom sistema de IoT, precisamos de algo como um sistema supervisório para acompanharmos em tempo real. Nada melhor que o Kibana Canvas.

Usando sua imaginação, criando queries como fonte de dados dos componentes, é possível criar seu dashboard personalizado.

Neste último episódio da nossa série sobre IoT e drones, vamos explorar como visualizar de maneira eficiente os dados coletados dos sensores do drone no Elasticsearch através do Filebeat.

Com o Elasticsearch populado com os dados da telemetria do drone, agora é hora de explorar esses dados de uma maneira visual e interativa. Para isso, vamos usar o Kibana, uma plataforma de análise e visualização de dados da Elastic.

No Kibana, vamos criar dashboards personalizados para exibir gráficos e métricas baseados nos dados da telemetria do drone. Além disso, vamos criar visualizações interativas, como mapas de calor e gráficos em tempo real, para ajudar a monitorar e entender os dados em tempo real.

Para criar dashboards e visualizações no Kibana, primeiro precisamos criar um índice no Elasticsearch para armazenar nossos dados da telemetria do drone. Em seguida, podemos usar o Kibana para criar dashboards e visualizações baseadas nesse índice.

Já havíamos criado o índice no episódio 2, então ele será usando como fonte das nossas informações.

Em resumo, nesta série de episódios, abordamos como coletar, processar e visualizar os dados da telemetria dos drones usando as ferramentas IoT. Começamos por apresentar o problema de coletar dados de sensores em drones em movimento e explicar como a combinação de Filebeat, Elasticsearch e Kibana pode ser uma solução eficiente. Em seguida, apresentamos como configurar o Filebeat e o Elasticsearch para coletar e armazenar dados da telemetria do drone. Finalmente, mostramos como criar dashboards e visualizações interativas no Kibana para ajudar a monitorar e entender esses dados de maneira eficiente.

Com as informações apresentadas nesta série, agora é possível coletar dados da telemetria dos drones, processá-los e visualizá-los de maneira eficiente. Isso pode ser útil para uma ampla gama de aplicações, desde monitoramento de condições climáticas até inspeção de edifícios e infraestruturas. Esperamos que você tenha encontrado esta série útil e informativa e que possa aplicar estas técnicas em seus próprios projetos de IoT e drones.

Abraços!

Este é o quinto capítulo da série [IoT Drones]. Caso tenha perdido algum episódio anterior, não se preocupe, confira a lista abaixo para acompanhar a série completa.

[IoT - Drones] Testando a Telemetria - Episódio 4

Alex Salgado — Sun, 12 Feb 2023 22:34:40 +0000

Neste episódio, vamos explorar como testar a telemetria dos drones. Para testar nosso cenário, precisamos ligar o drone Tello. Ao fazer isso, ele cria uma rede Wi-Fi "TELLO***" que podemos conectar ao nosso computador usando o código em Python.

Com o drone ligado, podemos criar vôos programaticamente, gravar vídeos e ler a telemetria dos sensores. De acordo com a documentação do Tello, é possível ler 16 informações de sensores, incluindo temperatura, altitude, tempo de vôo, movimentação nos eixos x, y, z, entre outras. Essas informações são coletadas no seguinte formato:

“pitch:%d;roll:%d;yaw:%d;vgx:%d;vgy%d;vgz:%d;templ:%d;temph:%d;tof:%d;h:%d;bat:%d;baro:%.2f; time:%d;agx:%.2f;agy:%.2f;agz:%.2f;\r\n”

Usamos o código em Python para ler esses dados na porta 8890, montar um JSON e publicá-los no MQTT no tópico "drones/drone01" de acordo com o padrão publish/subscribe. A frequência de leitura pode ser regulada no código Python (neste caso, 0,3 segundos).

Antes de iniciar a coleta da telemetria, precisamos acionar o Filebeat para que ele fique escutando as publicações no MQTT e enviando os dados para o Elasticsearch, através do pipeline "mqtt-test" que criamos anteriormente.

Na sua máquina com o Filebeat instalado, execute os seguintes comandos no terminal para testar, configurar e executar o Filebeat:

./filebeat test config
./filebeat test output
./filebeat setup

Se tudo estiver funcionando corretamente, podemos executar o Filebeat com o seguinte comando:

./filebeat -e

Para finalizar o teste acima, vamos criar um código para programar uma ação/Vôo com drone.

Código do Drone

Precisamos criar um código em python para ler os dados dos sensores do Drone e publicá-los no nosso broker MQTT. Toda publicação precisa de um tópico e no nosso caso será "drones/drone01". Se eu estivesse gerenciando uma frota de drones, poderia criar outros tópicos como drones/drone02, drones/drone03, etc.

Existem algumas bibliotecas que fornece mecanismos para a programação no Tello.
Aqui um exemplo da biblioteca djitellopy.

pip install djitellopy

E um simples código exemplo que imprime os dados da telemetria, coletadas do drone em pleno vôo.

# Drone telemetry with Tello
from asyncio import sleep
from djitellopy import Tello

tello = Tello()

tello.connect()

while True:
    print(tello.get_current_state())
    sleep(0.3)

Teste final

Agora, com o drone ligado e conectado, iniciamos a coleta da telemetria usando o seguinte comando:

python pub-drone-telemetry.py

Enquanto os dados são coletados pelo drone, processados pelo nosso pipeline e populados no índice, podemos ver os registros chegando através da opção "Discover" no Kibana.

Note os campos drone-data.sensorX criados na lateral esquerda da tela. Cada campo corresponde a um dado de sensor do drone no mesmo timestamp.

Agora que temos a telemetria coletada dos sensores do drone e enviada para o Elasticsearch através do Filebeat, no próximo episódio final, podemos explorar como visualizar esses dados de maneira eficiente no Kibana.

Abraços!

Este é o quarto capítulo da série [IoT Drones]. Caso tenha perdido algum episódio anterior, não se preocupe, confira a lista abaixo para acompanhar a série completa.

[IoT - Drones] Preparando a ingestão de dados através do Filebeat- Episódio 3

Alex Salgado — Mon, 30 Jan 2023 11:36:13 +0000

A Internet das Coisas (IoT) e drones estão se tornando cada vez mais populares e amplamente utilizados em muitas indústrias. A combinação de IoT e drones permite a coleta de dados em tempo real, o que é útil para análises e tomada de decisões. No entanto, armazenar e processar esses dados em grandes volumes pode ser um desafio. Aqui, mostraremos como preparar a ingestão de dados MQTT no Elasticsearch para simplificar esse processo.

Todo o processo para configurar o MQTT broker, foi definido no episódio anterior.

Para executar essa tarefa de ingestão de dados publicados no MQTT broker, vamos utilizar o Filebeat. Instalar e configurar o Filebeat é uma tarefa simples, mas é importante seguir alguns passos para garantir que tudo esteja funcionando corretamente.

Passo 1 - Instalar e configurar Filebeat

O Filebeat pode ser instalado de acordo com as instruções da documentação oficial. Em nosso caso, estamos usando a versão Cloud da Elastic.

A seguir, precisamos dizer ao Filebeat que gostaríamos de nos inscrever no tópico o qual conterá os dados publicados pelo drone.
Edite o arquivo filebeat.yml na seção inputs, como mostrado a seguir:

filebeat.inputs:
#--- drone
- type: mqtt
  hosts:
    - tcp://ec2-18-204-19-124.compute-1.amazonaws.com:1883
  topics:
    - drones/drone01
  tags:
    ["advent_calendar"]
  fields:
    fleet_id: "drone"
  fields_under_root: true

Passo 2 - Recebendo e transformando os dados dentro do Elasticsearch

A partir do momento em que o Beat se inscreve no tópico "drones/drone01" do MQTT, toda vez em que alguém publicar informações no mesmo (no caso, o nosso drone), o processo de ingestão de dados é acionado. A telemetria inicial publicada pelo drone, envia dados dos sensores no formato JSON. Dessa forma, criamos um pipeline de ingestão para que transforma os atributos do JSON em campos no nosso índice dentro do Elasticsearch. Seguindo a documentação, no menu "Stack Management>Ingest Pipelines>Create Pipelines"

Após nomear o seu pipeline, "mqtt-test", clique em "Add processor" para definir a regra do parser.

Em nosso caso, desejamos extrair os atributos do campo "message" que está no formato JSON e transformá-los em campos do próprio índice com prefixo "data-drone". Clique em "Add" para adicionar nosso processor e em seguida "Create Pipeline".

Como vocês sabem, existem várias formas de resolver problemas semelhantes no Elastic, é uma questão de arquitetura, performance, etc. Neste caso, por exemplo, poderíamos configurar um script no próprio Filebeat, mas para me beneficiar da UI e ilustrar melhor o funcionamento do processor, resolvi utilizar esta opção dentro do próprio Elasticsearch. Qual outra opção você usaria?

Criamos então o nosso pipeline "mqtt-test" :

[
  {
    "json": {
      "field": "message",
      "target_field": "drone-data"
    }
  }
]

Precisamos agora dizer ao Filebeat que acione esse pipeline após a ingestão dos dados do drone. Fazemos isso editando o arquivo filebeat.yml na seguinte seção:

output.elasticsearch:
  indices:
    - index: "my-mqtt-%{[agent.version]}-%{+yyyy.MM.dd}"
  pipeline: mqtt-test

Passo 3 - Reinicie o Filebeat

Depois de ter configurado o Filebeat para usar o pipeline de ingestão de dados, é necessário reiniciar o Filebeat para que as alterações tenham efeito.

Com estes passos, o Filebeat estará configurado para usar o pipeline de ingestão de dados do Elasticsearch para transformar os dados recebidos em campos separados no índice do Elasticsearch. Verifique o log do Filebeat periodicamente para garantir que tudo esteja funcionando corretamente e para resolver quaisquer problemas que possam ocor

Pronto, tudo configurado, hora de testar. atento ao próximo episódio :)

Abraços!

Este é o terceiro capítulo da série [IoT Drones]. Caso tenha perdido algum episódio anterior, não se preocupe, confira a lista abaixo para acompanhar a série completa.

[IoT - Drones] Configurando o MQTT Broker - Episódio 2

Alex Salgado — Mon, 23 Jan 2023 12:32:45 +0000

Primeiramente, gostaria de agradecer a todos que se manifestaram, compartilhando seus próprios cases e "dores" com Drones após a publicação do Episódio 1. Espero que consiga ajudá-los ainda mais e aqueles que nunca trabalharam nessa área, possam iniciar com mais informação.

A partir do arquitetura proposta no episódio 1, vamos seguindo na implementação.

Talvez umas das partes essenciais nessa arquitetura seja a instalação de um Broker utilizando o protocolo MQTT. Então vamos colocá-lo como primeiro passo de configuração em nosso projeto.

Antes porém, eu colocaria um passo 0.

Passo 0 - Configurar ambiente virtual Python

Como estamos desenvolvendo um projeto em Python, gosto de criar um ambiente separado. Assim teremos todas as dependências e bibliotecas configuradas e descritas em um só lugar, facilitando a reprodução do projeto.

Escolha uma pasta em seu computador (no meu caso estou utilizando um Macbook) e seguindo os passos do link https://docs.python.org/pt-br/3/library/venv.html, vamos criar nosso ambiente.

python3 -m venv venvdrone

A partir de agora, vamos trabalhar no ambiente venvdrone e todas as bibliotecas e pacotes necessárias serão documentadas e instaladas de forma independente.

Passo 1 - Criar ou usar um broker MQTT

Existem alguns brokers MQTT prontos para serem usados como teste, por exemplo: "test.mosquitto.org", sempre usando a porta 1883 como padrão de acesso via TCP, mas se você quer mais segurança, existem outras opções de portas com autenticação e encriptação.

Para nosso experimento, criei e instalei uma máquina EC2 na AWS e acionei o Mosquitto, deixando-o disponível no seguinte endereço.

tcp://ec2-18-204-19-124.compute-1.amazonaws.com:1883

Dessa forma, utilizando a biblioteca python Eclipse Paho MQTT é possível publicar e se inscrever no tópico usando o endereço do broker.

pip install paho-mqtt

Este comando instala o cliente python do paho para ser usado em nosso código.

Configurações feitas, precisamos de um código para testar.

from paho.mqtt import client as mqtt_client

broker = 'ec2-18-204-19-124.compute-1.amazonaws.com'
port = 1883
topic = "drones/drone01"
.
.
.
def publish(client):
    msg_count = 0
    while True:
        time.sleep(1)
        # Mock-up test for publish drone sensors in MQTT
        msg = '{"pitch": 89, "roll": 3}'

        result = client.publish(topic, msg)
        # result: [0, 1]
        status = result[0]
        if status == 0:
            print(f"Send `{msg}` to topic `{topic}`")
        else:
            print(f"Failed to send message to topic {topic}")
        msg_count += 1

A primeira linha importa a biblioteca do paho de forma a conseguir publicar e se inscrever em algum tópico gerenciado pelo broker mqtt.

Na linha seguinte, fizemos as configurações para conseguir acessar o broker, através de uma porta e definindo um tópico.

Na função def publish, criamos um código que publica um objeto json no tópico "drones/drone01", a cada 1 segundo. Caso haja erro na publicação, uma mensagem será enviada.

Pronto, finalizamos a primeira parte da implementação, configurando e testando o nosso broker mqtt.

Dúvidas? Como está sendo até aqui? Seguiremos no episódio 3.

Abraços!

Este é o segundo capítulo da série [IoT Drones]. Caso tenha perdido algum episódio anterior, não se preocupe, confira a lista abaixo para acompanhar a série completa.

[IoT - Drones] Trabalhando com telemetria - Episódio 1

Alex Salgado — Mon, 16 Jan 2023 13:30:58 +0000

Você tem interesse em Drones ou trabalha com UAVs? Como você monitora as condições da sua aeronave? E se você tiver uma frota deles? Você ainda está criando programas do zero para todas essas tarefas e ainda não resolveu seu problema?

Este post trata de telemetria de Drones. Como receber os dados dos sensores em tempo real, transformá-los e armazená-los em um banco de dados de alta performance na nuvem. Tudo isso para criar uma visualização de toda a sua frota e conseguir gerenciá-la de forma otimizada, rápida e de qualquer lugar, pois as informações de seus Veículos Aéreos Não Tripulados (UAVs) estarão na nuvem.

Pré-requisitos

Tudo que precisamos é um drone, um meio de comunicação para leitura de dados dos sensores, um banco para armazenar essa telemetria e uma tela bonita para visualizar as informações.

O Drone

Para esse experimento, vamos usar um DJI Tello que além do custo e tamanho reduzido, pode ser usado dentro de casa e possui API para programação em Python.

O Protocolo de comunicação MQTT

Para que haja comunicação entre o drone e o servidor, vamos utilizar o protocolo MQTT que trata-se de um meio de comunicação muito utilizado em arquiteturas IoT. O MQTT atua na camada de TCP, baseia-se no padrão pub/sub e permite a transmissão dos dados dos sensores em alta velocidade. Hoje, o MQTT é usado em uma ampla variedade de indústrias, como automotiva, manufatura, telecomunicações, petróleo e gás, etc.

Vamos utilizar o Mosquitto como message broker para implementar essa transmissão via MQTT.

Ingestão dos dados

Para coletar os dados publicados no MQTT, vamos utilizar o Beat da Elastic chamado Filebeat. Esse beat possui uma implementação customizada para ler diretamente os dados via MQTT.

Após a ingestão dos dados, iremos transferir os mesmos para o Elasticsearch.

O Banco de dados

A indústria 4.0 vem gerando bilhões de informações com seus projetos de robótica, carros autônomos, IIoT, etc. Então precisamos de um banco de dados que comporte essa quantidade imensa de informações geradas pelos sensores. Estas mesmas informações precisam estar disponíveis rapidamente quando solicitadas.
O Elasticsearch encaixa-se perfeitamente nesse cenário. Dessa forma, os dados chegarão ao banco através do Filebeat, e internamente as informações necessárias serão extraídas através de um pipeline de ingestão o qual armazenará no índice apropriado.

A visualização

Toda essa informação processada em tempo-real, poderá ser visualizada e analisada através do Kibana. Neste caso em específico, vamos utilizar o Kibana Canvas.

Arquitetura IoT

A arquitetura proposta então seria como na figura abaixo

Gostou? Gostaria de aprender a implementar esse sistema? Acompanhe o próximo Episódio ...

Abraços!

Este é o primeiro capítulo da série [IoT Drones]. Caso tenha perdido algum episódio anterior, não se preocupe, confira a lista abaixo para acompanhar a série completa.