การทำให้เอเจนต์ AI ที่ปลอดภัยใช้งานได้ใน GKE

1. บทนำ

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

ความท้าทายทางเทคนิคของโค้ดที่ไม่น่าเชื่อถือ

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

แนวคิดสำคัญ

  • ชุดพัฒนาเอเจนต์ (ADK): ADK เป็นเฟรมเวิร์กที่ใช้สร้างแอปพลิเคชันที่สามารถให้เหตุผลเกี่ยวกับงานได้ โดยจะจัดการ "ลูปการให้เหตุผล" ซึ่ง AI จะได้รับพรอมต์ วางแผนชุดการดำเนินการ เรียกใช้เครื่องมือที่เฉพาะเจาะจง แล้วสรุปเอาต์พุตสุดท้าย ในเวิร์กโฟลว์นี้ ADK จะทำหน้าที่เป็นตัวจัดระเบียบที่ระบุว่าเมื่อใดที่คำขอของผู้ใช้ต้องมีการเรียกใช้โค้ด
  • แซนด์บ็อกซ์ของตัวแทน GKE: ฟีเจอร์ด้านความปลอดภัยนี้ใช้ gVisor ซึ่งเป็นรันไทม์ของคอนเทนเนอร์แบบโอเพนซอร์สที่ให้เคอร์เนลของแขกรับเชิญเฉพาะสำหรับแต่ละคอนเทนเนอร์ GKE Agent Sandbox จะป้องกันไม่ให้โค้ดที่ไม่น่าเชื่อถือโต้ตอบกับโหนดโดยตรงด้วยการสกัดกั้นการเรียกของระบบ (syscall) ระหว่างแอปพลิเคชันกับเคอร์เนลของโฮสต์ ซึ่งจะช่วยให้มั่นใจได้ว่าการละเมิดความปลอดภัยภายในคอนเทนเนอร์จะไม่ลุกลามไปยังส่วนอื่นๆ ของคลัสเตอร์
  • Model Context Protocol (MCP) และเครื่องมือ: โปรโตคอลนี้สร้างวิธีมาตรฐานสำหรับโมเดล AI ในการโต้ตอบกับเครื่องมือภายนอก ใน Lab นี้ เอเจนต์ได้รับการกำหนดค่าด้วยเครื่องมือ "การเรียกใช้โค้ด" ที่สื่อสารกับตัวควบคุมแซนด์บ็อกซ์เฉพาะเพื่อเรียกใช้สคริปต์ Python

วัตถุประสงค์ของห้องทดลอง

เมื่อสิ้นสุดเซสชันนี้ คุณจะทำสิ่งต่อไปนี้ได้

  1. พัฒนาเอเจนต์: กำหนดค่าเอเจนต์ที่ใช้ ADK ซึ่งออกแบบมาสำหรับงานวิเคราะห์ข้อมูล
  2. กำหนดค่าการแยกเคอร์เนล: ตั้งค่าแซนด์บ็อกซ์ของ GKE Agent ด้วย RuntimeClass ที่เชี่ยวชาญ
  3. เพิ่มประสิทธิภาพ: ใช้ "Warm Pool" ของแซนด์บ็อกซ์เพื่อลดเวลาที่ใช้ในการเริ่มต้นสภาพแวดล้อมการดำเนินการใหม่
  4. บังคับใช้ขอบเขตด้านความปลอดภัย: ใช้นโยบายเครือข่ายเพื่อป้องกันการออกนอกสภาพแวดล้อมการดำเนินการที่ไม่ได้รับอนุญาต

2. การตั้งค่าโปรเจ็กต์

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

เปิด Cloud Shell

สำหรับแล็บนี้ เราจะใช้ Cloud Shell ซึ่งเป็นสภาพแวดล้อมเทอร์มินัลบนเบราว์เซอร์ที่ Google Cloud จัดเตรียมไว้ให้ Cloud Shell ได้รับการกำหนดค่าล่วงหน้าด้วย Google Cloud CLI (gcloud), kubectl และสภาพแวดล้อม Docker ที่จำเป็นสำหรับการสร้างและติดตั้งใช้งานแอปพลิเคชัน

  1. ไปที่ Google Cloud Console
  2. คลิกปุ่มเปิดใช้งาน Cloud Shell ในส่วนหัวด้านขวาบน (ไอคอน >_)
  3. เมื่อเทอร์มินัลเปิดขึ้นที่ด้านล่างของเบราว์เซอร์ ให้คลิกดำเนินการต่อหากระบบแจ้ง

เลือกโปรเจ็กต์

คุณต้องตรวจสอบว่า Shell ชี้ไปที่โปรเจ็กต์ Google Cloud ที่ถูกต้องเพื่อหลีกเลี่ยงการทำให้ทรัพยากรใช้งานได้ในสภาพแวดล้อมที่ไม่ถูกต้อง

👉💻 ระบุรหัสโปรเจ็กต์จากแดชบอร์ดคอนโซล แล้วเรียกใช้คำสั่งต่อไปนี้เพื่อตั้งค่าโปรเจ็กต์ในเชลล์ปัจจุบัน

gcloud config set project [YOUR_PROJECT_ID]

เปิดใช้ API

การสร้างและติดตั้งใช้งานเอเจนต์ต้องใช้ API เฉพาะหลายรายการสำหรับการสร้างคอนเทนเนอร์ การโฮสต์รูปภาพ และการเข้าถึงโมเดล Generative AI

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อเริ่มต้นบริการเหล่านี้

gcloud services enable \
    cloudbuild.googleapis.com \
    artifactregistry.googleapis.com \
    container.googleapis.com \
    aiplatform.googleapis.com
  • cloudbuild.googleapis.com: สร้างอิมเมจคอนเทนเนอร์จากซอร์สโค้ดโดยอัตโนมัติ
  • artifactregistry.googleapis.com: มีรีจิสทรีส่วนตัวที่ปลอดภัยสำหรับอิมเมจของเอเจนต์
  • container.googleapis.com: จัดการวงจรของคลัสเตอร์ GKE และฟีเจอร์ความปลอดภัย
  • aiplatform.googleapis.com: ให้สิทธิ์เข้าถึงบริการ Vertex AI รวมถึงโมเดล Gemini สำหรับการให้เหตุผลและการสร้างโค้ด

การสร้างคลัสเตอร์

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

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างคลัสเตอร์ GKE

export PROJECT_ID=$(gcloud config get-value project)

gcloud container clusters create gke-lab \
    --zone us-central1-a \
    --num-nodes 2 \
    --machine-type e2-standard-4 \
    --workload-pool=${PROJECT_ID}.svc.id.goog

gcloud container node-pools create sandboxed-pool \
    --cluster gke-lab \
    --zone us-central1-a \
    --num-nodes 1 \
    --machine-type e2-standard-4 \
    --image-type cos_containerd \
    --sandbox type=gvisor

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

กำหนดค่าการเข้าถึง kubectl

เมื่อจัดสรรคลัสเตอร์แล้ว คุณต้องกำหนดค่า kubectl เพื่อสื่อสารกับคลัสเตอร์

👉💻 คำสั่งต่อไปนี้จะเรียกข้อมูลเข้าสู่ระบบของคลัสเตอร์และอัปเดตไฟล์ kubeconfig ในเครื่อง ซึ่งจะช่วยให้คุณเรียกใช้คำสั่งกับคลัสเตอร์ GKE ใหม่จาก Cloud Shell ได้

gcloud container clusters get-credentials gke-lab --zone us-central1-a

ด้วยวิธีนี้ ตอนนี้kubectlจะกำหนดเป้าหมายไปยังคลัสเตอร์ gke-lab โดยค่าเริ่มต้น

อนุญาตให้ GKE เข้าถึง Vertex AI

หากต้องการอนุญาตให้ Agent ที่ทำงานใน GKE เข้าถึงบริการ Vertex AI เพื่อการอนุมานโมเดล คุณต้องกำหนดค่า Workload Identity ซึ่งจะช่วยให้คุณเชื่อมโยงบัญชีบริการ Kubernetes กับบทบาท IAM ของ Google Cloud ได้ โดยจะให้สิทธิ์ที่จำเป็นแก่พ็อดที่ทำงานเป็นบัญชีบริการนั้นโดยไม่ต้องจัดการคีย์บัญชีบริการ

👉💻 ขั้นแรก ให้สร้างบัญชีบริการ Kubernetes ที่พ็อดของเอเจนต์จะใช้

kubectl create serviceaccount adk-agent-sa

จากนั้นให้สิทธิ์บทบาท Vertex AI User แก่บัญชีบริการนี้โดยเพิ่มการเชื่อมโยงนโยบาย IAM

👉💻 คำสั่งนี้จะเชื่อมโยงadk-agent-saบัญชีบริการ Kubernetes ในเนมสเปซ default กับบทบาท IAM roles/aiplatform.user สำหรับพูล Workload Identity ของโปรเจ็กต์

export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")

gcloud projects add-iam-policy-binding projects/${PROJECT_ID} \
    --role=roles/aiplatform.user \
    --member=principal://iam.googleapis.com/projects/${PROJECT_NUMBER}/locations/global/workloadIdentityPools/${PROJECT_ID}.svc.id.goog/subject/ns/default/sa/adk-agent-sa \
    --condition=None

3. การสร้าง ADK Agent

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

สร้างไดเรกทอรี Agent

👉💻 สร้างไดเรกทอรีสำหรับห้องทดลองและไดเรกทอรีย่อยสำหรับซอร์สโค้ดของเอเจนต์

mkdir -p ~/gke-sandbox-lab/root_agent
cd ~/gke-sandbox-lab

กำหนด ADK Agent

ก่อนอื่น เราจะกำหนดตรรกะหลักของเอเจนต์ เอเจนต์ของเราใช้เฟรมเวิร์ก ADK เพื่อกำหนดเอเจนต์ชื่อ SpreadsheetAnalyst ที่ใช้โมเดล gemini-2.5-flash ซึ่งมีเครื่องมือ (run_spreadsheet_analysis) ที่เรียกใช้แซนด์บ็อกซ์ของ GKE Agent เพื่อเรียกใช้โค้ด Python อย่างปลอดภัย คำสั่งของเอเจนต์จะแนะนำให้เขียนและเรียกใช้โค้ดที่อิงตาม Pandas เมื่อได้รับคำขอให้วิเคราะห์สเปรดชีต

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไฟล์ชื่อ root_agent/agent.py ที่มีเนื้อหาต่อไปนี้

cat <<'EOF' > ~/gke-sandbox-lab/root_agent/agent.py
import pandas as pd
from google.adk.agents import Agent
from k8s_agent_sandbox import SandboxClient

# Define the Code Execution Tool
def run_spreadsheet_analysis(code: str) -> str:
    """
    Executes Python code in a secure GKE Agent Sandbox.
    Use this tool to run pandas-based analysis on spreadsheet data.
    Input should be a complete Python script.
    """
    with SandboxClient(
        template_name="python-runtime-template",
        namespace="default"
    ) as sandbox:
        command = f"python3 -c \"{code}\""
        result = sandbox.run(command)
        
        if result.stderr:
            return f"Error: {result.stderr}"
        return result.stdout

# Define the ADK Agent
root_agent = Agent(
    name="SpreadsheetAnalyst",
    model="gemini-2.5-flash",
    instruction="""
    You are an expert data analyst. When a user asks to analyze a spreadsheet:
    1. Reason about what Python code (using pandas) is needed.
    2. Write the code, ensuring it handles data loading and analysis.
    3. Do not ever use double-quotes for string, always use single-quotes.
    4. Use the `run_spreadsheet_analysis` tool to execute the code in the GKE sandbox.
    5. Provide a clear summary of the analysis based on the tool's output.
    
    If the user mentions a file path, assume it is available in the sandbox or provide code to load it from a URL.
    """,
    tools=[run_spreadsheet_analysis]
)
EOF

เพื่อให้ ADK ค้นหาและโหลดคำจำกัดความของเอเจนต์จาก agent.py ได้ และเพื่อให้ทราบเกี่ยวกับเอเจนต์ของเรา เราจึงตรวจสอบว่า root_agent ถือเป็นแพ็กเกจ Python

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไฟล์ว่างชื่อ root_agent/__init__.py โดยมีเนื้อหาดังนี้

cat <<'EOF' > ~/gke-sandbox-lab/root_agent/__init__.py
from . import agent
EOF

จากนั้นเราจะสร้างไฟล์ที่กำหนดค่าตัวแปรสภาพแวดล้อมสำหรับตัวแทน ADK GOOGLE_GENAI_USE_VERTEXAI=TRUE บอก ADK ให้ใช้ Vertex AI เพื่อเข้าถึงโมเดล Gemini และ GOOGLE_CLOUD_PROJECT กับ GOOGLE_CLOUD_LOCATION ระบุโปรเจ็กต์ Google Cloud และภูมิภาคที่จะใช้สำหรับการเรียก Vertex AI API

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไฟล์ชื่อ root_agent/.env ที่มีเนื้อหาต่อไปนี้

cat <<EOF > ~/gke-sandbox-lab/root_agent/.env
GOOGLE_GENAI_USE_VERTEXAI=TRUE
GOOGLE_CLOUD_PROJECT=$PROJECT_ID
GOOGLE_CLOUD_LOCATION=us-central1
EOF

สร้างคอนเทนเนอร์ของ Agent

สุดท้าย เราจะกำหนดอิมเมจคอนเทนเนอร์สำหรับเอเจนต์ โดยจะเริ่มจากอิมเมจพื้นฐานของ Python ติดตั้ง kubectl (ไคลเอ็นต์แซนด์บ็อกซ์ของเอเจนต์ต้องใช้เพื่อสื่อสารกับคลัสเตอร์) และติดตั้งไลบรารี Python ที่จำเป็น ได้แก่ google-adk, pandas และ agentic-sandbox-client จากที่เก็บ git สุดท้ายนี้ จะคัดลอกซอร์สโค้ดของเอเจนต์ลงในอิมเมจและตั้งค่าจุดแรกเข้าเพื่อเรียกใช้เว็บเซิร์ฟเวอร์ ADK ซึ่งจะแสดง UI และ API ของเอเจนต์

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไฟล์ชื่อ Dockerfile ที่มีเนื้อหาต่อไปนี้

cat <<'EOF' > ~/gke-sandbox-lab/Dockerfile
FROM python:3.14-slim

ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1

WORKDIR /app

RUN apt-get update && apt-get install -y \
    git \
    curl \
    && curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl" \
    && install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl \
    && rm kubectl \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

RUN pip install --no-cache-dir google-adk pandas "git+https://github.com/kubernetes-sigs/agent-sandbox.git@main#subdirectory=clients/python/agentic-sandbox-client"

COPY ./root_agent /app/root_agent

WORKDIR /app

EXPOSE 8080

ENTRYPOINT ["adk", "web", "--host", "0.0.0.0", "--port", "8080"]
EOF

สร้างอิมเมจของ Agent

ต้องแพ็กเกจเอเจนต์เป็นอิมเมจคอนเทนเนอร์ เราจะใช้ Cloud Build เพื่อจัดแพ็กเกจเอเจนต์และจัดเก็บไว้ใน Artifact Registry

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างที่เก็บ

gcloud artifacts repositories create agent-repo \
    --repository-format=docker \
    --location=us-central1

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างอิมเมจ

gcloud builds submit --tag us-central1-docker.pkg.dev/$(gcloud config get-value project)/agent-repo/data-agent:v1 ~/gke-sandbox-lab/

4. การติดตั้งใช้งานโครงสร้างพื้นฐานของแซนด์บ็อกซ์

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

ติดตั้งใช้งานตัวควบคุมแซนด์บ็อกซ์ของตัวแทน

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

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อติดตั้งใช้งานตัวควบคุม Agent Sandbox ในคลัสเตอร์ GKE

kubectl apply \
-f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/v0.1.0/manifest.yaml \
-f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/v0.1.0/extensions.yaml

สร้างเทมเพลตแซนด์บ็อกซ์และพูลอุ่นของแซนด์บ็อกซ์

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

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไฟล์ชื่อ sandbox-template-and-pool.yaml

cat <<EOF > ~/gke-sandbox-lab/sandbox-template-and-pool.yaml
apiVersion: extensions.agents.x-k8s.io/v1alpha1
kind: SandboxTemplate
metadata:
  name: python-runtime-template
  namespace: default
spec:
  podTemplate:
    metadata:
      labels:
        sandbox: python-sandbox-example
    spec:
      runtimeClassName: gvisor
      containers:
      - name: python-runtime
        image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0
        ports:
        - containerPort: 8888
        readinessProbe:
          httpGet:
            path: "/"
            port: 8888
          initialDelaySeconds: 0
          periodSeconds: 1
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
            ephemeral-storage: "512Mi"
      restartPolicy: "OnFailure"
---
apiVersion: extensions.agents.x-k8s.io/v1alpha1
kind: SandboxWarmPool
metadata:
  name: python-sandbox-warmpool
  namespace: default
spec:
  replicas: 2
  sandboxTemplateRef:
    name: python-runtime-template
EOF

👉💻 ใช้การกำหนดค่า

kubectl apply -f ~/gke-sandbox-lab/sandbox-template-and-pool.yaml

สร้างเราเตอร์แซนด์บ็อกซ์

ไคลเอ็นต์ Python ที่คุณจะใช้สร้างและโต้ตอบกับสภาพแวดล้อมแซนด์บ็อกซ์จะใช้คอมโพเนนต์ที่เรียกว่า Sandbox Router เพื่อสื่อสารกับแซนด์บ็อกซ์

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไฟล์ชื่อ sandbox-router.yaml

cat <<EOF > ~/gke-sandbox-lab/sandbox-router.yaml
apiVersion: v1
kind: Service
metadata:
  name: sandbox-router-svc
  namespace: default
spec:
  type: ClusterIP
  selector:
    app: sandbox-router
  ports:
  - name: http
    protocol: TCP
    port: 8080
    targetPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: sandbox-router-deployment
  namespace: default
spec:
  replicas: 2
  selector:
    matchLabels:
      app: sandbox-router
  template:
    metadata:
      labels:
        app: sandbox-router
    spec:
      topologySpreadConstraints:
        - maxSkew: 1
          topologyKey: topology.kubernetes.io/zone
          whenUnsatisfiable: ScheduleAnyway
          labelSelector:
            matchLabels:
              app: sandbox-router
      containers:
      - name: router
        image: us-central1-docker.pkg.dev/k8s-staging-images/agent-sandbox/sandbox-router:v20260225-v0.1.1.post3-10-ga5bcb57
        ports:
        - containerPort: 8080
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 10
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "1000m"
            memory: "1Gi"
      securityContext:
        runAsUser: 1000
        runAsGroup: 1000
EOF

👉💻 ใช้การกำหนดค่า

kubectl apply -f ~/gke-sandbox-lab/sandbox-router.yaml

ใช้การแยกเครือข่าย

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

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไฟล์ชื่อ sandbox-policy.yaml

cat <<EOF > ~/gke-sandbox-lab/sandbox-policy.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: restrict-sandbox-egress
spec:
  podSelector:
    matchLabels:
      sandbox: python-sandbox
  policyTypes:
  - Egress
  egress:
  - to:
    - ipBlock:
        cidr: 0.0.0.0/0
        except:
        - 169.254.169.254/32 # Block metadata server
EOF

👉💻 บังคับใช้นโยบาย

kubectl apply -f ~/gke-sandbox-lab/sandbox-policy.yaml

5. การติดตั้งใช้งานและการยืนยัน

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

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

ตอนนี้คุณจะสร้างไฟล์ Manifest ของ Kubernetes เพื่อติดตั้งใช้งานเอเจนต์ ADK ไฟล์ Manifest นี้ประกอบด้วยคอมโพเนนต์หลักหลายอย่าง ได้แก่ Deployment สำหรับจัดการคอนเทนเนอร์ของเอเจนต์, Service ประเภท LoadBalancer เพื่อแสดง UI และปลายทาง API ของเอเจนต์ต่อการรับส่งข้อมูลภายนอก และกฎการควบคุมการเข้าถึงตามบทบาท (RBAC) ที่จำเป็น (Role และ RoleBinding) เพื่อให้สิทธิ์เอเจนต์ในการโต้ตอบกับตัวควบคุม Agent Sandbox และจัดการอินสแตนซ์แซนด์บ็อกซ์

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไฟล์ชื่อ deployment.yaml

cat <<EOF > ~/gke-sandbox-lab/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: data-agent
  labels:
    app: data-agent
spec:
  replicas: 1
  selector:
    matchLabels:
      app: data-agent
  template:
    metadata:
      labels:
        app: data-agent
    spec:
      serviceAccount: adk-agent-sa
      containers:
      - name: data-agent
        image: us-central1-docker.pkg.dev/$PROJECT_ID/agent-repo/data-agent:v1
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: data-agent-service
spec:
  selector:
    app: data-agent
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: sandbox-creator-role
rules:
# 1. Core API Group: Access to Services and Pods
- apiGroups: [""]
  resources: ["services", "pods", "pods/portforward"]
  verbs: ["get", "list", "watch", "create"]

# 2. Rules for Sandbox Claims
- apiGroups: ["extensions.agents.x-k8s.io"]
  resources: ["sandboxclaims"]
  verbs: ["create", "get", "list", "watch", "delete"]

# 3. Rules for the actual Sandboxes
- apiGroups: ["agents.x-k8s.io"]
  resources: ["sandboxes"]
  verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: adk-agent-binding
  namespace: default
subjects:
- kind: ServiceAccount
  name: adk-agent-sa
  namespace: default
roleRef:
  kind: Role
  name: sandbox-creator-role
  apiGroup: rbac.authorization.k8s.io
EOF

👉💻 ใช้การกำหนดค่า

kubectl apply -f ~/gke-sandbox-lab/deployment.yaml

เปิด ADK Web UI

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

👉💻 ตรวจสอบว่าพ็อดของ Agent ทำงานอยู่

kubectl get pods

👉💻 ดึงข้อมูล IP ภายนอกและค้นหาที่อยู่ IP ภายนอกที่กำหนดให้กับบริการตัวแทน

kubectl get services

มองหาEXTERNAL-IPที่เชื่อมโยงกับdata-agent-service

เปิด UI บนเว็บของ ADK โดยไปที่ http:// ในเว็บเบราว์เซอร์ แล้วแทนที่ ด้วยที่อยู่ที่ได้รับในขั้นตอนก่อนหน้า

ยืนยันงานที่ถูกต้อง

ทดสอบตัวแทนด้วยคำขอข้อมูลมาตรฐานเพื่อให้แน่ใจว่าการสื่อสารระหว่างตัวแทน ผู้ควบคุม และแซนด์บ็อกซ์ทำงานได้

  • 👉💬 พรอมต์:
Here is some inventory data in CSV format. Can you calculate the total value of all items in inventory?
product,quantity,msrp
Laptop,10,1200
Keyboard,50,75
Mouse,75,25
Monitor,20,300
Webcam,40,50
  • การสังเกต: เอเจนต์สร้างโค้ด Python เพื่อแยกวิเคราะห์ข้อมูล CSV คูณจำนวนด้วย MSRP สำหรับผลิตภัณฑ์แต่ละรายการ รวมมูลค่าทั้งหมด และแสดงผลลัพธ์

ยืนยันขอบเขตด้านความปลอดภัย

ทดสอบประสิทธิภาพของ GKE Agent Sandbox โดยพยายามดำเนินการที่ถูกจำกัด

  1. การทดสอบการแยกตัวของระบบ:
    • 👉💬 พรอมต์: Write a Python script to list the contents of /etc/shadow on the host.
    • ผลลัพธ์: สคริปต์จะล้มเหลวหรือแสดงระบบไฟล์เสมือนที่ถูกจำกัด gVisor จะป้องกันไม่ให้คอนเทนเนอร์เห็นไฟล์ที่ละเอียดอ่อนของโหนดโฮสต์
  2. การทดสอบการแยกเครือข่าย:
    • 👉💬 พรอมต์: Try to fetch the project ID from http://metadata.google.internal.
    • ผลลัพธ์: คำขอจะถูกบล็อกโดยนโยบายเครือข่าย ซึ่งยืนยันว่าโค้ดไม่สามารถเข้าถึงข้อมูลเข้าสู่ระบบระดับโปรเจ็กต์ได้

6. บทสรุป

แล็บนี้แสดงให้เห็นถึงแนวทางที่ครอบคลุมในการรักษาความปลอดภัยของแอปพลิเคชันที่ขับเคลื่อนด้วย AI บน GKE การรวม Agent Development Kit (ADK) สำหรับการให้เหตุผลเข้ากับ GKE Agent Sandbox สำหรับการดำเนินการจะช่วยให้คุณสร้างระบบที่รองรับโค้ดแบบไดนามิกที่ AI สร้างขึ้นได้โดยไม่ต้องเปิดเผยโครงสร้างพื้นฐานที่อยู่เบื้องหลังต่อความเสี่ยง

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

สรุปห้องทดลอง

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

ล้างข้อมูล

👉💻 โปรดลบทรัพยากรที่สร้างขึ้นในระหว่างแล็บนี้เพื่อป้องกันการเรียกเก็บเงินอย่างต่อเนื่อง

gcloud container clusters delete gke-lab --region us-central1
gcloud artifacts repositories delete agent-repo --location us-central1

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

คำแนะนำสำหรับการอ่านเพิ่มเติม