ข้อมูลการติดตามของเครื่องมือโดยใช้ OpenTelemetry

1. บทนำ

อัปเดตล่าสุด: 2021-03-05

การสังเกตการณ์แอปพลิเคชัน

การสังเกตการณ์และ OpenTelemetry

การสังเกตการณ์เป็นคำที่ใช้อธิบายแอตทริบิวต์ของระบบ ระบบที่มีความสามารถในการสังเกตได้ช่วยให้ทีมแก้ไขข้อบกพร่องของระบบได้อย่างมีประสิทธิภาพ ในบริบทดังกล่าว เสาหลัก 3 ประการของความสามารถในการสังเกตการณ์ ได้แก่ บันทึก เมตริก และการติดตาม เป็นเครื่องมือพื้นฐานสำหรับระบบในการรับความสามารถในการสังเกตการณ์

OpenTelemetry คือชุดข้อกำหนดและ SDK ที่ช่วยเร่งการวัดผลและการส่งออกข้อมูลการวัดและส่งข้อมูล (บันทึก เมตริก และการติดตาม) ที่ความสามารถในการสังเกตการณ์ต้องการ OpenTelemetry เป็นมาตรฐานแบบเปิดและโปรเจ็กต์ที่ขับเคลื่อนโดยชุมชนภายใต้ CNCF การใช้ประโยชน์จากไลบรารีที่โปรเจ็กต์และระบบนิเวศของโปรเจ็กต์มีให้ช่วยให้นักพัฒนาแอปสามารถวัดประสิทธิภาพแอปพลิเคชันในลักษณะที่เป็นกลางต่อผู้ให้บริการและสถาปัตยกรรมหลายแบบ

การติดตามแบบกระจาย

ในบรรดาบันทึก เมตริก และการติดตาม การติดตามคือการวัดและส่งข้อมูลทางไกลที่บอกเวลาในการตอบสนองของกระบวนการส่วนใดส่วนหนึ่งในระบบ โดยเฉพาะในยุคของไมโครเซอร์วิส การติดตามแบบกระจายคือตัวขับเคลื่อนที่สำคัญในการค้นหาคอขวดของเวลาในการตอบสนองในระบบแบบกระจายโดยรวม

เมื่อวิเคราะห์การติดตามแบบกระจาย การแสดงภาพข้อมูลการติดตามคือกุญแจสำคัญในการทำความเข้าใจเวลาในการตอบสนองโดยรวมของระบบได้อย่างรวดเร็ว ใน Distributed Trace เราจะจัดการชุดการเรียกเพื่อประมวลผลคำขอเดียวไปยังจุดแรกเข้าของระบบในรูปแบบของ Trace ที่มีหลายช่วง

ช่วงคือหน่วยงานแต่ละหน่วยที่ทำในระบบแบบกระจาย โดยจะบันทึกเวลาเริ่มต้นและเวลาสิ้นสุด ช่วงมักมีความสัมพันธ์แบบลำดับชั้นระหว่างกัน ในรูปภาพด้านล่าง ช่วงขนาดเล็กทั้งหมดเป็นช่วงย่อยของช่วง /messages ขนาดใหญ่ และจะรวมกันเป็น 1 Trace ที่แสดงเส้นทางการทำงานผ่านระบบ

Google Cloud Trace เป็นหนึ่งในตัวเลือกสำหรับแบ็กเอนด์ของ Distributed Trace และผสานรวมกับผลิตภัณฑ์อื่นๆ ใน Google Cloud ได้เป็นอย่างดี

สิ่งที่คุณจะสร้าง

ใน Codelab นี้ คุณจะติดตั้งเครื่องมือข้อมูลการติดตามในบริการที่ชื่อ "Shakesapp" ซึ่งทำงานในคลัสเตอร์ Kubernetes ที่ทำงานใน Google Kubernetes Engine สถาปัตยกรรมของ Shakesapp เป็นไปตามที่อธิบายไว้ด้านล่าง

ไคลเอ็นต์ส่งสตริงการค้นหาไปยังเซิร์ฟเวอร์
เซิร์ฟเวอร์ยอมรับคำค้นหาจากไคลเอ็นต์ ดึงข้อมูลผลงานทั้งหมดของเชกสเปียร์ในรูปแบบข้อความจาก Google Cloud Storage ค้นหาบรรทัดที่มีคำค้นหา และส่งคืนหมายเลขบรรทัดที่ตรงกันไปยังไคลเอ็นต์

คุณจะใช้ข้อมูลการติดตามในคำขอ

สิ่งที่คุณจะได้เรียนรู้

วิธีเริ่มต้นใช้งานไลบรารีการติดตาม OpenTelemetry ในโปรเจ็กต์ Python
วิธีสร้างช่วงโดยใช้ไลบรารี
วิธีเผยแพร่บริบทของช่วงผ่านสายระหว่างคอมโพเนนต์ของแอป
วิธีส่งข้อมูลการติดตามไปยัง Google Cloud Trace
วิธีวิเคราะห์การติดตามใน Google Cloud Trace

Codelab นี้อธิบายวิธีติดตั้งเครื่องมือในไมโครเซอร์วิส ตัวอย่างนี้มีเพียง 3 องค์ประกอบ (เครื่องมือสร้างภาระงาน ไคลเอ็นต์ และเซิร์ฟเวอร์) เพื่อให้เข้าใจได้ง่าย แต่คุณสามารถใช้กระบวนการเดียวกันที่อธิบายไว้ใน Codelab นี้กับระบบที่ซับซ้อนและมีขนาดใหญ่กว่าได้

สิ่งที่คุณต้องมี

ความรู้เกี่ยวกับ Python 3

2. การตั้งค่าและข้อกำหนด

การตั้งค่าสภาพแวดล้อมแบบเรียนรู้ด้วยตนเอง

หากยังไม่มีบัญชี Google (Gmail หรือ Google Apps) คุณต้องสร้างบัญชี ลงชื่อเข้าใช้คอนโซล Google Cloud Platform ( console.cloud.google.com) แล้วสร้างโปรเจ็กต์ใหม่

หากมีโปรเจ็กต์อยู่แล้ว ให้คลิกเมนูแบบเลื่อนลงเพื่อเลือกโปรเจ็กต์ที่ด้านซ้ายบนของคอนโซล

แล้วคลิกปุ่ม "โปรเจ็กต์ใหม่" ในกล่องโต้ตอบที่ปรากฏขึ้นเพื่อสร้างโปรเจ็กต์ใหม่

หากยังไม่มีโปรเจ็กต์ คุณจะเห็นกล่องโต้ตอบแบบนี้เพื่อสร้างโปรเจ็กต์แรก

กล่องโต้ตอบการสร้างโปรเจ็กต์ในภายหลังจะช่วยให้คุณป้อนรายละเอียดของโปรเจ็กต์ใหม่ได้

โปรดจดจำรหัสโปรเจ็กต์ ซึ่งเป็นชื่อที่ไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมด (ชื่อด้านบนมีผู้ใช้แล้วและจะใช้ไม่ได้ ขออภัย) ซึ่งจะเรียกว่า PROJECT_ID ในภายหลังใน Codelab นี้

จากนั้นหากยังไม่ได้ดำเนินการ คุณจะต้องเปิดใช้การเรียกเก็บเงินใน Developers Console เพื่อใช้ทรัพยากร Google Cloud และเปิดใช้ Cloud Trace API

การทำตาม Codelab นี้ไม่ควรมีค่าใช้จ่ายเกิน 2-3 ดอลลาร์ แต่ก็อาจมีค่าใช้จ่ายมากกว่านี้หากคุณตัดสินใจใช้ทรัพยากรเพิ่มเติมหรือปล่อยให้ทรัพยากรทำงานต่อไป (ดูส่วน "การล้างข้อมูล" ที่ท้ายเอกสารนี้) ราคาของ Google Cloud Trace, Google Kubernetes Engine และ Google Artifact Registry ระบุไว้ในเอกสารประกอบอย่างเป็นทางการ

ผู้ใช้ใหม่ของ Google Cloud Platform มีสิทธิ์รับช่วงทดลองใช้ฟรีมูลค่า$300 ซึ่งจะทำให้ Codelab นี้ไม่มีค่าใช้จ่ายใดๆ

การตั้งค่า Google Cloud Shell

แม้ว่าคุณจะใช้งาน Google Cloud และ Google Cloud Trace จากระยะไกลในแล็ปท็อปได้ แต่ใน Codelab นี้เราจะใช้ Google Cloud Shell ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานในระบบคลาวด์

เครื่องเสมือนที่ใช้ Debian นี้มาพร้อมเครื่องมือพัฒนาทั้งหมดที่คุณต้องการ โดยมีไดเรกทอรีหลักแบบถาวรขนาด 5 GB และทำงานใน Google Cloud ซึ่งช่วยเพิ่มประสิทธิภาพเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก ซึ่งหมายความว่าคุณจะต้องมีเพียงเบราว์เซอร์เท่านั้นสำหรับโค้ดแล็บนี้ (ใช่แล้ว ใช้ได้ใน Chromebook)

หากต้องการเปิดใช้งาน Cloud Shell จาก Cloud Console เพียงคลิกเปิดใช้งาน 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

ใน Codelab นี้ เราใช้ "poetry" เพื่อจัดการเวอร์ชันแพ็กเกจอย่างเคร่งครัด เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell

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

ตั้งค่าคลัสเตอร์ Google Kubernetes

ใน Codelab นี้ คุณจะได้เรียกใช้คลัสเตอร์ของ Microservice บน Google Kubernetes Engine (GKE) กระบวนการของ Codelab นี้มีดังนี้

ดาวน์โหลดโปรเจ็กต์พื้นฐานลงใน Cloud Shell
สร้าง Microservice ลงในคอนเทนเนอร์
อัปโหลดคอนเทนเนอร์ไปยัง Google Artifact Registry (GAR)
ทำให้คอนเทนเนอร์ใช้งานได้ใน GKE
แก้ไขซอร์สโค้ดของบริการเพื่อการตรวจสอบเครื่องมือติดตาม
ไปที่ขั้นตอนที่ 2

เปิดใช้ Kubernetes Engine

ก่อนอื่น เราจะตั้งค่าคลัสเตอร์ Kubernetes ที่ Shakesapp ทำงานบน 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 และ Skaffold

ตอนนี้เรามีคลัสเตอร์ Kubernetes พร้อมสำหรับการติดตั้งใช้งานแล้ว จากนั้นเราจะเตรียมตัวสำหรับรีจิสทรีคอนเทนเนอร์เพื่อพุชและติดตั้งใช้งานคอนเทนเนอร์ สำหรับขั้นตอนเหล่านี้ เราต้องตั้งค่า GAR และ Skaffold เพื่อใช้งาน

การตั้งค่า Artifact Registry

ไปที่เมนูของ "Artifact Registry" แล้วกดปุ่มเปิดใช้

หลังจากนั้นสักครู่ คุณจะเห็นเบราว์เซอร์ที่เก็บของ GAR คลิกปุ่ม "สร้างที่เก็บ" แล้วป้อนชื่อที่เก็บ

ในโค้ดแล็บนี้ ฉันตั้งชื่อที่เก็บข้อมูลใหม่ว่า trace-codelab รูปแบบของอาร์ติแฟกต์คือ "Docker" และประเภทตำแหน่งคือ "Region" เลือกภูมิภาคที่ใกล้กับภูมิภาคที่คุณตั้งค่าสำหรับโซนเริ่มต้นของ Google Compute Engine ตัวอย่างเช่น ตัวอย่างนี้เลือก "us-central1-f" ด้านบน ดังนั้นเราจึงเลือก "us-central1 (ไอโอวา)" ที่นี่ จากนั้นคลิกปุ่ม "สร้าง"

ตอนนี้คุณจะเห็น "trace-codelab" ในเบราว์เซอร์ที่เก็บ

เราจะกลับมาที่นี่ในภายหลังเพื่อตรวจสอบเส้นทางรีจิสทรี

การตั้งค่า Skaffold

Skaffold เป็นเครื่องมือที่มีประโยชน์เมื่อคุณทำงานสร้าง Microservice ที่ทำงานบน Kubernetes โดยจะจัดการเวิร์กโฟลว์ของการสร้าง พุช และการทำให้คอนเทนเนอร์ของแอปพลิเคชันใช้งานได้ด้วยชุดคำสั่งขนาดเล็ก โดยค่าเริ่มต้น Skaffold จะใช้ Docker Registry เป็นรีจิสทรีคอนเทนเนอร์ ดังนั้นคุณจึงต้องกำหนดค่า Skaffold ให้รู้จัก GAR เมื่อพุชคอนเทนเนอร์ไปยัง 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" แล้ว

กลับไปที่ Cloud Shell เรียกใช้คำสั่ง 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

ตอนนี้คุณพร้อมที่จะทำตามขั้นตอนถัดไปเพื่อตั้งค่าคอนเทนเนอร์ Kubernetes บน GKE แล้ว

สรุป

ในขั้นตอนนี้ คุณจะได้ตั้งค่าสภาพแวดล้อมของ Codelab ดังนี้

ตั้งค่า Cloud Shell
สร้างที่เก็บ Artifact Registry สำหรับ Container Registry
ตั้งค่า Skaffold เพื่อใช้ Container Registry
สร้างคลัสเตอร์ Kubernetes ที่ไมโครเซอร์วิสของ Codelab ทำงาน

ในขั้นตอนถัดไป คุณจะสร้าง พุช และติดตั้งใช้งานไมโครเซอร์วิสในคลัสเตอร์

3. สร้าง พุช และติดตั้งใช้งานไมโครเซอร์วิส

ดาวน์โหลดเนื้อหา Codelab

ในขั้นตอนก่อนหน้า เราได้ตั้งค่าข้อกำหนดเบื้องต้นทั้งหมดสำหรับ Codelab นี้แล้ว ตอนนี้คุณก็พร้อมที่จะเรียกใช้ไมโครเซอร์วิสทั้งหมดบนแพลตฟอร์มดังกล่าวแล้ว เนื้อหา Codelab โฮสต์อยู่ใน 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

manifests: ไฟล์ Manifest ของ Kubernetes
proto: คำจำกัดความ 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 หรือไม่ ในกรณีนี้ ให้ลองเพิ่มตัวเลือก "–default-repo" ลงใน "skaffold run" ดังนี้

$ skaffold run –tail –default-repo=us-central1-docker.pkg.dev/[รหัสโปรเจ็กต์]/[ชื่อที่เก็บ]

หลังจากการติดตั้งใช้งาน คุณจะเห็นบันทึกของแอปพลิเคชันจริงที่ส่งไปยัง 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 เพื่อการติดตามแบบกระจายของบริการแล้ว

สรุป

ในขั้นตอนนี้ คุณได้เตรียมสื่อ Codelab ในสภาพแวดล้อมและยืนยันว่า Skaffold ทำงานตามที่คาดไว้

ในขั้นตอนถัดไป คุณจะแก้ไขซอร์สโค้ดของบริการ Loadgen เพื่อวัดข้อมูลการติดตาม

4. การวัดคุมสำหรับ HTTP

แนวคิดของการตรวจสอบและการแพร่กระจายการติดตาม

ก่อนที่จะแก้ไขซอร์สโค้ด ผมขออธิบายสั้นๆ เกี่ยวกับวิธีการทำงานของการติดตามแบบกระจายในแผนภาพง่ายๆ

ในตัวอย่างนี้ เราจะใช้เครื่องมือกับโค้ดเพื่อส่งออกข้อมูลการติดตามและช่วงไปยัง Cloud Trace และเผยแพร่บริบทการติดตามในคำขอจากบริการ Loadgen ไปยังบริการเซิร์ฟเวอร์

แอปพลิเคชันต้องส่งข้อมูลเมตาของการติดตาม เช่น รหัสการติดตามและรหัสช่วง เพื่อให้ Cloud Trace รวบรวมช่วงทั้งหมดที่มีรหัสการติดตามเดียวกันไว้ในการติดตามเดียว นอกจากนี้ แอปพลิเคชันยังต้องเผยแพร่บริบทการติดตาม (การรวมกันของรหัสการติดตามและรหัสช่วงของช่วงระดับบนสุด) เมื่อขอใช้บริการดาวน์สตรีม เพื่อให้ทราบว่ากำลังจัดการบริบทการติดตามใด

OpenTelemetry ช่วยให้คุณทำสิ่งต่อไปนี้ได้

เพื่อสร้าง Trace ID และ Span ID ที่ไม่ซ้ำกัน
เพื่อส่งออก Trace ID และ Span ID ไปยังแบ็กเอนด์
เพื่อเผยแพร่บริบทการติดตามไปยังบริการอื่นๆ

ช่วงแรกของเครื่องมือ

บริการเครื่องมือสร้างภาระงาน

เปิด Cloud Shell Editor โดยกดปุ่ม ที่ด้านขวาบนของ Cloud Shell เปิด src/loadgen/loadgen.py จาก Explorer ในแผงด้านซ้าย แล้วค้นหาฟังก์ชัน 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 ในนั้น ในการใช้งานปัจจุบัน ส่วนนี้มีบรรทัดบันทึก 2 บรรทัดที่บันทึกจุดเริ่มต้นและจุดสิ้นสุดของการเรียกใช้ฟังก์ชัน ตอนนี้มาใช้ข้อมูล Span เพื่อติดตามเวลาในการตอบสนองของการเรียกฟังก์ชันกัน

ก่อนอื่นคุณต้องสร้างช่วงที่มีรหัสการติดตามและรหัสช่วงที่ไม่ซ้ำกัน 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

เนื่องจากเครื่องมือสร้างภาระงานเรียกใช้แอปพลิเคชันไคลเอ็นต์ใน HTTP ผ่านโมดูล 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}")

โปรดทราบว่าเนื่องจากนี่คือ Codelab เพื่อทำความเข้าใจวิธีการทำงานของการวัดประสิทธิภาพการติดตาม เราจึงกำหนดค่า Tracer ให้บันทึกคำขอทุกรายการและส่งไปยังแบ็กเอนด์ (SimpleSpanProcessor()) ไม่เหมาะกับสภาพแวดล้อมการทำงานจริง ดังนั้นโปรดเปลี่ยนส่วนนี้เมื่อคุณใช้เครื่องมือกับแอปพลิเคชันการทำงานจริง

ตอนนี้คุณสามารถวัด Span ด้วย Tracer ได้แล้ว ประเด็นที่นี่คือสิ่งที่คุณต้องทำคือการสร้างช่วงอย่างชัดเจน และนั่นก็คือทั้งหมด แม้ว่าจะมี 2 บรรทัดที่เพิ่มข้อมูลเมตาของเหตุการณ์ลงในช่วง แต่คุณไม่จำเป็นต้องสร้าง Trace ID และ Span ID ที่ไม่ซ้ำกันด้วยตนเองและฝังลงในช่วง

     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

บริการลูกค้าของเครื่องมือ

ในส่วนก่อนหน้า เราได้ติดตั้งเครื่องมือในส่วนที่อยู่ในสี่เหลี่ยมผืนผ้าสีแดงในภาพวาดด้านล่าง เราได้ติดตั้งข้อมูลช่วงในบริการเครื่องมือสร้างภาระงาน เช่นเดียวกับบริการเครื่องมือสร้างภาระงาน ตอนนี้เราต้องติดตั้งเครื่องมือบริการไคลเอ็นต์ ความแตกต่างจากบริการเครื่องมือสร้างภาระงานคือบริการไคลเอ็นต์ต้องดึงข้อมูลรหัสการติดตามที่ส่งต่อจากบริการเครื่องมือสร้างภาระงานในส่วนหัว HTTP และใช้รหัสเพื่อสร้างช่วง

เปิด 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 ในนามของผู้ใช้เพื่อดึงส่วนหัว HTTP เพื่อรับบริบทการติดตามด้วยโค้ดเพียงบรรทัดเดียว ชุมชน 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()

คุณอาจสังเกตเห็นว่าไม่เห็นช่วงจากบริการเซิร์ฟเวอร์ ซึ่งถูกต้องแล้วเนื่องจากเราไม่ได้ใช้เครื่องมือติดตาม Span ในบริการเซิร์ฟเวอร์เลย

สรุป

ในขั้นตอนนี้ คุณได้ติดตั้งเครื่องมือบริการเครื่องสร้างภาระงานและบริการไคลเอ็นต์ และยืนยันว่าคุณสามารถเผยแพร่บริบทการติดตามในบริการต่างๆ และส่งออกข้อมูลช่วงจากทั้ง 2 บริการไปยัง 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 ในฟังก์ชันแฮนเดิลเลอร์ฝังบริบทการติดตามลงในส่วนหัว HTTP ด้านล่างได้

อย่าลืมเพิ่มการอ้างอิงใหม่ลงใน pyproject.toml ด้วยคำสั่ง poetry add

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

ตอนนี้คุณจะเห็น Trace จำนวนมากในหน้ารายการ Trace ของ Cloud Trace คลิกการติดตามรายการใดรายการหนึ่ง แล้วคุณจะเห็นว่าช่วงครอบคลุมคำขอจากบริการเครื่องสร้างโหลดไปยังบริการเซิร์ฟเวอร์

สรุป

ในขั้นตอนนี้ คุณได้วัดคุมการสื่อสารที่ใช้ gRPC ด้วยการรองรับจากไลบรารีระบบนิเวศ OpenTelemetry นอกจากนี้ คุณยังยืนยันว่าบริบทการติดตามที่สร้างขึ้นในบริการเครื่องมือสร้างภาระงานได้ส่งไปยังบริการเซิร์ฟเวอร์เรียบร้อยแล้ว

6. ขอแสดงความยินดี

คุณสร้างการติดตามแบบกระจายด้วย OpenTelemetry และยืนยันเวลาในการตอบสนองของคำขอใน Microservice บน Google Cloud Trace เรียบร้อยแล้ว

หากต้องการฝึกเพิ่มเติม คุณสามารถลองทำตามหัวข้อต่อไปนี้ด้วยตนเอง

การติดตั้งใช้งานปัจจุบันจะส่งช่วงทั้งหมดที่สร้างขึ้นโดยการตรวจสอบสถานะ คุณจะกรองช่วงเหล่านั้นออกจาก Cloud Trace ได้อย่างไร ดูเคล็ดลับได้ที่นี่
เชื่อมโยงบันทึกเหตุการณ์กับช่วง และดูวิธีการทำงานใน Google Cloud Trace และ Google Cloud Logging ดูเคล็ดลับได้ที่นี่
แทนที่บริการบางอย่างด้วยบริการในภาษาอื่น แล้วลองใช้ OpenTelemetry กับบริการนั้นในภาษานั้น

ข้อควรระวัง: Google Kubernetes Engine และ Google Artifact Registry ใช้ทรัพยากรอย่างต่อเนื่อง

ล้างข้อมูล

หลังจากทำ Codelab นี้แล้ว โปรดหยุดคลัสเตอร์ 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 และผู้ดูแลระบบ" > "การตั้งค่า" จากแผงเมนู แล้วคลิกปุ่ม "ปิด"

จากนั้นป้อนรหัสโปรเจ็กต์ (ไม่ใช่ชื่อโปรเจ็กต์) ในแบบฟอร์มในกล่องโต้ตอบและยืนยันการปิด