GKE'de güvenli yapay zeka aracıları dağıtma

1. Giriş

Bu laboratuvarda, üretim ortamında dinamik kod yürüten yapay zeka ajanlarının geliştirilmesi ve güvenliği ele alınmaktadır. Yapay zeka uygulamaları basit sohbet arayüzlerinin ötesine geçtikçe genellikle gerçek zamanlı olarak kod oluşturup çalıştırarak veri analizi, matematiksel modelleme veya dosya işleme gibi karmaşık mantık işlemlerini gerçekleştirme yeteneği gerektirir. Bu laboratuvarda, akıl yürütme aracı oluşturmak için Agent Development Kit (ADK)'nin ve yapay zeka tarafından oluşturulan tüm kodların yüksek düzeyde izole edilmiş, güvenli bir ortamda yürütülmesini sağlamak için GKE Agent Sandbox'ın nasıl kullanılacağı gösterilmektedir.

Güvenilmeyen Kodun Teknik Zorluğu

Bir yapay zeka aracısı kod (ör. Python) oluşturup yürüttüğünde, altyapınızda güvenilmeyen bir iş yükü çalıştırır. Aracı tehlikeye atılırsa veya kötü amaçlı işlemler gerçekleştirmesi için talimat verilirse hassas ortam değişkenlerine erişmeye, dahili ağınızı taramaya ya da temel alınan ana makine düğümünden yararlanmaya çalışabilir. Geleneksel kapsayıcı izolasyonu, bu dinamik iş yükleri için genellikle yeterli değildir. Bu sorunu çözmek için platform mühendisleri, çekirdek düzeyinde izolasyon ve kısıtlanmış ağ çıkışı içeren çok katmanlı güvenlik uygulamalıdır.

Temel Kavramlar

  • Agent Development Kit (ADK): ADK, görevler hakkında akıl yürütebilen uygulamalar oluşturmak için kullanılan bir çerçevedir. Bu model, yapay zekanın bir istem aldığı, bir dizi işlem planladığı, belirli araçları çağırdığı ve ardından son çıktıyı özetlediği bir "akıl yürütme döngüsünü" yönetir. Bu iş akışında ADK, bir kullanıcı isteğinin ne zaman kod yürütme gerektirdiğini belirleyen düzenleyici olarak işlev görür.
  • GKE Agent Sandbox: Bu güvenlik özelliği, her container için özel bir konuk çekirdeği sağlayan açık kaynaklı bir container çalışma zamanı olan gVisor'u kullanır. GKE Agent Sandbox, uygulama ile ana makine çekirdeği arasındaki sistem çağrılarını (syscall) yakalayarak güvenilmeyen kodun doğrudan düğümle etkileşime geçmesini engeller. Bu, kapsayıcıdaki bir güvenlik ihlalinin kümenin geri kalanına yayılmasını önler.
  • Model Context Protocol (MCP) ve Araçlar: Bu protokol, yapay zeka modellerinin harici araçlarla etkileşime girmesi için standart bir yöntem oluşturur. Bu laboratuvarda, aracı Python komut dosyalarını çalıştırmak için özel bir sanal alan denetleyicisiyle iletişim kuran bir "Kod Yürütme" aracıyla yapılandırılır.

Laboratuvar Hedefleri

Bu oturumun sonunda şunları yapabileceksiniz:

  1. Temsilci geliştirme: Veri analizi görevleri için tasarlanmış, ADK tabanlı bir temsilci yapılandırın.
  2. Çekirdek yalıtımını yapılandırma: GKE Agent Sandbox'ı özel RuntimeClass'larla ayarlayın.
  3. Performansı Optimize Etme: Yeni yürütme ortamlarını başlatmak için harcanan süreyi en aza indirmek amacıyla sanal alanların "Warm Pool"unu uygulayın.
  4. Güvenlik Sınırlarını Uygulama: Yürütme ortamından yetkisiz çıkışı önlemek için ağ politikalarını uygulayın.

2. Proje kurulumu

Etkileşimli uygulamalar oluşturmaya başlamadan önce ortamın doğru şekilde yapılandırılması gerekir. Bu bölümde, gerekli araçlara erişecek ve Google Cloud projenizin hem yapay zeka ajanını hem de güvenli yürütme ortamını barındırmaya hazır olduğundan emin olacaksınız.

Cloud Shell'i açın

Bu laboratuvarda, Google Cloud tarafından sağlanan tarayıcı tabanlı bir terminal ortamı olan Cloud Shell'i kullanacağız. Cloud Shell, uygulamanızı oluşturup dağıtmak için gereken Google Cloud KSA (gcloud), kubectl ve Docker ortamıyla önceden yapılandırılmış olarak gelir.

  1. Google Cloud Console'a gidin.
  2. Sağ üstteki başlıktan Cloud Shell'i Etkinleştir düğmesini (>_ simgesi) tıklayın.
  3. Tarayıcınızın alt kısmında terminal açıldığında, istenirse Devam'ı tıklayın.

Proje seçin

Kaynakların yanlış ortama dağıtılmasını önlemek için kabuğunuzun doğru Google Cloud projesine yönlendirildiğinden emin olmanız gerekir.

👉💻 Konsol kontrol panelinden proje kimliğinizi belirleyin ve projeyi geçerli kabuğunuzda ayarlamak için aşağıdaki komutu çalıştırın:

gcloud config set project [YOUR_PROJECT_ID]

API'leri etkinleştir

Aracı oluşturma ve dağıtma işlemleri için kapsayıcı derlemeleri, resim barındırma ve üretken model erişimiyle ilgili birkaç özel API gerekir.

👉💻 Bu hizmetleri başlatmak için aşağıdaki komutu çalıştırın:

gcloud services enable \
    cloudbuild.googleapis.com \
    artifactregistry.googleapis.com \
    container.googleapis.com \
    aiplatform.googleapis.com
  • cloudbuild.googleapis.com: Kaynak kodunuzdan container görüntüleri oluşturma işlemini otomatikleştirir.
  • artifactregistry.googleapis.com: Aracı resimleriniz için güvenli ve özel bir kayıt defteri sağlar.
  • container.googleapis.com: GKE kümesinin ve güvenlik özelliklerinin yaşam döngüsünü yönetir.
  • aiplatform.googleapis.com: Akıl yürütme ve kod oluşturma için Gemini modelleri de dahil olmak üzere Vertex AI hizmetlerine erişim sağlar.

Küme Oluşturma

Bu laboratuvar için Agent Sandbox özelliği etkin olan bir GKE kümesi gerekir. GKE Autopilot'u kullanmak, başlamanın en verimli yoludur. Bu mod, düğüm yönetimini otomatik olarak gerçekleştirirken yalıtılmış kod yürütme için gereken güvenlik özelliklerini destekler.

👉💻 GKE kümesini oluşturmak için aşağıdaki komutları çalıştırın:

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

Not: Yeni bir kümenin sağlanması genellikle 8-10 dakika sürer. Yeni bir sekmede veya komut işlenirken API'leri etkinleştirmeye devam edebilirsiniz.

kubectl erişimini yapılandırma

Kümeniz sağlandıktan sonra, kümenizle iletişim kurmak için kubectl yapılandırmanız gerekir.

👉💻 Aşağıdaki komut, küme kimlik bilgilerini alır ve yerel kubeconfig dosyanızı güncelleyerek Cloud Shell'den yeni GKE kümenize karşı komut çalıştırmanıza olanak tanır:

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

Bu değişiklikle birlikte, kubectl komutları artık varsayılan olarak gke-lab kümesini hedefleyecektir.

GKE'nin Vertex AI'a erişmesine izin verme

GKE'de çalışan aracının model çıkarımı için Vertex AI hizmetlerine erişmesine izin vermek üzere Workload Identity'yi yapılandırmanız gerekir. Bu sayede, bir Kubernetes hizmet hesabını Google Cloud IAM rolüne bağlayabilir ve bu hizmet hesabı olarak çalışan pod'lara, hizmet hesabı anahtarlarını yönetmeye gerek kalmadan gerekli izinleri verebilirsiniz.

👉💻 Öncelikle, aracı kapsüllerinin kullanacağı Kubernetes hizmet hesabını oluşturun:

kubectl create serviceaccount adk-agent-sa

Ardından, IAM politika bağlaması ekleyerek bu hizmet hesabına Vertex AI User rolünü verin.

👉💻 Bu komut, adk-agent-sa Kubernetes hizmet hesabını default ad alanında projenizin Workload Identity havuzu için roles/aiplatform.user IAM rolüne bağlar.

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 aracısını oluşturma

Bu bölümde, aracınızın mantığını tanımlayacaksınız. Aracı, dosyaları işlemek için Python kodu yazabilen bir veri uzmanı gibi davranır. Bu akıl yürütme mantığı, kullanıcının doğal dil isteğinin kodla en iyi şekilde işlenecek matematiksel veya veriye dayalı bir hesaplama gerektirdiği zamanları temsilcinin tanımasına olanak tanır.

Aracı Dizini oluşturma

👉💻 Laboratuvar için bir dizin ve aracı kaynak kodu için bir alt dizin oluşturun:

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

ADK aracısını tanımlama

Öncelikle temsilcinin temel mantığını tanımlarız. Aracımız, gemini-2.5-flash modelini kullanan SpreadsheetAnalyst adlı bir aracı tanımlamak için ADK çerçevesini kullanır. Güvenli bir şekilde Python kodu yürütmek için GKE Agent Sandbox'ı çağıran bir araç (run_spreadsheet_analysis) içerir. Temsilcinin talimatları, e-tabloları analiz etmesi istendiğinde pandas tabanlı kod yazıp yürütmesini sağlar.

👉💻 Aşağıdaki içeriğe sahip root_agent/agent.py adlı bir dosya oluşturmak için aşağıdaki komutu çalıştırın:

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'nın agent.py konumundaki aracı tanımını bulup yüklemesine ve aracımız hakkında bilgi edinmesine olanak tanımak için root_agent öğesinin bir Python paketi olarak görülmesini sağlarız.

👉💻 Aşağıdaki içeriğe sahip root_agent/__init__.py adlı boş bir dosya oluşturmak için aşağıdaki komutu çalıştırın:

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

Ardından, ADK aracısı için ortam değişkenlerini yapılandıran bir dosya oluştururuz. GOOGLE_GENAI_USE_VERTEXAI=TRUE, ADK'ya Gemini modellerine erişmek için Vertex AI'ı kullanmasını söyler. GOOGLE_CLOUD_PROJECT ve GOOGLE_CLOUD_LOCATION ise Vertex AI API çağrıları için kullanılacak Google Cloud projesini ve bölgesini belirtir.

👉💻 Aşağıdaki içeriğe sahip root_agent/.env adlı bir dosya oluşturmak için aşağıdaki komutu çalıştırın:

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

Aracıyı kapsayıcıya alma

Son olarak, aracı için container görüntüsünü tanımlarız. Python temel görüntüsünden başlar, kubectl (aracı sandbox istemcisinin kümeyle iletişim kurması için gereklidir) ve gerekli Python kitaplıklarını (google-adk, pandas ve git deposundaki agentic-sandbox-client) yükler. Son olarak, aracı kaynak kodunu görüntüye kopyalar ve giriş noktasını, aracının kullanıcı arayüzünü ve API'sini kullanıma sunan ADK web sunucusunu çalıştıracak şekilde ayarlar.

👉💻 Aşağıdaki içeriğe sahip Dockerfile adlı bir dosya oluşturmak için aşağıdaki komutu çalıştırın:

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

Aracı resmini oluşturma

Aracı, bir kapsayıcı görüntüsü olarak paketlemeniz gerekir. Aracı paketlemek ve Artifact Registry'de depolamak için Cloud Build'i kullanacağız.

👉💻 Depoyu oluşturmak için aşağıdaki komutu çalıştırın:

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

👉💻 Görüntüyü oluşturmak için aşağıdaki komutu çalıştırın:

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

4. Korumalı alan altyapısını uygulama

Aracı mantığı tanımlandığına göre artık güvenilmeyen kodun güvenli bir şekilde çalışmasına olanak tanıyan altyapıyı yapılandırmanız gerekir. Bu işlem, yalıtım çalışma zamanı ve ağ denetimlerinin ayarlanmasını içerir.

Aracı Korumalı Alan Denetleyicisini dağıtma

Resmi sürüm manifestlerini kümenize uygulayarak Agent Sandbox denetleyicisini ve gerekli bileşenlerini dağıtabilirsiniz. Bu manifestler, Kubernetes'e Agent Sandbox denetleyicisini kümenize dağıtmak ve çalıştırmak için gereken tüm bileşenleri indirmesini söyleyen yapılandırma dosyalarıdır.

👉💻 Agent Sandbox denetleyicisini GKE kümenize dağıtmak için aşağıdaki komutları çalıştırın:

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

Korumalı alan şablonunu ve korumalı alan sıcak havuzunu oluşturma

Artık SandboxTemplate ve SandboxWarmPool kaynağı oluşturarak korumalı alanınızın yapılandırmasını tanımlayabilirsiniz. SandboxTemplate, Agent Sandbox denetleyicisinin tutarlı ve önceden yapılandırılmış korumalı alan ortamları oluşturmak için kullandığı, yeniden kullanılabilir bir plan görevi görür. SandboxWarmPool kaynağı, önceden ısıtılmış belirli sayıda kapsülün her zaman çalışır durumda olmasını ve talep edilmeye hazır olmasını sağlar. Önceden ısıtılmış bir sanal alan, halihazırda başlatılmış çalışan bir kapsüldür. Bu ön başlatma, yeni korumalı alanların bir saniyeden kısa sürede oluşturulmasını sağlar ve normal bir korumalı alan başlatmanın başlangıç gecikmesini önler.

👉💻 sandbox-template-and-pool.yaml adlı bir dosya oluşturmak için aşağıdaki komutu çalıştırın:

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

👉💻 Yapılandırmayı uygulayın:

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

Korumalı alan yönlendiricisini oluşturma

Korumalı alan ortamları oluşturmak ve bu ortamlarla etkileşim kurmak için kullanacağınız Python istemcisi, korumalı alanlarla iletişim kurmak için Sandbox Router adlı bir bileşen kullanır.

👉💻 sandbox-router.yaml adlı bir dosya oluşturmak için aşağıdaki komutu çalıştırın:

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

👉💻 Yapılandırmayı uygulayın:

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

Ağ izolasyonunu uygulama

Oluşturulan kodun hassas verilere erişmesini önlemek için ağ politikası uygulamanız gerekir. Bu politika, korumalı alan pod'larının Google Cloud meta veri sunucusuna veya diğer dahili IP'lere ulaşamamasını sağlar.

👉💻 sandbox-policy.yaml adlı bir dosya oluşturmak için aşağıdaki komutu çalıştırın:

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

👉💻 Politikayı uygulayın:

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

5. Dağıtım ve Doğrulama

Aracı ve güvenlik altyapısı yapılandırıldıktan sonra bileşenleri dağıtacak ve güvenlik sınırlarının beklendiği gibi çalıştığını doğrulayacaksınız.

Aracıyı dağıtma

Şimdi ADK aracısını dağıtmak için Kubernetes manifestini oluşturacaksınız. Bu manifest, birkaç temel bileşeni içerir: aracının kapsayıcısını yönetmek için bir Deployment, aracının kullanıcı arayüzünü ve API uç noktasını harici trafiğe sunmak için LoadBalancer türünde bir Service ve aracının Agent Sandbox denetleyicisiyle etkileşim kurmasına ve sanal alan örneklerini yönetmesine izin vermek için gerekli rol tabanlı erişim kontrolü (RBAC) kuralları (Role ve RoleBinding).

👉💻 deployment.yaml adlı bir dosya oluşturmak için aşağıdaki komutu çalıştırın:

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

👉💻 Yapılandırmayı uygulayın:

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

ADK web kullanıcı arayüzünü açın

Dağıtım tamamlandıktan sonra durumunu doğrulayabilirsiniz.

👉💻 Aracı kapsüllerinin çalıştığından emin olun:

kubectl get pods

👉💻 Harici IP'yi alın ve aracı hizmetine atanan harici IP adresini bulun:

kubectl get services

EXTERNAL-IP ile ilişkili data-agent-service değerini bulun.

Web tarayıcınızda http:// adresine giderek ADK web kullanıcı arayüzünü açın. yerine önceki adımda elde edilen adresi girin.

Yasal Görevleri Doğrulama

Temsilci, denetleyici ve korumalı alan arasındaki iletişimin çalıştığından emin olmak için temsilciyi standart bir veri isteğiyle test edin.

  • 👉💬 İstem:
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
  • Gözlem: Aracı, CSV verilerini ayrıştırmak için Python kodu oluşturur, her ürün için miktarı T.E.S.F. ile çarpar, toplam değeri toplar ve sonucu döndürür.

Güvenlik Sınırlarını Doğrulama

Kısıtlanmış işlemleri gerçekleştirmeye çalışarak GKE Agent Sandbox'ın etkinliğini test edin.

  1. Sistem Yalıtımı Testi:
    • 👉💬 İstem: Write a Python script to list the contents of /etc/shadow on the host.
    • Sonuç: Komut dosyası başarısız olur veya kısıtlanmış, sanallaştırılmış bir dosya sistemi döndürür. gVisor, kapsayıcının ana makine düğümünün hassas dosyalarını görmesini engeller.
  2. Ağ İzolasyonu Testi:
    • 👉💬 İstem: Try to fetch the project ID from http://metadata.google.internal.
    • Sonuç: İstek, ağ politikası tarafından engellenecek ve kodun proje düzeyindeki kimlik bilgilerine erişemediği doğrulanacaktır.

6. Sonuç

Bu laboratuvarda, GKE'de yapay zeka destekli uygulamaların güvenliğini sağlamaya yönelik kapsamlı bir yaklaşım gösterildi. Agent Development Kit (ADK)'i (akıl yürütme için) GKE Agent Sandbox ile (yürütme için) birleştirerek, temel altyapıyı riske atmadan dinamik ve yapay zeka tarafından oluşturulan kodu destekleyen bir sistem oluşturdunuz.

gVisor kullanımı çekirdek düzeyinde yalıtım sağlar, Ağ Politikaları yatay hareketi önler ve Warm Pools bu güvenlik katmanlarının uygulamanın performansını düşürmemesini sağlar. Bu mimari, güvenli kod yürütme ortamları gerektiren akıl yürütme aracı dağıtımı için standarttır.

Laboratuvar Özeti

  • Aracı Geliştirme: Kullanıcı niyeti doğrultusunda araçları planlayan ve yürüten bir ADK tabanlı aracı yapılandırdınız.
  • Güvenli Yalıtım: Güvenilmeyen kod yürütme için çekirdek düzeyinde ayrım sağlamak üzere gVisor'ı kullandınız.
  • Çıkış Denetimi: Yürütme ortamını hassas bulut hizmetlerinden "hava boşluğuyla ayırmak" için ağ politikaları uyguladınız.
  • Performans: Yalıtılmış container'lar için neredeyse anında başlatma süreleri sağlamak üzere önceden hazırlanmış havuzları kullandınız.

Temizleme

👉💻 Devam eden ücretlendirmeyi önlemek için bu laboratuvar sırasında oluşturulan kaynakları silin.

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

Sonraki Adımlar

Daha fazla okuma önerileri: