08 ‐ Kibana: Visualização de dados, Gerenciamento da Stack e Machine Learning - BktechBrazil/elastic-eck GitHub Wiki

O Kibana é a interface gráfica do Elastic Stack. É através dele que você explora os dados armazenados no Elasticsearch, cria visualizações, monta dashboards, gerencia a stack e acompanha o estado do cluster — tudo pelo navegador, sem precisar escrever código.

Na versão 9.x, o Kibana evoluiu além de uma ferramenta de visualização: ele se tornou o ponto central de operação de toda a stack, reunindo observabilidade, segurança, gestão de índices, criação de pipelines e automações com inteligência artificial em uma única interface.

E no ECK? O Kibana é um recurso Kibana gerenciado pelo operator. Não existe kibana.yml para editar no servidor: as configurações vão no campo spec.config do manifesto, e o operator reinicia o pod para aplicá-las. Todo o resto deste capítulo — Discover, dashboards, Machine Learning, usuários — é feito na interface do Kibana, igual em qualquer instalação.

O Kibana 9.x organiza as funcionalidades em grandes grupos acessíveis pelo menu lateral:

O Kibana vem com três conjuntos de dados de exemplo prontos para uso, que incluem dados realistas, Data Views, dashboards pré-construídos e até workpads do Canvas. São a forma mais rápida de explorar as funcionalidades do Kibana sem precisar configurar ingestão de dados.

Após a instalação, cada conjunto cria automaticamente:

• O índice com os dados
• A Data View correspondente
• Dashboards prontos para exploração
• Workpads do Canvas (no caso do eCommerce)

Os dados dos sample sets têm timestamps relativos à data de instalação — incluindo dados no futuro. Isso é intencional para que os dashboards sempre exibam dados recentes independentemente de quando foram instalados.

Os laboratórios usam o cluster lab-es com um node, o Kibana lab-kb e os três conjuntos de Sample Data. Quase tudo é feito na interface do Kibana.

No terminal da VM:

cd ~/eck-lab
kubectl -n elastic get elasticsearch,kibana

Resultado esperado: lab-es com HEALTH green, NODES 1 e PHASE Ready, e lab-kb com HEALTH green.

PASSWORD=$(kubectl -n elastic get secret lab-es-es-elastic-user \
  -o go-template='{{.data.elastic | base64decode}}')
echo "Senha do elastic: $PASSWORD"

pkill -f "port-forward.*5601" || true
nohup kubectl -n elastic port-forward --address 0.0.0.0 service/lab-kb-kb-http 5601 > /tmp/pf-kibana.log 2>&1 &
sleep 2
cat /tmp/pf-kibana.log

Resultado esperado: a senha do usuário elastic e a mensagem Forwarding from 0.0.0.0:5601 -> 5601.

O túnel fica ligado ao pod do Kibana que estava rodando quando ele foi aberto. Se esse pod for reiniciado ou recriado, o túnel cai e o Kibana deixa de responder no navegador: execute este bloco novamente.

No navegador, abra https://<IP_DA_VM>:5601 e faça login com o usuário elastic e a senha exibida.

Confira no Console (Dev Tools) quais conjuntos já estão instalados:

GET /_cat/indices/kibana_sample_data_*?v&h=health,index,docs.count

Para instalar os que faltarem:

1. No Kibana, acesse Menu → Integrations (ou use a busca global e pesquise por "Integrations")
2. No campo de busca de integrações, pesquise por Sample Data
3. Clique em Sample Data para abrir a página
4. Clique em Add data em cada conjunto que ainda não estiver instalado (Sample web logs, Sample flight data e Sample eCommerce orders)

Os índices dos Sample Data são criados com 1 réplica. Como o lab-es tem um único node, ajuste para 0 réplicas:

PUT /kibana_sample_data_*/_settings
{
  "index.number_of_replicas": 0
}

Confira que os três índices estão green:

GET /_cat/indices/kibana_sample_data_*?v&h=health,index,docs.count

O Kibana não lê índices diretamente: ele lê Data Views (antes chamadas de index patterns). Uma Data View aponta para um ou mais índices por um padrão de nome — por exemplo, kibana_sample_data_ecommerce, ou logs-* para vários — e define qual campo representa o tempo. Discover, Lens, dashboards, Maps, Machine Learning e alertas começam sempre por uma Data View.

1. Acesse Menu → Stack Management → Data Views.

   

   

2. Confira que as Data Views criadas pelos Sample Data estão na lista: Kibana Sample Data eCommerce, Kibana Sample Data Logs e Kibana Sample Data Flights.

   

3. Para um índice sem Data View, clique em Create data view, informe o padrão do índice (por exemplo, filebeat-*) e escolha o campo de tempo correto (@timestamp para eventos e logs, order_date para os pedidos do eCommerce).

O Discover é o ponto de partida para exploração de dados no Kibana. Ele permite buscar, filtrar e inspecionar documentos armazenados nos índices do Elasticsearch em tempo real, sem precisar escrever queries manualmente. Ele é a ferramenta de investigação (um erro, um pico, um cliente); os dashboards são a de acompanhamento.

Criar e selecionar uma Data View: uma Data View define de quais índices os dados serão lidos e qual campo será usado como referência de tempo. É o primeiro passo antes de explorar qualquer dado.

Barra de busca com KQL ou Lucene: o Kibana Query Language (KQL) é a forma mais simples de filtrar dados no Discover. Ele oferece autocomplete e é mais intuitivo do que a Query DSL. Exemplo:

status: 200 and url: "/api/*"

Histograma temporal: exibe a distribuição dos documentos ao longo do tempo. Permite identificar picos, quedas e padrões de volume rapidamente, além de selecionar intervalos clicando e arrastando diretamente no gráfico.

Lista de documentos: exibe os documentos que correspondem à busca atual. Cada documento pode ser expandido para visualizar todos os campos e seus valores. É possível adicionar ou remover colunas para personalizar a visualização.

Seletor de tempo: controla o intervalo de tempo dos dados exibidos — desde os últimos 15 minutos até períodos customizados.

Salvar e compartilhar: buscas podem ser salvas com um nome e reutilizadas em dashboards ou compartilhadas com outros usuários.

# igualdade em keyword
customer_gender : "FEMALE"

# numérico e combinação lógica
taxful_total_price > 50 and taxful_total_price <= 100

# curinga em texto
category : *Clothing*

# OR e negação
response.keyword : "404" or response.keyword : "500"
not machine.os : "ios"

# campo existe
url : *

# combinação de campos
geo.dest : "US" and bytes > 5000

O intervalo de datas não entra no KQL: ele vem do seletor de tempo no topo da tela.

1. Acesse Menu → Discover

2. Selecione a Data View Kibana Sample Data Logs (kibana_sample_data_logs)

3. Ajuste o seletor de tempo para Last 7 days

   

4. Observe o histograma — identifique picos e quedas no volume de logs ao longo do período

5. Na barra de busca, filtre usando KQL:

   response: 404
   

6. Observe quantos documentos de erro 404 existem no período

7. Tente um filtro mais complexo:

   response : 404 AND request : *kibana*
   

8. Adicione as colunas clientip, response, url e geo.dest à tabela clicando no ícone ao lado de cada campo no painel esquerdo

9. Expanda um documento clicando na seta à esquerda para ver todos os campos disponíveis

10. Salve a busca com o nome erros-404-kibana clicando em Save

Os Dashboards permitem reunir múltiplas visualizações em uma única tela, criando uma visão consolidada dos dados. É a funcionalidade mais usada no dia a dia para monitoramento e apresentação de resultados.

O Lens é o editor de visualizações do Kibana: você arrasta campos e ele sugere o gráfico e escolhe a agregação apropriada. Por baixo, é a mesma dupla das agregações do Elasticsearch — bucket (eixo X, fatias) e metric (eixo Y, tamanho).

Os tipos mais usados: barras/colunas, linha/área (séries temporais), pizza/donut (proporções), métrica (um número em destaque, um KPI), tabela, mapa, heatmap e treemap.

Dica: comece sempre pela pergunta ("receita por categoria ao longo do tempo?") e deixe o Lens propor o gráfico. Só depois refine o tipo. O seletor de tipo à direita troca o gráfico sem perder a configuração, e o Break down by quebra uma série por categoria (vira várias linhas ou barras).

Acesse Menu → Dashboards → Create dashboard.

Um dashboard é composto por painéis — cada painel contém uma visualização, uma tabela, um controle ou qualquer outro elemento. Os painéis podem ser redimensionados e reorganizados livremente.

• Lens: editor visual de gráficos — a forma recomendada de criar visualizações no Kibana 9.x. Suporta barras, linhas, área, pizza, treemap, métrica, gauge, e outros tipos.
• Mapa: visualização geoespacial integrada ao Maps.
• Markdown: painel de texto livre com formatação — útil para adicionar títulos, instruções ou links no dashboard.
• Saved search: exibe o resultado de uma busca salva do Discover.
• Controles: filtros interativos (listas de opções, sliders de intervalo e de tempo) que afetam todos os painéis do dashboard ao mesmo tempo.

O seletor de tempo e os filtros aplicados no dashboard afetam todos os painéis simultaneamente. Isso permite que o usuário navegue nos dados de forma interativa sem precisar configurar cada painel individualmente. Clicar numa barra ou fatia de um gráfico também cria um filtro que se aplica ao dashboard inteiro.

Dashboards podem ser:

• Compartilhados via URL: gera um link direto para o dashboard com os filtros e período de tempo atuais
• Exportados como PDF ou PNG: pelo menu Export do dashboard. É um recurso pago (Reporting), disponível com a licença trial
• Incorporados em páginas externas: via iframe com o link de embed gerado pelo Kibana

Usa o Sample Data eCommerce (kibana_sample_data_ecommerce).

Passo 1 — Receita por dia (linha): acesse Menu → Visualize Library → Create visualization → Lens e selecione a Data View Kibana Sample Data eCommerce.

• Eixo X: order_date (Date histogram).
• Eixo Y: Sum de taxful_total_price.
• Tipo: Line. Salve como Receita por dia.

Passo 2 — Receita por categoria (barras):

• Eixo X: category.keyword (Top values, 5 valores).
• Eixo Y: Sum de taxful_total_price.
• Tipo: Bar. Salve como Receita por categoria.

Passo 3 — Ticket médio (métrica):

• Métrica: Average de taxful_total_price.
• Tipo: Metric. Salve como Ticket médio.

Passo 4 — Montar o dashboard: acesse Menu → Dashboards → Create dashboard, adicione as três visualizações a partir da biblioteca (Visualize Library) e organize os painéis arrastando e redimensionando.

Passo 5 — Adicionar um controle: adicione ao dashboard um controle do tipo Options list no campo category.keyword. O menu que aparece no topo filtra todos os painéis pela categoria escolhida.

Passo 6 — Interatividade: clique numa barra do gráfico Receita por categoria e veja o dashboard inteiro filtrar; remova o filtro na barra superior. Mude o intervalo de tempo global e observe todos os painéis responderem. Salve o dashboard como Visão de Vendas.

Usa o Sample Data Flights (kibana_sample_data_flights).

1. Acesse Menu → Dashboards → Create dashboard
2. Clique em Add panel → Lens
3. No Lens, selecione a Data View Kibana Sample Data Flights
4. Arraste o campo timestamp para o eixo X e FlightDelayMin (Average) para o eixo Y
5. Selecione o tipo de gráfico Line — você verá o atraso médio de voos ao longo do tempo
6. Clique em Save and return
7. Adicione um segundo painel: Add panel → Lens
   • Crie um gráfico de barras com Carrier no eixo X e contagem de documentos no eixo Y
   • Ordene pelo maior número de voos
8. Adicione um terceiro painel: Add panel → Lens
   • Selecione o tipo Metric
   • Arraste AvgTicketPrice com agregação Average — exibe o preço médio dos tickets
9. Adicione um painel Markdown com o título ## Dashboard de Voos
10. Aplique um filtro global no dashboard clicando em Add filter: Cancelled: false
11. Observe como todos os painéis respondem ao filtro simultaneamente
12. Salve o dashboard com o nome Análise de Voos

Tudo o que é criado no Kibana — Data Views, visualizações, dashboards, buscas salvas, mapas — é um Saved Object. Os Saved Objects podem ser exportados em um arquivo .ndjson e importados em outro Kibana. É assim que um dashboard é versionado em Git ou promovido entre ambientes (desenvolvimento → produção), no mesmo espírito declarativo dos manifestos do ECK.

1. Acesse Menu → Stack Management → Saved Objects.
2. Selecione o dashboard Visão de Vendas e clique em Export.
3. Mantenha ligada a opção Include related objects, para que a Data View e as visualizações usadas pelo dashboard também sejam exportadas.
4. Clique em Export: o navegador baixa um arquivo .ndjson.

Para levar o dashboard a outro Kibana, use Import na mesma tela e selecione o arquivo.

O Canvas é uma ferramenta de criação de apresentações visuais dentro do Kibana. Diferentemente dos Dashboards — que têm um layout fixo em grade —, o Canvas oferece liberdade total de posicionamento, permitindo criar layouts personalizados que combinam dados, texto e elementos gráficos.

• Apresentações executivas com dados em tempo real
• Relatórios visuais customizados para clientes
• Painéis de TV/monitor com layout personalizado
• Infográficos dinâmicos conectados ao Elasticsearch

Cada elemento no Canvas é um workpad — uma área de trabalho com dimensões configuráveis. Dentro do workpad, você adiciona elementos:

• Métricas e números: exibem valores calculados de agregações
• Gráficos: semelhantes ao Lens, mas com controle total de posicionamento
• Imagens e formas: elementos visuais estáticos para compor o layout
• Texto: blocos de texto livre com formatação
• Expressões Canvas: cada elemento é alimentado por uma expressão em linguagem própria do Canvas, que define de onde os dados vêm e como são transformados

Menu → Analytics → Canvas → Create workpad

O Maps é a ferramenta de visualização geoespacial do Kibana. Permite criar mapas interativos usando dados do Elasticsearch que contenham campos do tipo geo_point ou geo_shape.

• Pontos: cada documento com coordenadas é representado como um ponto no mapa
• Heatmaps: concentração de pontos em áreas — útil para identificar regiões de alta atividade
• Clusters: agrupa pontos próximos em um único marcador com contagem
• Linhas e polígonos: trajetórias, rotas, regiões geográficas
• Camadas de tile: mapas base de provedores externos (OpenStreetMap, Elastic Maps Service)

É possível desenhar um retângulo ou polígono diretamente no mapa para filtrar apenas os documentos dentro daquela área. O filtro é aplicado em tempo real e pode ser propagado para outros painéis de um dashboard.

Menu → Analytics → Maps → Create map

Este lab usa os dois sample data com campos geoespaciais: Flights (rotas de voos) e Web Logs (localização dos visitantes).

O mapa base vem do Elastic Maps Service, na internet: o navegador que abre o Kibana precisa ter acesso a ele.

Passo 1 — Criar o mapa:

1. Acesse Menu → Analytics → Maps → Create map
2. O mapa base (tile layer) já estará visível. Ajuste o seletor de tempo para Last 7 days

Passo 2 — Adicionar a camada de destinos como clusters:

1. Clique em Add layer
2. Selecione Clusters and grids
3. Selecione a Data View Kibana Sample Data Flights
4. No campo Geospatial field, selecione DestLocation
5. Clique em Add and continue
6. Em Layer settings, defina o nome como Destinos
7. Em Scaling, mantenha o tipo Clusters — isso agrupará destinos próximos em um único marcador com a contagem de voos
8. Clique em Save & close

Passo 3 — Adicionar a camada de origens como pontos:

1. Clique em Add layer
2. Selecione Documents
3. Selecione a Data View Kibana Sample Data Flights
4. No campo Geospatial field, selecione OriginLocation
5. Clique em Add and continue
6. Em Layer settings, defina o nome como Origens
7. Em Tooltip fields, adicione os campos Origin, Carrier e FlightNum — esses campos aparecerão ao clicar em um ponto
8. Clique em Save & close

Passo 4 — Explorar o mapa:

• Faça zoom em uma região com muitos pontos — os clusters se quebram em pontos individuais à medida que você aproxima
• Clique em um ponto de origem para ver as informações do voo no tooltip
• Clique em um cluster para ver quantos voos têm destino naquela área

Passo 5 — Adicionar um filtro geográfico:

1. Na barra de ferramentas do mapa, clique no ícone de retângulo (Draw to filter)
2. Desenhe um retângulo sobre a Europa
3. O mapa filtrou para mostrar apenas origens na área selecionada
4. Observe que o contador de documentos no canto inferior mudou
5. Remova o filtro clicando no X ao lado do filtro geográfico na barra superior

Passo 6 — Salvar o mapa:

1. Clique em Save no canto superior direito
2. Nomeie como Mapa de Voos
3. Marque Add to dashboard se quiser incluir no dashboard Análise de Voos

Passo 1 — Criar um novo mapa:

1. Menu → Analytics → Maps → Create map
2. Ajuste o seletor de tempo para Last 7 days

Passo 2 — Adicionar o heatmap:

1. Clique em Add layer
2. Selecione Heat map
3. Selecione a Data View Kibana Sample Data Logs
4. No campo Geospatial field, selecione geo.coordinates
5. Clique em Add and continue
6. Em Layer settings, defina o nome como Intensidade de acessos
7. Ajuste a opacidade para 0.8 para melhor visualização
8. Clique em Save & close

Passo 3 — Adicionar filtro por erros:

1. Na barra de filtros, clique em Add filter
2. Defina: campo response, operador is, valor 404
3. O heatmap agora mostra de onde vêm os acessos que resultaram em erro 404

Passo 4 — Comparar com acessos normais:

1. Desative o filtro de 404 clicando no toggle do filtro
2. O heatmap voltou a mostrar todos os acessos
3. Compare a distribuição geográfica — erros 404 têm padrão diferente dos acessos normais?

Passo 5 — Salvar:

Salve o mapa como Heatmap de Acessos Web.

O módulo de Machine Learning do Kibana permite criar e monitorar jobs de análise automática de dados — sem necessidade de conhecimento avançado em ciência de dados. O ML aprende o comportamento normal dos dados e aponta o que foge dele, sem que você precise definir regras fixas ("se passar de X, alerte").

O caso de uso mais comum. Você define uma métrica a ser monitorada (como número de requisições por minuto, tempo de resposta médio, ou volume de logs de erro) e o Elasticsearch aprende o comportamento normal ao longo do tempo, incluindo a sazonalidade (dia e noite, dias da semana). Quando um valor desvia significativamente do padrão esperado, o job registra uma anomalia com um score de 0 a 100.

Exemplos de aplicação:

• Detectar queda inesperada no número de transações
• Identificar pico anormal de erros 500 em uma API
• Alertar sobre comportamento incomum de um usuário em logs de autenticação

Um job de detecção de anomalias é definido por três escolhas:

• Bucket span: a granularidade de tempo. O ML resume os dados em intervalos (buckets) desse tamanho — por exemplo, 15m ou 1h — e analisa cada um;
• Detector: a função e o campo analisados, como count (quantidade de eventos), mean(tempo_resposta) ou sum(bytes);
• Campo de partição ou divisão (opcional): cria uma linha de base separada por entidade — por exemplo, uma por host, por url ou por país.

Permite aplicar algoritmos de machine learning supervisionados e não supervisionados diretamente nos dados do Elasticsearch:

• Classificação: prever a categoria de um documento (ex: spam ou não spam)
• Regressão: prever um valor numérico (ex: preço estimado de um imóvel)
• Detecção de outliers: identificar documentos que fogem significativamente dos demais

A detecção de anomalias e o Data Frame Analytics são recursos pagos: exigem licença Platinum ou Enterprise. Na licença Basic, que é a padrão do ECK, eles não estão disponíveis. Para o laboratório, use a licença trial de 30 dias.

Os jobs de ML rodam em nodes com o papel ml, em processos nativos que ficam fora do heap da JVM. No ECK, o papel é definido em node.roles, no config de um nodeSet. Quando node.roles não é informado, o node recebe todos os papéis — inclusive ml.

O ML tem um limite próprio de memória: por padrão, xpack.ml.max_machine_memory_percent permite usar até 30% da memória da máquina para os processos de ML. Essa memória se soma ao heap, dentro do limite de memória do container.

Em produção, é comum ter um nodeSet dedicado a ML, com bastante memória e apenas os papéis ml e remote_cluster_client, separando a carga de ML da carga de dados.

É preciso um manifesto novo para o laboratório? Não. O manifesto elasticsearch.yaml do lab-es não define node.roles, então o node já tem o papel ml. Com o limite de 4 GiB do container, cerca de 1,2 GiB fica disponível para o ML, o suficiente para os jobs sobre os Sample Data, que usam poucas dezenas de MB. Aumentar o heap e a memória do pod, como faz o manifesto lab-es-ml.yaml do repositório, só é necessário para jobs maiores ou para vários jobs ao mesmo tempo — e reinicia o pod do Elasticsearch.

Neste lab vamos criar um job de detecção de anomalias que monitora o volume de requisições por hora nos logs web, identificando períodos com comportamento fora do padrão.

Passo 1 — Conferir a licença:

No Console:

GET /_license

Se o type for trial e o status active, siga para o Passo 2. Se for basic, ative a trial:

1. Abra a página License Management pelo menu Stack Management ou digitando License Management na busca global.
2. No quadro de trial, clique em Start trial e confirme.
3. Repita o GET /_license e confirme o type trial.

A trial do Elasticsearch só pode ser ativada uma vez e dura 30 dias.

Passo 2 — Conferir o papel ml e a memória disponível:

GET /_cat/nodes?v&h=name,node.role,heap.max,ram.max

A coluna node.role do lab-es-es-default-0 inclui a letra l, que representa o papel ml.

GET /_ml/info?filter_path=limits

O campo limits.total_ml_memory mostra a memória que o ML pode usar no cluster, e limits.effective_max_model_memory_limit o maior limite de memória que um job pode pedir.

Passo 3 — Acessar o Machine Learning:

1. Acesse Menu → Analytics → Machine Learning
2. Clique na aba Anomaly Detection
3. Clique em Create job

Passo 4 — Selecionar os dados:

1. Selecione a Data View Kibana Sample Data Logs
2. O assistente mostra os tipos de job disponíveis. Repare que, para esta Data View, ele também oferece a configuração pronta Kibana sample data web logs, com jobs pré-configurados pela Elastic. Neste lab vamos criar o job manualmente

Passo 5 — Escolher o tipo de job:

O Kibana oferece três tipos de wizard:

• Single metric: monitora uma única métrica. Mais simples e mais fácil de interpretar.
• Multi metric: monitora várias métricas ao mesmo tempo, com particionamento por um campo.
• Population: detecta comportamento anômalo de entidades individuais comparando com o grupo.

Selecione Single metric para este lab.

Passo 6 — Definir o período:

Clique em Use full data para que o job analise todo o período coberto pelos Sample Data, e depois em Next.

Passo 7 — Configurar o job:

1. Em Aggregation, selecione Count — vamos monitorar o volume de documentos por janela de tempo
2. Em Bucket span, defina 1h — o job vai analisar o volume de requisições a cada 1 hora
3. O preview do gráfico mostra o volume histórico — observe se há padrões visíveis (picos diários, quedas nos fins de semana)
4. Clique em Next

Passo 8 — Nomear e criar o job:

1. Defina o Job ID como web-logs-volume-anomaly
2. Em Job description, escreva: Detecção de anomalias no volume de requisições por hora
3. Marque Enable model plot — isso permite visualizar o intervalo esperado no gráfico além dos pontos de anomalia
4. Clique em Next → Next → Create job and start datafeed

Passo 9 — Acompanhar o processamento:

O job vai processar os dados históricos. Acompanhe o progresso na barra que aparece após a criação. Dependendo do volume de dados, pode levar de alguns segundos a alguns minutos.

Passo 10 — Visualizar os resultados:

1. Quando o processamento terminar, clique em View results
2. O Single Metric Viewer vai abrir mostrando:
   • A linha azul: o volume real de requisições por hora
   • A área sombreada: o intervalo esperado pelo modelo (banda de confiança)
   • Os pontos coloridos: anomalias detectadas (azul = baixa severidade, amarelo = média, vermelho = alta)
3. Clique em um ponto de anomalia para ver os detalhes: valor observado, valor esperado, score e hora exata

Passo 11 — Explorar o Anomaly Explorer:

1. Clique em Anomaly Explorer no menu lateral do Machine Learning
2. O swimlane mostra as anomalias ao longo do tempo em uma grade de cores
3. Clique em uma célula colorida para ver o detalhamento das anomalias naquele período
4. No painel inferior, os documentos mais influentes para cada anomalia são listados — você consegue investigar o que causou o pico ou queda

No Single Metric Viewer, a área sombreada representa o que o modelo aprendeu como "normal". Quando o volume sai dessa banda — para cima ou para baixo — o job registra uma anomalia. Isso é o que diferencia a detecção de anomalias de um simples threshold fixo: o modelo se adapta aos padrões sazonais dos dados (mais tráfego de manhã, menos à noite, variações de dia da semana).

Passo 12 (opcional) — Job multi-metric por entidade:

Crie um segundo job, agora do tipo Multi metric, sobre a mesma Data View:

• Detector: Count;
• Split field: geo.dest (uma linha de base por país de destino);
• Bucket span: 1h;
• Job ID: web-logs-volume-por-pais.

O ML aprende o "normal" de cada país separadamente e aponta anomalias específicas de cada um no Anomaly Explorer.

Passo 13 — Liberar a memória do ML:

Os jobs abertos ocupam memória do node. Ao terminar, remova-os em Machine Learning → Anomaly Detection → Jobs: selecione os jobs e use Delete. Ou, no Console:

DELETE /_ml/anomaly_detectors/web-logs-volume-anomaly?force=true

DELETE /_ml/anomaly_detectors/web-logs-volume-por-pais?force=true

O force=true fecha o job e para o datafeed antes de apagar. Se não criou o job opcional, o segundo comando retorna um erro de job inexistente, que pode ser ignorado.

O Dev Tools é o console interativo do Kibana para executar requisições diretamente contra a API do Elasticsearch. É equivalente ao curl, mas com autocomplete, formatação automática de JSON e histórico de comandos.

A aba mais usada. Permite executar qualquer operação da API REST do Elasticsearch:

GET /_cluster/health
 
GET /meu-indice/_search
{
  "query": {
    "match_all": {}
  }
}
 
PUT /novo-indice
{
  "settings": {
    "number_of_shards": 1
  }
}

Atalhos úteis:

• Ctrl + Enter: executa a query atual
• Ctrl + /: comenta/descomenta a linha
• Clique na seta verde ao lado da query para executar

Menu → Dev Tools

O Stack Management é a seção administrativa do Kibana. Reúne todas as configurações e operações de gestão do Elastic Stack em uma única interface.

Exibe todos os índices do cluster com informações de tamanho, número de documentos, status de saúde e configurações. Permite:

• Criar e deletar índices
• Visualizar e editar mappings e settings
• Gerenciar index templates e component templates
• Executar operações como force merge, flush e refresh

Caminho: Menu → Stack Management → Index Management

As Data Views (anteriormente chamadas de Index Patterns) definem de quais índices o Kibana vai ler os dados e qual campo representa o tempo. Precisam ser criadas antes de usar o Discover ou criar dashboards.

Caminho: Menu → Stack Management → Data Views → Create data view

Interface visual para criar e gerenciar ILM policies. Permite configurar as fases hot, warm, cold e delete sem escrever JSON.

Caminho: Menu → Stack Management → Index Lifecycle Policies

Interface para criar, testar e gerenciar Ingest Pipelines.

Caminho: Menu → Stack Management → Ingest Pipelines

Interface para criar e gerenciar pipelines do Logstash via Centralized Pipeline Management (recurso pago).

Caminho: Menu → Stack Management → Logstash Pipelines

Saved Objects lista, exporta e importa tudo o que foi criado no Kibana. License Management mostra a licença do cluster e permite ativar a trial.

Caminho: Menu → Stack Management → Saved Objects / License Management

Spaces são ambientes isolados dentro do Kibana. Cada space tem seus próprios dashboards, Data Views, configurações e permissões. É útil para separar ambientes de equipes diferentes (ex: time de segurança, time de observabilidade) ou projetos distintos dentro da mesma instalação do Kibana.

• Cada usuário pode ter acesso a um ou mais spaces
• É possível copiar objetos entre spaces
• O logo e as cores do Kibana podem ser customizados por space

Caminho: Menu → Stack Management → Spaces

A gestão de controle de acesso do Elastic Stack é feita pelo Kibana via Roles e Users.

Roles definem o que um usuário pode fazer:

• Acesso a índices específicos (leitura, escrita, criação, deleção)
• Acesso a funcionalidades do Kibana (Discover, Dashboards, Stack Management etc.)
• Acesso restrito a um ou mais Spaces

Users são as contas de acesso ao Kibana e ao Elasticsearch. Cada usuário recebe uma ou mais roles que definem suas permissões.

Autenticação via LDAP, SAML e OpenID Connect também é suportada, permitindo integração com provedores de identidade corporativos.

Caminho: Menu → Stack Management → Security → Roles / Users

1. Acesse Menu → Stack Management → Security → Roles → Create role
2. Defina um nome para a role: role_readonly_logs
3. Em Index privileges, adicione o padrão kibana_sample_data_logs e marque apenas read e view_index_metadata
4. Em Kibana privileges, selecione o Space Default e marque Read para Discover e Dashboard
5. Salve a role
6. Acesse Stack Management → Security → Users → Create user
7. Preencha nome usuario_restrito, senha e associe a role role_readonly_logs
8. Em uma aba anônima, acesse o Kibana com o novo usuário e verifique:
   • Consegue acessar o Discover e ver os dados de logs
   • Não consegue acessar o Stack Management
   • Não consegue ver dados de outros índices como kibana_sample_data_flights

O Kibana exibe o estado de saúde de toda a stack através da seção de Stack Monitoring.

O que você pode monitorar:

No ECK, não é preciso instalar um Metricbeat à parte: basta acrescentar o bloco spec.monitoring ao manifesto do Elasticsearch, do Kibana, dos Beats ou do Logstash. O operator acrescenta ao pod dois containers auxiliares (sidecars):

• um Metricbeat, que coleta as métricas de monitoramento;
• um Filebeat, que coleta os logs.

Os dois enviam os dados para o cluster de monitoramento indicado em elasticsearchRefs, com usuários criados pelo operator. Em produção, a recomendação é usar um cluster de monitoramento separado; no laboratório, o lab-es monitora a si mesmo, o que a documentação permite para ambientes que não são de produção.

Os sidecars aumentam o consumo de memória dos pods, e o Elasticsearch e o Kibana são reiniciados para recebê-los. No fim do lab, os manifestos originais são reaplicados.

Passo 1 — Criar o manifesto do Elasticsearch com monitoramento

É o manifesto elasticsearch.yaml com o bloco monitoring acrescentado:

cd ~/eck-lab
cat <<'EOF' > manifests/elasticsearch-monitoring.yaml
apiVersion: elasticsearch.k8s.elastic.co/v1
kind: Elasticsearch
metadata:
  name: lab-es
spec:
  version: 9.4.2
  monitoring:
    metrics:
      elasticsearchRefs:
        - name: lab-es
    logs:
      elasticsearchRefs:
        - name: lab-es
  nodeSets:
    - name: default
      count: 1
      config:
        node.store.allow_mmap: true
      podTemplate:
        spec:
          containers:
            - name: elasticsearch
              env:
                - name: ES_JAVA_OPTS
                  value: -Xms2g -Xmx2g
              resources:
                requests:
                  memory: 4Gi
                  cpu: "1"
                limits:
                  memory: 4Gi
      volumeClaimTemplates:
        - metadata:
            name: elasticsearch-data
          spec:
            accessModes: [ReadWriteOnce]
            resources:
              requests:
                storage: 20Gi
            storageClassName: local-path
EOF

Passo 2 — Criar o manifesto do Kibana com monitoramento

É o manifesto kibana.yaml com o mesmo bloco:

cat <<'EOF' > manifests/kibana-monitoring.yaml
apiVersion: kibana.k8s.elastic.co/v1
kind: Kibana
metadata:
  name: lab-kb
spec:
  version: 9.4.2
  count: 1
  elasticsearchRef:
    name: lab-es
  monitoring:
    metrics:
      elasticsearchRefs:
        - name: lab-es
    logs:
      elasticsearchRefs:
        - name: lab-es
  podTemplate:
    spec:
      containers:
        - name: kibana
          resources:
            requests:
              memory: 1Gi
              cpu: 500m
            limits:
              memory: 2Gi
EOF

Passo 3 — Aplicar os dois manifestos

kubectl apply -n elastic -f manifests/elasticsearch-monitoring.yaml
kubectl apply -n elastic -f manifests/kibana-monitoring.yaml
kubectl -n elastic get pods -w

Resultado esperado: o lab-es-es-default-0 é recriado e passa a mostrar 3/3 na coluna READY (Elasticsearch, Metricbeat e Filebeat); um novo pod lab-kb-kb-<sufixo> também aparece com 3/3. Aguarde os dois ficarem Running e pressione Ctrl+C.

Confira os containers do pod do Elasticsearch:

kubectl -n elastic get pod lab-es-es-default-0 -o jsonpath='{.spec.containers[*].name}{"\n"}'

Resultado esperado: elasticsearch metricbeat filebeat.

O pod do Kibana foi recriado, então abra o túnel novamente:

pkill -f "port-forward.*5601" || true
nohup kubectl -n elastic port-forward --address 0.0.0.0 service/lab-kb-kb-http 5601 > /tmp/pf-kibana.log 2>&1 &
sleep 2
cat /tmp/pf-kibana.log

Resultado esperado: Forwarding from 0.0.0.0:5601 -> 5601.

Passo 4 — Conferir os dados de monitoramento

Aguarde um ou dois minutos e confira no Console os índices de monitoramento, que são ocultos:

GET /_cat/indices/.monitoring-*,.ds-.monitoring-*?v&expand_wildcards=all&s=index

Aparecem os índices de monitoramento do Elasticsearch (.monitoring-es-...) e do Kibana (.monitoring-kibana-...). Se algum estiver yellow, ajuste as réplicas:

PUT /.monitoring-*/_settings?expand_wildcards=all
{
  "index.number_of_replicas": 0
}

Passo 5 — Explorar o Stack Monitoring

Abra Stack Monitoring pela busca global do Kibana. Aparecem o cluster lab-es, com o node e os índices, e a instância do lab-kb. Clique no node para ver CPU, memória, heap da JVM e o throughput de indexação e busca.

Se a página mostrar o erro Access Denied, citando kibana_admin e monitoring_user, acrescente ao spec do kibana-monitoring.yaml o bloco abaixo e reaplique o manifesto. Ele desliga a busca entre clusters (cross-cluster search) dos dados de monitoramento, ligada por padrão.

  config:
    monitoring.ui.ccs.enabled: false

Passo 6 — Voltar aos manifestos originais

kubectl apply -n elastic -f manifests/elasticsearch.yaml
kubectl apply -n elastic -f manifests/kibana.yaml
kubectl -n elastic get pods -w

Resultado esperado: os pods do Elasticsearch e do Kibana são recriados sem os sidecars e voltam a mostrar 1/1. Pressione Ctrl+C e abra o túnel do Kibana novamente, com o mesmo bloco do Passo 3. Os dados de monitoramento já coletados continuam nos índices .monitoring-*.

O Kibana possui um sistema nativo de alertas baseado em Rules — condições que são verificadas periodicamente e disparam Actions quando a condição é atendida. É o passo natural depois dos dashboards: sair do observar para o ser avisado.

Caminho: Menu → Stack Management → Rules → Create rule

• Threshold: alerta quando um valor ultrapassa um limite — ex: CPU média acima de 80% por 5 minutos
• Anomaly detection: alerta baseado em jobs de Machine Learning
• Elasticsearch query: alerta quando uma query retorna um número de documentos acima ou abaixo de um limite
• Log threshold: alerta sobre volume de logs que correspondem a um padrão
• Uptime / Synthetics: alerta quando um serviço fica indisponível

Quando uma rule dispara, ela pode executar actions:

• Enviar e-mail
• Enviar mensagem no Slack ou Teams
• Criar um webhook HTTP
• Abrir um case no Elastic Security
• Executar um índice no Elasticsearch

O Watcher — sistema de alertas baseado em API JSON — também continua disponível no 9.x.

• O Kibana é a interface do Elastic Stack. No ECK, ele é um recurso Kibana e suas configurações ficam no spec.config do manifesto; o uso da interface é o mesmo de qualquer instalação.
• Tudo começa por uma Data View, que aponta para os índices e define o campo de tempo.
• O Discover serve para investigar com KQL; o Lens monta visualizações a partir de bucket e metric; os dashboards reúnem painéis que respondem juntos ao tempo, aos filtros e aos controles.
• Dashboards, visualizações e Data Views são Saved Objects, que podem ser exportados em .ndjson e versionados.
• Canvas e Maps cobrem apresentações livres e dados geoespaciais.
• O Machine Learning detecta anomalias aprendendo o comportamento normal, com bucket span, detector e campo de partição. Exige licença paga (trial no laboratório) e roda em nodes com o papel ml, em memória fora do heap. O lab-es já tem esse papel, porque o manifesto não define node.roles.
• Roles e Users controlam o acesso a índices, funcionalidades e Spaces.
• No ECK, o Stack Monitoring é ativado pelo bloco spec.monitoring, que acrescenta sidecars de Metricbeat e Filebeat aos pods.
• Rules e Actions transformam consultas e jobs de ML em alertas.

8.1 a 8.3 - Kibana, Sample Data e Data Views

• Kibana
• Kibana configuration on ECK
• Sample data
• Data views

8.4 - Discover

• Discover
• KQL

8.5 e 8.6 - Lens, Dashboards e Saved Objects

• Lens
• Create a dashboard
• Add controls
• Create a dashboard with eCommerce data
• Share and export dashboards
• Saved objects

8.7 e 8.8 - Canvas e Maps

• Canvas
• Maps

8.9 - Machine Learning

• Machine learning
• Anomaly detection
• Data frame analytics
• Machine learning settings (xpack.ml.max_machine_memory_percent)
• Node roles
• Get machine learning info API
• Delete an anomaly detection job API
• Módulo de ML dos Sample Data web logs (Kibana 9.4)
• Manage your license in a self-managed cluster (License Management)
• Elastic subscriptions

8.10 e 8.11 - Dev Tools e Stack Management

• Console
• Index management
• Spaces
• Defining roles
• Native user authentication

8.12 - Monitoring

• Enable stack monitoring on ECK deployments
• Stack monitoring
• Monitoring settings in Kibana (monitoring.ui.ccs.enabled)

8.13 - Alertas e Regras

• Alerting
• Watcher