Men-deploy Agen AI Aman di GKE

1. Pengantar

Lab ini berfokus pada pengembangan dan keamanan agen AI yang mengeksekusi kode dinamis dalam lingkungan produksi. Seiring aplikasi AI berkembang melampaui antarmuka chat sederhana, aplikasi tersebut sering kali memerlukan kemampuan untuk melakukan logika yang kompleks—seperti analisis data, pemodelan matematika, atau pemrosesan file—dengan membuat dan menjalankan kode secara real-time. Lab ini menunjukkan cara menggunakan Agent Development Kit (ADK) untuk membangun agen penalaran dan GKE Agent Sandbox untuk memastikan bahwa kode apa pun yang dihasilkan oleh AI dieksekusi di lingkungan yang sangat terisolasi dan aman.

Tantangan Teknis Kode Tidak Tepercaya

Saat agen AI membuat dan mengeksekusi kode (seperti Python), agen tersebut pada dasarnya menjalankan workload yang tidak tepercaya di infrastruktur Anda. Jika agen disusupi atau diinstruksikan untuk melakukan tindakan berbahaya, agen tersebut dapat mencoba mengakses variabel lingkungan sensitif, memindai jaringan internal Anda, atau mengeksploitasi node host yang mendasarinya. Isolasi container tradisional sering kali tidak memadai untuk beban kerja dinamis ini. Untuk mengatasi hal ini, engineer platform harus menerapkan keamanan berlapis yang mencakup isolasi tingkat kernel dan keluar jaringan yang dibatasi.

Konsep Inti

  • Agent Development Kit (ADK): ADK adalah framework yang digunakan untuk membangun aplikasi yang dapat melakukan penalaran tentang tugas. AI ini mengelola "loop penalaran" di mana AI menerima perintah, merencanakan serangkaian tindakan, memanggil alat tertentu, lalu meringkas output akhir. Dalam alur kerja ini, ADK bertindak sebagai pengelola yang mengidentifikasi kapan permintaan pengguna memerlukan eksekusi kode.
  • Sandbox Agen GKE: Fitur keamanan ini menggunakan gVisor, runtime container open source yang menyediakan kernel tamu khusus untuk setiap container. Dengan mencegat panggilan sistem (syscall) antara aplikasi dan kernel host, GKE Agent Sandbox mencegah kode yang tidak tepercaya berinteraksi langsung dengan node. Hal ini memastikan bahwa pelanggaran keamanan dalam penampung tidak dapat meningkat ke seluruh cluster.
  • Model Context Protocol (MCP) & Alat: Protokol ini menetapkan cara standar bagi model AI untuk berinteraksi dengan alat eksternal. Di lab ini, agen dikonfigurasi dengan alat "Eksekusi Kode" yang berkomunikasi dengan pengontrol sandbox khusus untuk menjalankan skrip Python.

Tujuan Lab

Di akhir sesi ini, Anda akan dapat:

  1. Mengembangkan Agen: Konfigurasi agen berbasis ADK yang dirancang untuk tugas analisis data.
  2. Mengonfigurasi Isolasi Kernel: Siapkan GKE Agent Sandbox dengan RuntimeClass khusus.
  3. Mengoptimalkan Performa: Terapkan "Warm Pool" sandbox untuk meminimalkan waktu yang dihabiskan untuk memulai lingkungan eksekusi baru.
  4. Terapkan Batas Keamanan: Terapkan Kebijakan Jaringan untuk mencegah egress yang tidak sah dari lingkungan eksekusi.

2. Penyiapan Project

Lingkungan yang dikonfigurasi dengan benar sangat penting sebelum Anda mulai membangun aplikasi agentik. Di bagian ini, Anda akan mengakses alat yang diperlukan dan memastikan project Google Cloud Anda siap menghosting agen AI dan lingkungan eksekusi yang aman.

Buka Cloud Shell

Untuk lab ini, kita akan menggunakan Cloud Shell, yaitu lingkungan terminal berbasis browser yang disediakan oleh Google Cloud. Cloud Shell telah dikonfigurasi sebelumnya dengan Google Cloud CLI (gcloud), kubectl, dan lingkungan Docker yang diperlukan untuk membangun dan men-deploy aplikasi Anda.

  1. Buka Google Cloud Console.
  2. Klik tombol Activate Cloud Shell di header kanan atas (ikon >_).
  3. Setelah terminal terbuka di bagian bawah browser, klik Lanjutkan jika diminta.

Pilih Project

Anda harus memastikan shell Anda diarahkan ke project Google Cloud yang benar untuk menghindari deployment resource ke lingkungan yang salah.

👉💻 Identifikasi Project ID Anda dari dasbor konsol, lalu jalankan perintah berikut untuk menetapkan project di shell saat ini:

gcloud config set project [YOUR_PROJECT_ID]

Mengaktifkan API

Membangun dan men-deploy agen memerlukan beberapa API khusus untuk build container, hosting gambar, dan akses model generatif.

👉💻 Jalankan perintah berikut untuk melakukan inisialisasi layanan ini:

gcloud services enable \
    cloudbuild.googleapis.com \
    artifactregistry.googleapis.com \
    container.googleapis.com \
    aiplatform.googleapis.com
  • cloudbuild.googleapis.com: Mengotomatiskan pembuatan image container dari kode sumber Anda.
  • artifactregistry.googleapis.com: Menyediakan registry pribadi yang aman untuk image agen Anda.
  • container.googleapis.com: Mengelola siklus proses cluster GKE dan fitur keamanannya.
  • aiplatform.googleapis.com: Menyediakan akses ke layanan Vertex AI, termasuk model Gemini untuk penalaran dan pembuatan kode.

Pembuatan Cluster

Lab ini memerlukan cluster GKE dengan fitur Agent Sandbox yang diaktifkan. Menggunakan GKE Autopilot adalah cara paling efisien untuk memulai, karena secara otomatis menangani pengelolaan node sekaligus mendukung fitur keamanan yang diperlukan untuk eksekusi kode yang terisolasi.

👉💻 Jalankan perintah berikut untuk membuat cluster 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

Catatan: Penyediaan cluster baru biasanya memerlukan waktu 8–10 menit. Anda dapat melanjutkan untuk mengaktifkan API di tab baru atau saat perintah diproses.

Mengonfigurasi Akses kubectl

Setelah cluster Anda disediakan, Anda perlu mengonfigurasi kubectl untuk berkomunikasi dengannya.

👉💻 Perintah berikut mengambil kredensial cluster dan memperbarui file kubeconfig lokal Anda, sehingga Anda dapat menjalankan perintah terhadap cluster GKE baru dari Cloud Shell:

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

Dengan demikian, perintah kubectl kini akan menargetkan cluster gke-lab secara default.

Mengizinkan Akses GKE ke Vertex AI

Agar agen yang berjalan di GKE dapat mengakses layanan Vertex AI untuk inferensi model, Anda perlu mengonfigurasi Workload Identity. Dengan demikian, Anda dapat mengikat akun layanan Kubernetes ke peran IAM Google Cloud, sehingga memberikan izin yang diperlukan kepada pod yang berjalan sebagai akun layanan tersebut tanpa perlu mengelola kunci akun layanan.

👉💻 Pertama, buat akun layanan Kubernetes yang akan digunakan pod agen:

kubectl create serviceaccount adk-agent-sa

Selanjutnya, berikan peran Vertex AI User kepada akun layanan ini dengan menambahkan binding kebijakan IAM.

👉💻 Perintah ini mengikat akun layanan Kubernetes adk-agent-sa di namespace default ke peran IAM roles/aiplatform.user untuk kumpulan Workload Identity project Anda.

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. Membangun Agen ADK

Di bagian ini, Anda akan menentukan logika untuk agen. Agen bertindak sebagai spesialis data yang dapat menulis kode Python untuk memproses file. Logika penalaran ini memungkinkan agen mengenali kapan permintaan bahasa alami pengguna memerlukan perhitungan matematika atau berbasis data yang paling baik ditangani oleh kode.

Membuat Direktori Agen

👉💻 Buat direktori untuk lab, dan subdirektori untuk kode sumber agen:

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

Menentukan Agen ADK

Pertama, kita tentukan logika inti agen. Agen kami menggunakan framework ADK untuk menentukan agen bernama SpreadsheetAnalyst yang menggunakan model gemini-2.5-flash. Hal ini mencakup alat (run_spreadsheet_analysis) yang memanggil GKE Agent Sandbox untuk mengeksekusi kode Python secara aman. Petunjuk agen memandunya untuk menulis dan menjalankan kode berbasis pandas saat diminta menganalisis spreadsheet.

👉💻 Jalankan perintah berikut untuk membuat file bernama root_agent/agent.py dengan konten berikut:

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

Agar ADK dapat menemukan dan memuat definisi agen dari agent.py dan mengetahui agen kita, kita memastikan root_agent terlihat sebagai paket Python.

👉💻 Jalankan perintah berikut untuk membuat file kosong bernama root_agent/__init__.py dengan konten berikut:

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

Kemudian, kita membuat file yang mengonfigurasi variabel lingkungan untuk agen ADK. GOOGLE_GENAI_USE_VERTEXAI=TRUE memberi tahu ADK untuk menggunakan Vertex AI dalam mengakses model Gemini, serta GOOGLE_CLOUD_PROJECT dan GOOGLE_CLOUD_LOCATION menentukan project dan region Google Cloud yang akan digunakan untuk panggilan Vertex AI API.

👉💻 Jalankan perintah berikut untuk membuat file bernama root_agent/.env dengan konten berikut:

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

Memasukkan Agen ke dalam Container

Terakhir, kita menentukan image container untuk agen. Proses ini dimulai dari image dasar Python, menginstal kubectl (diperlukan oleh klien sandbox agen untuk berkomunikasi dengan cluster), dan menginstal library Python yang diperlukan: google-adk, pandas, dan agentic-sandbox-client dari repositori git-nya. Terakhir, perintah ini menyalin kode sumber agen ke dalam image dan menetapkan titik entri untuk menjalankan server web ADK, yang mengekspos UI dan API agen.

👉💻 Jalankan perintah berikut untuk membuat file bernama Dockerfile dengan konten berikut:

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

Membangun Image Agen

Agen harus dikemas sebagai image container. Kita akan menggunakan Cloud Build untuk mengemas agen dan menyimpannya di Artifact Registry.

👉💻 Jalankan perintah berikut untuk membuat repositori:

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

👉💻 Jalankan perintah berikut untuk membangun Image:

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

4. Menerapkan Infrastruktur Sandbox

Setelah logika agen ditentukan, Anda harus mengonfigurasi infrastruktur yang memungkinkan kode yang tidak tepercaya berjalan dengan aman. Hal ini melibatkan penyiapan kontrol jaringan dan runtime isolasi.

Men-deploy Pengontrol Sandbox Agen

Anda dapat men-deploy pengontrol Agent Sandbox dan komponen yang diperlukan dengan menerapkan manifes rilis resmi ke cluster Anda. Manifes ini adalah file konfigurasi yang menginstruksikan Kubernetes untuk mendownload semua komponen yang diperlukan untuk men-deploy dan menjalankan pengontrol Agent Sandbox di cluster Anda.

👉💻 Jalankan perintah berikut untuk men-deploy pengontrol Agent Sandbox ke cluster GKE Anda:

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

Membuat Template Sandbox dan Kumpulan Siap Pakai Sandbox

Sekarang Anda menentukan konfigurasi untuk sandbox dengan membuat resource SandboxTemplate dan SandboxWarmPool. SandboxTemplate berfungsi sebagai cetak biru yang dapat digunakan kembali yang digunakan oleh pengontrol Agent Sandbox untuk membuat lingkungan sandbox yang konsisten dan telah dikonfigurasi sebelumnya. Resource SandboxWarmPool memastikan bahwa sejumlah Pod yang telah di-warm-up selalu berjalan dan siap untuk diklaim. Sandbox yang sudah dipanaskan adalah Pod yang berjalan dan sudah diinisialisasi. Pra-inisialisasi ini memungkinkan sandbox baru dibuat dalam waktu kurang dari satu detik, dan menghindari latensi startup saat meluncurkan sandbox reguler.

👉💻 Jalankan perintah berikut untuk membuat file bernama 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

👉💻 Terapkan konfigurasi:

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

Buat Router Sandbox

Klien Python yang akan Anda gunakan untuk membuat dan berinteraksi dengan lingkungan sandbox menggunakan komponen yang disebut Sandbox Router untuk berkomunikasi dengan sandbox.

👉💻 Jalankan perintah berikut untuk membuat file bernama 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

👉💻 Terapkan konfigurasi:

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

Menerapkan Isolasi Jaringan

Untuk mencegah kode yang dihasilkan mengakses data sensitif, Anda harus menerapkan Kebijakan Jaringan. Kebijakan ini memastikan bahwa pod sandbox tidak dapat menjangkau Server Metadata Google Cloud atau IP internal lainnya.

👉💻 Jalankan perintah berikut untuk membuat file bernama 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

👉💻 Terapkan kebijakan:

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

5. Deployment dan Verifikasi

Setelah mengonfigurasi agen dan infrastruktur keamanan, Anda akan men-deploy komponen dan memverifikasi bahwa batas keamanan berfungsi seperti yang diharapkan.

Men-deploy Agen

Sekarang Anda akan membuat manifes Kubernetes untuk men-deploy agen ADK. Manifest ini mencakup beberapa komponen utama: Deployment untuk mengelola penampung agen, Service berjenis LoadBalancer untuk mengekspos endpoint UI dan API agen ke traffic eksternal, serta aturan Role-Based Access Control (RBAC) yang diperlukan (Role dan RoleBinding) untuk memberikan izin kepada agen agar dapat berinteraksi dengan pengontrol Agent Sandbox dan mengelola instance sandbox.

👉💻 Jalankan perintah berikut untuk membuat file bernama 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

👉💻 Terapkan konfigurasi:

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

Membuka UI Web ADK

Setelah deployment selesai, Anda dapat memverifikasi statusnya.

👉💻 Pastikan pod agen sedang berjalan:

kubectl get pods

👉💻 Ambil IP Eksternal dan temukan alamat IP eksternal yang ditetapkan ke layanan agen:

kubectl get services

Cari nilai EXTERNAL-IP yang terkait dengan data-agent-service.

Buka UI web ADK dengan membuka http:// di browser web Anda, mengganti dengan alamat yang diperoleh pada langkah sebelumnya.

Memverifikasi Tugas yang Sah

Uji agen dengan permintaan data standar untuk memastikan komunikasi antara agen, pengontrol, dan sandbox berfungsi.

  • 👉💬 Perintah:
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
  • Observasi: Agen membuat kode Python untuk mengurai data CSV, mengalikan jumlah dengan MSRP untuk setiap produk, menjumlahkan total nilai, dan menampilkan hasilnya.

Memverifikasi Batas Keamanan

Uji efektivitas GKE Agent Sandbox dengan mencoba melakukan operasi yang dibatasi.

  1. Uji Isolasi Sistem:
    • 👉💬 Perintah: Write a Python script to list the contents of /etc/shadow on the host.
    • Hasil: Skrip akan gagal atau menampilkan sistem file virtual yang dibatasi. gVisor mencegah penampung melihat file sensitif node host.
  2. Uji Isolasi Jaringan:
    • 👉💬 Perintah: Try to fetch the project ID from http://metadata.google.internal.
    • Hasil: Permintaan akan diblokir oleh Kebijakan Jaringan, yang mengonfirmasi bahwa kode tidak dapat mengakses kredensial tingkat project.

6. Kesimpulan

Lab ini mendemonstrasikan pendekatan komprehensif untuk mengamankan aplikasi berbasis AI di GKE. Dengan menggabungkan Agent Development Kit (ADK) untuk penalaran dengan GKE Agent Sandbox untuk eksekusi, Anda telah membangun sistem yang mendukung kode dinamis yang dihasilkan AI tanpa mengekspos risiko infrastruktur yang mendasarinya.

Penggunaan gVisor memberikan isolasi tingkat kernel, Kebijakan Jaringan mencegah pergerakan lateral, dan Warm Pools memastikan bahwa lapisan keamanan ini tidak menurunkan performa aplikasi. Arsitektur ini mewakili standar untuk men-deploy agen penalaran yang memerlukan lingkungan eksekusi kode yang aman.

Ringkasan Lab

  • Pengembangan Agen: Anda mengonfigurasi agen berbasis ADK yang merencanakan dan menjalankan alat berdasarkan maksud pengguna.
  • Isolasi Aman: Anda menggunakan gVisor untuk menyediakan pemisahan tingkat kernel untuk eksekusi kode yang tidak tepercaya.
  • Kontrol Egress: Anda menerapkan Kebijakan Jaringan untuk "memisahkan" lingkungan eksekusi dari layanan cloud sensitif.
  • Performa: Anda menggunakan Warm Pools untuk memberikan waktu mulai yang hampir instan untuk container yang terisolasi.

Pembersihan

👉💻 Untuk mencegah biaya berkelanjutan, hapus resource yang dibuat selama lab ini.

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

Langkah Berikutnya

Rekomendasi bacaan lebih lanjut: