Esta página foi traduzida pela API Cloud Translation.

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:

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.
Selecione a guia Biblioteca de amostra.
Selecione a categoria Coletor do OpenTelemetry.
Selecione o painel "Coletor do OpenTelemtry".
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.106.0
  googlemanagedprometheus:
    user_agent: Google-Cloud-OTLP manifests:0.1.0 otel/opentelemetry-collector-contrib:0.106.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.106.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.