Men-deploy OpenTelemetry Collector di Google Kubernetes Engine

Dokumen ini menunjukkan cara menjalankan OpenTelemetry Collector di cluster GKE untuk mengumpulkan log, metrik, dan trace OTLP dari aplikasi berinstrumen dan mengekspor data tersebut ke Google Cloud.

Sebelum memulai

Untuk menjalankan OpenTelemetry Collector di GKE, Anda memerlukan resource berikut:

  • Project Google Cloud dengan Cloud Monitoring API, Cloud Trace API, dan Cloud Logging API diaktifkan.

    • Jika Anda tidak memiliki project Google Cloud, lakukan hal berikut:

      1. Di konsol Google Cloud, buka New Project:

        Membuat Project Baru

      2. Di kolom Project Name, masukkan nama untuk project Anda, lalu klik Create.

      3. Buka Penagihan:

        Buka Penagihan

      4. Pilih project yang baru saja Anda buat jika belum dipilih di bagian atas halaman.

      5. Anda akan diminta untuk memilih profil pembayaran yang sudah ada atau membuat profil baru.

      Monitoring API, Trace API, dan Logging API diaktifkan secara default untuk project baru.

    • Jika Anda sudah memiliki project Google Cloud, pastikan Monitoring API, Trace API, dan Logging API diaktifkan:

      1. Buka API & layanan:

        Buka API & layanan

      2. Pilih project Anda.

      3. Klik  Aktifkan API dan layanan.

      4. Telusuri setiap API berdasarkan namanya.

      5. Di hasil penelusuran, klik API yang disebutkan. Monitoring API akan muncul sebagai "Stackdriver Monitoring API".

      6. Jika "API enabled" tidak ditampilkan, klik tombol Enable.

  • Cluster Kubernetes. Jika Anda tidak memiliki cluster Kubernetes, ikuti petunjuk di Memulai cepat untuk GKE.

  • Alat command line berikut:

    • gcloud
    • kubectl

    Alat gcloud dan kubectl adalah bagian dari Google Cloud CLI. Untuk mengetahui informasi tentang cara menginstalnya, lihat Mengelola komponen Google Cloud CLI. Untuk melihat komponen gcloud CLI yang telah Anda instal, jalankan perintah berikut:

    gcloud components list

Men-deploy Pengumpul

Pipeline Collector dapat di-deploy langsung dari GitHub dengan perintah berikut setelah mengganti PROJECT_ID dengan ID project Google Cloud Anda:

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

Mengamati dan men-debug Pengumpul

OpenTelemetry Collector menyediakan metrik pengamatan mandiri secara langsung untuk membantu Anda memantau performanya dan memastikan waktu aktif pipeline penyerapan OTLP terus berlanjut.

Untuk memantau Kolektor, instal contoh dasbor untuk Kolektor. Dasbor ini menawarkan insight sekilas tentang beberapa metrik dari Pengumpul, termasuk waktu aktif, penggunaan memori, dan panggilan API ke Google Cloud Observability.

Untuk menginstal dasbor, lakukan hal berikut:

  1. Di konsol Google Cloud, buka halaman  Dasbor:

    Buka Dasbor

    Jika Anda menggunakan kotak penelusuran untuk menemukan halaman ini, pilih hasil yang subjudulnya adalah Monitoring.

  2. Pilih tab Sample Library.
  3. Pilih kategori OpenTelemetry Collector.
  4. Pilih dasbor "OpenTelemetry Collector".
  5. Klik  Impor.

Untuk mengetahui informasi selengkapnya tentang proses penginstalan, lihat Menginstal contoh dasbor.

Mengonfigurasi Pengumpul

Pipeline transfer OTLP mandiri mencakup konfigurasi OpenTelemetry Collector default yang dirancang untuk mengirimkan metrik, log, dan trace OTLP dalam volume tinggi dengan metadata GKE dan Kubernetes yang konsisten. Alat ini juga dirancang untuk mencegah masalah penyerapan umum.

Namun, Anda mungkin memiliki kebutuhan unik yang memerlukan penyesuaian konfigurasi default. Bagian ini menjelaskan setelan default yang dikirimkan dengan pipeline dan cara Anda dapat menyesuaikan setelan default tersebut agar sesuai dengan kebutuhan Anda.

Konfigurasi Pengumpul default terletak di GitHub sebagai 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

Pengekspor

Pengekspor default mencakup pengekspor googlecloud (untuk log dan rekaman aktivitas) dan pengekspor googlemanagedprometheus (untuk metrik).

Pengekspor googlecloud dikonfigurasi dengan nama log default. Ekspor googlemanagedprometheus tidak memerlukan konfigurasi default apa pun; lihat Memulai Pengumpul OpenTelemetry dalam dokumentasi Google Cloud Managed Service for Prometheus untuk mengetahui informasi selengkapnya tentang mengonfigurasi eksportir ini.

Prosesor

Konfigurasi default mencakup pemroses berikut:

  • batch: Dikonfigurasi untuk mengelompokkan permintaan telemetri dengan jumlah entri maksimum Google Cloud per permintaan, atau dengan interval minimum Google Cloud setiap 5 detik (mana saja yang lebih dulu).
  • k8sattributes: Menautkan atribut resource Kubernetes ke label telemetri secara otomatis.
  • memory_limiter: Membatasi penggunaan memori Collector pada tingkat yang wajar untuk mencegah error karena kehabisan memori dengan menghapus titik data di luar tingkat ini.
  • resourcedetection: Mendeteksi label resource Google Cloud secara otomatis seperti nama cluster dan project ID.
  • transform: Mengganti nama label metrik yang akan bentrok dengan kolom resource yang dipantau Google Cloud.

Penerima

Konfigurasi default hanya menyertakan penerima otlp. Lihat Memilih pendekatan instrumentasi untuk mendapatkan petunjuk mendetail tentang cara melakukan instrumentasi aplikasi untuk mendorong pelacakan dan metrik OTLP ke endpoint OTLP Pengumpul.

Langkah berikutnya: mengumpulkan dan melihat telemetri

Bagian ini menjelaskan cara men-deploy aplikasi contoh dan mengarahkan aplikasi tersebut ke endpoint OTLP Pengumpul, serta melihat telemetri di Google Cloud. Aplikasi contoh adalah generator kecil yang mengekspor rekaman aktivitas, log, dan metrik ke Kolektor.

Jika sudah memiliki aplikasi yang dilengkapi dengan OpenTelemetry SDK, Anda dapat mengarahkan aplikasi ke endpoint Pengumpul.

Untuk men-deploy aplikasi contoh, jalankan perintah berikut:

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

Untuk mengarahkan aplikasi yang ada yang menggunakan OpenTelemetry SDK ke endpoint Collector, tetapkan variabel lingkungan OTEL_EXPORTER_OTLP_ENDPOINT ke http://opentelemetry-collector.opentelemetry.svc.cluster.local:4317.

Setelah beberapa menit, telemetri yang dihasilkan oleh aplikasi mulai mengalir melalui Collector ke konsol Google Cloud untuk setiap sinyal.