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

1. บทนำ

5af4a7e43b0feaab.png

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

ความสามารถในการสังเกตของแอปพลิเคชัน

ความสามารถในการสังเกตและ OpenTelemetry

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

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

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

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

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

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

adbd3ecd69d410cb.png

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

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

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

68873c018a7be7de.png

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

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

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

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

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

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

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

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

การตั้งค่าสภาพแวดล้อมตามเวลาที่สะดวก

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

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

15b8b6ac4d917005.png

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

7136b3ee36ebaf89.png

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

90977ce514204b51.png

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

6d9573e346e930b4.png

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

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

eb5325f65619ad6a.png

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

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

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

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

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

หากต้องการเปิดใช้งาน Cloud Shell จาก Cloud Console เพียงคลิกเปิดใช้งาน Cloud Shell gcLMt5IuEcJJNnMId-Bcz3sxCd0rZn7IzT_r95C8UZeqML68Y1efBG_B0VRp7hc7qiZTLAF-TXD7SsOadxn8uadgHhaLeASnVS3ZHK39eOlKJOgj9SJua_oeGhMxRrbOg3qigddS2A (การจัดสรรและเชื่อมต่อกับสภาพแวดล้อมซึ่งจะใช้เวลาเพียงไม่นาน)

ff81d016724c4f67.png

fbe156ee6edfbb2e.png

เมื่อเชื่อมต่อกับ 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

a3e716fc9e7454e9.png

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

echo $GOOGLE_CLOUD_PROJECT

เอาต์พุต Comand

<PROJECT_ID>

สุดท้าย ให้ตั้งค่าโซนและการกำหนดค่าโปรเจ็กต์เริ่มต้น

gcloud config set compute/zone us-central1-f

คุณเลือกโซนต่างๆ ได้หลากหลาย ดูข้อมูลเพิ่มเติมได้ที่ภูมิภาคและ โซน

การตั้งค่า Python

ใน Codelab นี้ เราใช้ "บทกวี" จัดการเวอร์ชันแพ็กเกจได้อย่างเคร่งครัด เรียกใช้คำสั่งต่อไปนี้บน 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 มีดังนี้

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

เปิดใช้ Kubernetes Engine

ก่อนอื่น เราตั้งค่าคลัสเตอร์ Kubernetes ที่ Shakesapp ทำงานบน GKE เราจึงต้องเปิดใช้ GKE ไปที่เมนู "Kubernetes Engine" และกดปุ่ม "เปิดใช้"

56c680e93e169731.png

ตอนนี้คุณพร้อมที่จะสร้างคลัสเตอร์ 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 ที่พร้อมทำให้ใช้งานได้แล้ว ถัดไป เราจะเตรียมพร้อมสำหรับ Container Registry สำหรับพุชและติดตั้งใช้งานคอนเทนเนอร์ สําหรับขั้นตอนเหล่านี้ เราต้องตั้งค่า GAR และ Skaffold เพื่อใช้งาน

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

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

f7493243bae0cdf7.png

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

f97f337f5476651.png

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

2f04143077ca56db.png

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

7a3c1f47346bea15.png

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

การตั้งค่า Skaf Fold

Skaffold เป็นเครื่องมือที่มีประโยชน์เมื่อคุณสร้าง Microservice ที่ทำงานบน Kubernetes โดยจะจัดการกระบวนการสร้าง พุช และติดตั้งใช้งานคอนเทนเนอร์ของแอปพลิเคชันด้วยคำสั่งชุดเล็กๆ โดยค่าเริ่มต้น Skaffold จะใช้ Docker Registry เป็นรีจิสทรีคอนเทนเนอร์ คุณจึงต้องกำหนดค่า Skaffold ให้จดจำ GAR ในการพุชคอนเทนเนอร์ไป

เปิด Cloud Shell อีกครั้งและยืนยันว่าติดตั้ง Skaffold แล้ว (Cloud Shell จะติดตั้ง Skaffold ลงในสภาพแวดล้อมโดยค่าเริ่มต้น) เรียกใช้คำสั่งต่อไปนี้และดูเวอร์ชัน Skaffold

skaffold version

เอาต์พุตจากคำสั่ง

v1.20.0

ตอนนี้คุณลงทะเบียนที่เก็บเริ่มต้นสำหรับ Skaffold ที่จะใช้ได้แล้ว หากต้องการดูเส้นทางรีจิสทรี ให้ไปที่แดชบอร์ด Artifact Registry แล้วคลิกชื่อที่เก็บที่คุณเพิ่งตั้งค่าในขั้นตอนก่อนหน้า

55173fe922f40327.png

จากนั้นคุณจะเห็นเส้นทางเบรดครัมบ์ที่ด้านบนของหน้า คลิกไอคอน e157b1359c3edc06.png เพื่อคัดลอกเส้นทางรีจิสทรีไปยังคลิปบอร์ด

a9b0fa44c37e0178.png

เมื่อคลิกปุ่มคัดลอก คุณจะเห็นกล่องโต้ตอบที่ด้านล่างของเบราว์เซอร์พร้อมข้อความดังนี้

&quot;us-central1-docker.pkg.dev/psychic-order-307806/trace-codelab&quot; คัดลอกแล้ว

กลับไปที่ 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 Registy สำหรับ Container Registry แล้ว
  • ตั้งค่า Skaffold เพื่อใช้ Container Registry
  • สร้างคลัสเตอร์ Kubernetes ที่ Codelab Microservice ทำงาน

ถัดไป

ในขั้นตอนถัดไป คุณจะสร้าง พุช และทำให้ Microservice ใช้งานได้บนคลัสเตอร์

3. สร้าง พุช และติดตั้งใช้งาน Microservice

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

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

ถัดไป

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

4. เครื่องมือสำหรับ HTTP

แนวคิดของการใช้เครื่องมือการติดตามและการเผยแพร่

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

c8c659deaa9c9091.png

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

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

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

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

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

บริการสร้างโหลดเครื่องมือ

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

ขั้นแรก คุณต้องสร้าง Span ด้วยรหัสการติดตามและรหัส 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 Contenxt และเครื่องมือส่งออก

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

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

     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"

คุณยืนยันได้ว่าคำอธิบายทรัพยากร Dependency ที่เกี่ยวข้องเขียนด้วยภาษา pyproject.toml แล้ว

บริการไคลเอ็นต์สำหรับเครื่องมือ

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

ae074d4513c9931f.png

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

f7440360551980e.png

หากคลิกที่รายการใดรายการหนึ่ง คุณจะเห็นกราฟ Waterfall เช่น ด้านล่างที่อธิบายเวลาในการตอบสนองของแต่ละส่วนในระหว่างคําขอและกระบวนการตอบกลับ ค้นหาช่องทําเครื่องหมายถัดจาก "แสดงเหตุการณ์" แล้วคุณจะได้รับคําอธิบายประกอบภายในกราฟ Waterfall คำอธิบายประกอบเหล่านี้คือคำอธิบายประกอบที่คุณใช้วัดคุมโค้ดโดยใช้เมธอด span.add_event()

67596a4a313738.png

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

สรุป

ในขั้นตอนนี้ คุณได้ติดตั้งบริการตัวสร้างภาระงานและบริการลูกค้า และยืนยันว่าคุณสามารถเผยแพร่ Trace Context ไปยังบริการต่างๆ และส่งออกข้อมูล Span จากทั้ง 2 บริการไปยัง Cloud Trace ได้สำเร็จ

ถัดไป

ในขั้นตอนถัดไป คุณจะต้องใช้บริการลูกค้าและบริการเซิร์ฟเวอร์เพื่อยืนยันวิธีเผยแพร่บริบทการติดตามผ่าน gRPC

5. การวัดคุมสำหรับ gRPC

ในขั้นตอนก่อนหน้า เราได้บังคับใช้ช่วงครึ่งแรกของคำขอใน Microservice นี้ ในขั้นตอนนี้ เราพยายามวัดคุมการสื่อสารด้วย gRPC ระหว่างบริการลูกค้าและบริการของเซิร์ฟเวอร์ (สี่เหลี่ยมผืนผ้าสีเขียวและม่วงในรูปภาพด้านล่าง)

c4dec3e741c3ab4f.png

การวัดคุมอัตโนมัติสำหรับไคลเอ็นต์ 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()

สำหรับการบริการลูกค้า สิ่งที่เราต้องทำสำหรับเครื่องมือนั้นค่อนข้างเล็กมาก สิ่งที่เราต้องทำคือเผยแพร่บริบทการติดตาม ซึ่งเป็นชุดค่าผสมของรหัสการติดตามและรหัส Span ของช่วงปัจจุบันผ่าน gRPC เราจึงเรียกใช้ GrpcInstrumentatorClient.instrument() เพื่อให้ไคลเอ็นต์ gRPC ในฟังก์ชัน Hander สามารถฝังบริบทการติดตามลงในส่วนหัว HTTP ด้านล่างได้

โปรดตรวจสอบว่าได้เพิ่มทรัพยากร Dependency ใหม่ไปยัง 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"

เรียกใช้ Microservice และยืนยันการติดตาม

จากนั้นเรียกใช้โค้ดที่แก้ไขแล้วด้วยคำสั่ง skaffold

skaffold run --tail

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

141cb620245b689d.png

สรุป

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

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

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

สำหรับการออกกำลังกายระยะยาว คุณลองทำตามหัวข้อต่อไปนี้ด้วยตนเองได้

  • การนำไปใช้ในปัจจุบันจะส่งช่วงทั้งหมดที่สร้างโดยการตรวจสอบประสิทธิภาพการทำงาน คุณจะกรองระยะเวลาเหล่านั้นออกจาก Cloud Traces อย่างไร คำแนะนำอยู่ที่นี่
  • เชื่อมโยงบันทึกเหตุการณ์กับระยะเวลา แล้วดูว่าบันทึกนั้นทำงานอย่างไรใน 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 & จากแผงเมนู ผู้ดูแลระบบ" "การตั้งค่า" แล้วคลิก "ปิด"

578ca2b72a161e9d.png

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