Visão Geral

Este curso intensivo de 24 horas é projetado para capacitar profissionais a implementar e gerenciar uma solução de observabilidade completa para aplicações em ambientes Kubernetes utilizando o OpenTelemetry. Cobrindo desde os fundamentos da observabilidade e do Kubernetes até a instrumentação de aplicações, a configuração e implantação do OpenTelemetry Collector como um componente central no cluster, e a integração com backends de observabilidade líderes de mercado como Jaeger, Prometheus e Grafana. Os participantes aprenderão a coletar, processar, visualizar e analisar traces distribuídos, métricas de desempenho e logs estruturados, garantindo uma compreensão profunda do comportamento de seus sistemas nativos de nuvem. O curso abordará desafios específicos do Kubernetes, como autodescoberta, sidecars e escalabilidade, preparando os alunos para construir e manter infraestruturas observáveis e resilientes em larga escala.

Objetivo

Após realizar este curso OpenTelemetry com Kubernetes Observabilidade Abrangente para Aplicações em Containers, você será capaz de:

• Compreender os fundamentos da observabilidade em ambientes Kubernetes e o papel do OpenTelemetry.
• Instrumentar aplicações em diferentes linguagens para coletar traces, métricas e logs em clusters Kubernetes.
• Implementar e configurar o OpenTelemetry Collector como um componente chave para a coleta e processamento de telemetria no Kubernetes.
• Utilizar diferentes estratégias de implantação do Collector (DaemonSet, Deployment, Sidecar).
• Integrar o OpenTelemetry com backends de observabilidade (Jaeger, Prometheus, Grafana, Loki/Elasticsearch) para visualização e análise de dados.
• Configurar o autodescoberta de alvos para coleta de métricas e traces em ambientes dinâmicos do Kubernetes.
• Aplicar estratégias de amostragem (sampling) para gerenciar o volume de dados de traces em larga escala.
• Depurar e solucionar problemas em aplicações e na infraestrutura Kubernetes usando os dados de telemetria coletados.
• Implementar as melhores práticas para uma observabilidade eficaz em um ambiente de produção Kubernetes.

Publico Alvo

• Engenheiros de DevOps
• Engenheiros de Confiabilidade de Sites (SREs)
• Administradores de Sistemas Kubernetes
• Desenvolvedores de Software que trabalham com aplicações conteinerizadas e orquestradas por Kubernetes
• Arquitetos de Soluções e Cloud
• Profissionais interessados em monitoramento, depuração e otimização de ambientes em containers e microsserviços.

Pre-Requisitos

• Conhecimento sólido em conceitos de Kubernetes (Pods, Deployments, Services, Namespaces, Ingress).
• Familiaridade com a linha de comando kubectl.
• Noções básicas de Docker e containers.
• Entendimento de conceitos de monitoramento e logging em sistemas distribuídos.
• Conhecimento básico em pelo menos uma linguagem de programação (Python, Go, Java, Node.js, C#).

Materiais

Conteúdo Programatico

Módulo I: Introdução à Observabilidade em Kubernetes com OpenTelemetry (4 horas)

• 1.1 Desafios da Observabilidade em Kubernetes (1h)
  • Complexidade de ambientes conteinerizados e microsserviços.
  • Natureza efêmera dos Pods e desafios de coleta de dados.
  • Necessidade de traces distribuídos, métricas e logs correlacionados.
  • Visão geral da observabilidade nativa do Kubernetes (cAdvisor, Kube-state-metrics).
• 1.2 OpenTelemetry: Fundamentos e Arquitetura (1.5h)
  • Revisão dos pilares do OpenTelemetry: APIs, SDKs, Collector.
  • Traces, Spans e Context Propagation no OpenTelemetry.
  • Métricas: Counters, Gauges, Histograms e seus atributos.
  • Logs: Eventos estruturados e correlação de contexto.
  • O papel do OpenTelemetry como padrão da CNCF para observabilidade.
• 1.3 Configuração do Ambiente de Laboratório em Kubernetes (1.5h)
  • Preparação de um cluster Kubernetes local (Minikube/Kind) ou em nuvem.
  • Instalação e configuração de ferramentas essenciais (kubectl, Helm).
  • Deploy básico dos backends de observabilidade (Jaeger, Prometheus, Grafana, Loki/Elasticsearch) usando Helm Charts ou manifestos Kubernetes.
  • Verificação da acessibilidade e funcionalidade dos backends.

Módulo II: Instrumentação de Aplicações para Kubernetes (6 horas)

• 2.1 Instrumentação Manual de Aplicações com OpenTelemetry SDKs (2h)
  • Princípios de instrumentação em Java (Spring Boot), Python (Flask/FastAPI), Go, e Node.js (Express).
  • Criação de traces e spans customizados para fluxos de negócio.
  • Adição de atributos semânticos e customizados a spans e métricas.
  • Configuração dos exportadores OTLP (OpenTelemetry Protocol) para o Collector.
  • Exemplos práticos de instrumentação de serviços simples para deploy em Kubernetes.
• 2.2 Instrumentação Automática e Autodiscovery (2h)
  • Uso de auto-instrumentação via agentes (Java Agent, Python Agent) ou pacotes específicos para cada linguagem.
  • Instrumentação de bibliotecas populares (HTTP clients, bancos de dados, message brokers).
  • Conceito de Autodiscovery no Kubernetes para coletar dados de serviços.
  • Como o OpenTelemetry Collector pode ser configurado para descobrir alvos de instrumentação.
• 2.3 Coleta de Métricas de Runtime e Sistema (1h)
  • Coleta de métricas de runtime (JVM, Go Runtime, Python GIL, Node.js Event Loop) via instrumentação ou exporters específicos.
  • Coleta de métricas de uso de recursos do Pod/Container (CPU, memória, rede) via cAdvisor e Kube-state-metrics.
  • Enrichment de métricas com atributos de Kubernetes (Pod name, Namespace, Container ID).
• 2.4 Integração de Logs com OpenTelemetry em Kubernetes (1h)
  • Padrões de logging em Kubernetes: Sidecar, DaemonSet para coleta de logs.
  • Estruturação de logs para melhor análise.
  • Injeção de Trace ID e Span ID nos logs para correlação.
  • Configuração de bibliotecas de logging (Log4j2, Serilog, Python logging) para enviar logs via OpenTelemetry.
  • Exportação de logs via OTLP para o Collector.

Módulo III: OpenTelemetry Collector no Kubernetes (6 horas)

• 3.1 Arquitetura e Componentes do OpenTelemetry Collector (1.5h)
  • Revisão aprofundada de Receivers, Processors e Exporters.
  • Tipos de Receivers para Kubernetes: OTLP, HostMetrics, KubeletStats, Prometheus.
  • Tipos de Processors comuns para ambientes Kubernetes: resource, batch, memory_limiter, k8sattributes, filter, transform.
  • Tipos de Exporters para Jaeger, Prometheus, Loki, Elasticsearch.
• 3.2 Estratégias de Implantação do Collector em Kubernetes (2h)
  • Deploy como DaemonSet (para coleta de logs de host e métricas de nós).
  • Deploy como Deployment (para atuar como um gateway central ou endpoint OTLP).
  • Deploy como Sidecar (para instrumentação automática e coleta de telemetria específica de um Pod).
  • Configuração e gestão do ciclo de vida do Collector com Helm Charts ou manifestos YAML.
• 3.3 Configuração Avançada do Collector e Pipelines (2h)
  • Criação de pipelines complexos para traces, métricas e logs.
  • Processamento de dados: filtragem, amostragem, agregação, enriquecimento de atributos (e.g., adicionar labels de Kubernetes a traces e métricas).
  • Roteamento de telemetria para diferentes backends com base em regras.
  • Monitoramento do próprio Collector (métricas internas).
• 3.4 Escalabilidade e Resiliência do Collector (0.5h)
  • Considerações de escalabilidade para o Collector em clusters grandes.
  • Alta disponibilidade e estratégias de failover.
  • Melhores práticas para recursos e limites do Collector em Kubernetes.

Módulo IV: Backends de Observabilidade e Visualização em Kubernetes (6 horas)

• 4.1 Jaeger para Análise de Traces Distribuídos (2h)
  • Instalação e configuração do Jaeger em Kubernetes (Helm Chart).
  • Navegação na UI do Jaeger: Busca de traces, visualização de gráficos de chama (flame graphs) e diagramas de dependência.
  • Análise de latência, erros e gargalos em fluxos de requisição.
  • Correlação de traces com logs e métricas.
  • Uso de Jaeger para depuração de aplicações em Kubernetes.
• 4.2 Prometheus e Grafana para Métricas (2h)
  • Instalação e configuração do Prometheus e Grafana em Kubernetes (Helm Chart).
  • Configuração do Prometheus para fazer scrape de métricas do OpenTelemetry Collector e de outras fontes no Kubernetes (endpoints de métricas de pods, kube-state-metrics).
  • Criação de dashboards no Grafana com métricas do Prometheus, utilizando PromQL.
  • Configuração de alertas baseados em métricas de aplicação e infraestrutura.
  • Visualização de métricas do OpenTelemetry (contadores, histogramas) em dashboards relevantes.
• 4.3 Loki/Elasticsearch e Grafana para Logs (1.5h)
  • Instalação e configuração do Loki ou Elasticsearch/Kibana em Kubernetes.
  • Configuração do Grafana para consultar logs do Loki (LogQL) ou Elasticsearch (Lucene query syntax).
  • Correlação de logs com traces e métricas no Grafana.
  • Análise de logs estruturados para identificar problemas e padrões.
• 4.4 Dashboard e Alerta Combinados (0.5h)
  • Construção de um dashboard unificado no Grafana que combine traces (via plugin Tempo/Jaeger), métricas e logs para uma visão completa da aplicação e infraestrutura.
  • Criação de regras de alerta multi-fonte.

Módulo V: Tópicos Avançados e Melhores Práticas (2 horas)

• 5.1 Amostragem Avançada de Traces no Kubernetes (1h)
  • Estratégias de amostragem no SDK (client-side) e no Collector (server-side).
  • Configuração de tail_sampling_processor no Collector para amostragem baseada em regras (ex: amostrar todos os traces com erro).
  • Gerenciamento de volume de dados e custos de observabilidade em larga escala.
• 5.2 Observabilidade de Service Meshes (Istio, Linkerd) com OpenTelemetry (0.5h)
  • Como OpenTelemetry se integra com service meshes para coleta de telemetria out-of-the-box.
  • Comparação e complementaridade entre a observabilidade do service mesh e a instrumentação via OpenTelemetry.
• 5.3 Melhores Práticas e Casos de Uso em Produção (0.5h)
  • Dimensionamento do OpenTelemetry Collector para ambientes de produção.
  • Segurança na coleta de telemetria (autenticação, autorização).
  • Gerenciamento de custos de armazenamento e processamento de dados de observabilidade.
  • Automação da implantação da observabilidade em pipelines CI/CD.
  • Como usar dados de observabilidade para otimização de performance e tomada de decisão.