การประเมินโค้ดอัตโนมัติด้วย Agent Sandbox ใน GKE

1. บทนำ

ใน Codelab นี้ คุณจะทำให้แอปพลิเคชัน Hackathon Judge ใช้งานได้ใน Google Kubernetes Engine (GKE) และใช้ Kubernetes-sigs Agent Sandbox เพื่อเรียกใช้ภาระงานของ Agent อย่างปลอดภัย

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

สิ่งที่คุณต้องดำเนินการ

  • จัดสรรบริการ Google Cloud เป้าหมายและสร้าง API เป้าหมาย
  • เริ่มต้น GKE Autopilot และติดตั้ง CRD ของ Agent Sandbox, การกำหนดค่าคลัสเตอร์ และ Sandbox Router
  • ติดตั้งใช้งานเกตเวย์แซนด์บ็อกซ์ เทมเพลตการอ้างสิทธิ์แซนด์บ็อกซ์ และ WarmPool แซนด์บ็อกซ์
  • ทำให้ REST Backend API, Agent ของ Worker การตัดสิน ADK และ UI ส่วนหน้าของ React ใช้งานได้
  • กำหนดเส้นทางการโหลดบาลานซ์ภายนอกและเข้าถึงแพลตฟอร์มเพื่อเรียกใช้เวิร์กโฟลว์การตัดสินที่ปลอดภัยและอยู่ในแซนด์บ็อกซ์

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

  • เว็บเบราว์เซอร์ เช่น Chrome
  • โปรเจ็กต์ Google Cloud ที่เปิดใช้การเรียกเก็บเงิน

ทรัพยากรที่สร้างขึ้นใน Codelab นี้ควรมีค่าใช้จ่ายน้อยกว่า $5 ในค่าใช้จ่ายรันไทม์ทั้งหมด

2. ปัญหา: การประเมินโค้ดที่ไม่น่าเชื่อถืออย่างปลอดภัย

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

การเรียกใช้โค้ดที่ไม่น่าเชื่อถือในโครงสร้างพื้นฐานโดยตรงจะทำให้คุณมีความเสี่ยง เช่น

  • การแทรกโค้ด: สคริปต์ที่เป็นอันตรายอาจพยายามเข้าถึงหรือแก้ไขข้อมูลที่ละเอียดอ่อน
  • การเพิ่มสิทธิ์: โค้ดอาจพยายามเข้าถึงระบบหรือทรัพยากรเครือข่ายอื่นๆ โดยไม่ได้รับอนุญาต
  • การละเมิดทรัพยากร: โค้ดที่เขียนไม่ดีหรือการโจมตีแบบปฏิเสธการให้บริการอาจใช้ CPU, หน่วยความจำ หรือแบนด์วิดท์เครือข่ายมากเกินไป ซึ่งส่งผลกระทบต่อการดำเนินการอื่นๆ

เราต้องมีวิธีเรียกใช้โค้ดที่ส่งในสภาพแวดล้อมที่แยกออกจากระบบที่เหลือและการส่งอื่นๆ อย่างสมบูรณ์เพื่อทำการตัดสินแฮ็กกาธอนด้วย AI โดยอัตโนมัติ

3. โซลูชัน: แซนด์บ็อกซ์ของ Agent GKE

GKE Agent Sandbox เป็นฟีเจอร์ที่ออกแบบมาเพื่อความท้าทายนี้โดยเฉพาะ ซึ่งช่วยจัดการภาระงานแบบแยกต่างหาก มีสถานะ และแบบจำลองเดียวใน GKE และได้รับการเพิ่มประสิทธิภาพสำหรับกรณีการใช้งาน เช่น รันไทม์ของ AI Agent ซึ่งต้องดำเนินการโค้ดที่ไม่น่าเชื่อถืออย่างปลอดภัยและมีประสิทธิภาพ

ประโยชน์หลักๆ ของ Agent Sandbox มีดังนี้

  • การแยกที่ระดับเคอร์เนล: ให้การแยกที่ระดับเคอร์เนลที่แข็งแกร่งสำหรับโค้ดที่ไม่น่าเชื่อถือโดยใช้เทคโนโลยีต่างๆ เช่น gVisor ซึ่งจะป้องกันไม่ให้โค้ดเข้าถึงระบบโฮสต์หรือคอนเทนเนอร์อื่นๆ
  • การจัดสรรในระดับต่ำกว่าวินาที: จัดสรรสภาพแวดล้อมแซนด์บ็อกซ์ได้อย่างรวดเร็ว (โดยปกติจะใช้เวลาไม่ถึง 1 วินาที) ซึ่งมีความสำคัญอย่างยิ่งต่อการประเมินโค้ดตามความต้องการ
  • ความสามารถในการขยายระบบแบบ Cloud-Native: ใช้ประโยชน์จากประสิทธิภาพของ Kubernetes และโครงสร้างพื้นฐานที่มีการจัดการของ GKE

การใช้ Agent Sandbox ช่วยให้เราสร้างสภาพแวดล้อมแยกต่างหากที่พร้อมใช้งานได้ตามต้องการสำหรับการส่งผลงานแต่ละรายการในแฮ็กกาธอน จากนั้นเอเจนต์การตัดสินของ AI จะสั่งให้แซนด์บ็อกซ์ของเอเจนต์รันการทดสอบ คอมไพล์โค้ด หรือทำขั้นตอนการประเมินอื่นๆ ภายในแซนด์บ็อกซ์ที่ปลอดภัยนี้ได้โดยไม่ต้องเสี่ยงต่อความสมบูรณ์ของแพลตฟอร์มโดยรวม ซึ่งเป็นวิธีที่ปรับขนาดได้ ปลอดภัย และมีประสิทธิภาพในการให้คะแนนแฮ็กกาธอนโดยอัตโนมัติ

4. ก่อนที่คุณจะเริ่มต้น

เริ่มต้น Cloud Shell

คลิกปุ่มด้านล่างเพื่อเริ่ม Google Cloud Shell ซึ่งได้รับการกำหนดค่าล่วงหน้าด้วยเครื่องมือบรรทัดคำสั่งสำหรับนักพัฒนาแอปและคลาวด์ที่จำเป็น

เปิดใช้ API

เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อเปิดใช้ Google Cloud APIs เป้าหมายทั้งหมดที่จำเป็นต่อการเรียกใช้แพลตฟอร์ม

gcloud services enable \
  container.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com \
  pubsub.googleapis.com \
  aiplatform.googleapis.com \
  cloudresourcemanager.googleapis.com \
  iam.googleapis.com \
  bigquery.googleapis.com \
  bigqueryconnection.googleapis.com

เหตุผลที่เราเปิดใช้ API เหล่านี้: บริการของ Google Cloud จะปิดใช้โดยค่าเริ่มต้นเพื่อป้องกันการเข้าถึงและการเรียกเก็บเงินที่ไม่ได้รับอนุญาต เราเปิดใช้ API เหล่านี้เพื่อเปิดใช้งานการจัดการคอนเทนเนอร์เป็นกลุ่ม (GKE), ที่เก็บคอนเทนเนอร์ที่ปลอดภัย (Artifact Registry), การสร้างแพ็กเกจบิลด์แบบ Serverless (Cloud Build), คิวการรับส่งข้อความที่เชื่อถือได้ (Pub/Sub), บริการโมเดล AI (Vertex AI), การกำหนดค่าโปรเจ็กต์ (Cloud Resource Manager และ IAM), การวิเคราะห์ข้อมูลแบบ Serverless (BigQuery) และการเชื่อมโยง AI ระดับฐานข้อมูล (การเชื่อมต่อ BigQuery)

5. ตั้งค่าโครงสร้างพื้นฐาน

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

โคลนที่เก็บ

โคลนที่เก็บที่มีบริการแอปพลิเคชันทั้งหมด สคริปต์การตั้งค่า และการประกาศไฟล์ Manifest ของ Kubernetes

git clone --depth 1 --filter=blob:none --sparse https://github.com/GoogleCloudPlatform/devrel-demos.git
cd devrel-demos
git sparse-checkout set codelabs/ai-toolkit-lab-2/hackathon-judge
cd codelabs/ai-toolkit-lab-2/hackathon-judge

เรียกใช้สคริปต์การติดตั้งใช้งาน

deploy.sh สคริปต์จะตั้งค่าพื้นฐานของทรัพยากรระบบคลาวด์ โมเดลฐานข้อมูล และนโยบายคลัสเตอร์ Kubernetes พื้นฐานโดยอัตโนมัติ

เรียกใช้สคริปต์

./deploy.sh

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

การดำเนินการเป้าหมายที่สคริปต์ดำเนินการมีดังนี้

1. การตั้งค่าการกำหนดค่าสภาพแวดล้อม

สคริปต์จะสร้าง.envไฟล์กำหนดค่าเพื่อจัดเก็บพารามิเตอร์ตัวแปรของ GKE, Pub/Sub, BigQuery และโปรเจ็กต์ การจัดหาไฟล์นี้แบบไดนามิกจะสร้างคำจำกัดความของไฟล์ Manifest ของ Kubernetes ทั้งหมดในภายหลัง

เหตุผลที่เรากำหนดค่าไฟล์สภาพแวดล้อมนี้: ไฟล์ .env จะรวมพารามิเตอร์การกำหนดค่าไว้ที่ส่วนกลาง เพื่อให้มั่นใจว่าไฟล์ Manifest ของ GKE ที่เราใช้ด้วยตนเองในขั้นตอนต่อๆ ไปจะใช้การตั้งค่าระดับภูมิภาค ชื่อโปรเจ็กต์ และทรัพยากรที่เหมือนกัน ซึ่งจะแยกการกำหนดค่าสภาพแวดล้อมออกจากซอร์สโค้ดอย่างเคร่งครัด

2. การกำหนดค่า Google Cloud CLI และโปรเจ็กต์เป้าหมาย

สคริปต์จะตรวจสอบว่าได้ติดตั้งยูทิลิตี gcloud, bq, kubectl และ envsubst แล้วหรือไม่ ตรวจสอบสถานะการตรวจสอบสิทธิ์ และล็อกเป้าหมายการกำหนดค่าที่ใช้งานอยู่กับโปรเจ็กต์ที่อยู่ในระบบคลาวด์ Google Cloud ที่ใช้งานอยู่

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

3. การเปิดใช้ Google Cloud API เป้าหมาย

สคริปต์จะทำการตรวจสอบแบบ Idempotent เพื่อยืนยันและเปิดใช้ API ของบริการ Google Cloud เป้าหมาย (GKE, Artifact Registry, Cloud Build, Pub/Sub, Vertex AI, BigQuery และ IAM)

เหตุผลที่เราเปิดใช้ Google Cloud API: ต้องเปิดใช้งานบริการคลาวด์ที่มีการจัดการก่อนจึงจะเข้าถึงปลายทางหรือสร้างทรัพยากรได้ การเปิดใช้ตั้งแต่เริ่มต้นจะเตรียม API Gateway ของ GCP ระดับภูมิภาคให้พร้อมรับมือกับคำสั่งการจัดสรรทรัพยากรในภายหลัง

4. การจัดสรรที่เก็บ Docker ของ Artifact Registry

สคริปต์จะจัดสรรที่เก็บคอนเทนเนอร์ Docker ชื่อ hackathon-judge-repo ในตำแหน่งเป้าหมายที่เลือก

เหตุผลที่เราสร้างที่เก็บ Artifact Registry: คลัสเตอร์ GKE ต้องมีสิทธิ์เข้าถึงรีจิสทรีคอนเทนเนอร์ส่วนตัวอย่างปลอดภัยในเครือข่ายระดับภูมิภาคเดียวกันเพื่อดึงอิมเมจแอปพลิเคชันได้อย่างรวดเร็ว Artifact Registry มีโฮสต์ส่วนตัวที่ปลอดภัยสำหรับจัดทำแคตตาล็อก สแกน และจัดเก็บอิมเมจคอนเทนเนอร์ Docker

5. การจัดสรรคลัสเตอร์ GKE Autopilot

สคริปต์จะจัดสรรคลัสเตอร์ Google Kubernetes Engine (GKE) Autopilot ที่ชื่อ hackathon-judge-cluster

เหตุผลที่เราติดตั้งใช้งานคลัสเตอร์ GKE Autopilot: GKE Autopilot จะจัดการการจัดสรรโหนด การปรับขนาด การตรวจสอบสถานะ และการอัปเกรดความปลอดภัยของระบบปฏิบัติการโฮสต์โดยอัตโนมัติ โดยมีแพลตฟอร์มคอนเทนเนอร์ระดับโปรดักชันเพื่อจัดระเบียบบริการที่ทำงานอย่างต่อเนื่อง และกำหนดเวลาแซนด์บ็อกซ์ของ Worker ที่ปลอดภัยแบบไดนามิกตามความต้องการ

6. การกำหนดค่าหัวข้อและการสมัครใช้บริการ Pub/Sub

สคริปต์จะจัดสรรหัวข้อข้อความ (judging-tasks และ judging-results) พร้อมกับการสมัครใช้บริการสำหรับผู้ปฏิบัติงานและ API ที่เกี่ยวข้อง

เหตุผลที่เราใช้หัวข้อและการสมัครใช้บริการ Pub/Sub: การประเมินโค้ดที่ส่งมานั้นช้าและใช้ทรัพยากรมาก การใช้สถาปัตยกรรม Message Queue จะแยก API แบบซิงโครนัสที่หันหน้าไปทางผู้ใช้ออกจากโหนด Worker แบ็กเอนด์ของ API จะพุชงานไปยังหัวข้อ judging-tasks และ Agent ของ Worker จะดึงงานเมื่อพร้อมใช้งาน ซึ่งจะช่วยป้องกันการบล็อก API และมอบความสามารถในการลองใหม่โดยอัตโนมัติ

7. การกำหนดค่าชุดข้อมูล ตาราง และการเชื่อมต่อ AI ของ BigQuery

สคริปต์จะสร้างชุดข้อมูล hackathon_judge ใช้สคีมาฐานข้อมูล SQL เชิงโครงสร้าง โหลดระเบียนเริ่มต้น และให้สิทธิ์บทบาท AI และพื้นที่เก็บข้อมูลที่จำเป็นแก่บัญชีบริการการเชื่อมต่อ BigQuery ML

8. การทริกเกอร์บิลด์คอนเทนเนอร์โดยใช้ Cloud Build

สคริปต์จะทริกเกอร์cloudbuild.yamlคำจำกัดความเพื่อคอมไพล์ UI ของ React, เซิร์ฟเวอร์ REST ของ Go, Worker ADK ของ Python และแซนด์บ็อกซ์ FastAPI โดยจัดแพ็กเกจเป็นอิมเมจคอนเทนเนอร์ที่แยกต่างหากซึ่งติดแท็กด้วย SHA ของ Git Commit ของที่เก็บที่ใช้งานอยู่ และบันทึกลงใน Artifact Registry

9. การลงทะเบียนคำจำกัดความทรัพยากรที่กำหนดเอง (CRD) ของ Agent Sandbox

สคริปต์จะดาวน์โหลดและลงทะเบียนคำจำกัดความของทรัพยากรที่กำหนดเอง (Custom Resource Definition หรือ manifest.yaml และ extensions.yaml) ของ Kubernetes-sigs Agent Sandbox เวอร์ชันล่าสุดเพื่อขยายความสามารถหลักของ GKE

เหตุผลที่เราติดตั้งโครงสร้างพื้นฐานของ Agent Sandbox: คลัสเตอร์ Kubernetes มาตรฐานไม่รองรับการจัดสรรแซนด์บ็อกซ์แบบออนดีมานด์ที่ได้รับการปกป้อง การลงทะเบียน CRD ของ Agent Sandbox จะขยายระนาบควบคุมของ GKE ซึ่งช่วยให้ Kubernetes จัดการคอนเทนเนอร์ขนาดเล็กแบบแซนด์บ็อกซ์ที่ปลอดภัยได้โดยกำเนิดโดยใช้ทรัพยากรที่กำหนดเอง (เช่น SandboxTemplates และ SandboxClaims)

10. การกำหนดค่าเนมสเปซ บัญชีบริการ และ Workload Identity

สคริปต์จะจัดสรรเนมสเปซ hackathon-judge ลงทะเบียนบัญชีบริการ Kubernetes (KSA) และสร้างการแมป Workload Identity เพื่อให้สิทธิ์ Google Cloud แก่พ็อด GKE

11. การติดตั้งใช้งานเราเตอร์แซนด์บ็อกซ์

สคริปต์จะใช้k8s/sandbox_router.yaml Manifest เพื่อเริ่มการติดตั้งใช้งานและบริการของ Sandbox Router และรอให้มีสถานะปกติ

เหตุผลที่เราติดตั้งใช้งานเราเตอร์แซนด์บ็อกซ์: เราเตอร์แซนด์บ็อกซ์เป็นเกตเวย์ระนาบควบคุมภายในส่วนกลาง โดยจะแสดง API อย่างง่ายที่ตัวแทนผู้ปฏิบัติงานในการตัดสิน ADK เรียกใช้เพื่ออ้างสิทธิ์ เข้าถึง หรือเผยแพร่แซนด์บ็อกซ์ที่ปลอดภัย จัดการการกำหนดเส้นทางการกำหนด และแยกการจัดสรรพ็อดระดับคลัสเตอร์ออกจากตรรกะของแอปพลิเคชัน

6. กำหนดค่า Agent Sandbox Gateway, Claims และ WarmPool

ในขั้นตอนนี้ คุณจะต้องกำหนดค่าเกตเวย์เครือข่าย Sandbox เฉพาะทางด้วยตนเอง ลงทะเบียนเทมเพลตการอ้างสิทธิ์ Sandbox และติดตั้งใช้งาน Sandbox WarmPool เพื่อเปิดใช้การแซนด์บ็อกซ์ที่มีเวลาในการตอบสนองต่ำมาก

ตัวแปรสภาพแวดล้อมของแหล่งที่มา

ก่อนที่จะใช้เทมเพลตที่ต้องใช้ตัวแปรสภาพแวดล้อม ให้เรียกใช้สคริปต์ setup-env.sh เพื่อแยกวิเคราะห์และส่งออกตัวแปรที่จำเป็นทั้งหมดไปยังเชลล์

source ./setup-env.sh

สมัครใช้เกตเวย์แซนด์บ็อกซ์

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

kubectl apply -f k8s/sandbox-gateway.yaml

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

ใช้เทมเพลตการอ้างสิทธิ์ใน Sandbox

ใช้ envsubst เพื่อสร้างคำจำกัดความของเทมเพลตแซนด์บ็อกซ์ด้วยตัวแปรสภาพแวดล้อมที่ใช้งานอยู่ แล้วนำไปใช้

source ./setup-env.sh
envsubst < k8s/sandbox-claim-template.yaml | kubectl apply -f -

เหตุผลที่เราใช้เทมเพลตการอ้างสิทธิ์ใน Sandbox: เทมเพลตการอ้างสิทธิ์ใน Sandbox ทำหน้าที่เป็นการกำหนดค่าพิมพ์เขียวที่กำหนดสภาพแวดล้อม โดยจะระบุอิมเมจคอนเทนเนอร์ที่จะเรียกใช้ (มาพร้อมกับเครื่องมือสำหรับนักพัฒนาซอฟต์แวร์) พารามิเตอร์สภาพแวดล้อม (รหัสโปรเจ็กต์ GCP) พอร์ต และขีดจำกัดของทรัพยากร (เป้าหมาย CPU/หน่วยความจำ) โดยจะกำหนดค่า GKE ให้เรียกใช้อินสแตนซ์คอนเทนเนอร์เหล่านี้โดยใช้ gVisor (รันไทม์ gvisor) เพื่อรับประกันว่าโค้ดของผู้เข้าร่วมที่ไม่น่าเชื่อถือจะทำงานภายใต้เลเยอร์เพิ่มเติมของการแยกเสมือนจริงของเคอร์เนล

ใช้ WarmPool ของแซนด์บ็อกซ์

ใช้ Sandbox WarmPool เพื่อเริ่มต้นแซนด์บ็อกซ์ที่ทำงานอยู่ล่วงหน้า

kubectl apply -f k8s/sandbox-warmpool.yaml

ตรวจสอบว่าอินสแตนซ์สแตนด์บายของพูลอุ่นเริ่มต้นสำเร็จ

kubectl get pods -n hackathon-judge -l app=sandbox

เหตุผลที่เราใช้ WarmPool ของ Sandbox: การจัดสรร การกำหนดเวลา การดึงอิมเมจ และการบูตพ็อดคอนเทนเนอร์ใหม่ตามต้องการจะทำให้เกิดค่าใช้จ่ายในการเริ่มต้นที่สูงมาก (เวลา Cold Start 30 วินาทีขึ้นไป) Sandbox WarmPool จะดูแลพูลสแตนด์บายของพ็อดแซนด์บ็อกซ์ที่ใช้งานอยู่และอุ่นไว้ล่วงหน้า (5 สำเนาโดยค่าเริ่มต้น) เมื่อ Worker Agent ขอสภาพแวดล้อมการประเมิน Sandbox Router จะจัดสรรพ็อดที่ทำงานซึ่งอุ่นเครื่องไว้ล่วงหน้าทันที ซึ่งจะช่วยลดความล่าช้าในการเริ่มต้นให้เหลือเพียงไม่กี่วินาที

7. ทำให้คอมโพเนนต์ของแอปพลิเคชันใช้งานได้

เมื่อโครงสร้างพื้นฐานของแซนด์บ็อกซ์ที่ปลอดภัยทำงานอย่างเต็มที่แล้ว คุณจะสามารถติดตั้งใช้งาน API แบ็กเอนด์ส่วนกลาง, Worker Agent, อินเทอร์เฟซเว็บ React และการแมปเกตเวย์ขาเข้าได้

ติดตั้งใช้งานแบ็กเอนด์

ติดตั้งใช้งานแบ็กเอนด์ REST API ของ Orchestrator โดยทำดังนี้

source ./setup-env.sh
envsubst < k8s/backend.yaml | kubectl apply -f -

ติดตั้งใช้งาน Agent

ติดตั้งใช้งาน Agent ของผู้ปฏิบัติงานในการตัดสิน ADK

source ./setup-env.sh
envsubst < k8s/agent.yaml | kubectl apply -f -

ติดตั้งใช้งานฟรอนท์เอนด์

ติดตั้งใช้งานอินเทอร์เฟซผู้ใช้บนเว็บแบบอินเทอร์แอกทีฟ

source ./setup-env.sh
envsubst < k8s/frontend.yaml | kubectl apply -f -

กำหนดค่าเกตเวย์และการกำหนดเส้นทางภายนอก

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

kubectl apply -f k8s/gateway.yaml

เหตุผลที่เราติดตั้งใช้งานเกตเวย์ Ingress ภายนอก: เกตเวย์ภายนอกจะแสดงบริการของเราโดยใช้ Kubernetes Gateway API โดยจะจัดสรรที่อยู่ IP สาธารณะที่จัดสรรภาระงานและแมปเส้นทางตามกฎเส้นทาง ซึ่งจะนำคำขอ API ภายใต้ /api/* ไปยังแบ็กเอนด์ Go และแมปการเข้าชมเว็บของไคลเอ็นต์อื่นๆ ทั้งหมด (/) ไปยังฟรอนต์เอนด์ React เพื่อรักษาความปลอดภัยในการเข้าถึงคลัสเตอร์สาธารณะ

ยืนยันการเปิดตัว

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

kubectl rollout status deployment/backend -n hackathon-judge --timeout=300s
kubectl rollout status deployment/agent -n hackathon-judge --timeout=300s
kubectl rollout status deployment/frontend -n hackathon-judge --timeout=300s

8. ยืนยันและใช้แอปพลิเคชัน

เข้าถึง UI

ดึงข้อมูลที่อยู่ IP สาธารณะภายนอกของเกตเวย์ตัวจัดสรรภาระงานหลักที่จัดสรรใหม่

หากต้องการดูสถานะการจัดสรรแบบเรียลไทม์ ให้เรียกใช้คำสั่งด้วย Flag ของนาฬิกา (-w) แล้วรอจนกว่าระบบจะป้อนที่อยู่ IP สาธารณะในช่อง ADDRESS

kubectl get gateway -n hackathon-judge hackathon-judge-gateway -w

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

NAME                      CLASS    ADDRESS          PROGRAMMED   AGE
hackathon-judge-gateway   gke-l7   34.120.120.120   True         3m

เมื่อเห็นที่อยู่ IP สาธารณะที่ถูกต้องในคอลัมน์ ADDRESS และสถานะ PROGRAMMED เป็น True ให้กด Ctrl+C เพื่อหยุดการดู

เหตุผลที่เราได้รับสถานะเกตเวย์: API เกตเวย์จัดการการรับส่งข้อมูลขาเข้าสาธารณะ การตรวจสอบสถานะเกตเวย์จะแสดงที่อยู่ IP ภายนอกแบบสาธารณะที่ผ่านการจัดสรรภาระงานซึ่งตัวจัดสรรภาระงานภายนอกทั่วโลกของ Google Cloud จัดสรรให้กับคลัสเตอร์ของเรา ซึ่งแสดงถึงที่อยู่สาธารณะของแพลตฟอร์ม

เปิดที่อยู่ IP สาธารณะที่จัดสรรในเบราว์เซอร์เพื่อโหลดแดชบอร์ดผู้ตัดสินแฮ็กกาธอน

ส่งงาน

  • ใช้ UI ส่วนหน้าเพื่อไปยังแดชบอร์ด แล้วเลือกแฮ็กกาธอน

หน้าแดชบอร์ด

  • ในโปรเจ็กต์ใดก็ได้ คุณสามารถคลิก Run Agent เพื่อเริ่มให้เอเจนต์ให้คะแนนทั้งโปรเจ็กต์เทียบกับเกณฑ์การให้คะแนน

โปรเจ็กต์

ดูการเปิดตัว Privacy Sandbox

ตรวจสอบพ็อดที่ใช้งานอยู่ภายในเนมสเปซ hackathon-judge เพื่อดูพ็อดแซนด์บ็อกซ์ที่อ้างสิทธิ์และจัดสรรแบบไดนามิกสำหรับการดำเนินการตัดสิน

kubectl get pods -n hackathon-judge -w

ตรวจสอบบันทึกของพ็อดตัวแทนของ Worker เพื่อดูตรรกะการประเมินการตัดสิน ADK แบบทีละขั้นตอน

kubectl logs -l app=agent -n hackathon-judge

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

9. (ไม่บังคับ) วิธีการทำงาน

สถาปัตยกรรมแซนด์บ็อกซ์ของเอเจนต์

แม้ว่าฟังก์ชัน AI ของ BigQuery จะยอดเยี่ยมในการประเมินผลงานที่อิงตามข้อความและการอ้างสิทธิ์ใน README แต่การตัดสินโปรเจ็กต์ด้านวิศวกรรมจำเป็นต้องคอมไพล์โค้ด ติดตั้งไลบรารีของบุคคลที่สาม และเรียกใช้ชุดการทดสอบจริง

การเรียกใช้โค้ดของผู้ใช้แบบดิบๆ ทำให้เกิดความเสี่ยงด้านความปลอดภัยอย่างมาก ซึ่งรวมถึงการประนีประนอมโฮสต์ การหลุดออกจากคอนเทนเนอร์ และการเข้าถึงทรัพยากรที่ไม่ได้รับอนุญาต เฟรมเวิร์ก GKE Agent Sandbox ช่วยลดความเสี่ยงเหล่านี้ด้วยการจัดการภาระงานแซนด์บ็อกซ์ที่แยกต่างหากโดยใช้การจำลองเสมือน gVisor (runsc)

ขั้นตอนการโต้ตอบของระบบ

แผนภาพด้านล่างแสดงให้เห็นว่าองค์ประกอบต่างๆ ของระบบที่ขับเคลื่อนด้วยเหตุการณ์ของเราสื่อสารกันอย่างไรในระหว่างการดำเนินการตัดสินที่ปลอดภัยในแซนด์บ็อกซ์

วิธีการทำงานร่วมกันของเครื่องมือและคอมโพเนนต์ที่เกี่ยวข้อง

  • UI ฟรอนท์เอนด์ของ React: แสดงอินเทอร์เฟซแบบอินเทอร์แอกทีฟที่ผู้ใช้กำหนดค่าโมเดลเกณฑ์ ลงทะเบียนทีม ส่ง URL ของโปรเจ็กต์ และตรวจสอบตารางสรุปคะแนนที่เสร็จสมบูรณ์แล้ว รวมถึงความคลาดเคลื่อนของไฟล์ทั้งหมดและความคิดเห็นด้านวิศวกรรม
  • Go REST Backend API: จัดการปลายทาง API ทั่วโลก โดยจะจัดเก็บการกำหนดค่าโปรเจ็กต์ใน BigQuery และพุชงานการตัดสินไปยัง Pub/Sub เพื่อแยกไปป์ไลน์การดำเนินการด้านการคำนวณที่ซับซ้อน
  • Google Pub/Sub: ตัวกลางที่เน้นข้อความซึ่งจัดเก็บข้อความของงานอย่างปลอดภัยในคิว โดยประสานการสื่อสารแบบไม่พร้อมกันระหว่าง API กับอินสแตนซ์ของ Worker ที่ใช้งานอยู่
  • Worker ของ Python ADK (Supervisor Agent): Worker ที่ทำงานในเบื้องหลังซึ่งดึงงานจาก Pub/Sub โดยใช้ Google Agent Development Kit (ADK) เพื่อเริ่มต้น Supervisor Agent ระดับสูง ซึ่งได้รับคำสั่งให้ประสานงานการประเมิน ผู้ดูแลจะเรียกใช้เครื่องมือหลัก evaluate_repository เพื่อมอบหมายการทดสอบคำสั่งดิบแบบละเอียด
  • เราเตอร์และเกตเวย์ Sandbox (ระนาบควบคุม GKE): เกตเวย์ควบคุมภายในที่ลงทะเบียนคำจำกัดความทรัพยากรที่กำหนดเองของ Sandbox มาตรฐาน (SandboxClaims, SandboxTemplates) โดยจะประสานงานเครือข่าย GKE เพื่อจัดสรรและรักษาความปลอดภัยให้กับพ็อด รวมถึงส่งสตรีมการเชื่อมต่อกลับไปยังไคลเอ็นต์ของ Worker
  • WarmPool ของ Sandbox: WarmPool จะดูแลพ็อดสแตนด์บายที่ใช้งานอยู่เพื่อหลีกเลี่ยงเวลาเริ่มต้นของคอนเทนเนอร์ GKE ที่นาน ("Cold Start" นานกว่า 30 วินาที) เมื่อมีการอ้างสิทธิ์แซนด์บ็อกซ์ เราเตอร์จะแมปแซนด์บ็อกซ์นั้นทันทีในเวลาไม่ถึงวินาที จากนั้นจะกำหนดเวลาการรีไซเคิลเมื่อมีการเผยแพร่
  • การแยก gVisor (runsc): เคอร์เนลเสมือนในพื้นที่ผู้ใช้ที่ทำหน้าที่เป็นขอบเขตแซนด์บ็อกซ์ที่ปลอดภัย โดยจะสกัดกั้นการเรียกใช้ระบบจากพื้นที่คอนเทนเนอร์ไปยังเคอร์เนลของโหนด GKE เพื่อให้มั่นใจว่าคำสั่งดิบที่เป็นอันตราย (เช่น สคริปต์ของระบบหรือการตั้งค่าแพ็กเกจ) จะทำงานภายใต้การแยกเสมือนจริงที่สมบูรณ์
  • รันไทม์แซนด์บ็อกซ์ของ FastAPI: เซิร์ฟเวอร์ API ของ Python แบบเบาที่ทำงานภายในคอนเทนเนอร์แซนด์บ็อกซ์ โดยจะแสดงปลายทางที่ปลอดภัย (/execute, /upload, /download) ที่อนุญาตให้เครื่องมือของ Worker ภายนอกจัดการไฟล์และทริกเกอร์งาน Shell
  • Gemini CLI (@google/gemini-cli): สคริปต์เอเจนต์อัตโนมัติที่ติดตั้งภายในแซนด์บ็อกซ์ เมื่อทริกเกอร์ด้วยแฟล็กสภาพแวดล้อมในการพัฒนารันไทม์ (--yolo) ระบบจะใช้เอกสารคำสั่งการให้คะแนนที่เข้มงวด (prompt.md) และคำจำกัดความของเกณฑ์ (criteria.md) เพื่อดำเนินการต่อไปนี้
    • วิเคราะห์ลำดับชั้นของโค้ดเบสแบบไดนามิก (ใช้เครื่องมืออย่าง tree หรือ ripgrep)
    • ติดตั้งข้อกำหนดโดยอัตโนมัติ (ผ่านคำสั่งต่างๆ เช่น npm install, pip install, go build)
    • เรียกใช้การทดสอบการพัฒนาจริง (เช่น npm test หรือ pytest) เพื่อยืนยันฟังก์ชันการทำงาน
    • เรียกใช้โมเดล Vertex AI (ผ่านข้อมูลเข้าสู่ระบบการเชื่อมโยง Workload Identity ของคอนเทนเนอร์) เพื่อประเมินตรรกะของไฟล์ ตรวจสอบการอ้างสิทธิ์กับ README ตรวจหาฟีเจอร์ที่ไม่มีอยู่จริง บันทึกปัญหาด้านคุณภาพ และเขียนรายงานตารางสรุปสถิติที่มีโครงสร้างไปยัง evaluation.json
  • สภาพแวดล้อมของนักพัฒนาซอฟต์แวร์มาตรฐาน: รวม node, npm, yarn, pnpm, python, pip, uv, go, gh, git, tree, ripgrep และ playwright ไว้ในอิมเมจคอนเทนเนอร์แซนด์บ็อกซ์ เพื่อให้ Agent ย่อยแบบอัตโนมัติมีพื้นที่ทํางานทดสอบที่สมบูรณ์

10. ล้าง

โปรดลบทรัพยากรที่สร้างขึ้นระหว่างการทำ Codelab นี้เพื่อหลีกเลี่ยงการเรียกเก็บเงินอย่างต่อเนื่องกับบัญชี Google Cloud

./destroy.sh

เหตุผลที่เราล้างข้อมูลทรัพยากร: Google Cloud เรียกเก็บเงินตามรูปแบบการใช้ทรัพยากร ทรัพยากรที่ใช้งานอยู่ เช่น คลัสเตอร์ GKE Autopilot, ตัวจัดสรรภาระงานเครือข่าย และดิสก์ถาวร จะมีการเรียกเก็บเงินอย่างต่อเนื่องแม้ว่าจะไม่ได้ใช้งานก็ตาม การเรียกใช้ขั้นตอนนี้จะลบเนมสเปซของคลัสเตอร์เพื่อล้างออบเจ็กต์ Kubernetes และลบโฮสต์คลัสเตอร์ GKE Autopilot เองเพื่อสิ้นสุดการเรียกเก็บเงินทั้งหมดในทันที

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

ยินดีด้วย คุณติดตั้งใช้งานแอปพลิเคชันผู้พิพากษา Hackathon ด้วย Agent Sandbox ใน GKE เรียบร้อยแล้ว

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

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

  • โครงสร้างพื้นฐานของ GKE: วิธีจัดสรร GKE Autopilot และบริการ Google Cloud ที่รองรับ เช่น Pub/Sub และ BigQuery
  • การกำหนดค่า Agent Sandbox: วิธีกำหนดค่าคำจำกัดความทรัพยากรที่กำหนดเอง, SandboxTemplates, SandboxClaims และ Sandbox WarmPools ที่มีประสิทธิภาพสูง
  • การติดตั้งใช้งานไมโครเซอร์วิส: วิธีกำหนดค่าการเชื่อมโยง Workload Identity และติดตั้งใช้งานสถาปัตยกรรมไมโครเซอร์วิสแบบหลายคอมโพเนนต์ (Frontend React, REST Go, Worker ADK Agent และ Isolated Sandbox)
  • แซนด์บ็อกซ์ที่ปลอดภัย: วิธีใช้คอนเทนเนอร์เสมือน gVisor เพื่อเรียกใช้คำสั่งของบุคคลที่สามที่ไม่น่าเชื่อถืออย่างปลอดภัยในโหนด GKE

ขั้นตอนถัดไป

เอกสารอ้างอิง