GKE पर सुरक्षित एआई एजेंट डिप्लॉय करना

1. परिचय

यह लैब, ऐसे एआई एजेंट के डेवलपमेंट और सुरक्षा पर फ़ोकस करती है जो प्रोडक्शन एनवायरमेंट में डाइनैमिक कोड को एक्ज़ीक्यूट करते हैं. एआई ऐप्लिकेशन, अब सिर्फ़ चैट इंटरफ़ेस तक सीमित नहीं हैं. इसलिए, उन्हें अक्सर जटिल लॉजिक को लागू करने की ज़रूरत होती है. जैसे, डेटा विश्लेषण, गणितीय मॉडलिंग या फ़ाइल प्रोसेसिंग. इसके लिए, उन्हें रीयल-टाइम में कोड जनरेट करने और उसे चलाने की सुविधा की ज़रूरत होती है. इस लैब में, यह दिखाया गया है कि एजेंट डेवलपमेंट किट (एडीके) का इस्तेमाल करके, तर्क करने वाले एजेंट कैसे बनाए जाते हैं. साथ ही, GKE एजेंट सैंडबॉक्स का इस्तेमाल करके, यह कैसे पक्का किया जाता है कि एआई से जनरेट किया गया कोई भी कोड, सुरक्षित और अलग-थलग माहौल में एक्ज़ीक्यूट हो.

भरोसेमंद न होने वाले कोड से जुड़ी तकनीकी चुनौती

जब कोई एआई एजेंट, Python जैसे कोड को जनरेट और एक्ज़ीक्यूट करता है, तो वह आपके इन्फ़्रास्ट्रक्चर पर एक ऐसा वर्कलोड चलाता है जिस पर भरोसा नहीं किया जा सकता. अगर एजेंट से समझौता किया जाता है या उसे नुकसान पहुंचाने वाली कार्रवाइयां करने का निर्देश दिया जाता है, तो वह संवेदनशील एनवायरमेंट वैरिएबल को ऐक्सेस करने, आपके इंटरनल नेटवर्क को स्कैन करने या होस्ट नोड का गलत इस्तेमाल करने की कोशिश कर सकता है. इन डाइनैमिक वर्कलोड के लिए, कंटेनर को अलग रखने का पारंपरिक तरीका अक्सर काफ़ी नहीं होता. इस समस्या को हल करने के लिए, प्लैटफ़ॉर्म इंजीनियरों को कई लेयर वाली सुरक्षा लागू करनी होगी. इसमें कर्नल-लेवल का आइसोलेशन और नेटवर्क से बाहर निकलने पर पाबंदी शामिल है.

मुख्य सिद्धांत

  • एजेंट डेवलपमेंट किट (एडीके): एडीके एक फ़्रेमवर्क है. इसका इस्तेमाल ऐसे ऐप्लिकेशन बनाने के लिए किया जाता है जो टास्क के बारे में तर्क दे सकते हैं. यह "रीज़निंग लूप" को मैनेज करता है. इसमें एआई को प्रॉम्प्ट मिलता है, वह कार्रवाइयों की एक सीरीज़ प्लान करता है, खास टूल को कॉल करता है, और फिर फ़ाइनल आउटपुट की खास जानकारी देता है. इस वर्कफ़्लो में, ADK एक ऑर्केस्ट्रेटर के तौर पर काम करता है. यह पता लगाता है कि किसी उपयोगकर्ता के अनुरोध के लिए कोड को कब लागू करना है.
  • GKE एजेंट सैंडबॉक्स: सुरक्षा से जुड़ी यह सुविधा, gVisor का इस्तेमाल करती है. यह एक ओपन-सोर्स कंटेनर रनटाइम है. यह हर कंटेनर के लिए, खास गेस्ट कर्नल उपलब्ध कराता है. GKE एजेंट सैंडबॉक्स, ऐप्लिकेशन और होस्ट कर्नल के बीच सिस्टम कॉल (syscalls) को इंटरसेप्ट करता है. इससे, भरोसेमंद न होने वाले कोड को नोड के साथ सीधे तौर पर इंटरैक्ट करने से रोका जा सकता है. इससे यह पक्का होता है कि कंटेनर में सुरक्षा से जुड़ा कोई उल्लंघन होने पर, वह क्लस्टर के बाकी हिस्सों तक न पहुंचे.
  • मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी) और टूल: यह प्रोटोकॉल, एआई मॉडल के लिए बाहरी टूल के साथ इंटरैक्ट करने का एक स्टैंडर्ड तरीका तय करता है. इस लैब में, एजेंट को "कोड एक्ज़ीक्यूशन" टूल के साथ कॉन्फ़िगर किया गया है. यह टूल, Python स्क्रिप्ट चलाने के लिए एक खास सैंडबॉक्स कंट्रोलर के साथ कम्यूनिकेट करता है.

लैब के मकसद

इस सेशन के आखिर तक, ये काम किए जा सकेंगे:

  1. एजेंट डेवलप करना: डेटा विश्लेषण के कामों के लिए डिज़ाइन किए गए, ADK पर आधारित एजेंट को कॉन्फ़िगर करें.
  2. कर्नेल आइसोलेशन कॉन्फ़िगर करें: खास RuntimeClasses के साथ GKE एजेंट सैंडबॉक्स सेट अप करें.
  3. परफ़ॉर्मेंस ऑप्टिमाइज़ करें: नए एक्ज़ीक्यूशन एनवायरमेंट शुरू करने में लगने वाले समय को कम करने के लिए, सैंडबॉक्स का "वार्म पूल" लागू करें.
  4. सुरक्षा से जुड़ी सीमाओं को लागू करना: एक्ज़ीक्यूशन एनवायरमेंट से बिना अनुमति के डेटा बाहर जाने से रोकने के लिए, नेटवर्क की नीतियां लागू करें.

2. प्रोजेक्ट सेट अप करना

एजेंटिक ऐप्लिकेशन बनाना शुरू करने से पहले, एनवायरमेंट को सही तरीके से कॉन्फ़िगर करना ज़रूरी है. इस सेक्शन में, आपको ज़रूरी टूल का ऐक्सेस मिलेगा. साथ ही, यह पक्का किया जाएगा कि आपका Google Cloud प्रोजेक्ट, एआई एजेंट और उसके सुरक्षित एक्ज़ीक्यूशन एनवायरमेंट, दोनों को होस्ट करने के लिए तैयार है.

Cloud Shell खोलें

इस लैब के लिए, हम Cloud Shell का इस्तेमाल करेंगे. यह ब्राउज़र पर आधारित टर्मिनल एनवायरमेंट है, जिसे Google Cloud उपलब्ध कराता है. Cloud Shell में, Google Cloud CLI (gcloud), kubectl, और Docker एनवायरमेंट पहले से कॉन्फ़िगर किया गया होता है. इनकी मदद से, ऐप्लिकेशन बनाया और डिप्लॉय किया जा सकता है.

  1. Google Cloud Console पर जाएं.
  2. सबसे ऊपर दाएं हेडर में मौजूद, Cloud Shell चालू करें बटन (>_ आइकॉन) पर क्लिक करें.
  3. ब्राउज़र में सबसे नीचे टर्मिनल खुलने के बाद, अगर कहा जाए, तो जारी रखें पर क्लिक करें.

कोई प्रोजेक्ट चुनें

आपको यह पक्का करना होगा कि आपका शेल सही Google Cloud प्रोजेक्ट पर पॉइंट किया गया हो, ताकि संसाधनों को गलत एनवायरमेंट में डिप्लॉय करने से बचा जा सके.

👉💻 कंसोल के डैशबोर्ड से अपना प्रोजेक्ट आईडी ढूंढें. इसके बाद, प्रोजेक्ट को अपने मौजूदा शेल में सेट करने के लिए, यह निर्देश चलाएं:

gcloud config set project [YOUR_PROJECT_ID]

एपीआई चालू करें

एजेंट बनाने और उन्हें डिप्लॉय करने के लिए, कई खास तरह के एपीआई की ज़रूरत होती है. जैसे, कंटेनर बनाने, इमेज होस्ट करने, और जनरेटिव मॉडल को ऐक्सेस करने के लिए एपीआई.

👉💻 इन सेवाओं को शुरू करने के लिए, यह निर्देश चलाएं:

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 क्लस्टर ज़रूरी है. 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 मिनट लगते हैं. आपके पास नए टैब में एपीआई चालू करने का विकल्प होता है. इसके अलावा, कमांड प्रोसेस होने के दौरान भी एपीआई चालू किए जा सकते हैं.

kubectl का ऐक्सेस कॉन्फ़िगर करना

क्लस्टर उपलब्ध होने के बाद, आपको kubectl को कॉन्फ़िगर करना होगा, ताकि यह क्लस्टर से कम्यूनिकेट कर सके.

👉💻 यहां दी गई कमांड, क्लस्टर के क्रेडेंशियल वापस लाती है और आपकी लोकल kubeconfig फ़ाइल को अपडेट करती है. इससे, Cloud Shell से अपने नए GKE क्लस्टर के ख़िलाफ़ कमांड चलाई जा सकती हैं:

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

इस बदलाव के बाद, kubectl कमांड अब डिफ़ॉल्ट रूप से gke-lab क्लस्टर को टारगेट करेंगी.

GKE को Vertex AI ऐक्सेस करने की अनुमति देना

GKE पर चल रहे एजेंट को मॉडल इन्फ़रेंस के लिए, Vertex AI की सेवाओं को ऐक्सेस करने की अनुमति देने के लिए, आपको Workload Identity को कॉन्फ़िगर करना होगा. इससे, Kubernetes सेवा खाते को Google Cloud IAM की भूमिका से जोड़ा जा सकता है. इससे, उस सेवा खाते के तौर पर चलने वाले पॉड को ज़रूरी अनुमतियां मिल जाती हैं. इसके लिए, सेवा खाते की कुंजियों को मैनेज करने की ज़रूरत नहीं होती.

👉💻 सबसे पहले, Kubernetes सेवा खाता बनाएं. एजेंट पॉड इसका इस्तेमाल करेंगे:

kubectl create serviceaccount adk-agent-sa

इसके बाद, IAM नीति बाइंडिंग जोड़कर, इस सेवा खाते को Vertex AI User की भूमिका दें.

👉💻 यह कमांड, adk-agent-sa नेमस्पेस में मौजूद adk-agent-sa Kubernetes सेवा खाते को, आपके प्रोजेक्ट के Workload Identity Pool के लिए IAM भूमिका roles/aiplatform.user से बाइंड करती है.default

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 एजेंट बनाना

इस सेक्शन में, आपको अपने एजेंट के लिए लॉजिक तय करना होगा. यह एजेंट, डेटा विशेषज्ञ के तौर पर काम करता है. यह फ़ाइलों को प्रोसेस करने के लिए Python कोड लिख सकता है. इस लॉजिक की मदद से एजेंट यह पहचान पाता है कि किसी व्यक्ति के नैचुरल लैंग्वेज में किए गए अनुरोध के लिए, गणितीय या डेटा पर आधारित कैलकुलेशन की ज़रूरत है. इस तरह की कैलकुलेशन को कोड की मदद से सबसे अच्छी तरह से हैंडल किया जा सकता है.

एजेंट डायरेक्ट्री बनाना

👉💻 लैब के लिए एक डायरेक्ट्री और एजेंट के सोर्स कोड के लिए एक सबडायरेक्ट्री बनाएं:

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

ADK एजेंट तय करना

सबसे पहले, हम एजेंट के मुख्य लॉजिक को तय करते हैं. हमारा एजेंट, ADK फ़्रेमवर्क का इस्तेमाल करके, SpreadsheetAnalyst नाम के एजेंट को तय करता है. यह एजेंट, gemini-2.5-flash मॉडल का इस्तेमाल करता है. इसमें एक टूल (run_spreadsheet_analysis) शामिल है, जो Python कोड को सुरक्षित तरीके से चलाने के लिए GKE Agent Sandbox को कॉल करता है. एजेंट को दिए गए निर्देशों के मुताबिक, स्प्रेडशीट का विश्लेषण करने के लिए, 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

हम यह पक्का करते हैं कि root_agent को Python पैकेज के तौर पर देखा जाए, ताकि ADK, agent.py से एजेंट की परिभाषा का पता लगा सके और उसे लोड कर सके. साथ ही, हमारे एजेंट के बारे में जान सके.

👉💻 root_agent/__init__.py नाम की एक खाली फ़ाइल बनाने के लिए, यह कमांड चलाएं. इस फ़ाइल में यह कॉन्टेंट शामिल होगा:

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

इसके बाद, हम ADK एजेंट के लिए एनवायरमेंट वैरिएबल को कॉन्फ़िगर करने वाली फ़ाइल बनाते हैं. GOOGLE_GENAI_USE_VERTEXAI=TRUE, ADK को Gemini मॉडल ऐक्सेस करने के लिए Vertex AI का इस्तेमाल करने के लिए कहता है. साथ ही, GOOGLE_CLOUD_PROJECT और GOOGLE_CLOUD_LOCATION, Vertex AI API कॉल के लिए इस्तेमाल किए जाने वाले Google Cloud प्रोजेक्ट और क्षेत्र के बारे में बताते हैं.

👉💻 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

एजेंट को कंटेनर में रखना

आखिर में, हम एजेंट के लिए कंटेनर इमेज तय करते हैं. यह Python की बेस इमेज से शुरू होता है. इसमें kubectl इंस्टॉल किया जाता है. इसकी ज़रूरत एजेंट सैंडबॉक्स क्लाइंट को क्लस्टर से कम्यूनिकेट करने के लिए होती है. साथ ही, इसमें ज़रूरी Python लाइब्रेरी इंस्टॉल की जाती हैं: google-adk, pandas, और इसकी Git रिपॉज़िटरी से agentic-sandbox-client. आखिर में, यह एजेंट के सोर्स कोड को इमेज में कॉपी करता है. साथ ही, ADK वेब सर्वर को चलाने के लिए एंट्रीपॉइंट सेट करता है. इससे एजेंट का यूज़र इंटरफ़ेस (यूआई) और एपीआई दिखता है.

👉💻 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

एजेंट इमेज बनाना

एजेंट को कंटेनर इमेज के तौर पर पैकेज किया जाना चाहिए. हम एजेंट को पैकेज करने के लिए 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 Controller को डिप्लॉय करना

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

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

👉💻 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 Metadata Server या अन्य इंटरनल आईपी तक न पहुंच पाएं.

👉💻 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. परिनियोजन और पुष्टि करना

एजेंट और सुरक्षा इन्फ़्रास्ट्रक्चर को कॉन्फ़िगर करने के बाद, अब आपको कॉम्पोनेंट डिप्लॉय करने होंगे. साथ ही, यह पुष्टि करनी होगी कि सुरक्षा से जुड़ी सीमाएं उम्मीद के मुताबिक काम कर रही हैं.

एजेंट को डिप्लॉय करना

अब आपको ADK एजेंट को डिप्लॉय करने के लिए, Kubernetes मेनिफ़ेस्ट बनाना होगा. इस मेनिफ़ेस्ट में कई मुख्य कॉम्पोनेंट शामिल हैं: एजेंट के कंटेनर को मैनेज करने के लिए Deployment, एजेंट के यूज़र इंटरफ़ेस (यूआई) और एपीआई एंडपॉइंट को बाहरी ट्रैफ़िक के लिए उपलब्ध कराने के लिए LoadBalancer टाइप का Service, और एजेंट को एजेंट सैंडबॉक्स कंट्रोलर के साथ इंटरैक्ट करने और सैंडबॉक्स इंस्टेंस मैनेज करने की अनुमति देने के लिए, भूमिका के आधार पर ऐक्सेस कंट्रोल (आरबीएसी) के ज़रूरी नियम (Role और RoleBinding).

👉💻 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 का वेब यूज़र इंटरफ़ेस (यूआई) खोलना

डेटा ट्रांसफ़र पूरा होने के बाद, इसकी स्थिति की पुष्टि की जा सकती है.

👉💻 पक्का करें कि एजेंट पॉड चल रहे हों:

kubectl get pods

👉💻 एजेंट सेवा को असाइन किया गया एक्सटर्नल आईपी पता ढूंढने के लिए, एक्सटर्नल आईपी पता वापस पाएं:

kubectl get services

EXTERNAL-IP से जुड़ी EXTERNAL-IP वैल्यू ढूंढें.data-agent-service

अपने वेब ब्राउज़र में http:// पर जाकर, ADK का वेब यूज़र इंटरफ़ेस (यूआई) खोलें. की जगह, पिछले चरण में मिला पता डालें.

भरोसेमंद टास्क की पुष्टि करना

डेटा के लिए सामान्य अनुरोध करके एजेंट की जांच करें. इससे यह पक्का किया जा सकेगा कि एजेंट, कंट्रोलर, और सैंडबॉक्स के बीच कम्यूनिकेशन ठीक से काम कर रहा है.

  • 👉💬 प्रॉम्प्ट:
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
  • ऑब्ज़र्वेशन: एजेंट, CSV डेटा को पार्स करने के लिए Python कोड जनरेट करता है. इसके बाद, हर प्रॉडक्ट के लिए, संख्या को एमआरपी से गुणा करता है. इसके बाद, कुल वैल्यू को जोड़ता है और नतीजा दिखाता है.

सुरक्षा सीमाओं की पुष्टि करना

पाबंदी वाली कार्रवाइयां करके, GKE एजेंट सैंडबॉक्स की परफ़ॉर्मेंस की जांच करें.

  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. नतीजा

इस लैब में, GKE पर एआई की मदद से काम करने वाले ऐप्लिकेशन को सुरक्षित करने का पूरा तरीका दिखाया गया है. आपने तर्क करने के लिए एजेंट डेवलपमेंट किट (एडीके) और कोड को लागू करने के लिए GKE एजेंट सैंडबॉक्स को मिलाकर एक ऐसा सिस्टम बनाया है जो डाइनैमिक और एआई से जनरेट किए गए कोड के साथ काम करता है. साथ ही, इससे बुनियादी ढांचे को जोखिम नहीं होता.

gVisor का इस्तेमाल करने से, कर्नल-लेवल आइसोलेशन मिलता है. नेटवर्क की नीतियां, एक से दूसरे सिस्टम में डेटा ट्रांसफ़र होने से रोकती हैं. साथ ही, वार्म पूल यह पक्का करते हैं कि सुरक्षा की इन लेयर की वजह से, ऐप्लिकेशन की परफ़ॉर्मेंस कम न हो. यह आर्किटेक्चर, ऐसे रीज़निंग एजेंट को डिप्लॉय करने के लिए स्टैंडर्ड है जिनके लिए सुरक्षित कोड एक्ज़ीक्यूशन एनवायरमेंट की ज़रूरत होती है.

लैब के बारे में खास जानकारी

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

साफ़-सफ़ाई सेवा

👉💻 इस कोडलैब के दौरान बनाए गए संसाधनों को मिटाएं, ताकि आपसे शुल्क न लिया जाए.

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

अगले चरण

ज़्यादा जानकारी के लिए सुझाव: