Visão Geral

O curso Hands-On: Projeto Final OpenTelemetry:Este curso intensivo de 24 horas é o ápice do aprendizado em OpenTelemetry, projetado para consolidar e aprofundar o conhecimento dos participantes através da construção de um projeto prático completo. O curso focará na implementação de uma arquitetura de microsserviços do zero, instrumentando-a exaustivamente com OpenTelemetry para traces distribuídos, métricas e logs. Os alunos terão a oportunidade de aplicar todas as técnicas e conceitos aprendidos, desde a instrumentação de código em múltiplas linguagens até a configuração avançada do OpenTelemetry Collector e a integração com backends de observabilidade (Jaeger, Prometheus/Grafana, Loki/ELK). O objetivo é simular um cenário de produção realista, permitindo que os participantes experimentem os desafios e as recompensas de ter um sistema verdadeiramente observável, capaz de fornecer insights para depuração,

Objetivo

Após realizar este curso Hands-On Projeto Final OpenTelemetry, você será capaz de:

• Projetar e instrumentar uma arquitetura de microsserviços completa com OpenTelemetry para traces, métricas e logs.
• Selecionar e aplicar as estratégias de instrumentação (manual e automática) mais adequadas para diferentes cenários de aplicação.
• Configurar e otimizar um pipeline de telemetria robusto com o OpenTelemetry Collector, incluindo processadores avançados e estratégias de amostragem.
• Integrar e analisar dados de telemetria em backends de observabilidade líderes de mercado (Jaeger, Prometheus, Grafana, Loki/ELK).
• Correlacionar traces, métricas e logs de forma eficiente para uma visão unificada do sistema.
• Depurar problemas complexos em sistemas distribuídos utilizando os dados de observabilidade.
• Avaliar o impacto da instrumentação na performance da aplicação e otimizar a coleta de telemetria.
• Construir dashboards e alertas significativos que ofereçam visibilidade e capacidade de resposta.
• Apresentar um projeto de observabilidade completo e funcional como parte de seu portfólio.

Publico Alvo

• Desenvolvedores de Software, Arquitetos e Engenheiros de DevOps que já possuem conhecimento intermediário em OpenTelemetry e buscam experiência prática consolidada.
• Profissionais que concluíram cursos introdutórios ou intermediários em OpenTelemetry e desejam aplicar o conhecimento em um projeto real.
• Equipes que estão planejando ou iniciando a implementação de observabilidade com OpenTelemetry e querem um blueprint prático.
• Qualquer profissional que deseje construir um portfólio sólido em observabilidade e sistemas distribuídos.

Pre-Requisitos

• Conhecimento Sólido em OpenTelemetry: Familiaridade com os conceitos de traces, métricas, logs, OpenTelemetry Collector (receivers, processors, exporters) e instrumentação básica em pelo menos duas linguagens de programação (preferencialmente Java, Python, Node.js, .NET ou Go).
• Conhecimento de Arquitetura de Microsserviços: Compreensão de comunicação entre serviços, APIs REST/gRPC.
• Experiência com Docker e Docker Compose: Habilidade para configurar ambientes conteinerizados.
• Noções básicas de Kubernetes (opcional, mas um plus): Para deploy dos backends.

Materiais

Conteúdo Programatico

Módulo I: Planejamento e Arquitetura do Projeto (4 horas)

• 1.1 Definição do Projeto de Microsserviços (2h)
  • Proposta de um sistema de microsserviços de exemplo (e.g., e-commerce simplificado, sistema de gerenciamento de pedidos, app de notícias).
  • Definição dos serviços principais, suas responsabilidades e como se comunicam (REST, gRPC, filas de mensagens).
  • Escolha das linguagens de programação para cada microsserviço (pelo menos duas diferentes).
  • Desenho da arquitetura inicial e fluxos de requisição.
  • Configuração do ambiente de desenvolvimento inicial: Docker Compose para os serviços e backends.
• 1.2 Planejamento da Observabilidade (2h)
  • Identificação dos "Golden Signals" (Latency, Traffic, Errors, Saturation) para cada serviço.
  • Definição de quais traces, métricas e logs serão cruciais para depuração e monitoramento.
  • Estratégias de instrumentação: Onde aplicar instrumentação manual e onde a automática é suficiente.
  • Desenho do pipeline de telemetria com o OpenTelemetry Collector.
  • Definição dos backends de observabilidade a serem utilizados (Jaeger, Prometheus, Grafana, Loki/ELK).

Módulo II: Implementação da Instrumentação dos Microsserviços (6 horas)

• 2.1 Instrumentação de Traces Distribuídos (2.5h)
  • 2.1.1 Serviço 1 (Linguagem A): Implementação da instrumentação manual e automática para traces. Propagação de contexto (HTTP/gRPC/Messaging).
  • 2.1.2 Serviço 2 (Linguagem B): Implementação da instrumentação manual e automática para traces. Propagação de contexto entre serviços (chaining).
  • Adição de atributos semânticos e de negócio importantes em cada serviço.
  • Configuração dos exportadores OTLP nos SDKs para enviar traces para o OpenTelemetry Collector.
• 2.2 Instrumentação de Métricas de Aplicação (2h)
  • Instrumentação de métricas customizadas para cada serviço (e.g., Counter para requisições/erros, Histogram para latência de banco de dados/HTTP, Gauge para tamanho de fila).
  • Coleta de métricas de runtime e de sistema.
  • Configuração dos exportadores OTLP nos SDKs para enviar métricas para o OpenTelemetry Collector.
• 2.3 Integração de Logs e Correlação (1.5h)
  • Configuração das bibliotecas de logging em cada serviço para emitir logs estruturados (JSON).
  • Configuração dos SDKs para injetar automaticamente o Trace ID e Span ID nos logs.
  • Envio dos logs para o OpenTelemetry Collector via OTLP.
  • Garanta que os logs sejam ricos em contexto para facilitar a depuração.

Módulo III: Configuração e Otimização do OpenTelemetry Collector (6 horas)

• 3.1 Deploy e Configuração Base do Collector (2h)
  • Levantar o OpenTelemetry Collector com Docker Compose.
  • Configurar receivers OTLP para traces, métricas e logs.
  • Configurar processadores básicos: batch, memory_limiter, resource.
  • Configurar exporters para Jaeger, Prometheus e Loki/ELK.
  • Testar o fluxo de telemetria de ponta a ponta (serviços -> Collector -> Backends).
• 3.2 Processamento Avançado de Telemetria (2.5h)
  • 3.2.1 Traces: Implementar attributes_processor e transform_processor para padronizar/enriquecer traces. Usar spanmetrics_processor para gerar métricas de serviço a partir de traces.
  • 3.2.2 Métricas: Aplicar attributes_processor para adicionar labels ou renomear métricas.
  • 3.2.3 Logs: Usar attributes_processor ou transform_processor para enriquecer logs com metadados adicionais.
  • Implementar filter_processor para descartar telemetria não essencial.
• 3.3 Estratégias de Amostragem Inteligente (1.5h)
  • Configurar tail_sampling_processor no Collector para implementar regras de amostragem:
    • Amostrar 100% dos traces com erro.
    • Amostrar uma porcentagem de traces lentos.
    • Amostrar traces específicos baseados em atributos (e.g., ID de usuário VIP).
  • Entender o impacto da amostragem no volume de dados e na visibilidade.

Módulo IV: Análise e Visualização nos Backends (6 horas)

• 4.1 Análise Aprofundada de Traces com Jaeger (2h)
  • Explorar os traces gerados pelo projeto: identificar dependências, latências em cada serviço.
  • Simular erros em um serviço e rastrear a requisição completa no Jaeger.
  • Analisar gargalos de performance e identificar a causa raiz usando traces.
  • Visualizar Service Graphs para entender o mapa de dependências dos microsserviços.
• 4.2 Monitoramento de Métricas com Prometheus e Grafana (2h)
  • Configurar o Prometheus para fazer scrape do endpoint de métricas do Collector.
  • Criar um dashboard no Grafana focado nos Golden Signals de cada microsserviço (Latência, Tráfego, Erros, Saturação).
  • Visualizar métricas geradas pelo spanmetrics_processor (Service Map).
  • Criar alertas simples no Grafana para condições anormais (e.g., alta taxa de erros, latência elevada).
• 4.3 Análise e Busca de Logs Correlacionados (1.5h)
  • Configurar o Grafana para consultar logs do Loki (ou Kibana para Elasticsearch).
  • Realizar buscas complexas nos logs estruturados.
  • Correlacionar logs com traces: a partir de um log no Grafana/Kibana, pular para o trace correspondente no Jaeger.
  • Identificar padrões e tendências nos logs para depuração proativa.
• 4.4 Dashboard de Observabilidade Unificado (0.5h)
  • Construir um dashboard "single pane of glass" no Grafana que combine visualizações de traces (via plugin Tempo/Jaeger), métricas e logs, fornecendo uma visão holística do sistema.
  • Utilizar variáveis de template para navegar facilmente entre serviços ou ambientes.

Módulo V: Testes, Otimização e Apresentação do Projeto (2 horas)

• 5.1 Teste de Carga e Simulação de Falhas (1h)
  • Gerar carga no sistema de microsserviços (usando curl, Postman, ou uma ferramenta simples de carga).
  • Simular falhas em serviços (e.g., desligar um serviço, injetar latência, causar erros).
  • Utilizar as ferramentas de observabilidade para identificar e diagnosticar os problemas rapidamente.
  • Ajustar as configurações do Collector e SDKs com base nos resultados dos testes.
• 5.2 Otimização e Refinamento do Pipeline (0.5h)
  • Revisar as configurações do Collector e dos SDKs para otimizar o uso de recursos e o volume de telemetria.
  • Discutir trade-offs entre granularidade da telemetria e custo/performance.
  • Estratégias para gerenciamento de logs em produção (rotação, retenção).
• 5.3 Apresentação e Discussão do Projeto (0.5h)
  • Cada participante (ou grupo) apresenta seu projeto final, destacando os desafios enfrentados e as soluções implementadas.
  • Discussão em grupo sobre as melhores práticas e lições aprendidas.
  • Revisão de conceitos-chave e próximos passos na jornada da observabilidade.