Vídeo 06 - Desenvolvimento

[thpoiani]

Agora temos um serviço exposto e conseguimos começar a consultar a API.
Além disso fizemos alguns testes de integração, verificamos tracing e logging.

Você havia trabalhado anteriormente com testes de integração? É uma boa oportunidade para validação de contratos e verificações end-to-end.

OpenTelemetry nos dá uma visão interessante do comportamento da aplicação. Observabilidade é um tópico sempre em alta. Contudo não estamos adicionado um componente para Métricas. Algum sugestão de ferramenta?

[didifive]

Para teste de integração eu fiz algo mais simples com Spring Web e MockMVC, com o MockMVC fazia o teste das chamadas e respostas rest, daí tinha a opção de mockar o service ou usar o contexto do spring e conexão com banco de dados.
Ainda tenho muito o que aprender com o Quarkus, mas vi que ele facilitou bem a configuração para os testes de endpoints.

Sobre Observabilidade é legal, não explorei muito ainda, então vou ficar de olho na discussão e fazer pesquisas para melhorar conhecimento sobre.

[IgorEdu]

Por mais que não tenha muita experiência com as ferramentas, acredito que o Prometheus e o Grafana sejam boas opções para resolver a falta de um componente de métricas, alarmes, análise e visualização com dashboards personalizados.

[GilsonCoelho]

Isso me fez lembrar do antigo trabalho.
Onde um colega de infra uso o Kibana com Grafana para analisar o sistema com um todo para verificar falhas e lentidões na aplicação.
Ele fez isso acabar com a briga entre a equipe de Desenvolvedores e a equipe de Infra que ficavam colocando a culpa no outro .

[thpoiani]

Haha observabilidade salvando o dia novamente 🦸

[thpoiani]

Vale ressaltar que Grafana atualmente possui uma stack completa para observabilidade open source, com Loki para logging e Tempo para tracing

Refs:
https://github.com/grafana/intro-to-mltp
https://github.com/grafana/docker-otel-lgtm

[mauromortoni]

Etapas e melhores práticas para usar o OpenTelemetry com o objetivo de observabilidade e métricas:

1. Compreender os Conceitos Básicos

   • Traces: Rastreiam a execução de uma operação através de sistemas distribuídos.
   • Métricas: Coletam dados numéricos sobre o desempenho, como contadores e medidas de latência.
   • Logs: Capturam eventos e mensagens que ocorrem em um sistema.

2. Instalação e Configuração

   • Escolha a Biblioteca: Selecione a biblioteca OpenTelemetry apropriada para sua linguagem de programação (por exemplo, Java, Python, Go, etc.).
   • Instalação: Adicione a biblioteca ao seu projeto. Para a maioria das linguagens, você pode usar gerenciadores de pacotes (como Maven, pip, etc.).

   # Exemplo para Python
   pip install opentelemetry-api opentelemetry-sdk opentelemetry-instrumentation

3. Instrumentação

   • Instrumentação Manual: Adicione código para coletar métricas e rastreamento. Por exemplo, em Python:

   from opentelemetry import metrics, trace
   
   # Configurando o tracer
   tracer = trace.get_tracer(__name__)
   
   # Criando um span
   with tracer.start_as_current_span("span_name"):
       # Executa a lógica do seu código aqui
       pass

   • Instrumentação Automática: Use bibliotecas de instrumentação que automaticamente coletam dados de métricas e traces. Por exemplo, em um aplicativo web, você pode usar:

   from opentelemetry.instrumentation.flask import FlaskInstrumentor
   app = Flask(__name__)
   FlaskInstrumentor().instrument_app(app)

4. Configurar Exportadores

   • Escolher um Exportador: Determine onde você quer enviar os dados coletados. Existem exportadores para sistemas populares como Prometheus, Jaeger, Zipkin, e outros.
   • Configurar o Exportador: Configure o exportador na sua aplicação para enviar os dados para o destino desejado.

   from opentelemetry.exporter.prometheus import PrometheusMetricsExporter
   from opentelemetry.sdk.metrics import MeterProvider
   from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
   
   # Configurando o exportador
   exporter = PrometheusMetricsExporter()
   metric_reader = PeriodicExportingMetricReader(exporter)
   meter_provider = MeterProvider(metric_readers=[metric_reader])
   metrics.set_meter_provider(meter_provider)

5. Definir Métricas

   • Criar Métricas Personalizadas: Defina métricas relevantes para seu sistema, como contadores, histogramas ou medidas.
   • Exemplo de Contador:

   from opentelemetry.metrics import get_meter
   
   meter = get_meter(__name__)
   request_counter = meter.create_counter("request_count", description="Contador de requisições")
   
   request_counter.add(1)  # Incrementa o contador

6. Coletar e Visualizar Dados

   • Visualização: Use ferramentas como Prometheus, Grafana, Jaeger ou Zipkin para visualizar e analisar os dados coletados.
   • Configurar Painéis: Crie painéis em Grafana para monitorar suas métricas em tempo real.

7. Monitoramento e Alertas

   • Configurar Alertas: Use as métricas coletadas para configurar alertas em caso de anomalias. Isso pode ser feito em ferramentas de monitoramento como Grafana ou Prometheus.

8. Melhoria Contínua

   • Revisão Regular: Revise suas métricas e traces regularmente para garantir que eles continuem a fornecer insights úteis.
   • Ajustes e Refinamento: Refine a instrumentação e as métricas conforme necessário para se adaptar a mudanças no sistema ou novos requisitos.

9. Documentação e Colaboração

   • Documentar a Instrumentação: Mantenha uma documentação clara sobre a instrumentação utilizada e as métricas coletadas.
   • Colaborar com a Equipe: Envolva sua equipe na definição de métricas e na interpretação dos dados para promover uma cultura de observabilidade.

10. Seguir as Melhores Práticas

• Consistência: Use convenções de nomenclatura consistentes para suas métricas e spans.
• Minimizar o Overhead: Tente minimizar o impacto de desempenho ao instrumentar seu código.

Ao seguir essas etapas e práticas recomendadas, você pode implementar o OpenTelemetry de forma eficaz para melhorar a observabilidade e o monitoramento de seu sistema, garantindo um desempenho mais robusto e uma melhor experiência do usuário.

Exemplo de como usar o OpenTelemetry em um aplicativo Go para coletar métricas e traces.
Vamos instrumentar um simples servidor HTTP.

1.Instalação das Dependências

Para começar, você precisa instalar as bibliotecas necessárias. Execute o seguinte comando:

go get go.opentelemetry.io/otel
go get go.opentelemetry.io/otel/sdk
go get go.opentelemetry.io/otel/exporters/trace/jaeger
go get go.opentelemetry.io/otel/instrumentation/net/http/otelhttp

2.Código de Exemplo

Aqui está um exemplo simples de um servidor HTTP que utiliza OpenTelemetry para coletar traces e métricas:

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"

    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/trace/jaeger"
    "go.opentelemetry.io/otel/sdk"
    "go.opentelemetry.io/otel/sdk/resource"
    "go.opentelemetry.io/otel/sdk/trace"
    "go.opentelemetry.io/otel/instrumentation/net/http/otelhttp"
)

func initTracer() func() {
    // Configurar o exportador Jaeger
    exp, err := jaeger.NewRawExporter(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint("http://localhost:14268/api/traces")))
    if err != nil {
        log.Fatalf("failed to create Jaeger exporter: %v", err)
    }

    // Configurar o recurso
    res, err := resource.New(context.Background(), resource.WithAttributes(
        // Defina atributos de recurso, como nome do serviço
        resource.AttributeString("service.name", "my-go-service"),
    ))
    if err != nil {
        log.Fatalf("failed to create resource: %v", err)
    }

    // Configurar o tracer provider
    tp := trace.NewTracerProvider(
        trace.WithBatcher(exp),
        trace.WithResource(res),
    )
    otel.SetTracerProvider(tp)

    // Retornar uma função para fechar o tracer provider ao final
    return func() {
        if err := tp.Shutdown(context.Background()); err != nil {
            log.Fatal(err)
        }
    }
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    tracer := otel.Tracer("example.com/hello")
    _, span := tracer.Start(ctx, "helloHandler")
    defer span.End()

    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    // Inicializar o tracer
    shutdown := initTracer()
    defer shutdown()

    // Instrumentar o handler HTTP
    http.Handle("/hello", otelhttp.NewHandler(http.HandlerFunc(helloHandler), "hello"))
    
    log.Println("Servidor ouvindo na porta :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

3.Executar o Jaeger

Se você não tiver o Jaeger em execução, você pode rapidamente iniciar uma instância usando Docker:

docker run -d --name jaeger \
  -e COLLECTOR_ZIPKIN_HTTP_PORT=9411 \
  -e JAEGER_AGENT_HOST=localhost \
  -e JAEGER_SAMPLER_TYPE=const \
  -e JAEGER_SAMPLER_PARAM=1 \
  -p 5775:5775/udp \
  -p 6831:6831/udp \
  -p 6832:6832/udp \
  -p 5778:5778 \
  -p 14268:14268 \
  -p 14250:14250 \
  -p 16686:16686 \
  jaegertracing/all-in-one:1.29

4.Testar o Servidor

Agora, você pode executar seu aplicativo Go:

go run main.go

Em seguida, faça uma requisição para o endpoint:

curl http://localhost:8080/hello

5.Visualizar os Dados no Jaeger

Acesse a interface do Jaeger em 'http://localhost:16686'. Você deverá ver os traces coletados a partir do seu aplicativo Go.

Considerações Finais

Este exemplo mostra como configurar o OpenTelemetry em um aplicativo Go para coletar traces e enviar para o Jaeger. Você pode expandir isso para coletar métricas e logs, dependendo das suas necessidades. Certifique-se de ajustar as configurações e instrumentar outras partes do seu código conforme necessário para uma observabilidade completa.