Visão Geral

Este curso intensivo de 24 horas oferece uma imersão completa no universo da observabilidade de aplicações distribuídas, focando na utilização do OpenTelemetry, a tecnologia padrão da indústria para coleta de telemetria (traces, métricas e logs). Com uma abordagem prática e multi-linguagem, o curso capacitará desenvolvedores, arquitetos e profissionais de operações a instrumentar sistemas desenvolvidos em Java, .NET, Python e Node.js. Ao final, os participantes dominarão as técnicas necessárias para obter insights profundos sobre o comportamento de suas aplicações, identificar gargalos, depurar problemas complexos em ambientes distribuídos e otimizar a performance, garantindo a resiliência e a estabilidade dos sistemas. O conteúdo aborda desde os fundamentos da observabilidade e do OpenTelemetry até a implementação avançada, incluindo o uso do OpenTelemetry Collector e estratégias de amostragem, preparando os profissionais para construir e gerenciar sistemas distribuídos mais robustos e observáveis.

Objetivo

Após realizar este curso Instrumentação de Aplicações com OpenTelemetry Uma Abordagem Multi-Linguagem, você será capaz de:

• Compreender os conceitos fundamentais de observabilidade e seus pilares (traces, métricas, logs).
• Dominar a arquitetura e os componentes do OpenTelemetry.
• Instrumentar manualmente e automaticamente aplicações em Java, .NET, Python e Node.js para coletar traces distribuídos.
• Adicionar e enriquecer spans com atributos relevantes para depuração e análise.
• Instrumentar manualmente e automaticamente aplicações para coletar métricas de performance e comportamento.
• Integrar sistemas de logging existentes com o OpenTelemetry para correlacionar logs com traces e métricas.
• Configurar e utilizar o OpenTelemetry Collector para processar, filtrar, amostragem e exportar dados de telemetria.
• Visualizar e analisar dados de observabilidade em ferramentas como Jaeger, Prometheus, Grafana e Loki.
• Aplicar as melhores práticas de instrumentação para otimizar a observabilidade e a performance de sistemas distribuídos.
• Resolver problemas e depurar aplicações distribuídas usando dados de telemetria do OpenTelemetry.

Publico Alvo

• Desenvolvedores de Software (Back-end, Full-stack)
• Arquitetos de Sistemas
• Engenheiros de DevOps
• Engenheiros de Confiabilidade de Sites (SREs)
• Qualquer profissional interessado em monitoramento, depuração e otimização de aplicações distribuídas.

Pre-Requisitos

• Conhecimento básico em desenvolvimento de software em pelo menos uma das linguagens: Java, C# (.NET), Python ou Node.js.
• Familiaridade com conceitos básicos de sistemas distribuídos (APIs REST, comunicação entre serviços).
• Noções básicas de linha de comando e Docker.

Materiais

Conteúdo Programatico

Módulo 1: Fundamentos de Observabilidade e OpenTelemetry (4 horas)

• 1.1 Introdução à Observabilidade (1h)
  • O que é Observabilidade? Por que é importante?
  • Pilares da Observabilidade: Traces, Métricas e Logs.
  • Diferença entre Monitoramento e Observabilidade.
  • Desafios de Observabilidade em sistemas distribuídos.
• 1.2 Introdução ao OpenTelemetry (2h)
  • O que é OpenTelemetry? História e objetivos.
  • Componentes do OpenTelemetry: APIs, SDKs, Collector.
  • Conceitos Chave: Spans, Traces, Attributes, Resources, Metrics (Counters, Gauges, Histograms), Logs.
  • O papel do OpenTelemetry na Observabilidade.
  • Ecossistema OpenTelemetry (projetos, comunidade).
• 1.3 Configurando o Ambiente de Desenvolvimento (1h)
  • Ferramentas necessárias (IDEs, SDKs das linguagens, Docker).
  • Configuração de um backend de observabilidade (e.g., Jaeger/Zipkin para traces, Prometheus/Grafana para métricas, Loki/Elasticsearch para logs) localmente via Docker Compose.
  • Primeira execução de uma aplicação simples com trace básico.

Módulo 2: Instrumentação de Traces com OpenTelemetry (6 horas)

• 2.1 Traces e Spans em Detalhe (1h)
  • Estrutura de um Trace e um Span.
  • Context Propagation (W3C Trace Context).
  • Injeção e Extração de contexto.
  • Relacionamento entre Spans (Parent/Child, Link).
• 2.2 Instrumentação Manual de Traces (2h)
  • 2.2.1 Java: Configurando a API e o SDK, criando Tracer, SpanBuilder, Span, Context. Exemplo prático de uma aplicação simples.
  • 2.2.2 .NET: Configurando ActivitySource e Activity, criação e gerenciamento de activities. Exemplo prático.
  • 2.2.3 Python: Usando TracerProvider, Tracer, Span, decoradores para instrumentação. Exemplo prático.
  • 2.2.4 Node.js: NodeTracerProvider, Tracer, SpanOptions, gerenciamento de Spans. Exemplo prático.
• 2.3 Instrumentação Automática de Traces (2h)
  • 2.3.1 Java: Usando o Java Agent para instrumentação automática de frameworks populares (Spring Boot, HttpClient, etc.).
  • 2.3.2 .NET: Configuração de instrumentações automáticas para ASP.NET Core, HttpClient, etc.
  • 2.3.3 Python: Uso de opentelemetry-instrumentation para bibliotecas comuns (Flask, Requests, Django).
  • 2.3.4 Node.js: Configuração de @opentelemetry/instrumentation para Express, HTTP, etc.
  • Vantagens e desvantagens da instrumentação manual vs. automática.
• 2.4 Enriquecendo Spans com Atributos (1h)
  • Adicionando atributos semânticos e customizados aos spans.
  • Convenções de atributos do OpenTelemetry.
  • Melhores práticas para atribuição de dados.

Módulo 3: Instrumentação de Métricas com OpenTelemetry (5 horas)

• 3.1 Conceitos de Métricas (1h)
  • Tipos de Métricas: Counter, Gauge, Histogram, Summary (se relevante).
  • Agregação de Métricas.
  • Dimensionalidade de Métricas (Labels/Attributes).
  • Diferença entre Pull e Push de Métricas.
• 3.2 Instrumentação Manual de Métricas (2h)
  • 3.2.1 Java: MeterProvider, Meter, Counter, Gauge, Histogram. Exemplo prático.
  • 3.2.2 .NET: MeterProvider, Meter, Counter<T>, ObservableGauge<T>, Histogram<T>. Exemplo prático.
  • 3.2.3 Python: MeterProvider, Meter, Counter, Gauge, Histogram. Exemplo prático.
  • 3.2.4 Node.js: MeterProvider, Meter, Counter, ObservableGauge, Histogram. Exemplo prático.
• 3.3 Instrumentação Automática de Métricas (1h)
  • Instrumentação de métricas básicas de sistema e JVM/CLR/Python/Node.js runtime.
  • Integração com frameworks (e.g., Spring Boot Actuator, ASP.NET Core).
• 3.4 Exportadores de Métricas (1h)
  • Configuração de exportadores para Prometheus, OTLP (OpenTelemetry Protocol).
  • Configurando e visualizando métricas no Grafana.

Módulo 4: Instrumentação de Logs com OpenTelemetry (3 horas)

• 4.1 Fundamentos de Logs e Observabilidade (1h)
  • O papel dos logs na observabilidade.
  • Correlação de logs com traces (Trace ID e Span ID).
  • Estruturação de logs (JSON).
• 4.2 Integração de Logs com OpenTelemetry (2h)
  • 4.2.1 Java: Integração com Logback/Log4j2 e OpenTelemetry Log Appender.
  • 4.2.2 .NET: Integração com Serilog/NLog e OpenTelemetry ILoggerFactory.
  • 4.2.3 Python: Integração com o módulo logging do Python.
  • 4.2.4 Node.js: Integração com Pino/Winston.
  • Enriquecendo logs com Trace ID e Span ID.
  • Exportando logs via OTLP para um backend (e.g., Loki, Elasticsearch).

Módulo 5: OpenTelemetry Collector e Tópicos Avançados (4 horas)

• 5.1 OpenTelemetry Collector (2h)
  • Arquitetura e componentes do Collector: Receivers, Processors, Exporters.
  • Casos de uso: Coleta, processamento, filtragem, amostragem, roteamento, transformação de dados.
  • Configuração e implantação do Collector (standalone e em Docker/Kubernetes).
  • Exemplo de pipeline de traces, métricas e logs através do Collector.
• 5.2 Amostragem (Sampling) (1h)
  • Estratégias de amostragem: AlwaysOn, AlwaysOff, TraceIdRatioBased, ParentBased.
  • Implementação de amostragem no SDK e no Collector.
  • Impacto da amostragem na observabilidade e no custo.
• 5.3 Context Propagation Avançado (1h)
  • W3C Trace Context vs. B3 Propagation.
  • Propagação de contexto entre diferentes protocolos (HTTP, gRPC, Kafka, AMQP).
  • Considerações sobre segurança (propagação de dados sensíveis).

Módulo 6: Workshop Prático e Resolução de Problemas (2 horas)

• 6.1 Projeto Integrador (1.5h)
  • Desenvolvimento de uma pequena aplicação distribuída multi-linguagem (ex: um serviço em Java, outro em Python, um frontend em Node.js) que se comunicam.
  • Os participantes instrumentam todos os serviços com OpenTelemetry para traces, métricas e logs.
  • Utilização do OpenTelemetry Collector para coletar e exportar os dados para os backends de observabilidade configurados (Jaeger, Prometheus/Grafana, Loki/Elasticsearch).
• 6.2 Debugging e Análise (0.5h)
  • Simulação de erros e gargalos.
  • Utilização das ferramentas de observabilidade para identificar e resolver problemas usando os dados coletados.
  • Discussão de cenários comuns e melhores práticas.