Laboratório: Observabilidade distribuída com OpenTelemetry, Jaeger e aplicação Python

Roteiro para estudo em ambiente de laboratório ou de teste. Execute apenas em equipamentos, redes e contas que você tenha autorização para usar, com backup e homologação próprios. Comandos podem causar indisponibilidade ou perda de dados. Software e marcas citados pertencem aos seus titulares. Termos de Uso.

Duração estimada

120 min

Passos

10

Validações

4

Versões da documentação consultada

OpenTelemetry Collector a versão estável atual · Jaeger a versão estável atual · Python 3.8 ou superior · OpenTelemetry Python SDK a versão estável atual

Topologia

Uma aplicação Python roda em 10.0.0.2, instrumentada com OpenTelemetry SDK. Ela envia traces para o OpenTelemetry Collector em 10.0.0.3:4317 (OTLP/gRPC). O Collector exporta para o Jaeger em 10.0.0.4:14250. O Jaeger armazena e exibe traces via interface web em 10.0.0.4:16686.

[App Python]
    |
    | OTLP/gRPC (4317)
    v
[OTel Collector]
    |
    | Jaeger gRPC (14250)
    v
   [Jaeger]
    |
    | Web (16686)
    v
  [Usuário]

Equipamentos e software

Roteiro

1. Preparar ambiente da aplicação Python

   Crie uma VM ou use um computador com Python 3.8+ instalado. Instale pip se necessário.

   sudo apt update && sudo apt install python3 python3-pip -yCopiar

   O que você deve ver: Python e pip instalados sem erros

2. Instalar OpenTelemetry SDK e instrumentação para Flask

   Instale os pacotes necessários para instrumentar uma aplicação Flask.

   pip3 install flask opentelemetry-api opentelemetry-sdk opentelemetry-instrumentation-flask opentelemetry-exporter-otlpCopiar

   O que você deve ver: Pacotes instalados sem erros

3. Criar aplicação Flask instrumentada

   Crie um arquivo app.py com um endpoint simples e instrumentação OpenTelemetry.

   cat <<EOF > app.py
   from flask import Flask
   from opentelemetry.instrumentation.flask import FlaskInstrumentor
   from opentelemetry.sdk.trace import TracerProvider
   from opentelemetry.sdk.trace.export import BatchSpanProcessor
   from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
   from opentelemetry import trace
   
   app = Flask(__name__)
   FlaskInstrumentor().instrument_app(app)
   
   trace.set_tracer_provider(TracerProvider())
   otlp_exporter = OTLPSpanExporter(endpoint="10.0.0.3:4317", insecure=True)
   span_processor = BatchSpanProcessor(otlp_exporter)
   trace.get_tracer_provider().add_span_processor(span_processor)
   
   @app.route("/")
   def hello():
       return "Hello, OpenTelemetry!"
   
   if __name__ == "__main__":
       app.run(host="0.0.0.0", port=5000)
   EOFCopiar

   O que você deve ver: Arquivo app.py criado

4. Executar aplicação Flask

   Inicie a aplicação para que ela comece a gerar traces.

   python3 app.pyCopiar

   O que você deve ver: Aplicação rodando em 0.0.0.0:5000

5. Preparar ambiente do OpenTelemetry Collector

   Em outra VM ou computador, baixe e descompacte o OpenTelemetry Collector.

   wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/latest/download/otelcol_linux_amd64.tar.gz
   mkdir otelcol && tar -xzf otelcol_linux_amd64.tar.gz -C otelcolCopiar

   O que você deve ver: Binário do Collector disponível em ./otelcol

6. Criar configuração do Collector

   Crie um arquivo de configuração YAML para receber OTLP/gRPC e exportar para Jaeger.

   cat <<EOF > otelcol/config.yaml
   receivers:
     otlp:
       protocols:
         grpc:
           endpoint: 0.0.0.0:4317
   exporters:
     jaeger:
       endpoint: 10.0.0.4:14250
       tls:
         insecure: true
   service:
     pipelines:
       traces:
         receivers: [otlp]
         exporters: [jaeger]
   EOFCopiar

   O que você deve ver: Arquivo de configuração criado

7. Executar o OpenTelemetry Collector

   Inicie o Collector apontando para a configuração criada.

   ./otelcol/otelcol --config otelcol/config.yamlCopiar

   O que você deve ver: Collector inicializado sem erros

8. Preparar ambiente do Jaeger

   Em outra VM ou computador, baixe e execute o Jaeger All-in-One.

   docker run -d --name jaeger \
     -e COLLECTOR_GRPC_PORT=14250 \
     -p 16686:16686 -p 14250:14250 \
     jaegertracing/all-in-one:latestCopiar

   O que você deve ver: Container do Jaeger rodando, portas 14250 e 16686 abertas

9. Gerar tráfego na aplicação

   Acesse o endpoint da aplicação algumas vezes para gerar traces.

   curl http://10.0.0.2:5000/Copiar

   O que você deve ver: Resposta 'Hello, OpenTelemetry!'

10. Acessar interface web do Jaeger

    Abra o navegador e acesse http://10.0.0.4:16686. Procure pelo serviço Flask.

    O que você deve ver: Interface do Jaeger acessível, traces do serviço Flask disponíveis

Como saber que funcionou

Troubleshooting

Segurança e hardening

• Não exponha as portas 4317, 14250 e 16686 para a internet sem autenticação
• Use firewalls para restringir acesso entre as VMs
• Em produção, configure autenticação e TLS conforme a documentação

Checklist final

• Python e dependências instalados
• Aplicação Flask instrumentada rodando
• OpenTelemetry Collector rodando e configurado
• Jaeger rodando e acessível via web
• Traces do serviço Flask visíveis no Jaeger