1. परिचय
पिछली बार अपडेट किए जाने की तारीख: 05-03-2021
ऐप्लिकेशन को जांचने की क्षमता
देखना और OpenTelemetry
निगरानी करने की क्षमता का इस्तेमाल किसी सिस्टम के एट्रिब्यूट के बारे में बताने के लिए किया जाता है. मॉनिटर करने की क्षमता वाले सिस्टम की मदद से, टीमें अपने सिस्टम को लगातार डीबग कर सकती हैं. इस हिसाब से, निगरानी करने के तीन मुख्य आधार हैं; लॉग, मेट्रिक, और ट्रेस, सिस्टम को मॉनिटर करने की क्षमता पाने के बुनियादी इंस्ट्रुमेंट हैं.
OpenTelemetry, खास निर्देशों और SDK टूल का एक ऐसा सेट है जो इंस्ट्रुमेंटेशन और टेलीमेट्री डेटा (लॉग, मेट्रिक, और ट्रेस) को एक्सपोर्ट करने की रफ़्तार को बढ़ाता है, जिसके लिए निगरानी करने की ज़रूरत होती है. OpenTelemetry, CNCF के तहत एक ओपन स्टैंडर्ड और कम्यूनिटी की ओर से चलाया जाने वाला प्रोजेक्ट है. प्रोजेक्ट और इसके ईकोसिस्टम से मिली लाइब्रेरी का इस्तेमाल करके, डेवलपर अपने ऐप्लिकेशन को वेंडर न्यूट्रल तरीके से और एक से ज़्यादा आर्किटेक्चर के साथ इस्तेमाल कर सकते हैं.
डिस्ट्रिब्यूटेड ट्रेस
लॉग, मेट्रिक, और ट्रेस में से ट्रेस एक टेलीमेट्री है, जो सिस्टम में इस प्रोसेस के किसी खास हिस्से की इंतज़ार के समय के बारे में बताता है. खास तौर पर, माइक्रोसर्विस के दौर में, डिस्ट्रिब्यूटेड ट्रेस की मदद से, डिस्ट्रिब्यूट किए जाने वाले सिस्टम में आने वाली रुकावटों का पता लगाया जा सकता है.
डिस्ट्रिब्यूट किए गए ट्रेस का विश्लेषण करते समय, ट्रेस डेटा विज़ुअलाइज़ेशन एक नज़र में सिस्टम के पूरे इंतज़ार के समय को समझने का मुख्य ज़रिया होता है. डिस्ट्रिब्यूटेड ट्रेस में, हम सिस्टम के एंट्रीपॉइंट से जुड़े एक अनुरोध को प्रोसेस करने के लिए कई कॉल का सेट मैनेज करते हैं. यह अनुरोध कई स्पैन वाले ट्रेस के तौर पर होता है.
स्पैन, डिस्ट्रिब्यूटेड सिस्टम में किए गए काम की यूनिट को दिखाता है. इसमें, शुरू और खत्म होने का समय रिकॉर्ड होता है. स्पैन के एक-दूसरे के बीच अक्सर हैरारकी के संबंध होते हैं - नीचे की तस्वीर में, सभी छोटे स्पैन, एक बड़े /मैसेज स्पैन वाले चाइल्ड स्पैन हैं, और इन्हें एक ट्रेस में जोड़ दिया गया है, जो सिस्टम के ज़रिए काम का पाथ दिखाता है.
Google Cloud Trace, डिस्ट्रिब्यूटेड ट्रेस बैकएंड के लिए उपलब्ध विकल्पों में से एक है. साथ ही, यह Google Cloud में मौजूद अन्य प्रॉडक्ट के साथ अच्छी तरह इंटिग्रेट होता है.
आपको क्या बनाना होगा
इस कोडलैब में, आपको "Shakesapp" नाम की सेवाओं में इंस्ट्रुमेंट ट्रेस की जानकारी दिखेगी जो Google Kubernetes Engine पर चलने वाले Kubernetes क्लस्टर पर चलता है. शेक्स ऐप का आर्किटेक्चर नीचे बताया गया है:
- क्लाइंट, सर्वर को क्वेरी स्ट्रिंग भेजते हैं
- सर्वर, क्लाइंट की क्वेरी को स्वीकार करता है, Google Cloud Storage से शेक्सपियर के सभी कामों को टेक्स्ट फ़ॉर्मैट में फ़ेच करता है. साथ ही, क्वेरी वाली लाइनों में खोज करता है और क्लाइंट से मेल खाने वाली लाइन की संख्या दिखाता है.
अनुरोध में मौजूद ट्रेस की जानकारी का इस्तेमाल किया जाएगा.
आपको इनके बारे में जानकारी मिलेगी
- Python प्रोजेक्ट में OpenTelemetry ट्रेस लाइब्रेरी का इस्तेमाल शुरू करने का तरीका
- लाइब्रेरी के साथ स्पैन बनाने का तरीका
- ऐप्लिकेशन के कॉम्पोनेंट के बीच वायर पर स्पैन कॉन्टेक्स्ट लागू करने का तरीका
- Google Cloud Trace को ट्रेस का डेटा कैसे भेजें
- Google Cloud Trace पर ट्रेस का विश्लेषण करने का तरीका
यह कोडलैब आपकी माइक्रोसेवाओं को तैयार करने का तरीका बताता है. इसे आसानी से समझने के लिए, इस उदाहरण में सिर्फ़ तीन कॉम्पोनेंट शामिल किए गए हैं (लोड जनरेटर, क्लाइंट, और सर्वर). हालांकि, इस कोडलैब में बताई गई प्रोसेस को ज़्यादा जटिल और बड़ा सिस्टम भी लागू किया जा सकता है.
आपको इन चीज़ों की ज़रूरत होगी
- Python 3 की जानकारी
2. सेटअप और ज़रूरी शर्तें
अपने हिसाब से एनवायरमेंट सेटअप करना
अगर आपके पास पहले से Google खाता (Gmail या Google Apps) नहीं है, तो एक खाता बनाएं. Google Cloud Platform कंसोल ( console.cloud.google.com) में साइन इन करें और एक नया प्रोजेक्ट बनाएं.
अगर आपके पास पहले से कोई प्रोजेक्ट है, तो कंसोल के ऊपर बाईं ओर मौजूद, प्रोजेक्ट चुनने के लिए पुल डाउन मेन्यू पर क्लिक करें:
और 'नया प्रोजेक्ट' पर क्लिक करें बटन:
अगर आपके पास पहले से कोई प्रोजेक्ट नहीं है, तो आपको अपना पहला प्रोजेक्ट बनाने के लिए इस तरह का डायलॉग दिखेगा:
इसके बाद, प्रोजेक्ट बनाने वाले डायलॉग बॉक्स की मदद से अपने नए प्रोजेक्ट की जानकारी डाली जा सकती है:
वह प्रोजेक्ट आईडी याद रखें जो Google Cloud के सभी प्रोजेक्ट के लिए एक यूनीक नाम होता है. ऊपर दिया गया नाम पहले ही किसी दूसरे प्रोजेक्ट के लिए इस्तेमाल किया जा चुका है. इसलिए, यह आपके लिए काम नहीं करेगा! बाद में, इस कोडलैब में इसे PROJECT_ID के तौर पर दिखाया जाएगा.
इसके बाद, अगर आपने पहले से ऐसा नहीं किया है, तो आपको Google Cloud के संसाधनों का इस्तेमाल करने के लिए, Developers Console में बिलिंग चालू करनी होगी. साथ ही, Cloud Trace API को चालू करना होगा.
इस कोडलैब को आज़माने के लिए आपको कुछ डॉलर से ज़्यादा खर्च नहीं करना चाहिए. हालांकि, अगर आप ज़्यादा संसाधनों का इस्तेमाल करने का फ़ैसला करते हैं या उन्हें बंद कर देते हैं, तो यह ज़्यादा हो सकता है (इस दस्तावेज़ के आखिर में "क्लीनअप" सेक्शन देखें). Google Cloud Trace, Google Kubernetes Engine, और Google Artifacat Registry की कीमतों की जानकारी आधिकारिक दस्तावेज़ में दी गई है.
- Google Cloud के निगरानी करने की सुविधा की कीमत
- कीमत | Kubernetes Engine के दस्तावेज़
- Artifact Registry की कीमत | Artifact Registry का दस्तावेज़
Google Cloud Platform के नए उपयोगकर्ता 300 डॉलर के मुफ़्त में आज़माने की ज़रूरी शर्तें पूरी करते हैं. इसके तहत, कोडलैब का यह वर्शन बिना किसी शुल्क के इस्तेमाल किया जा सकता है.
Google Cloud Shell का सेटअप
Google Cloud और Google Cloud Trace को आपके लैपटॉप से दूर से भी ऑपरेट किया जा सकता है. हालांकि, इस कोडलैब में हम Google Cloud Shell का इस्तेमाल करेंगे. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.
Debian आधारित इस वर्चुअल मशीन में ऐसे सभी डेवलपमेंट टूल मौजूद हैं जिनकी आपको ज़रूरत पड़ेगी. यह पांच जीबी की स्थायी होम डायरेक्ट्री उपलब्ध कराता है और Google Cloud में चलता है. यह नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस को बेहतर बनाता है. इसका मतलब है कि इस कोडलैब के लिए आपको सिर्फ़ एक ब्राउज़र की ज़रूरत होगी. हां, यह Chromebook पर काम करता है.
Cloud Console से Cloud Shell को चालू करने के लिए, Cloud Shell को चालू करें 
पर क्लिक करें. प्रावधान करने और एनवायरमेंट से कनेक्ट होने में कुछ ही समय लगेगा.
Cloud Shell से कनेक्ट करने के बाद, आपको दिखेगा कि आपकी पुष्टि पहले ही हो चुकी है. साथ ही, यह प्रोजेक्ट पहले से ही आपके PROJECT_ID पर सेट है.
gcloud auth list
कमांड आउटपुट
Credentialed accounts: - <myaccount>@<mydomain>.com (active)
gcloud config list project
कमांड आउटपुट
[core] project = <PROJECT_ID>
अगर किसी कारण से, प्रोजेक्ट सेट नहीं है, तो बस निम्न आदेश जारी करें:
gcloud config set project <PROJECT_ID>
क्या आपको अपना PROJECT_ID चाहिए? देखें कि आपने सेटअप के चरणों में किस आईडी का इस्तेमाल किया है या इसे Cloud Console के डैशबोर्ड में देखें:
Cloud Shell, डिफ़ॉल्ट रूप से कुछ एनवायरमेंट वैरिएबल सेट करता है. ये वैरिएबल, आने वाले समय में कमांड चलाने के दौरान काम आ सकते हैं.
echo $GOOGLE_CLOUD_PROJECT
कॉमैंड आउटपुट
<PROJECT_ID>
आखिर में, डिफ़ॉल्ट ज़ोन और प्रोजेक्ट कॉन्फ़िगरेशन सेट करें.
gcloud config set compute/zone us-central1-f
आपके पास कई तरह के ज़ोन चुनने का विकल्प होता है. ज़्यादा जानकारी के लिए, क्षेत्र और ज़ोन.
Python सेटअप
इस कोडलैब में, हम "कविता" का इस्तेमाल करते हैं पैकेज वर्शन को सख्ती से प्रबंधित करने के लिए किया जा सकता है. Cloud Shell पर यह कमांड चलाएं:
curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python3 - source $HOME/.poetry/env
Google Kubernetes क्लस्टर सेट अप करना
इस कोडलैब में, Google Kubernetes Engine (GKE) पर माइक्रोसर्विस का क्लस्टर चलाया जाएगा. इस कोडलैब की प्रोसेस इस तरह है:
- Cloud Shell में बेसलाइन प्रोजेक्ट डाउनलोड करें
- कंटेनर में माइक्रोसर्विस बनाएं
- Google Artifact Registry (GAR) पर कंटेनर अपलोड करना
- GKE (जीकेई) पर कंटेनर डिप्लॉय करना
- ट्रेस इंस्ट्रुमेंटेशन के लिए सेवाओं का सोर्स कोड बदलें
- दूसरे चरण पर जाएं
Kubernetes इंजन चालू करना
सबसे पहले, हम Kubernetes क्लस्टर सेट अप करते हैं. इसमें GKE (जीकेई) पर शेक्स ऐप्लिकेशन चलता है. इसलिए, हमें GKE (जीकेई) चालू करना होगा. "Kubernetes Engine" मेन्यू पर जाएं और 'चालू करें' बटन दबाएं.
अब आप Kubernetes क्लस्टर बनाने के लिए तैयार हैं.
Kubernetes क्लस्टर बनाना
Cloud Shell पर, Kubernetes क्लस्टर बनाने के लिए नीचे दिया गया कमांड चलाएं. कृपया पुष्टि करें कि ज़ोन की वैल्यू उस क्षेत्र में है जिसे आपने Artifact Registry का डेटा स्टोर करने की जगह बनाने के लिए इस्तेमाल किया है. अगर आपके रिपॉज़िटरी क्षेत्र में ज़ोन शामिल नहीं है, तो ज़ोन की वैल्यू us-central1-f बदलें.
gcloud container clusters create otel-trace-codelab --zone us-central1-f \ --num-nodes 1 \ --machine-type e2-highcpu-4
कमांड आउटपुट
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 और स्केफ़ोल्ड का सेटअप
अब हमारे पास Kubernetes क्लस्टर है, जो डिप्लॉय करने के लिए तैयार है. इसके बाद, हम कंटेनर को पुश और डिप्लॉय करने के लिए, एक कंटेनर रजिस्ट्री की तैयारी करते हैं. इन चरणों का इस्तेमाल करने के लिए, हमें GAR और स्केलोल्ड सेट अप करना होगा.
Artifact Registry का सेटअप करना
"Artifact Registry" के मेन्यू पर जाएं और 'चालू करें' बटन दबाएं.
कुछ देर बाद, आपको GAR का डेटा स्टोर करने की जगह वाला ब्राउज़र दिखेगा. "डेटा स्टोर करने की जगह बनाएं" पर क्लिक करें बटन पर क्लिक करें और रिपॉज़िटरी का नाम डालें.
इस कोडलैब में, मैंने डेटा स्टोर करने की नई जगह को trace-codelab नाम दिया है. आर्टफ़ैक्ट का फ़ॉर्मैट "डॉकर" है और जगह का टाइप "Region" है. Google Compute Engine के डिफ़ॉल्ट ज़ोन के लिए सेट किए गए इलाके के आस-पास का इलाका चुनें. उदाहरण के लिए, इस उदाहरण में "us-central1-f" को चुना गया ऊपर दी गई है, इसलिए यहां हमने "us-central1 (आयोवा)" को चुना है. इसके बाद, "बनाएं" पर क्लिक करें बटन.
अब आपको "ट्रेस-कोडलैब" दिखता है रिपॉज़िटरी ब्राउज़र पर.
हम रजिस्ट्री पाथ की जांच करने के लिए बाद में यहां वापस आएंगे.
Skaffold का सेटअप
Skaffold, एक आसान टूल है. इसका इस्तेमाल Kubernetes पर, माइक्रोसर्विस बनाने के लिए किया जाता है. यह कमांड के छोटे सेट वाले ऐप्लिकेशन के कंटेनर बनाने, पुश करने, और डिप्लॉय करने का वर्कफ़्लो मैनेज करता है. Skoffold, डिफ़ॉल्ट रूप से कंटेनर रजिस्ट्री के रूप में Docker Registry का इस्तेमाल करते हैं. इसलिए, आपको कंटेनर को पुश करने पर GAR की पहचान करने के लिए, skaffold को कॉन्फ़िगर करना होगा.
Cloud Shell को फिर से खोलें और पुष्टि करें कि स्कैफ़ोल्ड को इंस्टॉल किया गया है. Cloud Shell पर, डिफ़ॉल्ट रूप से एनवायरमेंट में स्केलोल्ड इंस्टॉल होता है. निम्न कमांड चलाएं और स्केलोल्ड वर्शन देखें.
skaffold version
कमांड आउटपुट
v1.20.0
अब आपके पास स्केलोल्ड के इस्तेमाल के लिए, डिफ़ॉल्ट रिपॉज़िटरी को रजिस्टर करने का विकल्प है. रजिस्ट्री पाथ पाने के लिए, Artifact Registry के डैशबोर्ड पर जाएं. इसके बाद, डेटा स्टोर करने की उस जगह के नाम पर क्लिक करें जिसे आपने पिछले चरण में सेट अप किया था.
इसके बाद, आपको पेज के सबसे ऊपर ब्रेडक्रंब की जगहें दिखेंगी. रजिस्ट्री पाथ को क्लिपबोर्ड पर कॉपी करने के लिए, 
आइकॉन पर क्लिक करें.
'कॉपी करें' बटन पर क्लिक करने पर, आपको ब्राउज़र के सबसे नीचे एक डायलॉग बॉक्स दिखेगा. इस मैसेज में यह मैसेज दिखेगा:
"us-central1-docker.pkg.dev/psychic-order-307806/trace-codelab" कॉपी किया गया
क्लाउड शेल पर वापस जाएं. skaffold config set default-repo कमांड को उस वैल्यू के साथ चलाएं जिसे आपने अभी-अभी डैशबोर्ड से कॉपी किया है.
skaffold config set default-repo us-central1-docker.pkg.dev/psychic-order-307806/trace-codelab
कमांड आउटपुट
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
साथ ही, आपको रजिस्ट्री को Docker कॉन्फ़िगरेशन में कॉन्फ़िगर करना होगा. नीचे दिया गया निर्देश चलाएं:
gcloud auth configure-docker us-central1-docker.pkg.dev --quiet
कमांड आउटपुट
{
"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
अब आप GKE (जीकेई) पर Kubernetes कंटेनर सेट अप करने के लिए, अगले चरण पर जा सकते हैं.
खास जानकारी
इस चरण में, कोडलैब एनवायरमेंट को सेट अप किया जाता है:
- Cloud Shell सेट अप करना
- कंटेनर रजिस्ट्री के लिए, आर्टफ़ैक्ट रजिस्ट्री का डेटा स्टोर करने की जगह बनाई गई
- कंटेनर रजिस्ट्री का इस्तेमाल करने के लिए, skaffold सेट अप करना
- एक Kubernetes क्लस्टर बनाया गया है, जहां कोडलैब माइक्रोसर्विस चलता है
अगला वीडियो
अगले चरण में, आपको अपनी माइक्रोसर्विस को क्लस्टर में बनाना, पुश करना, और डिप्लॉय करना
3. माइक्रोसर्विस बनाएं, पुश करें, और डिप्लॉय करें
कोडलैब का कॉन्टेंट डाउनलोड करना
पिछले चरण में, हमने इस कोडलैब के लिए सभी ज़रूरी शर्तें सेट अप कर ली हैं. अब आप उनके ऊपर पूरी माइक्रोसेवाएं चलाने के लिए तैयार हैं. कोडलैब का कॉन्टेंट, GitHub पर होस्ट किया जाता है. इसलिए, यहां दिए गए git कमांड की मदद से, Cloud Shell एनवायरमेंट में उन्हें डाउनलोड करें.
cd ~ git clone https://github.com/GoogleCloudPlatform/opentelemetry-trace-codelab-python.git
प्रोजेक्ट की डायरेक्ट्री का स्ट्रक्चर इस तरह है:
shakesapp-python
├── LICENSE
├── manifests
│ ├── client.yaml
│ ├── loadgen.yaml
│ └── server.yaml
├── proto
│ └── shakesapp.proto
├── skaffold.yaml
└── src
├── client
├── loadgen
└── server
- मेनिफ़ेस्ट: Kubernetes मेनिफ़ेस्ट फ़ाइलें
- प्रोटो: क्लाइंट और सर्वर के बीच कम्यूनिकेशन के लिए प्रोटो डेफ़िनिशन
- src: हर सेवा के सोर्स कोड के लिए डायरेक्ट्री
- skaffold.yaml: skaffold के लिए कॉन्फ़िगरेशन फ़ाइल
skaffold कमांड चलाएं
आखिरकार, आप अभी बनाए गए Kubernetes क्लस्टर पर बनाने, पुश और लागू करने के लिए तैयार हैं. इसमें कई चरण शामिल हैं, लेकिन असल में यह आपके लिए सब कुछ करता है. इसे नीचे दिए गए निर्देश की मदद से करके देखते हैं:
cd shakesapp-python skaffold run --tail
आदेश चलाते ही, आपको docker build का लॉग आउटपुट दिखाई देता है और आप पुष्टि कर सकते हैं कि उन्हें रजिस्ट्री में सफलतापूर्वक पुश कर दिया गया है.
कमांड आउटपुट
... ---> 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
सभी सर्विस कंटेनर को पुश करने के बाद, Kubernetes के डिप्लॉयमेंट अपने-आप शुरू हो जाते हैं.
कमांड आउटपुट
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
चेतावनी: अगर आपको "चुने गए इमेज रिपॉज़िटरी (डेटा स्टोर करने की जगह) में पुश ऐक्सेस नहीं" जैसा गड़बड़ी का मैसेज मिलता है, तो देखें कि skaffold कमांड, Docker Hub (docker.io) में इमेज भेजने की कोशिश कर रहा है या नहीं. भले ही, skaffold में डिफ़ॉल्ट रेपो पर आपका कॉन्फ़िगरेशन कुछ भी हो. ऐसी स्थिति में, "–default-repo" जोड़कर देखें "स्केफ़ोल्ड रन" का विकल्प नीचे देखें.
$ skaffold चलाना –tail –default-repo=us-central1-docker.pkg.dev/[project ID]/[डेटा स्टोर करने की जगह का नाम]
डिप्लॉयमेंट के बाद, आपको हर कंटेनर में stdout पर भेजे जाने वाले असल ऐप्लिकेशन लॉग इस तरह दिखेंगे:
कमांड आउटपुट
[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"}
सेवाओं की डिस्ट्रिब्यूटेड ट्रेसिंग के लिए, अब आप OpenTelemetry के साथ अपना आवेदन तैयार कर सकते हैं.
खास जानकारी
इस चरण में, आपने अपने एनवायरमेंट में कोडलैब मटीरियल तैयार किया है और उम्मीद के मुताबिक स्कैफ़ोल्ड के चलने की पुष्टि की है.
अगला वीडियो
अगले चरण में, आपको ट्रेस जानकारी को तैयार करने के लिए, loadgen सेवा के सोर्स कोड में बदलाव करना होगा.
4. एचटीटीपी के लिए इंस्ट्रुमेंटेशन
ट्रेस इंस्ट्रुमेंटेशन और प्रोपगेशन का सिद्धांत
सोर्स कोड में बदलाव करने से पहले, मुझे एक आसान डायग्राम में यह बताना होगा कि डिस्ट्रिब्यूट किए गए ट्रेस कैसे काम करते हैं.
इस उदाहरण में, हम ट्रेस और स्पैन की जानकारी को Cloud Trace में एक्सपोर्ट करने के लिए कोड का इस्तेमाल करते हैं. साथ ही, लोड जेन सेवा से सर्वर सेवा को किए गए अनुरोध पर, ट्रेस कॉन्टेक्स्ट लागू करते हैं.
ऐप्लिकेशन को ट्रेस आईडी और स्पैन आईडी जैसा ट्रेस मेटाडेटा भेजना होगा, ताकि Cloud Trace ऐसी सभी स्पैन को इकट्ठा कर सके जिनमें एक ही ट्रेस आईडी है. साथ ही, ऐप्लिकेशन को डाउनस्ट्रीम सेवाओं का अनुरोध करने पर ट्रेस कॉन्टेक्स्ट (पैरंट स्पैन के ट्रेस आईडी और स्पैन आईडी का कॉम्बिनेशन) लागू करना होगा, ताकि उन्हें यह पता चल सके कि वे किस ट्रेस कॉन्टेक्स्ट को हैंडल कर रहे हैं.
OpenTelemetry इन कामों में आपकी मदद करता है:
- यूनीक ट्रेस आईडी और स्पैन आईडी जनरेट करने के लिए
- ट्रेस आईडी और स्पैन आईडी को बैकएंड में एक्सपोर्ट करने के लिए
- ट्रेस कॉन्टेक्स्ट को अन्य सेवाओं पर लागू करने के लिए
इंस्ट्रुमेंट की पहली अवधि
इंस्ट्रुमेंट लोड जनरेटर सेवा
क्लाउड शेल के सबसे ऊपर दाईं ओर मौजूद 
बटन को दबाकर, क्लाउड शेल एडिटर खोलें. बाएं पैनल में एक्सप्लोरर से src/loadgen/loadgen.py खोलें और 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)
main फ़ंक्शन में, आपको फ़ंक्शन call_client को कॉल करने वाला लूप दिखता है. मौजूदा तरीके के इस्तेमाल में, sectoin में दो लॉग लाइनें होती हैं, जो फ़ंक्शन कॉल की शुरुआत और आखिर में रिकॉर्ड करती हैं. आइए, अब फ़ंक्शन कॉल की इंतज़ार के समय को ट्रैक करने के लिए इंस्ट्रुमेंट स्पैन की जानकारी का इस्तेमाल करते हैं.
सबसे पहले, आपको एक खास ट्रेस आईडी और स्पैन आईडी वाला स्पैन बनाना होगा. OpenTelemetry इसके लिए आसान लाइब्रेरी उपलब्ध कराता है. OpenTelemetry लाइब्रेरी को अपने कोड में इंपोर्ट करने के लिए, ये लाइनें जोड़ें.
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
लोड जनरेटर, requests मॉड्यूल के ज़रिए क्लाइंट ऐप्लिकेशन को एचटीटीपी में कॉल कर रहा है. इसलिए, हम requests के लिए एक्सटेंशन पैकेज का इस्तेमाल करते हैं और इंस्ट्रुमेंटेशन को चालू करते हैं.
from opentelemetry.propagators.cloud_trace_propagator import CloudTraceFormatPropagator
+
+RequestsInstrumentor().instrument()
इसके बाद, ट्रेसर इंस्टेंस सेट अप करें, जो ट्रेस कॉन्टेन्क्स्ट और एक्सपोर्टर सेटिंग को हैंडल करता है
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}")
ध्यान दें कि यह एक कोडलैब है, जो ट्रेस इंस्ट्रुमेंटेशन के काम करने का तरीका समझने में मदद करता है. इसलिए, हम ट्रेसर को कॉन्फ़िगर करके हर अनुरोध को रिकॉर्ड करते हैं और उसे बैकएंड पर भेजते हैं. (SimpleSpanProcessor()) ऐसा करना, प्रोडक्शन के लिए सही नहीं है. इसलिए, प्रोडक्शन के लिए आवेदन करते समय इस हिस्से में बदलाव ज़रूर करें.
अब ट्रेसर की मदद से स्पेंस को इंस्ट्रुमेंट करें. यहां बिंदु यह है कि आपको स्पष्ट रूप से स्पैन जनरेट करना है, और बस इतना ही! हालांकि, इवेंट मेटाडेटा को स्पैन में जोड़ने वाली दो लाइनें, आपको मैन्युअल रूप से यूनीक ट्रेस आईडी और स्पैन आईडी जनरेट करने और उन्हें स्पैन में एम्बेड करने की ज़रूरत नहीं होती है.
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 बिल्ड ज़रूरी OpenTelemetry पैकेज फ़ेच कर सके, इसके लिए यह कमांड चलाएं:
poetry add "opentelemetry-exporter-gcp-trace=^1.0.0rc0" poetry add "opentelemetry-propagator-gcp=^1.0.0rc0" poetry add "opentelemetry-instrumentation-requests=^0.20b0"
यह पुष्टि की जा सकती है कि इससे जुड़ा डिपेंडेंसी ब्यौरा pyproject.toml में लिखा गया है.
इंस्ट्रुमेंट क्लाइंट सेवा
पिछले सेक्शन में, हमने नीचे दी गई ड्रॉइंग में लाल आयत में बंद हिस्से को इंस्ट्रुमेंट किया. हमने लोड जनरेटर सेवा में अवधि की जानकारी शामिल की है. लोड जनरेट करने वाली सेवा की तरह ही, अब हमें क्लाइंट सेवा को इंस्ट्रुमेंट करना होगा. लोड जनरेटर सेवा से अंतर यह है कि क्लाइंट सेवा को एचटीटीपी हेडर में लोड जनरेटर सेवा से ली गई ट्रेस आईडी जानकारी को एक्सट्रैक्ट करना होता है और स्पैन जनरेट करने के लिए आईडी का इस्तेमाल करना होता है.
क्लाउड शेल एडिटर खोलें और ज़रूरी मॉड्यूल जोड़ें. जैसा कि हमने लोड जनरेटर सेवा के लिए किया था.
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
आपने देखा है कि आपने अभी-अभी FlaskInstrumentor को इंपोर्ट किया है. यह उपयोगकर्ताओं की ओर से, फ़्लास्क ऐप्लिकेशन के लिए अपने-आप बनने वाले इंस्ट्रुमेंटेशन को चालू करता है, ताकि एक ही लाइन का इस्तेमाल करके ट्रेस कॉन्टेक्स्ट पाने के लिए एचटीटीपी हेडर एक्सट्रैक्ट किए जा सकें. OpenTelemetry कम्यूनिटी, दूसरी बड़ी लाइब्रेरी के साथ इसी तरह के काम के इंटिग्रेशन उपलब्ध कराती है. ज़्यादा जानकारी के लिए, आधिकारिक दस्तावेज़ देखें.
app = flask.Flask(__name__)
+FlaskInstrumentor().instrument_app(app)
इंस्ट्रुमेंटेशन शुरू करने से पहले, आपको फिर से वही ट्रेसर इंस्टेंस तैयार करना होगा जो हमने लोड जनरेटर सेवा में किया था.
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():
....
अब इससे हैंडलर में इंस्ट्रुमेंटेशन जोड़ा जा सकता है. main_handler() को ढूंढें और उस हिस्से में बदलाव करें जो सर्वर सेवा से gRPC अनुरोध भेजता है.
@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
इसी तरह जनरेटर सेवा लोड करने के लिए, नीचे दिए गए निर्देश से pyproject.toml में ज़रूरी पैकेज जोड़ें.
poetry add "opentelemetry-exporter-gcp-trace=^1.0.0rc0" poetry add "opentelemetry-propagator-gcp=^1.0.0rc0" poetry add "opentelemetry-instrumentation-flask=^0.20b0"
इसके बाद, skaffold run निर्देश से ऐप्लिकेशन लॉन्च करें और देखें कि Cloud Trace डैशबोर्ड क्या दिखाता है:
skaffold run --tail
कुछ बिल्ड देखने के बाद, मैसेज पुश और डिप्लॉय करने पर, आपको JSON फ़ॉर्मैट में ऐप्लिकेशन लॉग दिखेंगे. खुद को Cloud Trace पर जाएं > आपको ट्रेस की जानकारी मिल रही है या नहीं, यह देखने के लिए ट्रेस सूची. लोड जनरेटर सेवा समय-समय पर क्लाइंट सेवा को अनुरोध भेजती है और आपने सभी अनुरोधों के लिए ट्रेस चालू कर दिए हैं. इसलिए, आपको ट्रेस सूची में बहुत सारे बिंदु दिखने लगते हैं.
इनमें से किसी एक पर क्लिक करने पर, आपको नीचे एक वॉटरफ़ॉल ग्राफ़ दिखेगा. इसमें बताया गया है कि अनुरोध और जवाब की प्रोसेस के दौरान, हर हिस्से को लोड होने में कितना समय लगता है. "इवेंट दिखाएं" के बगल में मौजूद चेकबॉक्स को ढूंढने के बाद, आपको वॉटरफ़ॉल ग्राफ़ में एनोटेशन मिलेंगे. ये वे एनोटेशन हैं जिन्हें आपने span.add_event() तरीके से कोड में इंस्ट्रुमेंट किया है.
आपको ऐसा लग सकता है कि आपको सर्वर सेवा से स्पैन नहीं दिख रहे हैं. यह सही है, क्योंकि हमने सर्वर सेवा में भी Spans को इस्तेमाल नहीं किया है.
खास जानकारी
इस चरण में, आपने लोड जनरेटर सेवा और क्लाइंट सेवा को इंस्ट्रुमेंट किया है और पुष्टि की है कि आप सभी सेवाओं में ट्रेस कॉन्टेक्स्ट लागू कर सकते हैं और दोनों सेवाओं से स्पैन की जानकारी को Cloud Trace में एक्सपोर्ट कर सकते हैं.
अगला वीडियो
अगले चरण में, आपको क्लाइंट सेवा और सर्वर सेवा को इंस्ट्रुमेंट करना होगा, ताकि यह पुष्टि की जा सके कि gRPC के ज़रिए ट्रेस कॉन्टेक्स्ट को कैसे लागू किया जाए.
5. gRPC के लिए इंस्ट्रुमेंटेशन
पिछले चरण में, हमने इस माइक्रोसर्विस में अनुरोध के पहले आधे हिस्से को शामिल किया था. इस चरण में, हम क्लाइंट सेवा और सर्वर सेवा के बीच gRPC कम्यूनिकेशन करने की कोशिश करते हैं. (नीचे दिए गए चित्र में हरा और बैंगनी आयत)
gRPC क्लाइंट के लिए अपने-आप बनने वाले इंस्ट्रुमेंटेशन
OpenTelemetry के नेटवर्क में ऐसी कई लाइब्रेरी हैं जिन्हें आसानी से इस्तेमाल किया जा सकता है, जिनसे डेवलपर को इंस्ट्रुमेंट वाले ऐप्लिकेशन इस्तेमाल करने में मदद मिलती है. पिछले चरण में, हमने "अनुरोधों" के लिए अपने-आप काम करने वाले इंस्ट्रुमेंटेशन का इस्तेमाल किया था मॉड्यूल का इस्तेमाल नहीं किया जाएगा. इस चरण में, जब हम gRPC के ज़रिए ट्रेस कॉन्टेक्स्ट को लागू करने की कोशिश कर रहे हैं, तब हम इसके लिए लाइब्रेरी का इस्तेमाल करते हैं.
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()
क्लाइंट सेवा के लिए, हमें इंस्ट्रुमेंटेशन के लिए जो करना होगा वह बहुत छोटा है. हम ट्रेस संदर्भ का प्रचार करना चाहते हैं, जो gRPC के ज़रिए मौजूदा स्पैन के ट्रेस आईडी और स्पैन आईडी का कॉम्बिनेशन होता है. इसलिए हम GrpcInstrumentatorClient.instrument() को कॉल करते हैं, ताकि हैंडर फ़ंक्शन में मौजूद gRPC क्लाइंट, नीचे दिए गए एचटीटीपी हेडर में ट्रेस कॉन्टेक्स्ट एम्बेड कर सके.
poetry add निर्देश की मदद से, pyproject.toml में नई डिपेंडेंसी जोड़ना न भूलें:
poetry add "opentelemetry-instrumentation-grpc=^0.20b0"
gRPC सर्वर के लिए अपने-आप बनने वाले इंस्ट्रुमेंटेशन
हमने gRPC क्लाइंट के लिए जो किया, उसी तरह हम gRPC सर्वर के लिए ऑटोमैटिक इंस्ट्रुमेंटेशन को कहते हैं. फ़ॉलो करने के तरीकों जैसे इंपोर्ट जोड़ें और फ़ाइल में सबसे ऊपर GrpcInstrumentationServer().instrument() को कॉल करें.
चेतावनी: कॉल ज़रूर करें
GrpcInstrumentationServe()
इस चरण में, न कि
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()
+
इसके बाद, आपको ट्रेस की जानकारी Cloud Trace बैकएंड को भेजने के लिए, एक्सपोर्टर को जोड़ना होगा. 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)
सर्वर सेवा में, जोड़े गए नए पैकेज ज़रूर जोड़ें.
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"
माइक्रोसर्विस चलाएं और ट्रेस की पुष्टि करें
इसके बाद, skaffold कमांड से बदले गए कोड को चलाएं.
skaffold run --tail
अब एक बार फिर, आपको Cloud Trace के ट्रेस की सूची वाले पेज में कई ट्रेस दिखेंगे. किसी एक ट्रेस पर क्लिक करने पर आपको पता चलता है कि वह ट्रिगर, लोड जनरेट करने वाली सेवा से लेकर सर्वर सेवा तक के अनुरोध का हिस्सा है.
खास जानकारी
इस चरण में, आपने OpenTelemetry नेटवर्क लाइब्रेरी की मदद से gRPC आधारित कम्यूनिकेशन तैयार किया है. साथ ही, आपने पुष्टि की है कि लोड जनरेटर सेवा में जनरेट किया गया ट्रेस कॉन्टेक्स्ट, सर्वर सेवा को डिलीवर कर दिया गया है.
6. बधाई हो
आपने OpenTelemery की मदद से, डिस्ट्रिब्यूटेड ट्रेस बना लिए हैं. साथ ही, आपने Google Cloud Trace की माइक्रोसेवा में, अनुरोध के बाद के समय की पुष्टि कर दी है.
ज़्यादा समय तक कसरत करने के लिए, इन विषयों को खुद आज़माया जा सकता है.
- फ़िलहाल, लागू करने की प्रोसेस के दौरान हेल्थ जांच से जनरेट हुए सभी स्पैन भेजे जाते हैं. Cloud Traces से इन स्पैन को कैसे फ़िल्टर किया जा सकता है? हिंट यहां दिया गया है.
- इवेंट लॉग को स्पैन के साथ जोड़ें और देखें कि यह Google Cloud Trace और Google Cloud Logging पर कैसे काम करता है. हिंट यहां दिया गया है.
- किसी सेवा को दूसरी भाषा की सेवा से बदलें और उस भाषा के लिए OpenTelemetry के ज़रिए इसे आज़माएं
चेतावनी: Google Kubernetes Engine और Google Artifact Registry, संसाधनों का लगातार इस्तेमाल करते हैं.
खाली करने के लिए जगह
इस कोडलैब के बाद, कृपया Kubernetes क्लस्टर को बंद करें और प्रोजेक्ट को ज़रूर मिटाएं. इससे, Google Kubernetes Engine, Google Cloud Trace, Google Artifact Registry पर, आपसे अचानक कोई शुल्क न लिया जाए.
सबसे पहले, नीचे दिए गए निर्देश से क्लस्टर को मिटाएं:
skaffold delete
कमांड आउटपुट
Cleaning up... - deployment.apps "clientservice" deleted - service "clientservice" deleted - deployment.apps "loadgen" deleted - deployment.apps "serverservice" deleted - service "serverservice" deleted
क्लस्टर मिटाने के बाद, मेन्यू पैनल से, "IAM और एडमिन" > "सेटिंग", और फिर "बंद करें" पर क्लिक करें बटन.
इसके बाद, डायलॉग बॉक्स में दिए गए फ़ॉर्म में प्रोजेक्ट का आईडी डालें, न कि प्रोजेक्ट का नाम डालें और बंद करने की पुष्टि करें.