Implantar o coletor do OpenTelemetry no Google Kubernetes Engine

Neste documento, mostramos como executar o Coletor OpenTelemetry em um cluster do GKE para coletar registros, métricas e traces do OTLP de aplicativos instrumentados e exportar os dados para o Google Cloud.

Antes de começar

A execução do Coletor do OpenTelemetry no GKE requer os seguintes recursos:

  • Um projeto do Google Cloud com as APIs Cloud Monitoring, Cloud Trace e Cloud Logging ativadas.

    • Se você não tiver um projeto do Google Cloud, faça o seguinte:

      1. No Console do Google Cloud, acesse Novo projeto:

        Crie um novo projeto

      2. No campo Project Name, insira um nome para o projeto e clique em Criar.

      3. Acesse o Faturamento:

        Acessar "Faturamento"

      4. Selecione o projeto recém-criado se ele ainda não estiver selecionado na parte superior da página.

      5. Você precisará escolher um perfil para pagamentos atual ou criar um novo.

      As APIs Monitoring, Trace e Logging são ativadas por padrão para novos projetos.

    • Se você já tem um projeto do Google Cloud, verifique se as APIs Monitoring, Trace e Logging estão ativadas:

      1. Acessar APIs e serviços

        Acessar APIs e serviços

      2. Selecione o projeto.

      3. Clique em Ativar APIs e serviços.

      4. Pesquise cada API por nome.

      5. Nos resultados da pesquisa, clique na API nomeada. A API Monitoring aparece como "API Stackdriver Monitoring".

      6. Se a opção "API ativada" não for exibida, clique no botão Ativar.

  • Um cluster do Kubernetes. Se você não tiver um cluster do Kubernetes, siga as instruções no Guia de início rápido para GKE.

  • As seguintes ferramentas de linha de comando:

    • gcloud
    • kubectl

    As ferramentas gcloud e kubectl fazem parte da Google Cloud CLI. Para mais informações sobre como instalá-los, consulte Como gerenciar componentes da CLI do Google Cloud. Para ver os componentes da CLI gcloud que você instalou, execute o seguinte comando:

    gcloud components list

Implantar o coletor

O pipeline do coletor pode ser implantado diretamente do GitHub com os seguintes comandos depois de substituir PROJECT_ID pelo ID do seu projeto do Google Cloud:

export GCLOUD_PROJECT=PROJECT_ID
kubectl kustomize https://github.com/GoogleCloudPlatform/otlp-k8s-ingest.git/k8s/base | envsubst | kubectl apply -f -

Observar e depurar o coletor

O Coletor do OpenTelemetry fornece métricas de auto-observabilidade prontas para uso para ajudar você a monitorar seu desempenho e garantir o tempo de atividade contínuo do pipeline de ingestão OTLP.

Para monitorar o Coletor, instale o painel de amostra dele. Esse painel do Google Analytics oferece insights gerais sobre várias métricas do Coletor, incluindo tempo de atividade, uso de memória e chamadas de API para a observabilidade do Google Cloud.

Para instalar o painel, faça o seguinte:

  1. No console do Google Cloud, acesse a página  Painéis:

    Ir para Painéis

    Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoring.

  2. Selecione a guia Biblioteca de amostra.
  3. Selecione a categoria Coletor do OpenTelemetry.
  4. Selecione o painel "Coletor do OpenTelemtry".
  5. Clique em  Importar.

Para mais informações sobre o processo de instalação, consulte Instalar painéis de exemplo.

Configurar o coletor

O pipeline de ingestão autogerenciado do OTLP inclui uma Configuração do Coletor do OpenTelemetry padrão, projetada para entregar grandes volumes de métricas, registros e traces do OTLP com metadados consistentes do GKE e do Kubernetes anexados. Ele também foi projetado para evitar problemas comuns de ingestão.

No entanto, você pode ter necessidades únicas que exigem a personalização da configuração padrão Nesta seção, descrevemos os padrões fornecidos com o pipeline e como você pode personalizar esses padrões de acordo com suas necessidades.

A configuração padrão do coletor está no GitHub como config/collector.yaml

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

exporters:
  googlecloud:
    log:
      default_log_name: opentelemetry-collector
    user_agent: Google-Cloud-OTLP manifests:0.1.0 otel/opentelemetry-collector-contrib:0.105.0
  googlemanagedprometheus:
    user_agent: Google-Cloud-OTLP manifests:0.1.0 otel/opentelemetry-collector-contrib:0.105.0

extensions:
  health_check:
    endpoint: ${env:MY_POD_IP}:13133
processors:
  filter/self-metrics:
    metrics:
      include:
        match_type: strict
        metric_names:
        - otelcol_process_uptime
        - otelcol_process_memory_rss
        - otelcol_grpc_io_client_completed_rpcs
        - otelcol_googlecloudmonitoring_point_count
  batch:
    send_batch_max_size: 200
    send_batch_size: 200
    timeout: 5s

  k8sattributes:
    extract:
      metadata:
      - k8s.namespace.name
      - k8s.deployment.name
      - k8s.statefulset.name
      - k8s.daemonset.name
      - k8s.cronjob.name
      - k8s.job.name
      - k8s.node.name
      - k8s.pod.name
      - k8s.pod.uid
      - k8s.pod.start_time
    passthrough: false
    pod_association:
    - sources:
      - from: resource_attribute
        name: k8s.pod.ip
    - sources:
      - from: resource_attribute
        name: k8s.pod.uid
    - sources:
      - from: connection
  memory_limiter:
    check_interval: 1s
    limit_percentage: 65
    spike_limit_percentage: 20

  metricstransform/self-metrics:
    transforms:
    - action: update
      include: otelcol_process_uptime
      operations:
      - action: add_label
        new_label: version
        new_value: Google-Cloud-OTLP manifests:0.1.0 otel/opentelemetry-collector-contrib:0.105.0

  # We need to add the pod IP as a resource label so the k8s attributes processor can find it.
  resource/self-metrics:
    attributes:
    - action: insert
      key: k8s.pod.ip
      value: ${env:MY_POD_IP}

  resourcedetection:
    detectors: [gcp]
    timeout: 10s

  transform/collision:
    metric_statements:
    - context: datapoint
      statements:
      - set(attributes["exported_location"], attributes["location"])
      - delete_key(attributes, "location")
      - set(attributes["exported_cluster"], attributes["cluster"])
      - delete_key(attributes, "cluster")
      - set(attributes["exported_namespace"], attributes["namespace"])
      - delete_key(attributes, "namespace")
      - set(attributes["exported_job"], attributes["job"])
      - delete_key(attributes, "job")
      - set(attributes["exported_instance"], attributes["instance"])
      - delete_key(attributes, "instance")
      - set(attributes["exported_project_id"], attributes["project_id"])
      - delete_key(attributes, "project_id")

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:4317
      http:
        cors:
          allowed_origins:
          - http://*
          - https://*
        endpoint: ${env:MY_POD_IP}:4318
  prometheus/self-metrics:
    config:
      scrape_configs:
      - job_name: otel-self-metrics
        scrape_interval: 1m
        static_configs:
        - targets:
          - ${env:MY_POD_IP}:8888

service:
  extensions:
  - health_check
  pipelines:
    logs:
      exporters:
      - googlecloud
      processors:
      - k8sattributes
      - resourcedetection
      - memory_limiter
      - batch
      receivers:
      - otlp
    metrics/otlp:
      exporters:
      - googlemanagedprometheus
      processors:
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - transform/collision
      - batch
      receivers:
      - otlp
    metrics/self-metrics:
      exporters:
      - googlemanagedprometheus
      processors:
      - filter/self-metrics
      - metricstransform/self-metrics
      - resource/self-metrics
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - prometheus/self-metrics
    traces:
      exporters:
      - googlecloud
      processors:
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - otlp
  telemetry:
    metrics:
      address: ${env:MY_POD_IP}:8888

Exportadoras

Os exportadores padrão incluem o exportador googlecloud (para registros e traces) e o exportador googlemanagedprometheus (para métricas).

O exportador googlecloud está configurado com um nome de registro padrão. O exportador googlemanagedprometheus não requer configuração padrão. Consulte Introdução ao Coletor do OpenTelemetry na documentação do Google Cloud Managed Service para Prometheus para saber mais sobre a configuração deste exportador.

Processadores

A configuração padrão inclui os seguintes processadores:

  • batch Configurado para agrupar solicitações de telemetria com o número máximo de entradas por solicitação ou no intervalo mínimo do Google Cloud de cada 5 segundos (o que ocorrer primeiro).
  • k8sattributes Mapeia automaticamente os atributos de recursos do Kubernetes para rótulos de telemetria.
  • memory_limiter Limita o uso da memória do coletor em um nível razoável para evitar falhas por falta de memória ao descartar pontos de dados além desse nível.
  • resourcedetection Detecta automaticamente os rótulos de recursos do Google Cloud, como nome do cluster e ID do projeto.
  • transform: renomeia os rótulos de métricas que entrariam em conflito com os campos de recurso monitorado do Google Cloud.

Recebedores

A configuração padrão inclui apenas o receptor otlp. Consulte Escolher uma abordagem de instrumentação para instruções detalhadas sobre como instrumentar seus aplicativos para enviar traces e métricas do OTLP para o endpoint do OTLP do coletor.

Próximas etapas: coletar e visualizar telemetria

Esta seção descreve a implantação de um aplicativo de exemplo e a indicação do aplicativo para o endpoint OTLP do coletor, bem como a visualização da telemetria no Google Cloud. O aplicativo de exemplo é um pequeno gerador que exporta traces, registros e métricas para o coletor.

Se você já tiver um aplicativo instrumentado com um SDK do OpenTelemetry, é possível apontar seu aplicativo para o endpoint do coletor.

Para implantar o aplicativo de amostra, execute o seguinte comando:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/otlp-k8s-ingest/main/sample/app.yaml

Para apontar os aplicativos existentes que usam o SDK do OpenTelemetry no endpoint do coletor, defina a variável de ambiente OTEL_EXPORTER_OTLP_ENDPOINT como http://opentelemetry-collector.opentelemetry.svc.cluster.local:4317.

Após alguns minutos, a telemetria gerada pelo aplicativo começa a fluir pelo coletor para o console do Google Cloud para cada indicador.