OpenTelemetry का इस्तेमाल करके, इंस्ट्रुमेंट ट्रेस करने की जानकारी

1. परिचय

पिछले अपडेट की तारीख: 05-03-2021

ऐप्लिकेशन की निगरानी करने की सुविधा

Observability और OpenTelemetry

ऑब्ज़र्वेबिलिटी, किसी सिस्टम की एक विशेषता होती है. ऑब्ज़र्वेबिलिटी की सुविधा वाले सिस्टम की मदद से, टीमें अपने सिस्टम को आसानी से डीबग कर सकती हैं. इस संदर्भ में, सिस्टम के लिए तीन मुख्य बातें ज़रूरी हैं: लॉग, मेट्रिक, और ट्रेस. ये सिस्टम को ऑब्ज़र्वेबिलिटी हासिल करने में मदद करती हैं.

OpenTelemetry, स्पेसिफ़िकेशन और SDK का एक सेट है. यह टेलीमेट्री डेटा (लॉग, मेट्रिक, और ट्रेस) के इंस्ट्रुमेंटेशन और एक्सपोर्ट की प्रोसेस को तेज़ करता है. इस डेटा की ज़रूरत ऑब्ज़र्वेबिलिटी के लिए होती है. OpenTelemetry, एक ओपन स्टैंडर्ड है. साथ ही, यह CNCF के तहत कम्यूनिटी की ओर से चलाया जाने वाला प्रोजेक्ट है. प्रोजेक्ट और इसके इकोसिस्टम की ओर से उपलब्ध कराई गई लाइब्रेरी का इस्तेमाल करके, डेवलपर अपने ऐप्लिकेशन को वेंडर न्यूट्रल तरीके से और कई आर्किटेक्चर के हिसाब से इंस्ट्रुमेंट कर सकते हैं.

डिस्ट्रिब्यूटेड ट्रेस

लॉग, मेट्रिक, और ट्रेस में से ट्रेस, टेलीमेट्री है. यह सिस्टम में प्रोसेस के किसी खास हिस्से की लेटेन्सी के बारे में बताती है. खास तौर पर, माइक्रोसेवाओं के इस दौर में, डिस्ट्रिब्यूटेड ट्रेसिंग की मदद से, डिस्ट्रिब्यूटेड सिस्टम में लेटेन्सी की समस्याओं का पता लगाया जा सकता है.

डिस्ट्रिब्यूटेड ट्रेस का विश्लेषण करते समय, ट्रेस डेटा विज़ुअलाइज़ेशन की मदद से, सिस्टम की कुल लेटेंसी को एक नज़र में समझा जा सकता है. डिस्ट्रीब्यूटेड ट्रेस में, हम कॉल के एक सेट को मैनेज करते हैं, ताकि सिस्टम के एंट्रीपॉइंट पर एक अनुरोध को प्रोसेस किया जा सके. यह अनुरोध, एक ऐसे ट्रेस के तौर पर होता है जिसमें कई स्पैन शामिल होते हैं.

स्पैन, डिस्ट्रिब्यूटेड सिस्टम में किए गए काम की एक यूनिट को दिखाता है. यह रिकॉर्डिंग शुरू और बंद होने के समय को भी दिखाता है. स्पैन के बीच अक्सर क्रमबद्ध संबंध होते हैं. नीचे दी गई इमेज में, सभी छोटे स्पैन, बड़े /messages स्पैन के चाइल्ड स्पैन हैं. इन्हें एक ऐसे ट्रेस में असेंबल किया जाता है जो किसी सिस्टम में काम करने का तरीका दिखाता है.

Google Cloud Trace, डिस्ट्रिब्यूटेड ट्रेस बैकएंड के लिए उपलब्ध विकल्पों में से एक है. यह Google Cloud के अन्य प्रॉडक्ट के साथ अच्छी तरह से इंटिग्रेट किया गया है.

आपको क्या बनाने को मिलेगा

इस कोडलैब में, आपको "Shakesapp" नाम की सेवाओं में ट्रेस की जानकारी को इंस्ट्रुमेंट करना है. ये सेवाएं, Google Kubernetes Engine पर चल रहे Kubernetes क्लस्टर पर चलती हैं. Shakesapp का आर्किटेक्चर इस तरह से काम करता है:

क्लाइंट, सर्वर को क्वेरी स्ट्रिंग भेजता है
सर्वर, क्लाइंट से मिली क्वेरी को स्वीकार करता है. इसके बाद, Google Cloud Storage से शेक्सपियर की सभी रचनाओं को टेक्स्ट फ़ॉर्मैट में फ़ेच करता है. फिर, क्वेरी से मिलती-जुलती लाइनों को खोजता है और क्लाइंट को उन लाइनों की संख्या दिखाता है.

आपको पूरे अनुरोध में ट्रेस की जानकारी देनी होगी.

आपको क्या सीखने को मिलेगा

Python प्रोजेक्ट में OpenTelemetry Trace लाइब्रेरी का इस्तेमाल कैसे शुरू करें
लाइब्रेरी की मदद से स्पैन बनाने का तरीका
ऐप्लिकेशन कॉम्पोनेंट के बीच वायर पर स्पैन कॉन्टेक्स्ट को कैसे फैलाएं
Google Cloud Trace को ट्रेस डेटा भेजने का तरीका
Google Cloud Trace पर ट्रेस का विश्लेषण कैसे करें

इस कोडलैब में, माइक्रोसेवाओं को इंस्ट्रुमेंट करने का तरीका बताया गया है. इसे आसानी से समझने के लिए, इस उदाहरण में सिर्फ़ तीन कॉम्पोनेंट (लोड जनरेटर, क्लाइंट, और सर्वर) शामिल हैं. हालांकि, इस कोडलैब में बताई गई प्रोसेस को ज़्यादा जटिल और बड़े सिस्टम पर भी लागू किया जा सकता है.

आपको इन चीज़ों की ज़रूरत होगी

Python 3 की जानकारी

2. सेटअप और ज़रूरी शर्तें

अपने हिसाब से एनवायरमेंट सेट अप करना

अगर आपके पास पहले से कोई Google खाता (Gmail या Google Apps) नहीं है, तो आपको एक खाता बनाना होगा. Google Cloud Platform Console ( 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 Platform के नए उपयोगकर्ताओं को, मुफ़्त में आज़माने के लिए 300 डॉलर मिलते हैं. इससे इस कोडलैब का इस्तेमाल बिना किसी शुल्क के किया जा सकता है.

Google Cloud Shell सेटअप करना

Google Cloud और Google Cloud Trace को अपने लैपटॉप से रिमोटली ऐक्सेस किया जा सकता है. हालांकि, इस कोडलैब में हम Google Cloud Shell का इस्तेमाल करेंगे. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.

यह Debian पर आधारित वर्चुअल मशीन है. इसमें डेवलपमेंट के लिए ज़रूरी सभी टूल पहले से मौजूद हैं. यह 5 जीबी की होम डायरेक्ट्री उपलब्ध कराता है और Google Cloud में चलता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस बेहतर होती है. इसका मतलब है कि इस कोडलैब के लिए, आपको सिर्फ़ एक ब्राउज़र की ज़रूरत होगी. हां, यह Chromebook पर भी काम करता है.

Cloud Console से Cloud Shell को चालू करने के लिए, बस Cloud Shell चालू करें gcLMt5IuEcJJNnMId-Bcz3sxCd0rZn7IzT_r95C8UZeqML68Y1efBG_B0VRp7hc7qiZTLAF-TXD7SsOadxn8uadgHhaLeASnVS3ZHK39eOlKJOgj9SJua_oeGhMxRrbOg3qigddS2A पर क्लिक करें. इसे चालू होने और एनवायरमेंट से कनेक्ट होने में कुछ ही समय लगता है.

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 सेटअप करना

इस कोडलैब में, हम पैकेज के वर्शन को मैनेज करने के लिए "poetry" का इस्तेमाल करते हैं. Cloud Shell पर यह कमांड चलाएं:

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

Google Kubernetes Cluster सेट अप करना

इस कोडलैब में, Google Kubernetes Engine (GKE) पर माइक्रोसेवाओं का क्लस्टर चलाया जाएगा. इस कोडलैब की प्रोसेस इस तरह है:

बेसलाइन प्रोजेक्ट को Cloud Shell में डाउनलोड करें
कंटेनर में माइक्रोसेवाएं बनाना
कंटेनर को Google Artifact Registry (GAR) पर अपलोड करना
GKE पर कंटेनर डिप्लॉय करना
ट्रेस इंस्ट्रूमेंटेशन के लिए, सेवाओं के सोर्स कोड में बदलाव करना
दूसरे चरण पर जाएं

Kubernetes Engine चालू करें

सबसे पहले, हम एक Kubernetes क्लस्टर सेट अप करते हैं. इसमें Shakesapp, GKE पर चलता है. इसलिए, हमें GKE को चालू करना होगा. "Kubernetes Engine" मेन्यू पर जाएं और 'चालू करें' बटन दबाएं.

अब आपके पास Kubernetes क्लस्टर बनाने का विकल्प है.

Kubernetes क्लस्टर बनाना

Kubernetes क्लस्टर बनाने के लिए, Cloud Shell पर यह कमांड चलाएं. कृपया पुष्टि करें कि ज़ोन की वैल्यू उस क्षेत्र के हिसाब से है जिसका इस्तेमाल आपने 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 और skaffold सेटअप करना

अब हमारे पास डिप्लॉय करने के लिए, Kubernetes क्लस्टर तैयार है. इसके बाद, हम कंटेनर को पुश और डिप्लॉय करने के लिए, कंटेनर रजिस्ट्री तैयार करते हैं. इन चरणों के लिए, हमें GAR और skaffold को सेट अप करना होगा, ताकि इनका इस्तेमाल किया जा सके.

Artifact Registry का सेटअप

"Artifact Registry" के मेन्यू पर जाएं और 'चालू करें' बटन दबाएं.

कुछ समय बाद, आपको GAR का रिपॉज़िटरी ब्राउज़र दिखेगा. "CREATE REPOSITORY" बटन पर क्लिक करें और रिपॉज़िटरी का नाम डालें.

इस कोडलैब में, मैंने नई रिपॉज़िटरी का नाम trace-codelab रखा है. आर्टफ़ैक्ट का फ़ॉर्मैट "Docker" है और लोकेशन का टाइप "Region" है. Google Compute Engine के डिफ़ॉल्ट ज़ोन के लिए सेट किए गए क्षेत्र के आस-पास का क्षेत्र चुनें. उदाहरण के लिए, ऊपर दिए गए उदाहरण में "us-central1-f" चुना गया है. इसलिए, यहां हम "us-central1 (Iowa)" चुनते हैं. इसके बाद, "बनाएं" बटन पर क्लिक करें.

अब आपको रिपॉज़िटरी ब्राउज़र पर "trace-codelab" दिखेगा.

हम रजिस्ट्री पाथ की जांच करने के लिए, बाद में इस पेज पर वापस आएंगे.

Skaffold सेट अप करना

Skaffold एक काम का टूल है. इसका इस्तेमाल तब किया जाता है, जब Kubernetes पर चलने वाली माइक्रोसर्विस बनाई जाती हैं. यह ऐप्लिकेशन के कंटेनर बनाने, उन्हें पुश करने, और उन्हें डिप्लॉय करने के वर्कफ़्लो को मैनेज करता है. इसके लिए, कुछ ही कमांड का इस्तेमाल किया जाता है. Skaffold डिफ़ॉल्ट रूप से, Docker Registry को कंटेनर रजिस्ट्री के तौर पर इस्तेमाल करता है. इसलिए, आपको Skaffold को कॉन्फ़िगर करना होगा, ताकि वह कंटेनर को GAR पर पुश कर सके.

Cloud Shell को फिर से खोलें और पुष्टि करें कि Skaffold इंस्टॉल है या नहीं. (Cloud Shell, डिफ़ॉल्ट रूप से एनवायरमेंट में skaffold इंस्टॉल करता है.) यहां दिया गया कमांड चलाएं और Skaffold का वर्शन देखें.

skaffold version

कमांड आउटपुट

v1.20.0

अब, skaffold के इस्तेमाल के लिए डिफ़ॉल्ट रिपॉज़िटरी रजिस्टर की जा सकती है. रजिस्ट्री पाथ पाने के लिए, 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 सेट अप करना
कंटेनर रजिस्ट्री के लिए, Artifact Registry रिपॉज़िटरी बनाई गई
कंटेनर रजिस्ट्री का इस्तेमाल करने के लिए, skaffold सेट अप करना
Kubernetes क्लस्टर बनाया गया है, जहां कोडलैब की माइक्रोसर्विस चलती हैं

आगे बढ़ें

अगले चरण में, आपको क्लस्टर पर अपनी माइक्रोसेवाएं बनानी, पुश करनी, और डिप्लॉय करनी होंगी

3. माइक्रोसर्विसेज़ को बनाएं, पुश करें, और डिप्लॉय करें

कोडलैब का मटीरियल डाउनलोड करना

पिछले चरण में, हमने इस कोडलैब के लिए सभी ज़रूरी शर्तें सेट अप की हैं. अब इन पर पूरी माइक्रोसेवाएँ चलाई जा सकती हैं. कोड लैब का मटीरियल GitHub पर होस्ट किया गया है. इसलिए, इसे Cloud Shell एनवायरमेंट में डाउनलोड करने के लिए, यहां दिए गए git कमांड का इस्तेमाल करें.

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 मेनिफ़ेस्ट फ़ाइलें
proto: क्लाइंट और सर्वर के बीच कम्यूनिकेशन के लिए प्रोटो परिभाषा
src: हर सेवा के सोर्स कोड के लिए डायरेक्ट्री
skaffold.yaml: skaffold के लिए कॉन्फ़िगरेशन फ़ाइल

skaffold कमांड चलाना

आखिर में, आपके पास पूरे कॉन्टेंट को अभी बनाए गए Kubernetes क्लस्टर पर बनाने, पुश करने, और डिप्लॉय करने का विकल्प होता है. इस प्रोसेस में कई चरण शामिल हैं, लेकिन असल में Skaffold आपके लिए सब कुछ करता है. आइए, इस कमांड का इस्तेमाल करके देखते हैं:

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 में डिफ़ॉल्ट रिपो पर आपका कॉन्फ़िगरेशन कुछ भी हो. ऐसे में, "skaffold run" में "–default-repo" विकल्प जोड़कर देखें. जैसे, यहां दिखाया गया है.

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

डिप्लॉयमेंट के बाद, आपको हर कंटेनर में 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 के साथ इंटिग्रेट करने के लिए तैयार है. इससे सेवाओं की डिस्ट्रिब्यूटेड ट्रेसिंग की जा सकेगी.

खास जानकारी

इस चरण में, आपने अपने एनवायरमेंट में कोडलैब का मटीरियल तैयार कर लिया है. साथ ही, आपने पुष्टि कर ली है कि skaffold उम्मीद के मुताबिक काम कर रहा है.

आगे बढ़ें

अगले चरण में, ट्रेस की जानकारी को इंस्ट्रुमेंट करने के लिए, लोडजन सेवा के सोर्स कोड में बदलाव करें.

4. एचटीटीपी के लिए इंस्ट्रूमेंटेशन

ट्रेस इंस्ट्रूमेंटेशन और प्रोपगेशन का कॉन्सेप्ट

सोर्स कोड में बदलाव करने से पहले, आइए हम एक आसान डायग्राम की मदद से यह समझ लेते हैं कि डिस्ट्रिब्यूटेड ट्रेसिंग कैसे काम करती है.

इस उदाहरण में, हम कोड को Cloud Trace में Trace और Span की जानकारी एक्सपोर्ट करने के लिए इंस्ट्रुमेंट करते हैं. साथ ही, लोडजन सेवा से सर्वर सेवा तक के अनुरोध में ट्रेस कॉन्टेक्स्ट को आगे बढ़ाते हैं.

ऐप्लिकेशन को Cloud Trace में ट्रेस मेटाडेटा भेजना होगा. जैसे, ट्रेस आईडी और स्पैन आईडी. इससे Cloud Trace, एक ही ट्रेस आईडी वाले सभी स्पैन को एक ट्रेस में इकट्ठा कर पाएगा. साथ ही, ऐप्लिकेशन को डाउनस्ट्रीम सेवाओं का अनुरोध करते समय, ट्रेस कॉन्टेक्स्ट (पैरंट स्पैन का ट्रेस आईडी और स्पैन आईडी का कॉम्बिनेशन) को आगे बढ़ाना होगा, ताकि उन्हें पता चल सके कि वे किस ट्रेस कॉन्टेक्स्ट को हैंडल कर रही हैं.

OpenTelemetry की मदद से ये काम किए जा सकते हैं:

यूनीक ट्रेस आईडी और स्पैन आईडी जनरेट करने के लिए
इस कुकी का इस्तेमाल, Trace ID और Span ID को बैकएंड में एक्सपोर्ट करने के लिए किया जाता है
इस कुकी का इस्तेमाल, ट्रेस कॉन्टेक्स्ट को अन्य सेवाओं तक पहुंचाने के लिए किया जाता है

इंस्ट्रूमेंट फ़र्स्ट स्पैन

इंस्ट्रूमेंट लोड जनरेटर सेवा

Cloud Shell के सबसे ऊपर दाईं ओर मौजूद, बटन दबाकर Cloud Shell Editor खोलें. बाईं ओर मौजूद एक्सप्लोरर में जाकर 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 फ़ंक्शन को कॉल कर रहा है. मौजूदा तरीके में, सेक्शन में दो लॉग लाइनें होती हैं. ये फ़ंक्शन कॉल की शुरुआत और खत्म होने की जानकारी रिकॉर्ड करती हैं. अब फ़ंक्शन कॉल की लेटेन्सी को ट्रैक करने के लिए, स्पैन की जानकारी को इंस्ट्रुमेंट करते हैं.

सबसे पहले, आपको एक स्पैन बनाना होगा. इसके लिए, आपको एक यूनीक ट्रेस आईडी और स्पैन आईडी की ज़रूरत होगी. 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()

इसके बाद, Tracer इंस्टेंस सेट अप करें. यह Trace Context और एक्सपोर्टर सेटिंग को मैनेज करता है

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

ध्यान दें कि यह कोडलैब, ट्रेस इंस्ट्रूमेंटेशन के काम करने के तरीके को समझने के लिए है. इसलिए, हम Tracer को हर अनुरोध को रिकॉर्ड करने और उन्हें बैकएंड में भेजने के लिए कॉन्फ़िगर करते हैं. (SimpleSpanProcessor()) यह प्रोडक्शन एनवायरमेंट के लिए सही नहीं है. इसलिए, प्रोडक्शन ऐप्लिकेशन को इंस्ट्रुमेंट करते समय, इस हिस्से को ज़रूर बदलें.

अब Tracer की मदद से, स्पैन को इंस्ट्रूमेंट किया जा सकता है. यहां यह बताया गया है कि आपको स्पैन को साफ़ तौर पर जनरेट करना होगा. बस इतना ही! हालांकि, स्पैन में इवेंट मेटाडेटा जोड़ने वाली दो लाइनें हैं, लेकिन आपको यूनीक ट्रेस आईडी और स्पैन आईडी को मैन्युअल तरीके से जनरेट करने और उन्हें स्पैन में एम्बेड करने की ज़रूरत नहीं है.

     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 build को ज़रूरी 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 में लिखी गई है.

इंस्ट्रुमेंट क्लाइंट सेवा

पिछले सेक्शन में, हमने नीचे दी गई इमेज में लाल रंग के रेक्टैंगल में मौजूद हिस्से को इंस्ट्रूमेंट किया था. हमने लोड जनरेटर सेवा में स्पैन की जानकारी को इंस्ट्रूमेंट किया है. लोड जनरेटर सेवा की तरह ही, अब हमें क्लाइंट सेवा को इंस्ट्रुमेंट करना होगा. लोड जनरेटर सेवा से यह अलग है. क्लाइंट सेवा को एचटीटीपी हेडर में, लोड जनरेटर सेवा से मिली ट्रेस आईडी की जानकारी को निकालना होगा. साथ ही, स्पैन जनरेट करने के लिए इस आईडी का इस्तेमाल करना होगा.

Cloud Shell Editor खोलें और ज़रूरी मॉड्यूल जोड़ें. जैसे, हमने लोड जनरेटर सेवा के लिए किया था.

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 इंपोर्ट किया है. इससे उपयोगकर्ताओं की ओर से, Flask ऐप्लिकेशन के लिए अपने-आप इंस्ट्रुमेंटेशन चालू हो जाता है. साथ ही, कोड की एक लाइन की मदद से, ट्रेस कॉन्टेक्स्ट पाने के लिए एचटीटीपी हेडर निकाले जा सकते हैं. OpenTelemetry कम्यूनिटी, अन्य मुख्य लाइब्रेरी के साथ भी इसी तरह के काम के इंटिग्रेशन उपलब्ध कराती है. ज़्यादा जानकारी के लिए, आधिकारिक दस्तावेज़ पढ़ें.

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

इंस्ट्रुमेंटेशन शुरू करने से पहले, आपको Tracer इंस्टेंस को उसी तरह से तैयार करना होगा जिस तरह से हमने लोड जनरेटर सेवा में किया था.

 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() तरीके से कोड में इंस्ट्रूमेंट किया है.

आपको दिख सकता है कि सर्वर सेवा से स्पैन नहीं दिख रहे हैं. यह सही है, क्योंकि हमने सर्वर सेवा में स्पैन को इंस्ट्रूमेंट नहीं किया है.

खास जानकारी

इस चरण में, आपने लोड जनरेटर सेवा और क्लाइंट सेवा को इंस्ट्रूमेंट किया है. साथ ही, पुष्टि की है कि आपके पास सभी सेवाओं में ट्रेस कॉन्टेक्स्ट को सही तरीके से फैलाने और दोनों सेवाओं से स्पैन की जानकारी को 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()

क्लाइंट सेवा के लिए, हमें इंस्ट्रूमेंटेशन के लिए बहुत कम काम करना होगा. हमें Trace Context को आगे बढ़ाना है. यह gRPC के ज़रिए, मौजूदा स्पैन के Trace ID और Span ID का कॉम्बिनेशन होता है. इसलिए, हम 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. बधाई हो

आपने OpenTelemetry की मदद से डिस्ट्रिब्यूटेड ट्रेस बना लिए हैं. साथ ही, Google Cloud Trace पर माइक्रोसेवा के लिए अनुरोधों की लेटेन्सी की पुष्टि कर ली है.

ज़्यादा अभ्यास के लिए, इन विषयों को खुद आज़माएं.

मौजूदा तरीके से, परफ़ॉर्मेंस की जांच के दौरान जनरेट किए गए सभी स्पैन भेजे जाते हैं. Cloud Trace से उन स्पैन को कैसे फ़िल्टर किया जाता है? जवाब यहां है.
इवेंट लॉग को स्पैन से जोड़ें और देखें कि यह 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 और एडमिन" > "सेटिंग" चुनें. इसके बाद, "बंद करें" बटन पर क्लिक करें.

इसके बाद, डायलॉग बॉक्स में मौजूद फ़ॉर्म में प्रोजेक्ट आईडी (प्रोजेक्ट का नाम नहीं) डालें और बंद करने की पुष्टि करें.