Halaman ini diterjemahkan oleh Cloud Translation API.

Men-deploy OpenTelemetry Collector Buatan Google di Google Kubernetes Engine
Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Dokumen ini menjelaskan cara menjalankan OpenTelemetry Collector Buatan Google di Google Kubernetes Engine untuk mengumpulkan log, metrik, dan trace OTLP dari aplikasi berinstrumen, lalu mengekspor data tersebut ke Google Cloud.

Sebelum memulai

Untuk menjalankan OpenTelemetry Collector Buatan Google, 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 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 yang 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:
  
  Enable the APIs
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
```

Mengonfigurasi izin untuk Kolektor

Jika telah menonaktifkan identitas workload GKE, Anda dapat melewati bagian ini.

Untuk memastikan bahwa akun layanan kubernetes OpenTelemetry Collector memiliki izin yang diperlukan untuk mengekspor telemetri, minta administrator untuk memberikan akun layanan kubernetes OpenTelemetry Collector peran IAM berikut di project Anda:

Monitoring Metric Writer (roles/monitoring.metricWriter)
Logging Log Writer (roles/logging.logWriter)
Agen Cloud Trace (roles/cloudtrace.agent)

Untuk mengetahui informasi selengkapnya tentang cara memberikan peran, lihat Mengelola akses ke project, folder, dan organisasi.

Administrator Anda mungkin juga dapat memberikan izin yang diperlukan kepada akun layanan kubernetes OpenTelemetry Collector melalui peran kustom atau peran bawaan lainnya.

Untuk mengonfigurasi izin, gunakan perintah add-iam-policy-binding berikut:

gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role=roles/logging.logWriter \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector
gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role=roles/monitoring.metricWriter \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector
gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role=roles/cloudtrace.agent \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector

Sebelum menjalankan perintah, ganti variabel berikut:

PROJECT_ID: ID project.
PROJECT_NUMBER: Nomor project Google Cloud.

Men-deploy Kolektor

Pipeline Collector dapat di-deploy langsung dari contoh yang telah diperiksa dan disediakan oleh repo Proses Transfer Kubernetes OTLP Mandiri. Anda dapat men-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 -

Sebelum menjalankan perintah, ganti variabel berikut:

PROJECT_ID: ID project.

Mengonfigurasi Kolektor

Kami menyediakan konfigurasi OpenTelemetry Collector untuk Anda gunakan dengan Collector buatan Google. Konfigurasi ini dirancang untuk mengirimkan metrik, log, dan trace OTLP dengan volume tinggi dengan metadata GKE dan Kubernetes yang konsisten. Konfigurasi ini juga dirancang untuk mencegah masalah penyerapan umum. Anda dapat menambahkan ke konfigurasi, tetapi sebaiknya jangan menghapus elemen.

Bagian ini menjelaskan konfigurasi yang disediakan, komponen utama seperti eksportir, pemroses, penerima, dan komponen lain yang tersedia.

Konfigurasi Kolektor yang disediakan

Anda dapat menemukan konfigurasi Kolektor untuk lingkungan Kubernetes di repositori otlp-k8s-ingest:

# 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.2.0 OpenTelemetry Collector Built By Google/0.121.0 (linux/amd64)
  googlemanagedprometheus:
    user_agent: Google-Cloud-OTLP manifests:0.2.0 OpenTelemetry Collector Built By Google/0.121.0 (linux/amd64)

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.replicaset.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.2.0 OpenTelemetry Collector Built By Google/0.121.0 (linux/amd64)

  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")

  # The relative ordering of statements between ReplicaSet & Deployment and Job & CronJob are important.
  # The ordering of these controllers is decided based on the k8s controller documentation available at
  # https://kubernetes.io/docs/concepts/workloads/controllers.
  # The relative ordering of the other controllers in this list is inconsequential since they directly
  # create pods.
  transform/aco-gke:
    metric_statements:
    - context: datapoint
      statements:
      - set(attributes["top_level_controller_type"], "ReplicaSet") where resource.attributes["k8s.replicaset.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.replicaset.name"]) where resource.attributes["k8s.replicaset.name"] != nil
      - set(attributes["top_level_controller_type"], "Deployment") where resource.attributes["k8s.deployment.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.deployment.name"]) where resource.attributes["k8s.deployment.name"] != nil
      - set(attributes["top_level_controller_type"], "DaemonSet") where resource.attributes["k8s.daemonset.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.daemonset.name"]) where resource.attributes["k8s.daemonset.name"] != nil
      - set(attributes["top_level_controller_type"], "StatefulSet") where resource.attributes["k8s.statefulset.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.statefulset.name"]) where resource.attributes["k8s.statefulset.name"] != nil
      - set(attributes["top_level_controller_type"], "Job") where resource.attributes["k8s.job.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.job.name"]) where resource.attributes["k8s.job.name"] != nil
      - set(attributes["top_level_controller_type"], "CronJob") where resource.attributes["k8s.cronjob.name"] != nil
      - set(attributes["top_level_controller_name"], resource.attributes["k8s.cronjob.name"]) where resource.attributes["k8s.cronjob.name"] != nil

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:4317
      http:
        cors:
          allowed_origins:
          - http://*
          - https://*
        endpoint: ${env:MY_POD_IP}:4318
  otlp/self-metrics:
    protocols:
      grpc:
        endpoint: ${env:MY_POD_IP}:14317

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
      - transform/aco-gke
      - batch
      receivers:
      - otlp
    metrics/self-metrics:
      exporters:
      - googlemanagedprometheus
      processors:
      - filter/self-metrics
      - metricstransform/self-metrics
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - otlp/self-metrics
    traces:
      exporters:
      - googlecloud
      processors:
      - k8sattributes
      - memory_limiter
      - resourcedetection
      - batch
      receivers:
      - otlp
  telemetry:
    logs:
      encoding: json
    metrics:
      readers:
      - periodic:
          exporter:
            otlp:
              protocol: grpc
              endpoint: ${env:MY_POD_IP}:14317

Pengekspor

Konfigurasi Pengumpul mencakup eksportir berikut:

Pengekspor googlecloud, untuk log dan trace. Eksporter ini dikonfigurasi dengan nama log default.
Ekspor googlemanagedprometheus, untuk metrik. Eksporter ini tidak memerlukan konfigurasi apa pun, tetapi ada opsi konfigurasi. Untuk informasi tentang opsi konfigurasi untuk eksportir googlemanagedprometheus, lihat Memulai OpenTelemetry Collector dalam dokumentasi Google Cloud Managed Service for Prometheus.

Prosesor

Konfigurasi Pengumpul mencakup pemroses berikut:

batch: Dikonfigurasi untuk mengelompokkan permintaan telemetri pada Google Cloud jumlah maksimum entri per permintaan, atau pada Google Cloud interval minimum setiap 5 detik (mana saja yang tercapai lebih dahulu).
memory_limiter: Memasang batas penggunaan memori Pengumpul untuk mencegah error kehabisan memori dengan menghapus titik data saat batas terlampaui.
resourcedetection: Mendeteksi label resource Google Cloud secara otomatis seperti project_id dan cluster_name.
k8sattributes: Menautkan atribut resource Kubernetes ke label telemetri secara otomatis.
transform: Mengganti nama label metrik yang bentrok dengan label di Google Cloud resource yang dimonitor.

Penerima

Konfigurasi Pengumpul hanya menyertakan penerima otlp. Untuk informasi tentang cara melengkapi aplikasi Anda dengan instrumentasi untuk mengirim pelacakan dan metrik OTLP ke endpoint OTLP Pengumpul, lihat Memilih pendekatan instrumentasi.

Komponen yang tersedia

OpenTelemetry Collector Buatan Google berisi komponen yang diperlukan sebagian besar pengguna untuk memungkinkan pengalaman yang kaya dalam Google Cloud Observability. Untuk mengetahui daftar lengkap komponen yang tersedia, lihat Components di repositori opentelemetry-operations-collector.

Untuk meminta perubahan atau penambahan pada komponen yang tersedia, buka permintaan fitur. di repositori opentelemetry-operations-collector.

Membuat telemetri

Bagian ini menjelaskan cara men-deploy aplikasi contoh dan mengarahkan aplikasi tersebut ke endpoint OTLP Pengumpul, serta melihat telemetri diGoogle 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.

Melihat telemetri

OpenTelemetry Collector Buatan Google mengirimkan metrik, log, dan trace dari aplikasi yang diinstrumentasikan ke Google Cloud Observability. Kolektor juga mengirimkan metrik pengamatan mandiri. Bagian berikut menjelaskan cara melihat telemetri ini.

Melihat metrik

Kolektor OpenTelemetry Buatan Google mengumpulkan metrik Prometheus yang dapat Anda lihat menggunakan Metrics Explorer. Metrik yang dikumpulkan bergantung pada instrumentasi aplikasi, meskipun Pengumpul buatan Google juga menulis beberapa metrik mandiri.

Untuk melihat metrik yang dikumpulkan oleh OpenTelemetry Collector Buatan Google, lakukan tindakan berikut:

Di konsol Google Cloud, buka halaman Metrics explorer:
Buka Metrics explorer

Jika Anda menggunakan kotak penelusuran untuk menemukan halaman ini, pilih hasil yang subjudulnya adalah Monitoring.
Di toolbar konsol Google Cloud, pilih project Google Cloud Anda. Untuk konfigurasi App Hub, pilih project host App Hub atau project pengelolaan folder yang mengaktifkan aplikasi.
Pada elemen Metric, luaskan menu Select a metric, masukkan Prometheus Target di panel filter, lalu gunakan submenu untuk memilih jenis dan metrik resource tertentu:
1. Di menu Active resources, pilih Prometheus Target.
2. Untuk memilih metrik, gunakan menu Kategori metrik aktif dan Metrik aktif. Metrik yang dikumpulkan oleh OpenTelemetry Collector Buatan Google memiliki awalan prometheus.googleapis.com.
3. Klik Terapkan.
Konfigurasi cara data dilihat.
Jika pengukuran untuk metrik bersifat kumulatif, Metrics Explorer akan otomatis menormalisasi data yang diukur menurut periode penyelarasan, sehingga diagram akan menampilkan rasio. Untuk mengetahui informasi selengkapnya, lihat Jenis, tipe, dan konversi.

Saat nilai bilangan bulat atau ganda diukur, seperti dengan metrik counter, Metrics Explorer akan otomatis menjumlahkan semua deret waktu. Untuk mengubah perilaku ini, tetapkan menu pertama entri Aggregation ke None.

Untuk informasi selengkapnya tentang cara mengonfigurasi diagram, lihat Memilih metrik saat menggunakan Metrics Explorer.

Melihat trace Anda

Untuk melihat data rekaman aktivitas, lakukan hal berikut:

Di konsol Google Cloud, buka halaman Trace Explorer:
Buka Trace Explorer

Anda juga dapat menemukan halaman ini menggunakan kotak penelusuran.
Di toolbar konsol Google Cloud, pilih project Google Cloud Anda. Untuk konfigurasi App Hub, pilih project host App Hub atau project pengelolaan folder yang mengaktifkan aplikasi.
Di bagian tabel halaman, pilih baris.
Pada diagram Gantt di panel Trace details, pilih rentang.

Panel akan terbuka dan menampilkan informasi tentang permintaan yang dilacak. Detail ini mencakup metode, kode status, jumlah byte, dan agen pengguna pemanggil.
Untuk melihat log yang terkait dengan rekaman aktivitas ini, pilih tab Logs & Events.

Tab ini menampilkan setiap log. Untuk melihat detail entri log, luaskan entri log. Anda juga dapat mengklik View Logs dan melihat log menggunakan Logs Explorer.

Untuk informasi selengkapnya tentang cara menggunakan Cloud Trace Explorer, lihat Menemukan dan menjelajahi trace.

Melihat log

Dari Logs Explorer, Anda dapat memeriksa log, dan juga dapat melihat rekaman aktivitas terkait, jika ada.

Di konsol Google Cloud, buka halaman Logs Explorer:
Buka Logs Explorer

Jika Anda menggunakan kotak penelusuran untuk menemukan halaman ini, pilih hasil yang subjudulnya adalah Logging.
Temukan entri log dari aplikasi berinstrumen Anda. Untuk melihat detailnya, luaskan entri log.
Klik Traces pada entri log dengan pesan trace, lalu pilih View trace details.

Panel Trace details akan terbuka dan menampilkan rekaman aktivitas yang dipilih.

Untuk mengetahui informasi selengkapnya tentang cara menggunakan Logs Explorer, lihat Melihat log menggunakan Logs Explorer.

Mengamati dan men-debug Pengumpul

OpenTelemetry Collector Buatan Google secara otomatis memberikan metrik pengamatan mandiri untuk membantu Anda memantau performanya dan memastikan uptime berkelanjutan pipeline penyerapan OTLP.

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:

Di konsol Google Cloud, buka halaman Dasbor:
Buka Dasbor

Jika Anda menggunakan kotak penelusuran untuk menemukan halaman ini, pilih hasil yang subjudulnya adalah Monitoring.
Klik Dashboard Templates.
Telusuri dasbor OpenTelemetry Collector.
Opsional: Untuk melihat pratinjau dasbor, pilih dasbor.
Klik Tambahkan dasbor ke daftar Anda, lalu selesaikan dialog.

Dialog ini memungkinkan Anda memilih nama dasbor, dan menambahkan label ke dasbor.

Untuk informasi selengkapnya tentang cara menginstal dasbor, lihat Menginstal template dasbor.