OpenTelemetry kullanarak araç izleme bilgileri

1. Giriş

Son güncelleme: 2021-03-05

Uygulamanın gözlemlenebilirliği

Gözlemlenebilirlik ve OpenTelemetry

Gözlemlenebilirlik, bir sistemin özelliğini tanımlamak için kullanılan terimdir. Gözlemlenebilirlik özelliği olan bir sistem, ekiplerin sistemlerinde aktif olarak hata ayıklamasına olanak tanır. Bu bağlamda, gözlemlenebilirliğin üç temel unsuru olan günlükler, metrikler ve izler, sistemin gözlemlenebilirlik kazanması için temel enstrümantasyondur.

OpenTelemetry, gözlemlenebilirliğin gerektirdiği telemetri verilerinin (günlükler, metrikler ve izlemeler) enstrümantasyonunu ve dışa aktarılmasını hızlandıran bir dizi spesifikasyon ve SDK'dır. OpenTelemetry, CNCF bünyesinde açık standartlı ve topluluk odaklı bir projedir. Projenin ve ekosisteminin sağladığı kitaplıkları kullanarak geliştiriciler, uygulamalarını satıcıdan bağımsız bir şekilde ve birden fazla mimariye karşı kullanabilir.

Dağıtılmış İzleme

Günlükler, metrikler ve izler arasında iz, sistemdeki sürecin belirli bir bölümünün gecikmesini bildiren telemetridir. Özellikle mikro hizmetler çağında, dağıtılmış izleme, genel dağıtılmış sistemdeki gecikme sorunlarını bulmak için güçlü bir araçtır.

Dağıtılmış izleri analiz ederken iz verilerinin görselleştirilmesi, genel sistem gecikmelerini bir bakışta anlamanın anahtarıdır. Dağıtılmış izlemede, sisteme giriş noktasına yapılan tek bir isteği işlemek için bir dizi çağrı, birden fazla kapsam içeren bir izleme biçiminde ele alınır.

Span, dağıtılmış bir sistemde yapılan ve başlangıç ile bitiş zamanlarını kaydeden tek bir iş birimini ifade eder. Kapsamlar genellikle birbirleriyle hiyerarşik ilişkilere sahiptir. Aşağıdaki resimde, daha küçük tüm kapsamlar büyük bir /messages kapsamının alt kapsamlarıdır ve sistemdeki iş akışını gösteren tek bir İz'de birleştirilir.

Google Cloud Trace, dağıtılmış izleme arka ucu için seçeneklerden biridir ve Google Cloud'daki diğer ürünlerle iyi entegre edilmiştir.

Ne oluşturacaksınız?

Bu codelab'de, Google Kubernetes Engine'de çalışan bir Kubernetes kümesinde çalışan "Shakesapp" adlı hizmetlerde izleme bilgilerini kullanacaksınız. Shakesapp'in mimarisi aşağıda açıklanmıştır:

İstemciler, sunucuya bir sorgu dizesi gönderir.
Sunucu, istemciden gelen sorguyu kabul eder, Google Cloud Storage'dan tüm Shakespeare eserlerini metin biçiminde getirir, sorguyu içeren satırları arar ve eşleşen satırın numarasını istemciye döndürür.

İzleme bilgilerini istek genelinde kullanırsınız.

Neler öğreneceksiniz?

Python projesinde OpenTelemetry Trace kitaplıklarını kullanmaya başlama
Kitaplıkla kapsam oluşturma
Kapsam bağlamlarını uygulama bileşenleri arasında kablo üzerinden yayma
İz verilerini Google Cloud Trace'e gönderme
Google Cloud Trace'te izleme nasıl analiz edilir?

Bu codelab'de, mikro hizmetlerinize nasıl izleme araçları ekleyeceğiniz açıklanmaktadır. Bu örneği kolay anlaşılır hale getirmek için yalnızca 3 bileşen (yük oluşturucu, istemci ve sunucu) içerir. Ancak bu codelab'de açıklanan aynı süreci daha karmaşık ve büyük sistemlere de uygulayabilirsiniz.

Gerekenler

Python 3 bilgisi

2. Kurulum ve Gereksinimler

Yönlendirmesiz ortam kurulumu

Google Hesabınız (Gmail veya Google Apps) yoksa hesap oluşturmanız gerekir. Google Cloud Platform Console'da ( console.cloud.google.com) oturum açın ve yeni bir proje oluşturun.

Önceden oluşturduğunuz bir projeniz varsa konsolun sol üst kısmındaki proje seçimi açılır menüsünü tıklayın:

ve yeni bir proje oluşturmak için açılan iletişim kutusunda "YENİ PROJE" düğmesini tıklayın:

Henüz bir projeniz yoksa ilk projenizi oluşturmak için aşağıdaki gibi bir iletişim kutusu görürsünüz:

Sonraki proje oluşturma iletişim kutusunda yeni projenizin ayrıntılarını girebilirsiniz:

Tüm Google Cloud projelerinde benzersiz bir ad olan proje kimliğini unutmayın (Yukarıdaki ad zaten alınmış olduğundan sizin için çalışmayacaktır). Bu codelab'de daha sonra PROJECT_ID olarak adlandırılacaktır.

Ardından, henüz yapmadıysanız Google Cloud kaynaklarını kullanmak için Developers Console'da faturalandırmayı etkinleştirmeniz ve Cloud Trace API'yi etkinleştirmeniz gerekir.

Bu codelab'i tamamlamak size birkaç dolardan fazla maliyet getirmemelidir. Ancak daha fazla kaynak kullanmaya karar verirseniz veya kaynakları çalışır durumda bırakırsanız maliyet artabilir (bu belgenin sonundaki "temizleme" bölümüne bakın). Google Cloud Trace, Google Kubernetes Engine ve Google Artifact Registry'nin fiyatları resmi dokümanlarda belirtilmiştir.

Google Cloud Platform'un yeni kullanıcıları, bu codelab'i tamamen ücretsiz hale getirecek 300 ABD doları değerinde ücretsiz deneme sürümünden yararlanabilir.

Google Cloud Shell Kurulumu

Google Cloud ve Google Cloud Trace, dizüstü bilgisayarınızdan uzaktan çalıştırılabilir. Ancak bu codelab'de, bulutta çalışan bir komut satırı ortamı olan Google Cloud Shell'i kullanacağız.

Bu Debian tabanlı sanal makine, ihtiyaç duyacağınız tüm geliştirme araçlarını içerir. 5 GB boyutunda kalıcı bir ana dizin bulunur ve Google Cloud'da çalışır. Bu sayede ağ performansı ve kimlik doğrulama önemli ölçüde güçlenir. Bu nedenle, bu codelab için ihtiyacınız olan tek şey bir tarayıcıdır (Chromebook'ta da çalışır).

Cloud Shell'i Cloud Console'dan etkinleştirmek için Cloud Shell'i Etkinleştir'i gcLMt5IuEcJJNnMId-Bcz3sxCd0rZn7IzT_r95C8UZeqML68Y1efBG_B0VRp7hc7qiZTLAF-TXD7SsOadxn8uadgHhaLeASnVS3ZHK39eOlKJOgj9SJua_oeGhMxRrbOg3qigddS2A tıklamanız yeterlidir (ortamın sağlanması ve bağlantının kurulması yalnızca birkaç saniye sürer).

Cloud Shell'e bağlandıktan sonra kimliğinizin doğrulandığını ve projenin, PROJECT_ID'nize ayarlandığını görürsünüz.

gcloud auth list

Komut çıkışı

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

gcloud config list project

Komut çıkışı

[core]
project = <PROJECT_ID>

Herhangi bir nedenle proje ayarlanmamışsa şu komutu verin:

gcloud config set project <PROJECT_ID>

PROJECT_ID cihazınızı mı arıyorsunuz? Kurulum adımlarında hangi kimliği kullandığınızı kontrol edin veya Cloud Console kontrol panelinde arayın:

Cloud Shell, gelecekteki komutları çalıştırırken faydalı olabilecek bazı ortam değişkenlerini de varsayılan olarak ayarlar.

echo $GOOGLE_CLOUD_PROJECT

Komut çıkışı

<PROJECT_ID>

Son olarak, varsayılan alt bölgeyi ve proje yapılandırmasını ayarlayın.

gcloud config set compute/zone us-central1-f

Çeşitli bölgeler arasından seçim yapabilirsiniz. Daha fazla bilgi için Bölgeler ve Alt Bölgeler başlıklı makaleyi inceleyin.

Python kurulumu

Bu codelab'de, paket sürümlerini sıkı bir şekilde yönetmek için "poetry" kullanıyoruz. Cloud Shell'de aşağıdaki komutu çalıştırın:

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

Google Kubernetes kümesi oluşturma

Bu codelab'de, Google Kubernetes Engine'de (GKE) bir mikro hizmet kümesi çalıştıracaksınız. Bu codelab'in süreci aşağıdaki gibidir:

Temel proje dosyasını Cloud Shell'e indirin.
Mikro hizmetleri container'lara yerleştirme
Google Artifact Registry'ye (GAR) kapsayıcı yükleme
Container'ları GKE'ye dağıtma
İzleme enstrümantasyonu için hizmetlerin kaynak kodunu değiştirme
2. adıma geçin.

Kubernetes Engine'i etkinleştirme

Öncelikle, Shakesapp'in GKE'de çalıştığı bir Kubernetes kümesi oluşturuyoruz. Bu nedenle GKE'yi etkinleştirmemiz gerekiyor. "Kubernetes Engine" menüsüne gidin ve ETKİNLEŞTİR düğmesine basın.

Artık Kubernetes kümesi oluşturmaya hazırsınız.

Kubernetes kümesi oluşturma

Cloud Shell'de Kubernetes kümesi oluşturmak için aşağıdaki komutu çalıştırın. Lütfen bölge değerinin, Artifact Registry deposu oluşturma için kullandığınız bölgenin altında olduğunu onaylayın. Depo bölgeniz bölgeyi kapsamıyorsa bölge değerini us-central1-f olarak değiştirin.

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

Komut çıkışı

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

Artifact Registry ve skaffold kurulumu

Artık dağıtıma hazır bir Kubernetes kümemiz var. Ardından, kapsayıcıları göndermek ve dağıtmak için bir kapsayıcı kayıt defteri hazırlıyoruz. Bu adımlar için GAR'ı ve Skaffold'u kurmamız gerekir.

Artifact Registry kurulumu

"Artifact Registry" menüsüne gidin ve ETKİNLEŞTİR düğmesine basın.

Bir süre sonra GAR'ın depo tarayıcısını görürsünüz. "CREATE REPOSITORY" (Depo oluştur) düğmesini tıklayın ve deponun adını girin.

Bu codelab'de yeni depoya trace-codelab adını veriyorum. Yapının biçimi "Docker", konum türü ise "Bölge" olmalıdır. Google Compute Engine varsayılan bölgesi için ayarladığınız bölgeye yakın bir bölge seçin. Örneğin, yukarıdaki örnekte "us-central1-f" seçildiğinden burada "us-central1 (Iowa)" seçilir. Ardından "OLUŞTUR" düğmesini tıklayın.

Artık "trace-codelab"i depo tarayıcısında görebilirsiniz.

Kayıt defteri yolunu kontrol etmek için daha sonra buraya geri döneceğiz.

Skaffold kurulumu

Skaffold, Kubernetes'te çalışan mikro hizmetler oluştururken kullanışlı bir araçtır. Küçük bir komut grubuyla uygulama container'larını oluşturma, gönderme ve dağıtma iş akışını yönetir. Skaffold, varsayılan olarak Docker Registry'yi Container Registry olarak kullandığından, container'ları gönderirken GAR'ı tanıyacak şekilde Skaffold'u yapılandırmanız gerekir.

Cloud Shell'i tekrar açın ve Skaffold'ın yüklü olup olmadığını doğrulayın. (Cloud Shell, skaffold'u ortama varsayılan olarak yükler.) Aşağıdaki komutu çalıştırıp Skaffold sürümünü görün.

skaffold version

Komut çıkışı

v1.20.0

Artık, skaffold'un kullanacağı varsayılan veri deposunu kaydedebilirsiniz. Kayıt yolu almak için Artifact Registry kontrol paneline gidin ve önceki adımda ayarladığınız deponun adını tıklayın.

Ardından, sayfanın üst kısmında içerik haritası yollarını görürsünüz. Kayıt defteri yolunu panoya kopyalamak için simgesini tıklayın.

Kopyala düğmesini tıkladığınızda tarayıcının alt kısmında aşağıdaki gibi bir mesaj içeren iletişim kutusu görürsünüz:

"us-central1-docker.pkg.dev/psychic-order-307806/trace-codelab" kopyalandı

Cloud Shell'e geri dönün. skaffold config set default-repo komutunu, kontrol panelinden kopyaladığınız değerle birlikte çalıştırın.

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

Komut çıkışı

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

Ayrıca, kayıt defterini Docker yapılandırmasına göre yapılandırmanız gerekir. Aşağıdaki komutu çalıştırın:

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

Komut çıkışı

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

Artık GKE'de Kubernetes kapsayıcısı oluşturma işleminin bir sonraki adımına geçebilirsiniz.

Özet

Bu adımda codelab ortamınızı ayarlarsınız:

Cloud Shell'i ayarlama
Container Registry için bir Artifact Registry deposu oluşturduysanız
Container Registry'yi kullanmak için Skaffold'u ayarlama
Codelab mikro hizmetlerinin çalıştığı bir Kubernetes kümesi oluşturduysanız

Sıradaki

Sonraki adımda, mikro hizmetlerinizi oluşturup kümeye gönderecek ve dağıtacaksınız.

3. Mikro hizmetleri oluşturma, aktarma ve dağıtma

Codelab materyalini indirin

Önceki adımda, bu codelab için tüm ön koşulları ayarladık. Artık tüm mikro hizmetleri bunların üzerinde çalıştırmaya hazırsınız. Codelab materyali GitHub'da barındırıldığından, aşağıdaki git komutuyla Cloud Shell kabuk ortamına indirin.

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

Projenin dizin yapısı aşağıdaki gibidir:

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

manifests: Kubernetes manifest dosyaları
proto: İstemci ile sunucu arasındaki iletişim için proto tanımı
src: Her hizmetin kaynak kodu için dizinler
skaffold.yaml: Skaffold'un yapılandırma dosyası

Skaffold komutunu çalıştırma

Son olarak, tüm içeriği oluşturmaya, aktarmaya ve yeni oluşturduğunuz Kubernetes kümesine dağıtmaya hazırsınız. Bu, birden fazla adım içeren bir işlem gibi görünüyor ancak gerçekte her şeyi sizin için yapan Scaffold'dur. Bunu aşağıdaki komutla deneyelim:

cd shakesapp-python
skaffold run --tail

Komutu çalıştırdığınız anda docker build öğesinin günlük çıkışını görür ve bunların kayıt defterine başarıyla gönderildiğini onaylayabilirsiniz.

Komut çıkışı

...
---> 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

Tüm hizmet kapsayıcıları gönderildikten sonra Kubernetes dağıtımları otomatik olarak başlar.

Komut çıkışı

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

Dikkat: "Belirtilen görüntü deposuna aktarma erişimi yok" gibi bir hata alırsanız skaffold komutunun, skaffold'daki varsayılan depoda yapılandırmanızdan bağımsız olarak görüntüleri Docker Hub'a (docker.io) aktarmaya çalışıp çalışmadığını kontrol edin. Bu durumda, "skaffold run" komutuna aşağıdaki gibi "–default-repo" seçeneğini eklemeyi deneyin.

$ skaffold run –tail –default-repo=us-central1-docker.pkg.dev/[proje kimliği]/[depo adı]

Dağıtımdan sonra, her kapsayıcıda stdout'a gönderilen gerçek uygulama günlüklerini şu şekilde görürsünüz:

Komut çıkışı

[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"}

Son olarak, hizmetlerin dağıtılmış izlenmesi için uygulamanızı OpenTelemetry ile enstrümante etmeye başlayabilirsiniz.

Özet

Bu adımda, ortamınızdaki codelab materyalini hazırladınız ve skaffold'un beklendiği gibi çalıştığını onayladınız.

Sıradaki

Bir sonraki adımda, izleme bilgilerini izlemek için loadgen hizmetinin kaynak kodunu değiştireceksiniz.

4. HTTP için araçlar

İzleme enstrümantasyonu ve yayılımı kavramı

Kaynak kodunu düzenlemeden önce, dağıtılmış izlemelerin nasıl çalıştığını basit bir şemayla kısaca açıklayayım.

Bu örnekte, izleme ve kapsam bilgilerini Cloud Trace'e aktarmak ve yük oluşturma hizmetinden sunucu hizmetine yapılan istekte izleme bağlamını yaymak için kodu izleme araçlarıyla donatıyoruz.

Cloud Trace'in aynı iz kimliğine sahip tüm aralıkları tek bir izde birleştirebilmesi için uygulamanın iz kimliği ve aralık kimliği gibi iz meta verilerini göndermesi gerekir. Ayrıca, uygulamanın iz bağlamlarını (üst aralığın iz kimliği ve aralık kimliğinin kombinasyonu) aşağı akış hizmetlerine istek gönderirken yayması gerekir. Böylece, hangi iz bağlamını işlediğinin farkında olabilir.

OpenTelemetry ile yapabilecekleriniz:

Benzersiz izleme kimliği ve kapsam kimliği oluşturmak için
İzleme kimliğini ve kapsam kimliğini arka uca aktarmak için
İzleme bağlamlarını diğer hizmetlere yaymak için

Instrument first span

Yük oluşturucu hizmeti

Cloud Shell'in sağ üst kısmındaki düğmesine basarak Cloud Shell Düzenleyici'yi açın. Sol bölmedeki Gezgin'den src/loadgen/loadgen.py öğesini açın ve main işlevini bulun.

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)

main işlevinde, döngünün call_client işlevini çağırdığını görürsünüz. Mevcut uygulamada, bölüm işlev çağrısının başlangıcını ve bitişini kaydeden 2 günlük satırına sahiptir. Şimdi işlev çağrısının gecikmesini izlemek için Span bilgilerini ölçelim.

Öncelikle, benzersiz bir İzleme Kimliği ve Kapsam Kimliği ile bir Kapsam oluşturmanız gerekir. OpenTelemetry, bu amaçla kullanışlı bir kitaplık sunar. OpenTelemetry kitaplıklarını kodunuza aktarmak için aşağıdaki satırları ekleyin.

 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

Yük oluşturucu, istemci uygulamasını requests modülü aracılığıyla HTTP'de çağırdığı için requests için uzantı paketini kullanır ve enstrümantasyonu etkinleştiririz.

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

Ardından, Trace Context ve dışa aktarma ayarlarını işleyen Tracer örneğini ayarlayın.

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

Bu codelab'in, izleme enstrümantasyonunun nasıl çalıştığını anlamaya yönelik olduğunu unutmayın. Bu nedenle, Tracer'ı her isteği kaydedip arka uca gönderecek şekilde yapılandırıyoruz. (SimpleSpanProcessor()) Bu, üretim ortamlarına uygun değildir. Bu nedenle, üretim uygulamanızı izlerken bu bölümü değiştirdiğinizden emin olun.

Artık Tracer ile Spans'i izleyebilirsiniz. Buradaki önemli nokta, açıkça bir Span oluşturmanız gerektiğidir. Etkinlik meta verilerini Span'e ekleyen iki satır olsa da benzersiz İzleme Kimliği ve Span Kimliği'ni manuel olarak oluşturup Span'e yerleştirmeniz gerekmez.

     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)

Docker derlemesinin gerekli OpenTelemetry paketlerini getirebilmesi için aşağıdaki komutu çalıştırın:

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

İlgili bağımlılık açıklamasının pyproject.toml dilinde yazıldığını onaylayabilirsiniz.

Enstrüman müşteri hizmetleri

Önceki bölümde, aşağıdaki çizimde kırmızı dikdörtgen içine alınmış kısmı izledik. Yük oluşturucu hizmetinde span bilgilerini enstrümante ettik. Yük oluşturucu hizmetine benzer şekilde, şimdi de istemci hizmetini izlememiz gerekiyor. Yük oluşturucu hizmetinden farkı, istemci hizmetinin HTTP üstbilgisinde yük oluşturucu hizmetinden yayılan İzleme Kimliği bilgilerini ayıklaması ve bu kimliği kullanarak Aralıklar oluşturmasıdır.

Cloud Shell Düzenleyici'yi açın ve yük oluşturucu hizmetinde yaptığımız gibi gerekli modülleri ekleyin.

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

Kullanıcılar adına Flask uygulaması için otomatik enstrümantasyonu etkinleştiren ve tek bir kod satırıyla izleme bağlamlarını elde etmek üzere HTTP üstbilgilerini ayıklayan FlaskInstrumentor öğesini yeni içe aktardığınızı fark ediyorsunuz. OpenTelemetry topluluğu, diğer büyük kitaplıklarla benzer şekilde faydalı entegrasyonlar sunar. Daha fazla bilgi için resmi belgelere göz atabilirsiniz.

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

Enstrümantasyonu başlatmadan önce, yük oluşturucu hizmetinde yaptığımıza benzer şekilde Tracer örneğini hazırlamanız gerekir.

 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():
    ....

Artık işleyiciye enstrümantasyon eklemeye hazırsınız. main_handler() simgesini bulun ve sunucu hizmetine gRPC isteği gönderen kısmı değiştirin.

@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

Yük oluşturucu hizmetine benzer şekilde, aşağıdaki komutu kullanarak gerekli paketleri pyproject.toml içine ekleyin.

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

Ardından, uygulamayı skaffold run komutuyla başlatmayı deneyin ve Cloud Trace kontrol panelinin ne gösterdiğine bakın:

skaffold run --tail

Bazı derleme, gönderme ve dağıtma mesajlarını gördükten sonra uygulama günlüklerini JSON biçiminde görürsünüz. İz bilgilerini alıp almadığınızı kontrol etmek için Cloud Trace > İz listesi'ne gidin. Yük oluşturucu hizmeti, istemci hizmetine düzenli olarak istek gönderdiğinden ve tüm istekler için izlemeleri etkinleştirdiğinizden izleme listesinde çok sayıda nokta görmeye başlarsınız.

Bunlardan birini tıkladığınızda, istek ve yanıt sürecindeki her bölümün gecikmesini açıklayan aşağıdaki gibi bir şelale grafiği görürsünüz. "Etkinlikleri Göster"in yanındaki onay kutusunu işaretleyin. Ardından, basamaklı grafikte ek açıklamaları görürsünüz. Bu ek açıklamalar, span.add_event() yöntemiyle kodda oluşturduğunuz ek açıklamalardır.

Sunucu hizmetinden gelen aralıkları görmediğinizi fark edebilirsiniz. Sunucu hizmetinde hiç Span oluşturmadığımız için bu doğrudur.

Özet

Bu adımda, yük oluşturucu hizmetini ve istemci hizmetini enstrümante ettiniz. Ayrıca, iz bağlamını hizmetler arasında başarıyla yayabildiğinizi ve her iki hizmetten de Cloud Trace'e aralık bilgilerini dışa aktarabildiğinizi doğruladınız.

Sıradaki

Bir sonraki adımda, İzleme Bağlamı'nın gRPC üzerinden nasıl yayılacağını onaylamak için istemci hizmetini ve sunucu hizmetini izleme araçlarıyla donatacaksınız.

5. gRPC için enstrümantasyon

Önceki adımda, bu mikro hizmetlerdeki isteğin ilk yarısını izledik. Bu adımda, istemci hizmeti ile sunucu hizmeti arasındaki gRPC iletişimini izlemeye çalışırız. (Aşağıdaki resimde yeşil ve mor dikdörtgen)

gRPC istemcisi için otomatik enstrümantasyon

OpenTelemetry'nin ekosistemi, geliştiricilerin uygulamaları izlemesine yardımcı olan birçok kullanışlı kitaplık sunar. Önceki adımda, "istekler" modülü için otomatik enstrümantasyon kullandık. Bu adımda, izleme bağlamını gRPC üzerinden yaymaya çalıştığımız için kitaplığı kullanıyoruz.

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

İstemci hizmeti için enstrümantasyon konusunda yapmamız gerekenler oldukça azdır. Yapmak istediğimiz şey, mevcut aralığın İzleme Kimliği ve Aralık Kimliği'nin birleşimi olan İzleme Bağlamı'nı gRPC aracılığıyla yaymaktır. Bu nedenle, işleyici işlevindeki gRPC istemcisinin İzleme Bağlamını alttaki HTTP üstbilgisine yerleştirebilmesi için GrpcInstrumentatorClient.instrument() işlevini çağırırız.

pyproject.toml öğesine poetry add komutuyla yeni bağımlılıklar eklediğinizden emin olun:

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

gRPC sunucusu için otomatik enstrümantasyon

gRPC istemcisi için yaptığımız gibi, gRPC sunucusu için otomatik enstrümantasyon diyoruz. Dosyanın en üstüne takip edilenler ve arama gibi içe aktarma işlemleri ekleyin GrpcInstrumentationServer().instrument().

Dikkat:

GrpcInstrumentationServe()

bu adımda değil

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()
+

Ardından, iz bilgilerini Cloud Trace arka ucuna göndermek için dışa aktarıcıyı eklersiniz. serve() işlevine aşağıdaki kodu ekleyin.

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)

Sunucu hizmetine yeni eklenen paketleri eklediğinizden emin olun.

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"

Mikro hizmeti çalıştırın ve izlemeyi onaylayın

Ardından, değiştirilen kodunuzu skaffold komutuyla çalıştırın.

skaffold run --tail

Şimdi de Cloud Trace'in İz listesi sayfasında bir sürü iz görüyorsunuz. İzlerden birini tıkladığınızda yük oluşturucu hizmetinden sunucu hizmetine yapılan isteğin kapsamını görebilirsiniz.

Özet

Bu adımda, OpenTelemetry ekosistem kitaplıklarının desteğiyle gRPC tabanlı iletişimi izlediniz. Ayrıca, yük oluşturucu hizmetinde oluşturulan izleme bağlamının sunucu hizmetine başarıyla teslim edildiğini de onayladınız.

6. Tebrikler

OpenTelemetry ile dağıtılmış izlemeler oluşturmayı başardınız ve Google Cloud Trace'te mikro hizmet genelindeki istek gecikmelerini onayladınız.

Daha kapsamlı alıştırmalar için aşağıdaki konuları kendi başınıza deneyebilirsiniz.

Mevcut uygulama, durum denetimi tarafından oluşturulan tüm kapsamları gönderir. Bu aralıkları Cloud Trace'lerden nasıl filtreleyebilirsiniz? İpucunu burada bulabilirsiniz.
Etkinlik günlüklerini aralıklarla ilişkilendirin ve Google Cloud Trace ile Google Cloud Logging'de nasıl çalıştığını görün. İpucunu burada bulabilirsiniz.
Bazı hizmetleri başka bir dildeki hizmetlerle değiştirin ve bu dilde OpenTelemetry ile izlemeyi deneyin.

Dikkat: Google Kubernetes Engine ve Google Artifact Registry, kaynağı sürekli olarak tüketir.

Temizleme

Bu codelab'den sonra lütfen Kubernetes kümesini durdurun ve Google Kubernetes Engine, Google Cloud Trace, Google Artifact Registry'de beklenmedik ücretler almamak için projeyi sildiğinizden emin olun.

İlk olarak aşağıdaki komutla kümeyi silin:

skaffold delete

Komut çıkışı

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

Küme silindikten sonra menü bölmesinde "IAM ve Yönetici" > "Ayarlar"ı seçin ve ardından "KAPAT" düğmesini tıklayın.

Ardından, iletişim kutusundaki forma proje kimliğini (proje adını değil) girin ve kapatma işlemini onaylayın.