במאמר הזה מוסבר איך להריץ קוד שנוצר על ידי AI בארגז חול מבודד באשכול של Google Kubernetes Engine (GKE). אתם יוצרים תבנית של ארגז חול ומאגר של ארגזי חול מוכנים באשכול. לאחר מכן, מריצים סקריפט של Python שמבקש ארגז חול מהמאגר ומריץ פקודה בארגז החול. הסקריפט משתמש בלקוח Python של Agent Sandbox, ספרייה ליצירה ולניהול של ארגזי חול.
הרצת קוד לא מהימן בארגז חול עוזרת להגן על המערכת מפני נקודות חולשה פוטנציאליות בקוד שנוצר על ידי AI, להגביר את מהירות הפיתוח ולשפר את האבטחה של הפריסות. במאמר מידע על Agent Sandbox ב-GKE מוסבר איך Agent Sandbox ב-GKE מבודד קוד לא מהימן שנוצר על ידי AI.
עלויות
Agent Sandbox ב-GKE היא תוכנה בקוד פתוח שאפשר להשתמש בה ללא עלות נוספת. התמחור של GKE חל על המשאבים שאתם יוצרים, כולל משאבי המחשוב שמשמשים את הבקר של Agent Sandbox.
לפני שמתחילים
-
בדף לבחירת הפרויקט במסוף Google Cloud , בוחרים פרויקט ב- Google Cloud או יוצרים אותו.
התפקידים שנדרשים כדי לבחור או ליצור פרויקט
- בחירת פרויקט: כדי לבחור פרויקט לא נדרש תפקיד IAM ספציפי – אתם יכולים לבחור כל פרויקט שקיבלתם בו תפקיד.
-
יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד "יצירת פרויקטים" (
roles/resourcemanager.projectCreator), שכולל את ההרשאהresourcemanager.projects.create. איך מקצים תפקידים?
מפעילים את Kubernetes Engine API, אם הוא עדיין לא מופעל.
התפקידים שנדרשים כדי להפעיל ממשקי API
כדי להפעיל ממשקי API, צריך את ההרשאה
serviceusage.services.enable. אם אתם יצרתם את הפרויקט, סביר להניח שכבר יש לכם את ההרשאה הזו דרך התפקיד "בעלים" (roles/owner). אחרת, אתם יכולים לקבל את ההרשאה הזו דרך התפקיד "אדמין בממשק 'שימוש בשירות'" (roles/serviceusage.serviceUsageAdmin). איך מקצים תפקידים?-
מפעילים את Cloud Shell במסוף Google Cloud .
- מוודאים שיש את ההרשאות הנדרשות כדי להשלים את ההדרכה.
- מוודאים שיש לכם אשכול GKE שמותקן בו הבקר של Agent Sandbox ופרוס בו Sandbox Router. אם לא, בצעו רק את הפעולות שמפורטות בקטעים הבאים במאמר התקנת Agent Sandbox ב-GKE, ואז חזרו למסמך הזה:
אין צורך להשלים את שאר החלקים במסמך הזה, כמו פריסת סביבת ארגז חול (sandbox).
בהמשך המסמך הזה, תיצרו משאבי
SandboxTemplateו-SandboxWarmPoolמשלכם.
התפקידים הנדרשים
כדי לקבל את ההרשאות שנדרשות ליצירה ולניהול של ארגזי חול, צריך לבקש מהאדמין להקצות לכם ב-IAM את התפקיד אדמין של Kubernetes Engine (roles/container.admin) בפרויקט.
כדי לקרוא הסבר על מתן תפקידים, ראו איך מנהלים את הגישה ברמת הפרויקט, התיקייה והארגון.
יכול להיות שאפשר לקבל את ההרשאות הנדרשות גם באמצעות תפקידים בהתאמה אישית או תפקידים מוגדרים מראש.
הגדרה של משתני סביבה
כדי לפשט את הפקודות שאתם מריצים במסמך הזה, אתם יכולים להגדיר משתני סביבה ב-Cloud Shell. ב-Cloud Shell, מריצים את הפקודות הבאות כדי להגדיר את משתני הסביבה השימושיים הבאים:
export CLUSTER_NAME="agent-sandbox-cluster"
export LOCATION="us-central1"
הנה הסבר על משתני הסביבה האלה:
-
CLUSTER_NAME: השם של אשכול GKE, לדוגמהagent-sandbox-cluster. -
LOCATION: האזור או התחום שבו נמצא אשכול GKE. Google Cloud אם משתמשים באשכול Autopilot, מגדירים את האזור (לדוגמה,us-central1). אם משתמשים באשכול Standard, מגדירים את התחום (לדוגמה,us-central1-a).
פריסת סביבת ארגז חול (sandbox)
בקטע הזה נסביר איך ליצור את תוכנית ארגז החול (משאב SandboxTemplate), לאמת את נתב הרשת ולהתקין את לקוח Python שבו תשתמשו כדי ליצור אינטראקציה עם ארגז החול.
הדרך המומלצת ליצור את ארגז החול ולקיים איתו אינטראקציה היא באמצעות לקוח Python של Agentic Sandbox. הלקוח הזה מספק ממשק שמפשט את כל מחזור החיים של ארגז החול, מהיצירה ועד לניקוי. זו ספריית Python שמאפשרת ליצור, להשתמש ולמחוק ארגזי חול באופן פרוגרמטי.
הלקוח משתמש ב-Sandbox Router כנקודת כניסה מרכזית לכל התנועה. בדוגמה שמתוארת במאמר הזה, הלקוח יוצר מנהרה לנתב הזה באמצעות הפקודה kubectl port-forward, כך שלא צריך לחשוף כתובות IP ציבוריות. חשוב לזכור שהשימוש ב-kubectl port-forward הוא לא פתרון מאובטח, וצריך להשתמש בו רק בסביבות פיתוח.
יצירת משאבים מסוג SandboxTemplate ו-SandboxWarmPool
עכשיו מגדירים את ארגז החול על ידי יצירת משאב SandboxTemplate ומשאב SandboxWarmPool. המשאב SandboxTemplate פועל כתוכנית שאפשר להשתמש בה שוב, והבקר של Agent Sandbox משתמש בה כדי ליצור סביבות עקביות ומוגדרות מראש של ארגז חול. המשאב SandboxWarmPool עוזר לוודא שמספר מסוים של פודים שהוכנו מראש תמיד פועלים ומוכנים לשימוש. ארגז חול שחומם מראש הוא Pod פועל שכבר אותחל. ההפעלה המוקדמת הזו מאפשרת ליצור ארגזי חול חדשים תוך פחות משנייה, ומונעת את זמן האחזור של הפעלת ארגז חול רגיל:
ב-Cloud Shell, יוצרים קובץ בשם
sandbox-template-and-pool.yamlעם התוכן הבא:apiVersion: extensions.agents.x-k8s.io/v1beta1 kind: SandboxTemplate metadata: name: python-sandbox-template namespace: default spec: podTemplate: metadata: labels: sandbox: python-sandbox-example spec: runtimeClassName: gvisor automountServiceAccountToken: false # Required securityContext: runAsNonRoot: true # Required nodeSelector: sandbox.gke.io/runtime: gvisor # Required tolerations: - key: "sandbox.gke.io/runtime" value: "gvisor" effect: "NoSchedule" # Required 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" limits: cpu: "500m" memory: "1Gi" # Required securityContext: capabilities: drop: ["ALL"] # Required restartPolicy: "OnFailure" --- apiVersion: extensions.agents.x-k8s.io/v1beta1 kind: SandboxWarmPool metadata: name: python-sandbox-warmpool namespace: default spec: replicas: 2 sandboxTemplateRef: name: python-sandbox-templateמחילים את המניפסט של
SandboxTemplateו-SandboxWarmPool:kubectl apply -f sandbox-template-and-pool.yamlמחכים עד שארגזי החול של המאגר החם יהיו מוכנים:
kubectl wait sandboxwarmpool python-sandbox-warmpool \ --for=jsonpath='{.status.readyReplicas}'=2 \ --timeout=600sבהמשך המאמר, לקוח Python יוצר משאב
SandboxClaim. אם הלקוח יוצר את הבקשה לפני שארגזי החול של המאגר מוכנים, יכול להיות שהבקר ייצור ארגז חול חדש לבקשה במקום להקצות אחד מהמאגר. באשכול Autopilot, יכול להיות שיעברו כמה דקות עד שארגזי החול יהיו מוכנים, כי יכול להיות ש-GKE יצטרך ליצור בשבילם צמתים.
אימות הנתב של ארגז החול
לקוח Python שבו תשתמשו כדי ליצור סביבות של ארגז חול ולתקשר איתן משתמש ברכיב שנקרא Sandbox Router כדי לתקשר עם ארגזי החול.
בדוגמה הזו, משתמשים במצב פיתוח של הלקוח לצורך בדיקה. המצב הזה מיועד לפיתוח מקומי, ומשתמש בפקודה kubectl port-forward כדי ליצור מנהרה ישירה מהמכונה המקומית לשירות Sandbox Router שפועל באשכול. גישת המנהור הזו מייתרת את הצורך בכתובת IP ציבורית או בהגדרה מורכבת של Ingress, ומפשטת את האינטראקציה עם ארגזי החול מהסביבה המקומית.
מוודאים ש-Sandbox Router פועל במרחב השמות agent-sandbox-system:
kubectl get deployment sandbox-router --namespace=agent-sandbox-system
כשהנתב פועל, בעמודה READY מוצג שכל הרפליקות מוכנות, לדוגמה 2/2. אם הפקודה מחזירה את השגיאה NotFound, פורסים את הנתב לפי השלבים שמפורטים בקטע פריסת הנתב של ארגז החול.
התקנת לקוח Python
אחרי שפורסים את הרכיבים בתוך האשכול, כמו Sandbox Router, השלב האחרון בהכנה הוא להתקין את Agentic Sandbox Python client במחשב המקומי. חשוב לזכור שהלקוח הזה הוא ספריית Python שמאפשרת ליצור, להשתמש ולמחוק ארגזי חול באופן פרוגרמטי. תשתמשו בו בקטע הבא כדי לבדוק את הסביבה:
יוצרים ומפעילים סביבה וירטואלית של Python:
python3 -m venv .venv source .venv/bin/activateמתקינים את חבילת הלקוח. משתמשים באותה גרסה כמו של בקר Agent Sandbox:
pip install k8s-agent-sandbox==1.0.6
בדיקת ארגז החול (sandbox)
אחרי שכל רכיבי ההגדרה מוכנים, אתם יכולים ליצור ארגז חול ולבצע בו פעולות באמצעות ספריית הלקוח של Agentic Sandbox ב-Python.
יוצרים סקריפט Python בשם
test_sandbox.pyעם התוכן הבא:from k8s_agent_sandbox import SandboxClient from k8s_agent_sandbox.models import SandboxLocalTunnelConnectionConfig # Tunnels to svc/sandbox-router-svc in the agent-sandbox-system namespace. # cleanup=True deletes the sandbox when the script exits. client = SandboxClient( connection_config=SandboxLocalTunnelConnectionConfig(), cleanup=True, ) sandbox = client.create_sandbox(warmpool="python-sandbox-warmpool", namespace="default") try: print(sandbox.commands.run("echo 'Hello from the sandboxed environment!'").stdout) except Exception as e: print(f"An error occurred: {e}")בטרמינל (כשהסביבה הווירטואלית עדיין פעילה), מריצים את סקריפט הבדיקה:
python3 test_sandbox.py
ההודעה "Hello from the sandboxed environment!" אמורה להופיע, והיא הפלט מסביבת ה-sandbox.
כל הכבוד! הפעלתם בהצלחה פקודת מעטפת בתוך ארגז חול מאובטח. באמצעות השיטה sandbox.commands.run(), אתם יכולים להריץ כל פקודת מעטפת, ו-Agent Sandbox ב-GKE מריץ את הפקודה בתוך מחסום מאובטח שמגן על הצמתים של האשכול ועל עומסי עבודה אחרים מפני קוד לא מהימן. כך סוכן AI או כל תהליך עבודה אוטומטי יכולים לבצע משימות בצורה בטוחה ואמינה.
כשמריצים את הסקריפט, SandboxClient מטפל בכל השלבים בשבילכם. הוא יוצר את המשאב SandboxClaim כדי להפעיל את ארגז החול, ממתין שארגז החול יהיה מוכן, ואז משתמש ב-method sandbox.commands.run() כדי להריץ פקודות bash shell בתוך הקונטיינר המאובטח. לאחר מכן הלקוח מתעד ומדפיס את ה-stdout מהפקודה הזו. בגלל שהסקריפט מגדיר את הפרמטר cleanup לערך True, הלקוח מוחק את ארגז החול כשהתוכנית נסגרת.
כשנוצר משאב SandboxClaim, מוקצה לתביעה ארגז חול זמין מהמאגר החם והתביעה מסומנת כ"מוכנה". המשאב SandboxWarmPool יתחדש באופן אוטומטי כדי לשמור על מספר הרפליקות שהוגדר.
כדי לבדוק אם ארגז חול ספציפי נתבע או זמין, בודקים את ownerReferences במטא-נתונים של המשאב Sandbox. אם הערך של השדה kind הוא SandboxClaim, סימן שארגז החול נמצא בשימוש. אם הערך של השדה kind הוא SandboxWarmPool, ארגז החול לא פעיל וממתין לתביעת בעלות.
הרצת ארגזי חול בסביבת ייצור
במסמך הזה, אתם יוצרים אינטראקציה עם ארגזי חול מחוץ לאשכול באמצעות Cloud Shell. לקוח Python משתמש בפרטי הכניסה של המשתמש כדי לאמת את האשכול ולנהל את המשאבים של ארגז החול, ומשתמש בפקודה kubectl port-forward כדי ליצור חיבור עם ארגזי החול. השלבים האלה מתאימים לתרחישי פיתוח.
בסביבת הייצור, אפליקציית בקרה (כמו כלי לניהול AI) אחראית ליצירה ולניהול של משאבי ארגז החול. כדי להשתמש ב-Agent Sandbox ב-GKE בסביבת ייצור, כדאי להביא בחשבון את הדברים הבאים:
אימות: אפליקציית הבקר צריכה לבצע אימות מול שרת ה-API של האשכול כדי להריץ ארגזי חול. הגדרת האימות משתנה בהתאם למקום שבו אפליקציית הבקר פועלת, באופן הבא:
- אם אפליקציית הבקר פועלת כ-Pod באותו אשכול, משתמשים ב-Kubernetes RBAC או באיחוד זהויות של עומסי עבודה ל-GKE עם כללי מדיניות IAM כדי לתת ל-ServiceAccount של ה-Pod ב-Kubernetes את ההרשאות הנדרשות לצפייה בארגזי חול או לגילוי נקודות קצה ברשת.
- אם אפליקציית הבקר פועלת מחוץ לאשכול, צריך להשתמש באיחוד שירותי אימות הזהות של עומסי עבודה או בחשבונות שירות של IAM כדי לתת לאפליקציה זהות שאפשר להפנות אליה בכללי מדיניות ההרשאה.
ניתוב: בקשות מלקוח Python באפליקציית הבקר צריכות להגיע לנתב Sandbox באשכול. בסביבת הייצור, משתמשים באחת מהשיטות הבאות כדי ליצור חיבור לרשת:
- אם אפליקציית הבקר פועלת באותו אשכול, משתמשים בפונקציה
SandboxDirectConnectionConfigכדי לטרגט את כתובת ה-URL והיציאה שבהן משתמש שירות Sandbox Router. - אם אפליקציית הבקר פועלת מחוץ לאשכול, משתמשים ב-GKE Gateway API כדי ליצור מאזן עומסים פנימי או חיצוני. בקוד הלקוח, משתמשים בפונקציה
SandboxGatewayConnectionConfigכדי להפנות לשער.
מידע נוסף על שיטות הניתוב האלה זמין בדוגמאות לשימוש ב-GitHub ובשלבי הפריסה של Gateway לנתב.
- אם אפליקציית הבקר פועלת באותו אשכול, משתמשים בפונקציה
גישה של ארגז החול למשאבי Google Cloud : אם קוד ארגז החול צריך לשלוח בקשות לממשקי API של Google Cloud , כמו Cloud Storage, צריך להשתמש במדיניות IAM עם איחוד זהויות של עומסי עבודה ל-GKE כדי לתת ל-Kubernetes ServiceAccount שבו משתמש ה-Pod של ארגז החול את ההרשאות שנדרשות לגישה הזו. מדיניות ברירת המחדל של הרשת חוסמת את הגישה לשרת המטא-נתונים של Google Cloud (
169.254.169.254), לכן צריך להתאים אישית את מדיניות הרשת כדי לאפשר את התנועה הזו.הגבלות על מדיניות הרשת ב-Kubernetes: כברירת מחדל, Agent Sandbox ב-GKE אוכף מדיניות אבטחה מחמירה של מתעדף אבטחה כברירת מחדל (
networkPolicyManagement: Managed). ההגבלות הבאות חלות במסגרת המדיניות הזו:- Ingress חסום מכל המקורות, חוץ מהנתב הייעודי של ארגז החול (פודים עם התווית
app: sandbox-routerבמרחב השמותagent-sandbox-system). - מותרת תעבורת נתונים יוצאת לאינטרנט הציבורי, אבל תעבורת נתונים יוצאת לטווחי LAN פרטיים (RFC 1918), ל-DNS פנימי של אשכול (CoreDNS) ולשרת המטא-נתונים של ספק שירותי הענן (
169.254.0.0/16) חסומה באופן מפורש.
כדי להשתמש באיחוד זהויות של עומסי עבודה ל-GKE או לגשת למשאבים פרטיים אחרים, צריך להגדיר מדיניות רשת ב-Kubernetes בהתאמה אישית במשאב
SandboxTemplate. במאמר ניהול מדיניות הרשת ב-Agent Sandbox מוסבר איך להגדיר את המדיניות ואיך להתאים אישית את התבניות (למשל, ארגזי חול עם air gap או שילוב של איחוד זהויות של עומסי עבודה ל-GKE).- Ingress חסום מכל המקורות, חוץ מהנתב הייעודי של ארגז החול (פודים עם התווית
כללי מדיניות האבטחה של ארגז החול
כברירת מחדל, Agent Sandbox ב-GKE לא מחיל מדיניות אבטחה על ארגזי חול. כדי לאכוף את הגדרות הבידוד של ארגזי החול, כדאי להחיל את secure-sandbox-policy Kubernetes Validating Admission Policy (VAP) המומלצת ממאגר Agent Sandbox ב-GitHub. איך מיישמים את מדיניות האבטחה המומלצת?
המדיניות אוכפת דרישות בידוד, כמו דרישה ל-gVisor, השבתת hostNetwork וחסימת אמצעי אחסון של hostPath. המדיניות גם אוכפת דרישות הקשחה, כמו ביטול כל היכולות, מניעת הוספה של יכולות חדשות ודרישה להפעיל קונטיינרים כמשתמשים שאינם משתמשי root ולהגדיר מגבלות משאבים. לרשימת הדרישות המלאה לפריסת Agent Sandbox ב-GKE
שינוי או הסרה של אילוצי מדיניות
מכיוון שאתם מחילים את המדיניות בעצמכם, אתם יכולים לשנות אותה כך שתתאים לעומסי העבודה שלכם. אם עומסי העבודה שלכם דורשים פטורים מחלק מהכללים, אתם יכולים לשנות את המדיניות כדי להסיר אילוצים ספציפיים או למחוק את קישור המדיניות לחלוטין. הסרת אילוץ מפחיתה את הבידוד שהמדיניות מספקת, לכן צריך להסיר רק את האילוצים שעומסי העבודה שלכם דורשים.
כדי לשנות את המדיניות ולהסיר אילוץ ספציפי (לדוגמה, כדי לאפשר למארזים לפעול כשורש או להשמיט מגבלות על משאבים), עורכים את המשאב ValidatingAdmissionPolicy:
kubectl edit validatingadmissionpolicy secure-sandbox-policy
בכלי לעריכת טקסט שנפתח, מאתרים את הקטע validations ומסירים או משנים את ביטוי האילוץ שחוסם את עומס העבודה.
לחלופין, אם אתם רוצים להפסיק את אכיפת המדיניות באשכול, אתם יכולים למחוק את קישור המדיניות:
kubectl delete validatingadmissionpolicybinding secure-sandbox-binding
בעיות מוכרות
בקטע הזה מתוארות בעיות מוכרות שקשורות לשימוש בארגז החול לסוכנים ב-GKE, ואיך לפתור אותן או לעקוף אותן.
מדיניות האבטחה חוסמת יכולות כשמשתמשים ברשת שירות (service mesh)
אם הפעלתם את מדיניות האבטחה המומלצת ואתם מנסים לפרוס ארגז חול שמשולב עם Service mesh sidecar (לדוגמה, Envoy או Istio), יכול להיות שהמדיניות תחסום את יצירת ארגז החול ותופיע שגיאה כמו זו:
sandbox create error: sandboxes.agents.x-k8s.io "claude-cli-claim-managed" is forbidden:
ValidatingAdmissionPolicy 'secure-sandbox-policy' with binding 'secure-sandbox-binding'
denied request: Security Violation: Capabilities.add must be empty. You cannot add capabilities.
- הסיבה: ב-sidecars של Service mesh משתמשים לעיתים קרובות בקונטיינר init, כמו
istio-initאוproxy-init. הקונטיינרים האלה של init דורשים יכולות כמוNET_ADMINאוNET_RAWכדי להגדיר כלליiptablesלניתוב שקוף של תעבורת נתונים יוצאת. המדיניותsecure-sandbox-policyValidatingAdmissionPolicy חוסמת את כל תוספות היכולות בכל סוגי הקונטיינרים. - פתרון עקיף: מכיוון שאתם מנהלים את המדיניות הזו באשכול, אתם יכולים לשנות את
ValidatingAdmissionPolicyכדי לאפשר למאגרי init מהימנים ספציפיים לבקש יכולות שלNET_ADMINו-NET_RAW. איך משנים או מסירים אילוצים במדיניות? לדוגמה, אפשר לעדכן את ביטויי האימות או המשתנים של המדיניות כדי להחריג שמות של קונטיינרים מהימנים מכלל היכולות.
זמן אחזור או זמן קצוב לתפוגה של תעבורת נתונים יוצאת כשמתחברים ל-Google APIs דרך IPv6
יכול להיות שבעומסי עבודה בתוך ארגז החול יהיו זמני קצובים לתפוגה של חיבורים או זמן אחזור ארוך, עד שתי דקות, כשמנסים להתחבר למשאבים חיצוניים או לממשקי Google API (כמו Vertex AI או Cloud Storage).
- הסיבה: אם באשכול GKE מופעל IPv6 עם מחסנית כפולה, פענוח ה-DNS של Google APIs מחזיר גם כתובות IPv4 (A) וגם כתובות IPv6 (AAAA). חלק מהאלגוריתמים במנועי זמן ריצה, כמו Node.js, מנסים קודם להתחבר דרך IPv6. אם ל-VPC של GKE אין נתיב תקין לתעבורת נתונים יוצאת ב-IPv6, כמו Cloud NAT או שער אינטרנט ל-IPv6, חיבור ה-TCP מפסיק להגיב עד שפג הזמן הקצוב לתפוגה של TCP SYN. לאחר מכן, חיבור ה-TCP חוזר ל-IPv4.
פתרון: כדי לפתור את הבעיה, מבצעים אחת מהפעולות הבאות:
- הגדרת תעבורת נתונים יוצאת (egress) של IPv6: כדי לאפשר לתעבורת נתונים יוצאת של IPv6 לחזור לאשכול, צריך להגדיר Cloud NAT או שער אינטרנט תקינים של IPv6 ברשת ה-VPC.
העדפת IPv4 בעומס העבודה: כדי להעדיף פענוח DNS של IPv4, מגדירים את זמן הריצה של עומס העבודה. לדוגמה, באפליקציית Node.js, אתם יכולים להגדיר את משתני הסביבה הבאים בהגדרה של
SandboxTemplate:env: - name: NODE_OPTIONS value: "--dns-result-order=ipv4first --no-network-family-autoselection"
מחיקת משאבים
כדי להימנע מחיובים בחשבון Google Cloud , צריך למחוק את אשכול GKE שיצרתם:
gcloud container clusters delete ${CLUSTER_NAME} \
--location=${LOCATION} \
--quiet
המאמרים הבאים
- איך שומרים ומשחזרים את Agent Sandbox בסביבות GKE באמצעות קובצי Snapshot של Pod
- GitHub
- איך משתמשים ב-Kata Containers בקוד פתוח עם Agent Sandbox ב-GKE Kata Containers הוא לא מוצר של Google Cloud . אם אתם מתקינים את התוכנה הזו ומשתמשים בה, אתם אחראים לניהול ולפתרון בעיות. התמיכה והסכמי ה-SLA של Google לא חלים על Kata Containers.
- כדי להבין את הטכנולוגיה הבסיסית שמספקת בידוד אבטחה לעומסי העבודה, קראו את המאמר ארגז חול (Sandbox) של GKE.
- למידע נוסף על שיפור האבטחה של האשכולות ועומסי העבודה, קראו את הסקירה הכללית על האבטחה ב-GKE.