Curso OpenTelemetry com Kubernetes

  • DevOps | CI | CD | Kubernetes | Web3

Curso OpenTelemetry com Kubernetes

24 horas
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
Inglês/Português/Lab Prático
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.
TENHO INTERESSE

Cursos Relacionados

Curso Ansible Red Hat Basics Automation Technical Foundation

16 horas

Curso Terraform Deploying to Oracle Cloud Infrastructure

24 Horas

Curso Ansible Linux Automation with Ansible

24 horas

Ansible Overview of Ansible architecture

16h

Advanced Automation: Ansible Best Practices

32h