Informasi rekaman aktivitas instrumen menggunakan OpenTelemetry

1. Pengantar

Terakhir Diperbarui: 05-03-2021

Kemampuan observasi aplikasi

Kemampuan observasi dan OpenTelemetry

Kemampuan observasi adalah istilah yang digunakan untuk mendeskripsikan atribut sistem. Sistem dengan kemampuan observasi memungkinkan tim men-debug sistem mereka secara aktif. Dalam konteks tersebut, tiga pilar observabilitas, yaitu log, metrik, dan rekaman aktivitas, adalah instrumentasi mendasar bagi sistem untuk mendapatkan observabilitas.

OpenTelemetry adalah serangkaian spesifikasi dan SDK yang mempercepat instrumentasi dan ekspor data telemetri (log, metrik, dan trace) yang diperlukan untuk kemampuan observasi. OpenTelemetry adalah project yang didorong komunitas dan standar terbuka di bawah CNCF. Dengan memanfaatkan library yang disediakan project dan ekosistemnya, developer dapat menginstrumentasikan aplikasi mereka dengan cara yang netral terhadap vendor dan terhadap beberapa arsitektur.

Distributed Trace

Di antara log, metrik, dan rekaman aktivitas, rekaman aktivitas adalah telemetri yang menunjukkan latensi bagian tertentu dari proses dalam sistem. Terutama di era microservice, pelacakan terdistribusi adalah pendorong yang kuat untuk mengetahui hambatan latensi dalam sistem terdistribusi secara keseluruhan.

Saat menganalisis rekaman aktivitas terdistribusi, visualisasi data rekaman aktivitas adalah kunci untuk memahami latensi sistem secara keseluruhan dalam sekejap. Dalam pelacakan terdistribusi, kami menangani serangkaian panggilan untuk memproses satu permintaan ke titik entri sistem dalam bentuk Pelacakan yang berisi beberapa Rentang.

Rentang mewakili setiap unit pekerjaan yang dilakukan dalam sistem terdistribusi, yang mencatat waktu mulai dan berhenti. Rentang sering kali memiliki hubungan hierarkis satu sama lain - dalam gambar di bawah, semua rentang yang lebih kecil adalah rentang turunan dari rentang /messages yang besar, dan dikumpulkan menjadi satu Rekaman Aktivitas yang menunjukkan jalur kerja melalui sistem.

Google Cloud Trace adalah salah satu opsi untuk backend pelacakan terdistribusi dan terintegrasi dengan baik dengan produk lain di Google Cloud.

Yang akan Anda bangun

Dalam codelab ini, Anda akan menginstrumentasi informasi rekaman aktivitas di layanan yang disebut "Shakesapp" yang berjalan di cluster Kubernetes yang berjalan di Google Kubernetes Engine. Arsitektur Shakesapp adalah seperti yang dijelaskan di bawah ini:

• Klien mengirimkan string kueri ke server
• Server menerima kueri dari klien, mengambil semua karya Shakespeare dalam format teks dari Google Cloud Storage, menelusuri baris yang berisi kueri, dan menampilkan nomor baris yang cocok kepada klien.

Anda akan menginstrumentasi informasi rekaman aktivitas di seluruh permintaan.

Yang akan Anda pelajari

• Cara mulai menggunakan library Trace OpenTelemetry di project Python
• Cara membuat rentang dengan library
• Cara menyebarkan konteks rentang melalui jaringan antara komponen aplikasi
• Cara mengirim data rekaman aktivitas ke Google Cloud Trace
• Cara menganalisis rekaman aktivitas di Google Cloud Trace

Codelab ini menjelaskan cara menginstrumentasi microservice Anda. Agar mudah dipahami, contoh ini hanya berisi 3 komponen (generator beban, klien, dan server), tetapi Anda dapat menerapkan proses yang sama yang dijelaskan dalam codelab ini ke sistem yang lebih kompleks dan besar.

Yang Anda butuhkan

• Pengetahuan tentang Python 3

2. Penyiapan dan Persyaratan

Penyiapan lingkungan mandiri

Jika belum memiliki Akun Google (Gmail atau Google Apps), Anda harus membuatnya. Login ke Google Cloud Platform console (console.cloud.google.com) dan buat project baru.

Jika Anda sudah memiliki project, klik menu pull-down pilihan project di kiri atas konsol:

dan klik tombol 'PROJECT BARU' dalam dialog yang dihasilkan untuk membuat project baru:

Jika belum memiliki project, Anda akan melihat dialog seperti ini untuk membuat project pertama:

Dialog pembuatan project berikutnya memungkinkan Anda memasukkan detail project baru:

Ingat project ID yang merupakan nama unik di semua project Google Cloud (maaf, nama di atas telah digunakan dan tidak akan berfungsi untuk Anda!) Project ID tersebut selanjutnya akan dirujuk di codelab ini sebagai PROJECT_ID.

Selanjutnya, jika Anda belum melakukannya, Anda harus mengaktifkan penagihan di Developers Console untuk menggunakan resource Google Cloud dan mengaktifkan Cloud Trace API.

Menjalankan melalui codelab ini tidak akan menghabiskan biaya lebih dari beberapa dolar, tetapi bisa lebih jika Anda memutuskan untuk menggunakan lebih banyak resource atau jika Anda membiarkannya berjalan (lihat bagian "pembersihan" di akhir dokumen ini). Harga Google Cloud Trace, Google Kubernetes Engine, dan Google Artifact Registry tercantum dalam dokumentasi resmi.

• Harga untuk Google Cloud Observability
• Harga | Dokumentasi Kubernetes Engine
• Harga Artifact Registry | Dokumentasi Artifact Registry

Pengguna baru Google Cloud Platform memenuhi syarat untuk mendapatkan uji coba gratis senilai $300, yang menjadikan codelab ini sepenuhnya gratis.

Penyiapan Google Cloud Shell

Meskipun Google Cloud dan Google Cloud Trace dapat dioperasikan dari jarak jauh menggunakan laptop Anda, dalam codelab ini, kita akan menggunakan Google Cloud Shell, lingkungan command line yang berjalan di Cloud.

Mesin virtual berbasis Debian ini memuat semua alat pengembangan yang akan Anda perlukan. Layanan ini menawarkan direktori beranda tetap sebesar 5 GB dan beroperasi di Google Cloud, sehingga sangat meningkatkan performa dan autentikasi jaringan. Ini berarti bahwa semua yang Anda perlukan untuk codelab ini adalah browser (ya, ini berfungsi di Chromebook).

Untuk mengaktifkan Cloud Shell dari Cloud Console, cukup klik Aktifkan Cloud Shell (hanya perlu beberapa saat untuk melakukan penyediaan dan terhubung ke lingkungan).

Setelah terhubung ke Cloud Shell, Anda akan melihat bahwa Anda sudah diautentikasi dan project sudah ditetapkan ke PROJECT_ID.

gcloud auth list

Output perintah

Credentialed accounts:
 - <myaccount>@<mydomain>.com (active)

Catatan: Alat command line gcloud sudah terinstal di Cloud Shell dan Anda pasti akan menikmati dukungannya untuk penyelesaian tab. Untuk mengetahui informasi selengkapnya, lihat ringkasan alat command line gcloud.

gcloud config list project

Output perintah

[core]
project = <PROJECT_ID>

Jika, untuk beberapa alasan, project belum disetel, cukup jalankan perintah berikut:

gcloud config set project <PROJECT_ID>

Mencari PROJECT_ID Anda? Periksa ID yang Anda gunakan di langkah-langkah penyiapan atau cari di dasbor Cloud Console:

Cloud Shell juga menetapkan beberapa variabel lingkungan secara default, yang mungkin berguna saat Anda menjalankan perintah di masa mendatang.

echo $GOOGLE_CLOUD_PROJECT

Output perintah

<PROJECT_ID>

Terakhir, tetapkan zona dan konfigurasi project default.

gcloud config set compute/zone us-central1-f

Anda dapat memilih berbagai zona yang berbeda. Untuk informasi selengkapnya, lihat Region & Zona.

Catatan: Saat Anda menjalankan gcloud di komputer Anda sendiri, setelan konfigurasi akan tetap ada di seluruh sesi. Namun di Cloud Shell, Anda perlu menyetelnya untuk setiap sesi atau sambungan ulang baru.

Penyiapan Python

Dalam codelab ini, kita menggunakan "poetry" untuk mengelola versi paket secara ketat. Jalankan perintah berikut di Cloud Shell:

curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python3 -
source $HOME/.poetry/env

Menyiapkan Cluster Google Kubernetes

Dalam codelab ini, Anda akan menjalankan cluster microservice di Google Kubernetes Engine (GKE). Proses codelab ini adalah sebagai berikut:

1. Download project dasar ke Cloud Shell
2. Membangun microservice ke dalam container
3. Mengupload container ke Google Artifact Registry (GAR)
4. Men-deploy container ke GKE
5. Ubah kode sumber layanan untuk instrumentasi pelacakan
6. Lanjutkan ke langkah 2

Aktifkan Kubernetes Engine

Pertama, kita menyiapkan cluster Kubernetes tempat Shakesapp berjalan di GKE, jadi kita perlu mengaktifkan GKE. Buka menu "Kubernetes Engine" dan tekan tombol AKTIFKAN.

Sekarang Anda siap membuat cluster Kubernetes.

Membuat cluster Kubernetes

Di Cloud Shell, jalankan perintah berikut untuk membuat cluster Kubernetes. Pastikan nilai zona berada di bawah region yang telah Anda gunakan untuk pembuatan repositori Artifact Registry. Ubah nilai zona us-central1-f jika region repositori Anda tidak mencakup zona tersebut.

gcloud container clusters create otel-trace-codelab --zone us-central1-f \
--num-nodes 1 \
--machine-type e2-highcpu-4

Output perintah

Creating cluster otel-trace-codelab in us-central1-f... Cluster is being health-checked (master is healthy)...done.
Created [https://container.googleapis.com/v1/projects/psychic-order-307806/zones/us-central1-f/clusters/otel-trace-codelab].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/us-central1-f/otel-trace-codelab?project=psychic-order-307806
kubeconfig entry generated for otel-trace-codelab.
NAME                LOCATION       MASTER_VERSION    MASTER_IP        MACHINE_TYPE  NODE_VERSION      NUM_NODES  STATUS
otel-trace-codelab  us-central1-f  1.18.12-gke.1210  104.154.162.176  e2-medium     1.18.12-gke.1210  3          RUNNING

Penyiapan Artifact Registry dan skaffold

Sekarang kita memiliki cluster Kubernetes yang siap untuk di-deploy. Selanjutnya, kita menyiapkan container registry untuk mengirim dan men-deploy container. Untuk langkah ini, kita perlu menyiapkan GAR dan skaffold untuk menggunakannya.

Penyiapan Artifact Registry

Buka menu "Artifact Registry" dan tekan tombol AKTIFKAN.

Setelah beberapa saat, Anda akan melihat browser repositori GAR. Klik tombol "CREATE REPOSITORY" dan masukkan nama repositori.

Dalam codelab ini, saya menamai repositori baru dengan trace-codelab. Format artefak adalah "Docker" dan jenis lokasi adalah "Region". Pilih region yang dekat dengan region yang Anda tetapkan untuk zona default Google Compute Engine. Misalnya, contoh ini memilih "us-central1-f" di atas, jadi di sini kita memilih "us-central1 (Iowa)". Kemudian, klik tombol "BUAT".

Sekarang Anda melihat "trace-codelab" di browser repositori.

Kita akan kembali ke sini nanti untuk memeriksa jalur registri.

Penyiapan Skaffold

Skaffold adalah alat praktis saat Anda mengerjakan pembangunan microservice yang berjalan di Kubernetes. Hal ini menangani alur kerja pembuatan, mengirim, dan men-deploy container aplikasi dengan serangkaian kecil perintah. Secara default, Skaffold menggunakan Docker Registry sebagai registry container, jadi Anda perlu mengonfigurasi Skaffold agar mengenali GAR saat mengirim container ke.

Buka kembali Cloud Shell dan konfirmasi apakah skaffold sudah diinstal. (Cloud Shell menginstal skaffold ke lingkungan secara default.) Jalankan perintah berikut dan lihat versi skaffold.

skaffold version

Output perintah

v1.20.0

Catatan: Jika Anda menjalankan codelab di lingkungan di luar Cloud Shell, Anda perlu menginstal skaffold sendiri. gcloud components install memungkinkan Anda menginstal skaffold.

Sekarang, Anda dapat mendaftarkan repositori default untuk digunakan skaffold. Untuk mendapatkan jalur registri, buka dasbor Artifact Registry dan klik nama repositori yang baru saja Anda siapkan di langkah sebelumnya.

Kemudian, Anda akan melihat jejak breadcrumb di bagian atas halaman. Klik ikon untuk menyalin jalur registri ke papan klip.

Saat mengklik tombol salin, Anda akan melihat dialog di bagian bawah browser dengan pesan seperti:

"us-central1-docker.pkg.dev/psychic-order-307806/trace-codelab" telah disalin

Kembali ke cloud shell. Jalankan perintah skaffold config set default-repo dengan nilai yang baru saja Anda salin dari dasbor.

skaffold config set default-repo us-central1-docker.pkg.dev/psychic-order-307806/trace-codelab

Output perintah

set value default-repo to us-central1-docker.pkg.dev/psychic-order-307806/trace-codelab for context gke_stackdriver-sandbox-3438851889_us-central1-b_stackdriver-sandbox

Selain itu, Anda perlu mengonfigurasi registry ke konfigurasi Docker. Jalankan perintah berikut:

gcloud auth configure-docker us-central1-docker.pkg.dev --quiet

Output perintah

{
  "credHelpers": {
    "gcr.io": "gcloud",
    "us.gcr.io": "gcloud",
    "eu.gcr.io": "gcloud",
    "asia.gcr.io": "gcloud",
    "staging-k8s.gcr.io": "gcloud",
    "marketplace.gcr.io": "gcloud",
    "us-central1-docker.pkg.dev": "gcloud"
  }
}
Adding credentials for: us-central1-docker.pkg.dev

Sekarang Anda siap melanjutkan ke langkah berikutnya untuk menyiapkan container Kubernetes di GKE.

Ringkasan

Pada langkah ini, Anda akan menyiapkan lingkungan codelab:

• Menyiapkan Cloud Shell
• Membuat repositori Artifact Registry untuk registry container
• Menyiapkan Skaffold untuk menggunakan container registry
• Membuat cluster Kubernetes tempat microservice codelab berjalan

Berikutnya

Pada langkah berikutnya, Anda akan mem-build, mengirim, dan men-deploy microservice ke cluster

3. Membangun, mengirim, dan men-deploy microservice

Download materi codelab

Pada langkah sebelumnya, kita telah menyiapkan semua prasyarat untuk codelab ini. Sekarang Anda siap menjalankan seluruh microservice di atasnya. Materi codelab dihosting di GitHub, jadi download ke lingkungan Cloud Shell dengan perintah git berikut.

cd ~
git clone https://github.com/GoogleCloudPlatform/opentelemetry-trace-codelab-python.git

Struktur direktori project adalah sebagai berikut:

shakesapp-python
├── LICENSE
├── manifests
│   ├── client.yaml
│   ├── loadgen.yaml
│   └── server.yaml
├── proto
│   └── shakesapp.proto
├── skaffold.yaml
└── src
    ├── client
    ├── loadgen
    └── server

• manifes: File manifes Kubernetes
• proto: definisi proto untuk komunikasi antara klien dan server
• src: direktori untuk kode sumber setiap layanan
• skaffold.yaml: File konfigurasi untuk skaffold

Jalankan perintah skaffold

Terakhir, Anda siap membangun, mengirim, dan men-deploy seluruh konten ke cluster Kubernetes yang baru saja Anda buat. Terdengar seperti berisi beberapa langkah, tetapi sebenarnya skaffold melakukan semuanya untuk Anda. Mari kita coba dengan perintah berikut:

cd shakesapp-python
skaffold run --tail

Segera setelah menjalankan perintah, Anda akan melihat output log docker build dan dapat mengonfirmasi bahwa image berhasil di-push ke registry.

Output perintah

...
---> Running in c39b3ea8692b
 ---> 90932a583ab6
Successfully built 90932a583ab6
Successfully tagged us-central1-docker.pkg.dev/psychic-order-307806/trace-codelab/serverservice:step1
The push refers to repository [us-central1-docker.pkg.dev/psychic-order-307806/trace-codelab/serverservice]
cc8f5a05df4a: Preparing
5bf719419ee2: Preparing
2901929ad341: Preparing
88d9943798ba: Preparing
b0fdf826a39a: Preparing
3c9c1e0b1647: Preparing
f3427ce9393d: Preparing
14a1ca976738: Preparing
f3427ce9393d: Waiting
14a1ca976738: Waiting
3c9c1e0b1647: Waiting
b0fdf826a39a: Layer already exists
88d9943798ba: Layer already exists
f3427ce9393d: Layer already exists
3c9c1e0b1647: Layer already exists
14a1ca976738: Layer already exists
2901929ad341: Pushed
5bf719419ee2: Pushed
cc8f5a05df4a: Pushed
step1: digest: sha256:8acdbe3a453001f120fb22c11c4f6d64c2451347732f4f271d746c2e4d193bbe size: 2001

Setelah semua container layanan di-push, deployment Kubernetes akan dimulai secara otomatis.

Output perintah

sha256:b71fce0a96cea08075dc20758ae561cf78c83ff656b04d211ffa00cedb77edf8 size: 1997
Tags used in deployment:
 - serverservice -> us-central1-docker.pkg.dev/psychic-order-307806/trace-codelab/serverservice:step4@sha256:8acdbe3a453001f120fb22c11c4f6d64c2451347732f4f271d746c2e4d193bbe
 - clientservice -> us-central1-docker.pkg.dev/psychic-order-307806/trace-codelab/clientservice:step4@sha256:b71fce0a96cea08075dc20758ae561cf78c83ff656b04d211ffa00cedb77edf8
 - loadgen -> us-central1-docker.pkg.dev/psychic-order-307806/trace-codelab/loadgen:step4@sha256:eea2e5bc8463ecf886f958a86906cab896e9e2e380a0eb143deaeaca40f7888a
Starting deploy...
 - deployment.apps/clientservice created
 - service/clientservice created
 - deployment.apps/loadgen created
 - deployment.apps/serverservice created
 - service/serverservice created

Perhatian: Jika Anda mendapatkan error seperti "No push access to specified image repository", periksa apakah perintah skaffold mencoba mengirim image ke Docker Hub (docker.io) terlepas dari konfigurasi Anda di repo default di skaffold. Dalam hal ini, coba tambahkan opsi "–default-repo" ke "skaffold run" seperti di bawah.

$ skaffold run –tail –default-repo=us-central1-docker.pkg.dev/[project ID]/[repository name]

Setelah deployment, Anda akan melihat log aplikasi sebenarnya yang dikeluarkan ke stdout di setiap container seperti ini:

Output perintah

[server] {"event": "starting server: 0.0.0.0:5050", "severity": "info", "timestamp": "2021-03-17T05:25:56.758575Z"}
[client] [2021-03-17 05:25:54 +0000] [1] [INFO] Starting gunicorn 20.0.4
[client] [2021-03-17 05:25:54 +0000] [1] [INFO] Listening at: http://0.0.0.0:8080 (1)
[client] [2021-03-17 05:25:54 +0000] [1] [INFO] Using worker: threads
[client] [2021-03-17 05:25:54 +0000] [7] [INFO] Booting worker with pid: 7
[client] {"event": "server address is serverservice:5050", "severity": "info", "timestamp": "2021-03-17T05:25:54.888627Z"}
[client] {"event": "request to server with query: world", "severity": "info", "timestamp": "2021-03-17T05:26:11.550923Z"}
[server] {"event": "query: world", "severity": "info", "timestamp": "2021-03-17T05:26:11.567048Z"}
[loadgen] {"event": "check connectivity: http://clientservice:8080/_healthz", "severity": "info", "timestamp": "2021-03-17T05:26:11.533605Z"}
[loadgen] {"event": "/_healthz response: ok", "severity": "info", "timestamp": "2021-03-17T05:26:11.544267Z"}
[loadgen] {"event": "confirmed connection ot clientservice", "severity": "info", "timestamp": "2021-03-17T05:26:11.544527Z"}

Terakhir, Anda siap untuk mulai menginstrumentasi aplikasi dengan OpenTelemetry untuk pelacakan terdistribusi layanan.

Ringkasan

Pada langkah ini, Anda telah menyiapkan materi codelab di lingkungan Anda dan mengonfirmasi bahwa skaffold berjalan seperti yang diharapkan.

Berikutnya

Pada langkah berikutnya, Anda akan mengubah kode sumber layanan loadgen untuk menginstrumentasi informasi rekaman aktivitas.

4. Instrumentasi untuk HTTP

Konsep instrumentasi dan propagasi rekaman aktivitas

Sebelum mengedit kode sumber, kami akan menjelaskan secara singkat cara kerja rekaman aktivitas terdistribusi dalam diagram sederhana.

Dalam contoh ini, kita menginstrumentasikan kode untuk mengekspor informasi Trace dan Span ke Cloud Trace serta memperluas konteks trace di seluruh permintaan dari layanan loadgen ke layanan server.

Aplikasi perlu mengirim metadata Trace seperti ID Trace dan ID Span agar Cloud Trace dapat mengumpulkan semua span yang memiliki ID Trace yang sama menjadi satu trace. Selain itu, aplikasi perlu menyebarkan konteks rekaman aktivitas (kombinasi ID Rekaman Aktivitas dan ID Span dari span induk) saat meminta layanan hilir, sehingga layanan tersebut dapat mengetahui konteks rekaman aktivitas yang sedang ditanganinya.

OpenTelemetry membantu Anda:

• untuk membuat ID Aktivitas dan ID Rentang yang unik
• untuk mengekspor Trace ID dan Span ID ke backend
• untuk menyebarkan konteks rekaman aktivitas ke layanan lain

Span pertama instrumen

Mengukur layanan pembuat beban

Buka Cloud Shell Editor dengan menekan tombol di kanan atas Cloud Shell. Buka src/loadgen/loadgen.py dari penjelajah di panel kiri dan temukan fungsi main.

src/loadgen/loadgen.py

def main():
    ...
    # start request loop to client service
    logger.info("start client request loop")
    addr = f"http://{target}"
    while True:
        logger.info("start request to client")
        call_client(addr)
        logger.info("end request to client")
        time.sleep(2.0)

Dalam fungsi main, Anda melihat loop yang memanggil fungsi call_client di dalamnya. Dalam penerapan saat ini, bagian ini memiliki 2 baris log yang mencatat awal dan akhir panggilan fungsi. Sekarang, mari kita instrumentasikan informasi Span untuk melacak latensi panggilan fungsi.

Pertama, Anda perlu membuat Span dengan ID Aktivitas dan ID Span yang unik. OpenTelemetry menyediakan library praktis untuk hal ini. Tambahkan baris berikut untuk mengimpor library OpenTelemetry ke dalam kode Anda.

 import structlog
+from opentelemetry import propagate, trace
+from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.instrumentation.requests import RequestsInstrumentor
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.propagators.cloud_trace_propagator import CloudTraceFormatPropagator

Karena generator beban memanggil aplikasi klien di HTTP melalui modul requests, kita menggunakan paket ekstensi untuk requests dan mengaktifkan instrumentasi.

 from opentelemetry.propagators.cloud_trace_propagator import CloudTraceFormatPropagator
+
+RequestsInstrumentor().instrument()

Kemudian, siapkan instance Tracer yang menangani setelan Trace Context dan eksportir

     target = os.environ.get("CLIENT_ADDR", "0.0.0.0:8080")

+    exporter = CloudTraceSpanExporter()
+    trace.get_tracer_provider().add_span_processor(SimpleSpanProcessor(exporter))
+    tracer = trace.get_tracer(__name__)
+    propagate.set_global_textmap(CloudTraceFormatPropagator())
+    trace.set_tracer_provider(TracerProvider())
+
     # connectivity check to client service
     healthz = f"http://{target}/_healthz"
     logger.info(f"check connectivity: {healthz}")

Perhatikan bahwa karena ini adalah codelab untuk memahami cara kerja instrumentasi rekaman aktivitas, kita mengonfigurasi Tracer untuk merekam setiap permintaan dan mengirimkannya ke backend. (SimpleSpanProcessor()) Hal ini tidak sesuai untuk lingkungan produksi, jadi pastikan untuk mengubah bagian ini saat Anda menginstrumentasi aplikasi produksi.

Sekarang Anda dapat mengukur rentang dengan Tracer. Intinya, yang perlu Anda lakukan adalah membuat Span secara eksplisit, dan selesai. Meskipun ada dua baris yang menambahkan metadata peristiwa ke dalam Span, Anda tidak perlu membuat ID Aktivitas dan ID Rentang yang unik secara manual dan menyematkannya ke dalam Span.

     logger.info("start client request loop")
     addr = f"http://{target}"
     while True:
-        logger.info("start request to client")
-        call_client(addr)
-        logger.info("end request to client")
+        with tracer.start_as_current_span("loadgen") as root_span:
+            root_span.add_event(name="request_start")
+            logger.info("start request to client")
+            call_client(addr)
+            root_span.add_event(name="request_end")
+            logger.info("end request to client")
         time.sleep(2.0)

Agar build Docker dapat mengambil paket OpenTelemetry yang diperlukan, jalankan perintah berikut:

poetry add "opentelemetry-exporter-gcp-trace=^1.0.0rc0"
poetry add "opentelemetry-propagator-gcp=^1.0.0rc0"
poetry add "opentelemetry-instrumentation-requests=^0.20b0"

Anda dapat mengonfirmasi bahwa deskripsi dependensi yang sesuai ditulis dalam pyproject.toml.

Mengukur layanan klien

Di bagian sebelumnya, kita menginstrumentasikan bagian yang berada dalam kotak merah pada gambar di bawah. Kami menginstrumentasikan informasi rentang di layanan generator beban. Mirip dengan layanan pembuat beban, sekarang kita perlu menginstrumentasi layanan klien. Perbedaannya dengan layanan pembuat beban adalah layanan klien perlu mengekstrak informasi ID Aktivitas yang disebarkan dari layanan pembuat beban di header HTTP dan menggunakan ID tersebut untuk membuat Rentang.

Buka Cloud Shell Editor dan tambahkan modul yang diperlukan seperti yang kita lakukan untuk layanan pembuat beban.

src/client/client.py

 import flask
 import grpc
 import structlog
+from opentelemetry import propagate, trace
+from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
+from opentelemetry.instrumentation.flask import FlaskInstrumentor
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.propagators.cloud_trace_propagator import \
+    CloudTraceFormatPropagator

 import shakesapp_pb2
 import shakesapp_pb2_grpc

Anda melihat bahwa Anda baru saja mengimpor FlaskInstrumentor yang memungkinkan instrumentasi otomatis untuk aplikasi Flask atas nama pengguna untuk mengekstrak header HTTP guna mendapatkan Konteks Pelacakan dengan satu baris kode. Komunitas OpenTelemetry menyediakan integrasi berguna serupa dengan library utama lainnya. Untuk informasi selengkapnya, Anda dapat melihat dokumentasi resminya.

 app = flask.Flask(__name__)
+FlaskInstrumentor().instrument_app(app)

Sebelum memulai instrumentasi, sekali lagi, Anda perlu menyiapkan instance Tracer dengan cara yang sama seperti yang kita lakukan di layanan pembuat beban.

 logger.info(f"server address is {SERVER_ADDR}")

+exporter = CloudTraceSpanExporter()
+trace.get_tracer_provider().add_span_processor(SimpleSpanProcessor(exporter))
+propagate.set_global_textmap(CloudTraceFormatPropagator())
+trace.set_tracer_provider(TracerProvider())

 @app.route("/")
 def main_handler():
    ....

Sekarang siap untuk menambahkan instrumentasi di handler. Temukan main_handler() dan ubah bagian yang mengirim permintaan gRPC ke layanan server.

@app.route("/")
def main_handler():
    q, count = random.choice(list(queries.items()))

    # get Tracer
    tracer = trace.get_tracer(__name__)

    with tracer.start_as_current_span("client") as cur_span:
        channel = grpc.insecure_channel(SERVER_ADDR)
        stub = shakesapp_pb2_grpc.ShakespeareServiceStub(channel)
        logger.info(f"request to server with query: {q}")
        cur_span.add_event("server_call_start")
        resp = stub.GetMatchCount(shakesapp_pb2.ShakespeareRequest(query=q))
        cur_span.add_event("server_call_end")
        if count != resp.match_count:
            raise UnexpectedResultError(
                f"The expected count for '{q}' was {count}, but result was {resp.match_count } obtained"
            )
        result = str(resp.match_count)
        logger.info(f"matched count for '{q}' is {result}")
    return result

Mirip dengan layanan pembuat beban, tambahkan paket yang diperlukan ke pyproject.toml dengan perintah berikut.

poetry add "opentelemetry-exporter-gcp-trace=^1.0.0rc0"
poetry add "opentelemetry-propagator-gcp=^1.0.0rc0"
poetry add "opentelemetry-instrumentation-flask=^0.20b0"

Kemudian, coba luncurkan aplikasi dengan perintah skaffold run dan lihat apa yang ditampilkan dasbor Cloud Trace:

skaffold run --tail

Setelah melihat beberapa pesan build, push, dan deployment, Anda akan melihat log aplikasi dalam format JSON. Buka Cloud Trace > Trace list untuk memeriksa apakah Anda mendapatkan informasi trace. Karena layanan generator beban mengirim permintaan ke layanan klien secara berkala dan Anda mengaktifkan rekaman aktivitas untuk semua permintaan, Anda akan melihat banyak titik pada daftar rekaman aktivitas.

Dengan mengklik salah satunya, Anda akan melihat grafik waterfall seperti di bawah yang menjelaskan latensi setiap bagian selama proses permintaan dan respons. Temukan kotak centang di samping "Tampilkan Acara", lalu Anda akan mendapatkan anotasi di dalam grafik waterfall. Anotasi ini adalah anotasi yang Anda ukur dalam kode dengan metode span.add_event().

Anda mungkin melihat bahwa Anda tidak melihat rentang dari layanan server. Jawaban ini benar karena kita belum menginstrumentasi Span di layanan server sama sekali.

Ringkasan

Pada langkah ini, Anda telah menginstrumentasikan layanan pembuat beban dan layanan klien serta mengonfirmasi bahwa Anda dapat berhasil menyebarkan Konteks Trace di seluruh layanan dan mengekspor informasi Span dari kedua layanan ke Cloud Trace.

Berikutnya

Pada langkah berikutnya, Anda akan menginstrumentasikan layanan klien dan layanan server untuk mengonfirmasi cara menyebarkan Konteks Trace melalui gRPC.

5. Instrumentasi untuk gRPC

Pada langkah sebelumnya, kita telah menginstrumentasi paruh pertama permintaan di microservice ini. Pada langkah ini, kita mencoba menginstrumentasikan komunikasi gRPC antara layanan klien dan layanan server. (Persegi panjang hijau dan ungu pada gambar di bawah)

Instrumentasi otomatis untuk klien gRPC

Ekosistem OpenTelemetry menawarkan banyak library praktis yang membantu developer menginstrumentasi aplikasi. Pada langkah sebelumnya, kita menggunakan instrumentasi otomatis untuk modul "requests". Pada langkah ini, karena kita mencoba menyebarkan Konteks Pelacakan melalui gRPC, kita menggunakan library untuk melakukannya.

src/client/client.py

 import flask
 import grpc
 import structlog
 from opentelemetry import propagate, trace
 from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
 from opentelemetry.instrumentation.flask import FlaskInstrumentor
+from opentelemetry.instrumentation.grpc import GrpcInstrumentorClient
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import SimpleSpanProcessor
 from opentelemetry.propagators.cloud_trace_propagator import \
     CloudTraceFormatPropagator
 import shakesapp_pb2
 import shakesapp_pb2_grpc


 app = flask.Flask(__name__)
 FlaskInstrumentor().instrument_app(app)
+GrpcInstrumentorClient().instrument()

Untuk layanan klien, yang perlu kita lakukan untuk instrumentasi cukup kecil. Yang ingin kita lakukan adalah menyebarkan Konteks Trace, yang merupakan kombinasi ID Trace dan ID Span dari Span saat ini melalui gRPC. Jadi, kita memanggil GrpcInstrumentatorClient.instrument() agar klien gRPC dalam fungsi handler dapat menyematkan Konteks Pelacakan ke dalam header HTTP di bawahnya.

Pastikan untuk menambahkan dependensi baru ke pyproject.toml dengan perintah poetry add:

poetry add "opentelemetry-instrumentation-grpc=^0.20b0"

Instrumentasi otomatis untuk server gRPC

Seperti yang kita lakukan untuk klien gRPC, kita memanggil instrumentasi otomatis untuk server gRPC. Tambahkan impor seperti berikut dan panggil GrpcInstrumentationServer().instrument() di bagian atas file.

Perhatian: Pastikan untuk memanggil

GrpcInstrumentationServe() 

dalam langkah ini, bukan

GrpcInstrumentationClient()

.

src/server/server.py

 import grpc
 import structlog
 from google.cloud import storage
 from grpc_health.v1 import health_pb2, health_pb2_grpc
+from opentelemetry import propagate, trace
+from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
+from opentelemetry.instrumentation.grpc import GrpcInstrumentorServer
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.propagators.cloud_trace_propagator import CloudTraceFormatPropagator

 import shakesapp_pb2
 import shakesapp_pb2_grpc


 BUCKET_NAME = "dataflow-samples"
 BUCKET_PREFIX = "shakespeare/"

+# enable auto gRPC server trace instrumentation
+GrpcInstrumentorServer().instrument()
+

Selanjutnya, Anda akan menambahkan pengekspor untuk mengirim informasi trace ke backend Cloud Trace. Tambahkan kode berikut dalam fungsi serve().

def serve():
+    # start trace exporter
+    trace.set_tracer_provider(TracerProvider())
+    trace.get_tracer_provider().add_span_processor(
+        SimpleSpanProcessor(CloudTraceSpanExporter())
+    )
+    propagators.set_global_textmap(CloudTraceFormatPropagator())
+
+    # add gRPC services to server
     server = grpc.server(futures.ThreadPoolExecutor(max_workers=4))
     service = ShakesappService()
     shakesapp_pb2_grpc.add_ShakespeareServiceServicer_to_server(service, server)
     health_pb2_grpc.add_HealthServicer_to_server(service, server)

Pastikan untuk menambahkan paket yang baru ditambahkan di layanan server.

poetry add "opentelemetry-exporter-gcp-trace=^1.0.0rc0"
poetry add "opentelemetry-instrumentation-grpc=^0.20b0"
poetry add "opentelemetry-propagator-gcp=^1.0.0rc0"
poetry add "opentelemetry-instrumentation=^0.20b0"

Menjalankan microservice dan mengonfirmasi rekaman aktivitas

Kemudian, jalankan kode yang telah diubah dengan perintah skaffold.

skaffold run --tail

Sekarang, Anda akan melihat banyak rekaman aktivitas di halaman Daftar rekaman aktivitas Cloud Trace. Klik salah satu rekaman aktivitas dan sekarang Anda akan menemukan rentang di seluruh permintaan dari layanan pembuat beban ke layanan server.

Ringkasan

Pada langkah ini, Anda menginstrumentasi komunikasi berbasis gRPC dengan dukungan dari library ekosistem OpenTelemetry. Selain itu, Anda mengonfirmasi bahwa Konteks Pelacakan yang dihasilkan di layanan generator beban berhasil dikirimkan ke layanan server.

6. Selamat

Anda telah berhasil membuat trace terdistribusi dengan OpenTelemetry dan mengonfirmasi latensi permintaan di seluruh microservice di Google Cloud Trace.

Untuk latihan yang lebih panjang, Anda dapat mencoba topik berikut sendiri.

• Implementasi saat ini mengirimkan semua rentang yang dihasilkan oleh health check. Bagaimana cara mengecualikan rentang tersebut dari Cloud Trace? Petunjuknya ada di sini.
• Hubungkan log peristiwa dengan rentang dan lihat cara kerjanya di Google Cloud Trace dan Google Cloud Logging. Petunjuknya ada di sini.
• Ganti beberapa layanan dengan layanan dalam bahasa lain dan coba instrumentasikan dengan OpenTelemetry untuk bahasa tersebut

Perhatian: Google Kubernetes Engine dan Google Artifact Registry menggunakan resource secara terus-menerus.

Pembersihan

Setelah menyelesaikan codelab ini, hentikan cluster Kubernetes dan pastikan untuk menghapus project agar Anda tidak dikenai biaya yang tidak terduga di Google Kubernetes Engine, Google Cloud Trace, Google Artifact Registry.

Pertama, hapus cluster dengan perintah berikut:

skaffold delete

Output perintah

Cleaning up...
 - deployment.apps "clientservice" deleted
 - service "clientservice" deleted
 - deployment.apps "loadgen" deleted
 - deployment.apps "serverservice" deleted
 - service "serverservice" deleted

Setelah menghapus cluster, dari panel menu, pilih "IAM & Admin" > "Settings", lalu klik tombol "SHUT DOWN".

Kemudian, masukkan Project ID (bukan Project Name) dalam formulir di dialog dan konfirmasi penonaktifan.