Visão Geral

Este curso intensivo de 24 horas é a porta de entrada para o mundo da observabilidade de software, focado em capacitar profissionais a compreender e aplicar os conceitos fundamentais do OpenTelemetry. Desenvolvido para quem está começando ou precisa de uma base sólida, o curso desmistifica a coleta de telemetria (traces, métricas e logs) em sistemas distribuídos. Os participantes aprenderão a arquitetura do OpenTelemetry, a instrumentar aplicações de exemplo em linguagens populares, a configurar o OpenTelemetry Collector para coletar e rotear dados e a visualizar essa telemetria em backends abertos. O objetivo é fornecer uma base robusta para que os alunos possam iniciar sua jornada na construção de sistemas mais transparentes, compreensíveis e fáceis de depurar, independentemente da complexidade da arquitetura.

Objetivo

Após realizar este curso OpenTelemetry Fundamentals: Os Pilares da Observabilidade Moderna, você será capaz de:

• Compreender os conceitos básicos de observabilidade e a importância de traces, métricas e logs.
• Entender a arquitetura e os componentes essenciais do OpenTelemetry.
• Instrumentar aplicações em linguagens populares para gerar traces distribuídos.
• Criar e entender o uso de métricas (contadores, medidores, histogramas) com OpenTelemetry.
• Integrar sistemas de logging existentes e correlacionar logs com traces.
• Configurar e operar o OpenTelemetry Collector para coleta, processamento e exportação de telemetria.
• Visualizar e analisar dados de traces em Jaeger.
• Visualizar e analisar métricas em Prometheus e Grafana.
• Compreender o fluxo de dados de observabilidade do início ao fim em um ambiente simulado.
• Aplicar os princípios fundamentais de instrumentação em seus próprios projetos.

Publico Alvo

• Desenvolvedores de Software (Back-end, Full-stack, Mobile) que estão começando a trabalhar com sistemas distribuídos.
• Engenheiros de DevOps e SREs em início de carreira ou que precisam reforçar os fundamentos de observabilidade.
• Estudantes de Ciência da Computação e Engenharia de Software.
• Arquitetos de Software que buscam entender os princípios de instrumentação.
• Profissionais de TI que desejam compreender o papel do OpenTelemetry no cenário atual de observabilidade.

Pre-Requisitos

• Conhecimento básico em lógica de programação e desenvolvimento de software em pelo menos uma linguagem (preferencialmente Java, Python, Node.js ou C#).
• Noções básicas de linha de comando.
• Familiaridade com o conceito de APIs (Application Programming Interfaces).
• (Opcional, mas útil) Noções básicas de Docker.

Materiais

Conteúdo Programatico

Módulo I: Introdução à Observabilidade e seus Pilares (4 horas)

• 1.1 O Que é Observabilidade? (1h)
  • Definição e importância da observabilidade em sistemas modernos.
  • Diferença entre Monitoramento e Observabilidade: o "o quê" vs. o "porquê".
  • Por que a observabilidade é crucial para sistemas distribuídos (microsserviços, nuvem).
• 1.2 Os Três Pilares da Observabilidade (2h)
  • Traces Distribuídos: O que são, como funcionam, para que servem (rastreando requisições através de múltiplos serviços).
  • Métricas: O que são, tipos (contadores, medidores, histogramas), para que servem (tendências, alertas).
  • Logs: O que são, logs estruturados vs. texto simples, para que servem (eventos pontuais, depuração).
  • Como esses pilares se complementam para fornecer uma visão holística.
• 1.3 Cenário de Observabilidade e Ferramentas (1h)
  • Visão geral das ferramentas de observabilidade no mercado (comerciais e open source).
  • Apresentação dos backends a serem usados no curso: Jaeger, Prometheus, Grafana, Loki.
  • Configuração inicial do ambiente de laboratório com Docker Compose (levantando Jaeger, Prometheus, Grafana, Loki).

Módulo II: OpenTelemetry: O Padrão para Coleta de Telemetria (6 horas)

• 2.1 Introdução ao OpenTelemetry (2h)
  • O que é OpenTelemetry (OTel)? Histórico, missão e comunidade (CNCF).
  • Por que o OpenTelemetry é importante: padronização, vendor-neutralidade, extensibilidade.
  • Componentes principais: APIs, SDKs e OpenTelemetry Collector.
• 2.2 Conceitos Essenciais do OpenTelemetry (2h)
  • TracerProvider, Tracer, SpanBuilder, Span: Construindo traces.
  • MeterProvider, Meter, Instruments (Counter, Gauge, Histogram): Coletando métricas.
  • LoggerProvider, LogRecord: Emitindo logs.
  • Context: Propagação de contexto (Trace ID, Span ID).
  • Attributes e Resources: Adicionando informações contextuais.
• 2.3 Primeiro Contato Hands-On com OpenTelemetry (2h)
  • Configuração de um projeto simples em uma linguagem (e.g., Python ou Node.js).
  • Instrumentação básica de uma função/endpoint para gerar um trace simples.
  • Adição de atributos a um span.
  • Configuração do SDK para exportar via OTLP (OpenTelemetry Protocol).
  • Visualização do trace no Jaeger.

Módulo III: Instrumentação de Traces e Métricas com OpenTelemetry (6 horas)

• 3.1 Traces Distribuídos na Prática (3h)
  • 3.1.1 Instrumentação Manual de Traces:
    • Criação de traces e spans em aplicações de exemplo (Java, .NET, Python, Node.js).
    • Estabelecendo relações Parent-Child entre spans.
    • Adição de Span Events para registrar pontos importantes no tempo de um span.
  • 3.1.2 Instrumentação Automática de Traces:
    • Utilizando bibliotecas de auto-instrumentação para frameworks comuns (e.g., HTTP requests, database calls).
    • Vantagens e desvantagens da instrumentação automática vs. manual.
  • 3.1.3 Propagação de Contexto:
    • Demonstração da propagação de Trace Context entre duas aplicações de microsserviços.
    • Visualização de um trace distribuído completo no Jaeger.
• 3.2 Métricas na Prática (3h)
  • 3.2.1 Instrumentação Manual de Métricas:
    • Criação e atualização de Counters (e.g., contagem de logins, erros).
    • Criação e atualização de Gauges (e.g., usuários ativos, tamanho de fila).
    • Criação e gravação de Histograms (e.g., latência de requisições, tamanho de payload).
    • Adição de atributos (labels) para métricas.
  • 3.2.2 Instrumentação Automática de Métricas:
    • Coleta de métricas de runtime (CPU, memória) e métricas básicas de sistema.
  • Configuração dos SDKs para exportar métricas via OTLP.
  • Visualização de métricas em Prometheus e criação de dashboards simples no Grafana.

Módulo IV: Logs e OpenTelemetry Collector (5 horas)

• 4.1 Integração de Logs com OpenTelemetry (2h)
  • O que são logs estruturados e por que usá-los.
  • Configuração de bibliotecas de logging populares (Logback/Log4j2, logging em Python, Pino/Winston) para emitir logs estruturados.
  • Enriquecimento de logs com Trace ID e Span ID para correlação.
  • Envio de logs para o OpenTelemetry Collector via OTLP.
• 4.2 Introdução ao OpenTelemetry Collector (2.5h)
  • Arquitetura do Collector: Receivers, Processors e Exporters.
  • Configuração do Collector via YAML:
    • Receivers: otlp (HTTP/gRPC).
    • Processors: batch (otimização de envio), resource (adicionar/modificar atributos de recursos).
    • Exporters: jaeger, prometheus, logging (para console), otlp (para outro Collector ou backend).
  • Criação de pipelines de telemetria dentro do Collector.
  • Deploy do Collector com Docker Compose.
• 4.3 Fluxo Completo da Telemetria (0.5h)
  • Revisão do fluxo de dados: Aplicação -> SDK -> Collector -> Backends.
  • Verificação da telemetria em cada estágio do pipeline.
  • Introdução à correlação de traces, métricas e logs através de IDs comuns.

Módulo V: Visualização Básica e Análise de Dados (3 horas)

• 5.1 Visualizando Traces com Jaeger (1h)
  • Busca de traces por serviço, operação, atributos.
  • Análise de gráficos de chama para identificar latências e dependências.
  • Entendendo os metadados dos spans.
  • Casos de uso para Jaeger na depuração de requisições.
• 5.2 Monitorando Métricas com Prometheus e Grafana (1h)
  • Visão geral do Prometheus: modelo de dados, PromQL (linguagem de consulta).
  • Criação de dashboards básicos no Grafana:
    • Gráficos de linha para contadores e medidores.
    • Histogramas para latência.
  • Configuração de fontes de dados no Grafana.
  • Interpretação de métricas para identificar tendências e problemas.
• 5.3 Explorando Logs com Loki/Grafana (1h)
  • Navegação no Grafana para explorar logs (Loki como fonte de dados).
  • Uso de LogQL para buscar e filtrar logs.
  • Correlação de logs com traces (usando o Trace ID presente nos logs).
  • Como os logs complementam traces e métricas para o troubleshooting.