Belajar OpenTelemetry - Pre-Requisites Skill & Setup Environment

#Pendahuluan

Selamat datang di series Belajar OpenTelemetry! Series ini akan membawa kalian menguasai OpenTelemetry (OTel) — framework observability vendor-neutral milik CNCF yang sudah graduated sejak Mei 2026 — untuk traces, metrics, dan logs dalam satu pipeline. Total ada 23 episode yang tersusun dalam enam fase, dari fondasi konsep sampai production readiness.

Sebelum menjalankan OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317 atau menginstrumentasi service pertama, ada skill dasar dan perangkat yang wajib kalian siapkan. Mengapa prasyarat ini penting? Karena OpenTelemetry bukan "satu tool" — ia adalah ekosistem: SDK di dalam aplikasi, Collector sebagai router data, dan backend yang menyimpan serta menampilkan telemetry. Tanpa memahami ketiga lapis ini, kalian akan kesulitan membedakan masalah di instrumentasi, di pipeline, atau di backend.

Episode 0 ini adalah peta jalan kalian: kita akan memastikan skill dasar terpenuhi, menyiapkan Docker dan runtime, lalu memverifikasi environment dengan stack telemetry pertama yang selalu berjalan di series ini.

#Skill Dasar yang Wajib Dimiliki

#Microservices & API (HTTP/gRPC)

OTel lahir dari dunia microservices. Kalian wajib memahami cara satu service memanggil service lain lewat HTTP atau gRPC, status code, dan header — karena context propagation (episode 4 dan 15) berjalan di atas header HTTP seperti traceparent. Tanpa pemahaman ini, korelasi trace lintas service akan terasa seperti sihir.

#Dasar Observability: Metrics, Logs, Traces

Inilah "three pillars" yang menjadi bahan baku OTel:

• Logs — catatan kejadian diskrit dengan timestamp (2026-08-16T12:00:00Z ERROR payment failed).
• Metrics — agregasi angka (counter, histogram) seperti http.server.request.duration.
• Traces — perjalanan satu request melewati banyak service, direpresentasikan sebagai kumpulan span yang tersambung.

Episode 2 akan membedah definisi ini lebih dalam; di sini cukup pahami perbedaan alaminya.

#Container & Docker

Hampir seluruh lab series ini dijalankan dengan Docker Compose — termasuk Collector dan backend. Kalian wajib nyaman dengan docker compose up, port mapping, dan network antar-container.

#Satu Bahasa Pemrograman

Series ini memakai Python untuk contoh instrumentasi karena SDK-nya paling sederhana dan mendukung auto-instrumentation yang kaya. Jika kalian lebih nyaman dengan Go/JavaScript/Java, konsepnya tetap identik — hanya sintaks SDK yang berbeda.

docker --version
docker compose version
python3 --version

Pastikan Docker versi modern dan Python 3.12+ terinstall.

#Perangkat Software yang Disiapkan

#Backend Penerima OTLP: Jaeger

Jaeger adalah backend tracing paling ringan untuk belajar. Ia menerima data lewat OTLP dan menampilkannya di UI web. Image-nya: jaegertracing/jaeger.

#OpenTelemetry Collector

Collector adalah router data yang menerima telemetry dari SDK lalu mengirimnya ke backend. Untuk series ini kita pakai image otel/opentelemetry-collector-contrib karena kaya processor dan receiver. Kita bedah arsitekturnya di episode 9-14.

#Stack Observability: docker-compose.yml

Buat folder lab, lalu simpan file berikut:

services:
  jaeger:
    image: jaegertracing/jaeger:2.13.0
    ports:
      - "16686:16686"   # UI Jaeger
    environment:
      - COLLECTOR_OTLP_ENABLED=true
 
  collector:
    image: otel/opentelemetry-collector-contrib:0.156.0
    command: ["--config=/etc/otelcol-contrib/config.yaml"]
    volumes:
      - ./config.yaml:/etc/otelcol-contrib/config.yaml
    ports:
      - "4317:4317"     # OTLP/gRPC
      - "4318:4318"     # OTLP/HTTP
      - "8888:8888"     # metrics collector sendiri
    depends_on:
      - jaeger

Bersamaan dengan itu, buat konfigurasi Collector minimal:

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318
 
processors:
  batch:
 
exporters:
  otlp/jaeger:
    endpoint: jaeger:4317
    tls:
      insecure: true
  debug:
    verbosity: basic
 
service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlp/jaeger]
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [debug]
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [debug]

Catatan penting: pipeline traces menerima lewat otlp lalu mengirim ke Jaeger, sedangkan metrics dan logs cukup di-debug dulu ke terminal — kita fokus tracing di fase awal.

#Verifikasi Environment

Jalankan stack dan periksa semua service hidup:

cd ~/otel-lab
docker compose up -d
docker compose ps
curl -s localhost:4318/v1/traces -o /dev/null -w "%{http_code}\n"

curl -s localhost:4318/v1/traces akan mengembalikan 415 (Unsupported Media Type) karena kita tidak mengirim protobuf — itu justru tanda OTLP endpoint HTTP aktif dan menerima koneksi. Periksa juga UI Jaeger di http://localhost:16686; halaman harus terbuka walau belum ada trace.

Terakhir, verifikasi exporter SDK Python agar siap di episode 3:

python3 -m venv ~/otel-lab/venv
source ~/otel-lab/venv/bin/activate
pip install opentelemetry-sdk opentelemetry-api opentelemetry-exporter-otlp-proto-grpc opentelemetry-instrumentation

#Ringkasan Prasyarat

Rangkuman yang sudah kalian siapkan di episode 0:

• Skill: microservices & HTTP/gRPC, tiga pilar observability, Docker, dan satu bahasa (Python).
• Lab: folder ~/otel-lab dengan docker-compose.yml + config.yaml.
• Stack: Jaeger (2.13.0) dan collector contrib (0.156.0) berjalan via Compose.
• Verifikasi: docker compose ps sehat, OTLP/HTTP merespons di 4318, UI Jaeger terbuka, SDK Python terinstall.

Jika ada yang belum terpenuhi, berhenti dulu dan lengkapi sebelum melanjutkan. Perjalanan 22 episode ke depan akan jauh lebih lancar dengan pijakan yang kuat ini.

#Penutup

Inti yang harus dibawa pulang:

• OTel bekerja di tiga lapis: SDK (di aplikasi), Collector (router), dan backend (penyimpan + UI).
• Siapkan Docker Compose dengan Jaeger + collector contrib; pin versi image, jangan :latest.
• OTLP punya dua jalur: gRPC 4317 dan HTTP 4318.
• Verifikasi endpoint OTLP dengan curl dan install SDK Python sebelum melangkah.

Di episode 1 selanjutnya kita akan membahas sejarah, latar belakang, dan mengapa membutuhkan OpenTelemetry — dari perpecahan OpenTracing vs OpenCensus, merger pada 2019, status incubating 2021, hingga resmi graduated Mei 2026 sebagai standard observability de facto. Pastikan environment kalian sudah siap, karena perjalanan Belajar OpenTelemetry baru saja dimulai!