Men-deploy pelacakan terdistribusi untuk mengamati latensi microservice

Dokumen ini menunjukkan cara men-deploy arsitektur referensi seperti yang dijelaskan dalam Menggunakan pelacakan terdistribusi untuk mengamati latensi microservice. Deployment yang diilustrasikan dalam dokumen ini menangkap informasi trace pada aplikasi microservice menggunakan OpenTelemetry dan Cloud Trace.

Aplikasi sampel dalam deployment ini terdiri dari dua microservice yang ditulis dalam Go.

Dokumen ini mengasumsikan bahwa Anda sudah memahami hal-hal berikut:

• Bahasa pemrograman Go
• Google Kubernetes Engine (GKE)

Tujuan

• Membuat cluster GKE dan men-deploy aplikasi sampel.
• Meninjau kode instrumentasi OpenTelemetry.
• Meninjau trace dan log yang dihasilkan oleh instrumentasi.

Arsitektur

Diagram berikut menunjukkan arsitektur yang Anda deploy.

Anda menggunakan Cloud Build— platform continuous integration, penayangan, dan deployment yang terkelola sepenuhnya—untuk mem-build image container dari kode contoh dan menyimpannya di Artifact Registry. Cluster GKE mengambil image dari Artifact Registry pada saat deployment.

Layanan frontend menerima permintaan HTTP pada URL / dan memanggil layanan backend. Alamat layanan backend ditentukan oleh variabel lingkungan.

Layanan backend menerima permintaan HTTP di URL / dan melakukan panggilan keluar ke URL eksternal seperti yang ditentukan dalam variabel lingkungan. Setelah panggilan eksternal selesai, layanan backend menampilkan panggilan status HTTP (misalnya, 200) ke pemanggil.

Biaya

Dalam dokumen ini, Anda menggunakan komponen Google Cloud yang dapat ditagih berikut:

• GKE
• Compute Engine
• Cloud Trace
• Cloud Build
• Artifact Registry

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Setelah menyelesaikan tugas yang dijelaskan dalam dokumen ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, lihat Pembersihan.

Sebelum memulai

1. Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

2. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Buka pemilih project

3. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

4. Enable the GKE, Cloud Trace, Cloud Build, Cloud Storage, and Artifact Registry APIs.

   Enable the APIs

5. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Buka pemilih project

6. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

7. Enable the GKE, Cloud Trace, Cloud Build, Cloud Storage, and Artifact Registry APIs.

   Enable the APIs

Menyiapkan lingkungan Anda

Di bagian ini, Anda menyiapkan lingkungan Anda dengan alat yang Anda gunakan selama deployment. Anda menjalankan semua perintah terminal dalam deployment ini dari Cloud Shell.

1. Di konsol Google Cloud, aktifkan Cloud Shell.

   Aktifkan Cloud Shell

   Di bagian bawah Google Cloud Console, Cloud Shell sesi akan terbuka dan menampilkan perintah command line. Cloud Shell adalah lingkungan shell dengan Google Cloud CLI yang sudah terinstal, dan dengan nilai yang sudah ditetapkan untuk project Anda saat ini. Diperlukan waktu beberapa detik untuk melakukan inisialisasi sesi.

2. Menetapkan variabel lingkungan ke ID project Google Cloud Anda:

   export PROJECT_ID=$(gcloud config list --format 'value(core.project)' 2>/dev/null)
   

3. Download file yang diperlukan untuk deployment ini dengan meng-clone repositori Git terkait:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
   cd kubernetes-engine-samples/observability/distributed-tracing
   WORKDIR=$(pwd)
   

   Anda menjadikan folder repositori sebagai direktori kerja ($WORKDIR) tempat Anda melakukan semua tugas yang terkait dengan deployment ini. Dengan demikian, jika Anda tidak ingin menyimpan resource, Anda dapat menghapus folder tersebut saat Anda menyelesaikan deployment.

Menginstal alat

1. Di Cloud Shell, instal kubectx dan kubens:

   git clone https://github.com/ahmetb/kubectx $WORKDIR/kubectx
   export PATH=$PATH:$WORKDIR/kubectx
   

   Anda menggunakan alat ini untuk menangani beberapa cluster, konteks, dan namespace Kubernetes.

2. Di Cloud Shell, instal Apache Bench, alat pemuatan open source:

   sudo apt-get install apache2-utils
   

Membuat repositori Docker

Membuat repositori Docker guna menyimpan image sampel untuk deployment ini.

Membuat cluster GKE

Di bagian ini, Anda akan membuat dua cluster GKE tempat Anda men-deploy aplikasi contoh. Cluster GKE dibuat dengan akses hanya tulis ke Cloud Trace API secara default, sehingga Anda tidak perlu menentukan akses saat Anda membuat cluster.

1. Di Cloud Shell, buat cluster:

   gcloud container clusters create backend-cluster \
       --zone=us-west1-a \
       --verbosity=none --async
   
   gcloud container clusters create frontend-cluster \
       --zone=us-west1-a \
       --verbosity=none
   

   Dalam contoh ini, cluster berada di zona us-west1-a. Untuk informasi selengkapnya, lihat Geografi dan wilayah.

2. Dapatkan kredensial cluster dan simpan secara lokal:

   gcloud container clusters get-credentials backend-cluster --zone=us-west1-a
   gcloud container clusters get-credentials frontend-cluster --zone=us-west1-a
   

3. Ganti konteks cluster untuk mempermudah aksesnya nanti dalam deployment:

   kubectx backend=gke_${PROJECT_ID}_us-west1-a_backend-cluster
   kubectx frontend=gke_${PROJECT_ID}_us-west1-a_frontend-cluster
   

Meninjau instrumentasi OpenTelemetry

Di bagian berikut, Anda meninjau kode dari file main.go dalam aplikasi sampel. Hal ini membantu Anda mempelajari cara menggunakan propagasi konteks untuk memungkinkan span dari beberapa permintaan untuk ditambahkan ke satu trace induk.

Meninjau impor dalam kode aplikasi

import (
	"context"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"strconv"

	cloudtrace "github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/trace"
	"github.com/gorilla/mux"
	"go.opentelemetry.io/contrib/detectors/gcp"
	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
	"go.opentelemetry.io/contrib/propagators/autoprop"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/sdk/resource"
	"go.opentelemetry.io/otel/sdk/trace"
)

Perhatikan hal-hal berikut terkait impor:

• Paket go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp berisi plugin otelhttp, yang dapat menginstrumentasikan server HTTP atau klien HTTP. Instrumentasi server mengambil konteks span dari permintaan HTTP dan mencatat span untuk penanganan permintaan oleh server. Instrumentasi klien memasukkan konteks span ke dalam permintaan HTTP keluar dan mencatat span untuk waktu yang dihabiskan untuk menunggu respons.
• Paket go.opentelemetry.io/contrib/propagators/autoprop menyediakan implementasi antarmuka TextMapPropagator OpenTelemetry, yang digunakan oleh otelhttp untuk menangani propagasi. Propagator menentukan format dan kunci yang digunakan untuk menyimpan konteks trace dalam transport seperti HTTP. Secara khusus, otelhttp meneruskan header HTTP ke propagator. Propagator mengekstrak konteks span ke dalam konteks Go dari header, atau mengenkode dan memasukkan konteks span dalam konteks Go ke dalam header (bergantung pada klien atau server). Secara default, paket autoprop memasukkan dan mengekstrak konteks span menggunakan format propagasi konteks trace W3C.
• Impor github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/trace mengekspor trace ke Cloud Trace.
• Impor github.com/gorilla/mux adalah library yang digunakan aplikasi sampel untuk penanganan permintaan.
• Impor go.opentelemetry.io/contrib/detectors/gcp menambahkan atribut ke span, seperti cloud.availability_zone, yang mengidentifikasi tempat aplikasi Anda berjalan di dalam Google Cloud.
• Impor go.opentelemetry.io/otel, go.opentelemetry.io/otel/sdk/trace, dan go.opentelemetry.io/otel/sdk/resource yang digunakan untuk menyiapkan OpenTelemetry.

Meninjau fungsi main

Fungsi main menyiapkan ekspor trace ke Cloud Trace dan menggunakan mux router untuk menangani permintaan yang dibuat ke URL /.

func main() {
	ctx := context.Background()
	// Set up the Cloud Trace exporter.
	exporter, err := cloudtrace.New()
	if err != nil {
		log.Fatalf("cloudtrace.New: %v", err)
	}
	// Identify your application using resource detection.
	res, err := resource.New(ctx,
		// Use the GCP resource detector to detect information about the GKE Cluster.
		resource.WithDetectors(gcp.NewDetector()),
		resource.WithTelemetrySDK(),
	)
	if err != nil {
		log.Fatalf("resource.New: %v", err)
	}
	tp := trace.NewTracerProvider(
		trace.WithBatcher(exporter),
		trace.WithResource(res),
	)
	// Set the global TracerProvider which is used by otelhttp to record spans.
	otel.SetTracerProvider(tp)
	// Flush any pending spans on shutdown.
	defer tp.ForceFlush(ctx)

	// Set the global Propagators which is used by otelhttp to propagate
	// context using the w3c traceparent and baggage formats.
	otel.SetTextMapPropagator(autoprop.NewTextMapPropagator())

	// Handle incoming request.
	r := mux.NewRouter()
	r.HandleFunc("/", mainHandler)
	var handler http.Handler = r

	// Use otelhttp to create spans and extract context for incoming http
	// requests.
	handler = otelhttp.NewHandler(handler, "server")
	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%v", os.Getenv("PORT")), handler))
}

Perhatikan hal-hal berikut tentang kode ini:

• Anda mengonfigurasi TracerProvider OpenTelemetry, yang mendeteksi atribut saat dijalankan di Google Cloud, dan yang mengekspor trace ke Cloud Trace.
• Anda menggunakan fungsi otel.SetTracerProvider dan otel.SetTextMapPropagators untuk menetapkan setelan TracerProvider dan Propagator global. Secara default, library instrumentasi seperti otelhttp menggunakan TracerProvider yang terdaftar secara global untuk membuat span dan Propagator untuk menyebarkan konteks.
• Anda menggabungkan server HTTP dengan otelhttp.NewHandler untuk melengkapi server HTTP.

Meninjau fungsi mainHandler

func mainHandler(w http.ResponseWriter, r *http.Request) {
	// Use otelhttp to record a span for the outgoing call, and propagate
	// context to the destination.
	destination := os.Getenv("DESTINATION_URL")
	resp, err := otelhttp.Get(r.Context(), destination)
	if err != nil {
		log.Fatal("could not fetch remote endpoint")
	}
	defer resp.Body.Close()
	_, err = ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatalf("could not read response from %v", destination)
	}

	fmt.Fprint(w, strconv.Itoa(resp.StatusCode))
}

Untuk menangkap latensi permintaan keluar yang dibuat ke tujuan, Anda menggunakan plugin otelhttp untuk membuat permintaan HTTP. Anda juga menggunakan fungsi r.Context untuk menautkan permintaan masuk dengan permintaan keluar, seperti yang ditunjukkan dalam listingan berikut:

// Use otelhttp to record a span for the outgoing call, and propagate
// context to the destination.
resp, err := otelhttp.Get(r.Context(), destination)

Men-deploy aplikasi

Di bagian ini, Anda akan menggunakan Cloud Build untuk mem-build image container untuk layanan backend dan frontend. Anda kemudian men-deploy-nya ke cluster GKE.

Mem-build container Docker

1. Di Cloud Shell, kirimkan build dari direktori kerja:

   cd $WORKDIR
   gcloud builds submit . --tag us-west1-docker.pkg.dev/$PROJECT_ID/distributed-tracing-docker-repo/backend:latest
   

2. Pastikan bahwa image container berhasil dibuat dan tersedia di Artifact Registry:

   gcloud artifacts docker images list us-west1-docker.pkg.dev/$PROJECT_ID/distributed-tracing-docker-repo
   

   Image container tersebut berhasil dibuat jika output-nya mirip dengan yang berikut ini, dengan PROJECT_ID sebagai ID project Google Cloud Anda:

   NAME
   us-west1-docker.pkg.dev/PROJECT_ID/distributed-tracing-docker-repo/backend
   

Men-deploy layanan backend

1. Di Cloud Shell, tetapkan konteks kubectx ke cluster backend:

   kubectx backend
   

2. Buat file YAML untuk deployment backend:

   export PROJECT_ID=$(gcloud info --format='value(config.project)')
   envsubst < backend-deployment.yaml | kubectl apply -f -
   

3. Konfirmasi bahwa pod sedang berjalan:

   kubectl get pods
   

   Output menampilkan nilai Status dari Running:

   NAME                       READY   STATUS    RESTARTS   AGE
   backend-645859d95b-7mx95   1/1     Running   0          52s
   backend-645859d95b-qfdnc   1/1     Running   0          52s
   backend-645859d95b-zsj5m   1/1     Running   0          52s
   

4. Ekspos deployment backend menggunakan load balancer:

   kubectl expose deployment backend --type=LoadBalancer
   

5. Dapatkan alamat IP ldari ayanan backend:

   kubectl get services backend
   

   Outputnya mirip dengan hal berikut ini:

   NAME      TYPE           CLUSTER-IP     EXTERNAL-IP    PORT(S)          AGE
   backend   LoadBalancer   10.11.247.58   34.83.88.143   8080:30714/TCP   70s
   

   Jika nilai kolom EXTERNAL-IP adalah <pending>, ulangi perintah ini hingga nilainya adalah alamat IP.

6. Ambil alamat IP dari langkah sebelumnya dalam variabel:

   export BACKEND_IP=$(kubectl get svc backend -ojson | jq -r '.status.loadBalancer.ingress[].ip')
   

Men-deploy layanan frontend

1. Di Cloud Shell, tetapkan konteks kubectx ke cluster backend:

   kubectx frontend
   

2. Buat file YAML untuk deployment frontend:

   export PROJECT_ID=$(gcloud info --format='value(config.project)')
   envsubst < frontend-deployment.yaml | kubectl apply -f -
   

3. Konfirmasi bahwa pod sedang berjalan:

   kubectl get pods
   

   Output menampilkan nilai Status dari Running:

   NAME                        READY   STATUS    RESTARTS   AGE
   frontend-747b445499-v7x2w   1/1     Running   0          57s
   frontend-747b445499-vwtmg   1/1     Running   0          57s
   frontend-747b445499-w47pf   1/1     Running   0          57s
   

4. Ekspos deployment frontend menggunakan load balancer:

   kubectl expose deployment frontend --type=LoadBalancer
   

5. Dapatkan alamat IP ldari ayanan frontend:

   kubectl get services frontend
   

   Outputnya mirip dengan hal berikut ini:

   NAME       TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)         AGE
   frontend   LoadBalancer   10.27.241.93   34.83.111.232   8081:31382/TCP  70s
   

   Jika nilai kolom EXTERNAL-IP adalah <pending>, ulangi perintah ini hingga nilainya adalah alamat IP.

6. Ambil alamat IP dari langkah sebelumnya dalam variabel:

   export FRONTEND_IP=$(kubectl get svc frontend -ojson | jq -r '.status.loadBalancer.ingress[].ip')
   

Memuat aplikasi dan meninjau trace

Di bagian ini, Anda akan menggunakan utilitas Apache Bench guna membuat permintaan untuk aplikasi Anda. Anda kemudian meninjau trace yang dihasilkan di Cloud Trace.

1. Di Cloud Shell, gunakan Apache Bench untuk membuat 1000 permintaan menggunakan 3 thread serentak:

   ab -c 3 -n 1000 http://${FRONTEND_IP}:8081/
   

2. Di konsol Google Cloud, buka halaman Daftar Trace.

   Buka Daftar Trace

3. Untuk meninjau linimasa, klik salah satu URI yang diberi label sebagai server.

   

   Trace ini berisi empat span yang memiliki nama berikut:

   • Span server pertama merekam latensi menyeluruh dalam penanganan permintaan HTTP di server frontend.
   • Span HTTP GET pertama merekam latensi panggilan GET yang dibuat oleh klien frontend ke backend.
   • Span server kedua merekam latensi menyeluruh dalam penanganan permintaan HTTP di server backend.
   • Span HTTP GET kedua merekam latensi panggilan GET yang dilakukan oleh klien backend ke google.com.

   

Pembersihan

Cara termudah untuk menghilangkan penagihan adalah dengan menghapus project Google Cloud yang Anda buat untuk deployment. Sebagai alternatif, Anda dapat menghapus resource satu per satu.

Menghapus project

1. Di konsol Google Cloud, buka halaman Manage resource.

   Buka Manage resource

2. Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
3. Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Menghapus resource satu per satu

Untuk menghapus resource satu per satu daripada menghapus seluruh project, jalankan perintah berikut di Cloud Shell:

gcloud container clusters delete frontend-cluster --zone=us-west1-a
gcloud container clusters delete backend-cluster --zone=us-west1-a
gcloud artifacts repositories delete distributed-tracing-docker-repo --location us-west1

Langkah selanjutnya

• Pelajari tentang OpenTelemetry.
• Untuk arsitektur referensi, diagram, dan praktik terbaik lainnya, jelajahi Cloud Architecture Center.