Este documento foi traduzido usando tecnologia de tradução automática de máquina. Sempre trabalhamos para apresentar traduções precisas, mas não oferecemos nenhuma garantia em relação à integridade, precisão ou confiabilidade do conteúdo traduzido. Em caso de qualquer discrepância, a versão original em inglês prevalecerá e constituirá o texto official.

Introdução ao Open Telemetry no Kubernetes

Este guia fornece instruções sobre como monitorar um aplicativo.

  • O aplicativo/carga de trabalho monitorado em execução no cluster A.

  • O coletor Open Telemetry em execução próximo ao(s) aplicativo(s) observado(s), portanto no cluster A, e enviando os dados para SUSE® Observability.

  • SUSE® Observability em execução no cluster B, ou SUSE Cloud Observability.

Instrumentação de contêiner com Open Telemetry via coletor em execução como implantação Kubernetes

O coletor Open Telemetry

Para uma configuração de produção, é fortemente recomendado instalar o coletor, pois ele permite que seu serviço descarregue dados rapidamente e o coletor pode cuidar de manuseios adicionais como tentativas, agrupamento, criptografia ou até mesmo filtragem de dados sensíveis.

Instale o coletor OTel (Open Telemetry) no cluster A e configure-o para:

  • Receber dados de, potencialmente, muitos aplicativos instrumentados.

  • Enriquecer os dados coletados com atributos do Kubernetes.

  • Gerar métricas para rastreamentos.

  • Encaminhar os dados para SUSE® Observability, incluindo autenticação usando a chave da API.

SUSE® Observability também tenta reenviar dados quando há problemas de conexão.

Criar um Token de Serviço

Há duas maneiras de criar um token de serviço:

  • SUSE® Observability UI - abra o menu principal clicando no canto superior esquerdo da tela e vá para StackPacks > Open Telemetry. Se você ainda não fez isso, clique no botão INSTALL. Clique no botão CREATE NEW SERVICE TOKEN e copie o valor para a sua área de transferência.

  • SUSE® Observability CLI - veja Gerenciar tokens de serviço

O valor do token de serviço deve ser usado onde as instruções abaixo mencionam <SERVICE_TOKEN>.

Crie o namespace e um segredo para o token de serviço

Instale no namespace open-telemetry e use o token de serviço:

kubectl create namespace open-telemetry
kubectl create secret generic open-telemetry-collector \
    --namespace open-telemetry \
    --from-literal=API_KEY='<SERVICE_TOKEN>'

Configure e instale o coletor

Instalamos o coletor com um gráfico Helm fornecido pelo projeto Open Telemetry. Certifique-se de que você tenha o repositório de gráficos Helm do Open Telemetry configurado:

helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts

Crie um arquivo de valores otel-collector.yaml para o gráfico Helm. Aqui está um bom ponto de partida para uso com SUSE® Observability, substitua <otlp-suse-observability-endpoint:port> pelo seu endpoint OTLP (veja API OTLP para seu endpoint) e insira o nome do seu cluster Kubernetes em vez de <your-cluster-name>:

otel-collector.yaml
# Set the API key from the secret as an env var:
extraEnvsFrom:
  - secretRef:
      name: open-telemetry-collector
mode: deployment
image:
  # Use the collector container image that has all components important for k8s. In case of missing components the ghcr.io/open-telemetry/opentelemetry-collector-releases/opentelemetry-collector-contrib image can be used which
  # has all components in the contrib repository: https://github.com/open-telemetry/opentelemetry-collector-contrib
  repository: "ghcr.io/open-telemetry/opentelemetry-collector-releases/opentelemetry-collector-k8s"
ports:
  metrics:
    enabled: true
presets:
  kubernetesAttributes:
    enabled: true
    extractAllPodLabels: true
# This is the config file for the collector:
config:
  receivers:
    otlp:
      protocols:
        grpc:
          endpoint: 0.0.0.0:4317
        http:
          endpoint: 0.0.0.0:4318
    # Scrape the collectors own metrics
    prometheus:
      config:
        scrape_configs:
        - job_name: opentelemetry-collector
          scrape_interval: 10s
          static_configs:
          - targets:
            - ${env:MY_POD_IP}:8888
  extensions:
    # Use the API key from the env for authentication
    bearertokenauth:
      scheme: SUSEObservability
      token: "${env:API_KEY}"
  exporters:
    nop: {}
    otlp/suse-observability:
      auth:
        authenticator: bearertokenauth
      # Put in your own otlp endpoint, for example otlp-suse-observability.my.company.com:443
      endpoint: <otlp-suse-observability-endpoint:port>
      compression: snappy
  processors:
    memory_limiter:
      check_interval: 5s
      limit_percentage: 80
      spike_limit_percentage: 25
    batch: {}
    resource:
      attributes:
      - key: k8s.cluster.name
        action: upsert
        # Insert your own cluster name
        value: <your-cluster-name>
      - key: service.instance.id
        from_attribute: k8s.pod.uid
        action: insert
        # Use the k8s namespace also as the open telemetry namespace
      - key: service.namespace
        from_attribute: k8s.namespace.name
        action: insert
  connectors:
    # Generate metrics for spans
    spanmetrics:
      metrics_expiration: 5m
      namespace: otel_span
  service:
    extensions: [ health_check,  bearertokenauth ]
    pipelines:
      traces:
        receivers: [otlp]
        processors: [memory_limiter, resource, batch]
        exporters: [debug, spanmetrics, otlp/suse-observability]
      metrics:
        receivers: [otlp, spanmetrics, prometheus]
        processors: [memory_limiter, resource, batch]
        exporters: [debug, otlp/suse-observability]
      logs:
        receivers: [otlp]
        processors: []
        exporters: [nop]
    telemetry:
      metrics:
        address: ${env:MY_POD_IP}:8888

Use o mesmo nome de cluster que foi usado para instalar o Agente SUSE® Observability se você também usar o agente SUSE® Observability com o stackpack Kubernetes. Usar um nome de cluster diferente resultará em uma perspectiva de rastreamentos vazia para os componentes Kubernetes e tornará muito mais difícil correlacionar informações para SUSE® Observability e seus usuários.

Instale o coletor usando o arquivo de configuração:

helm upgrade --install opentelemetry-collector open-telemetry/opentelemetry-collector \
  --values otel-collector.yaml \
  --namespace open-telemetry

O coletor oferece muito mais receptores de configuração, processadores e exportadores, para mais detalhes veja nossa página do coletor. Para uso em produção, frequentemente grandes quantidades de spans são geradas. Portanto, configure amostragem.

Colete dados de telemetria do seu aplicativo

A maneira comum de coletar dados de telemetria é instrumentar seu aplicativo usando os SDKs do Open Telemetry.

Para outras linguagens, siga a documentação em opentelemetry.io e certifique-se de configurar o exportador SDK para enviar dados para o coletor que você acabou de instalar seguindo estas instruções.

Veja os resultados

Vá para SUSE® Observability e certifique-se de que o Stackpack Open Telemetry está instalado (via o menu principal -> Stackpacks).

Se seus pods estão recebendo tráfego, você deve ser capaz de encontrá-los sob o nome do serviço no Open Telemetry -> visão geral de serviços e instâncias de serviço. Os rastreamentos aparecem no explorador de rastreamentos e na perspectiva de rastreamentos para os componentes de serviço e instância de serviço. Métricas de span e métricas específicas de linguagem (se disponíveis) ficam disponíveis na perspectiva de métricas para os componentes.

Se você também tiver o stackpack Kubernetes instalado, os pods instrumentados também terão os rastreamentos disponíveis na perspectiva de rastreamentos.

Rancher RBAC

Para que o Rancher RBAC funcione, os dados de telemetria precisam ter os seguintes atributos de recurso presentes:

  • k8s.cluster.name - o nome do Cluster conforme usado pelo stackpack Kubernetes

  • k8s.namespace.name - um Namespace gerenciado por um Projeto do Rancher

Isso pode ser alcançado por uma configuração como a acima. Lá, o kubernetesAttributes preset do gráfico Helm opentelemetry-collector injeta um processador k8sattributes em cada pipeline.

Próximas etapas

Você pode adicionar novos gráficos aos componentes, por exemplo, o serviço ou a instância de serviço, para seu aplicativo, seguindo nosso guia. Também é possível criar novos monitores usando as métricas e configurar notificações para ser notificado quando seu aplicativo não estiver disponível ou tiver problemas de desempenho.