במאמר הזה מוסבר איך להתקין את הבקר של Agent Sandbox בקוד פתוח באשכול Google Kubernetes Engine (GKE), כדי להריץ עומסי עבודה מבודדים של סוכנים ב-Pods ייעודיים של Kubernetes. בנוסף, תלמדו איך ליצור משאב Sandbox שמריץ קוד לא מהימן בסביבת זמן הריצה של gVisor. ברוב עומסי העבודה של הסוכנים, כדאי להשתמש ב-Agent Substrate ב-GKE, כי הוא יכול להריץ יותר סוכנים באותם צמתים. כדאי להשתמש ב-Agent Sandbox ב-GKE כשכל סוכן צריך Pod ייעודי, מעבדי GPU או TPU, PodSpec מלא של Kubernetes או אשכול GKE Autopilot. כדי להשוות בין Agent Sandbox ב-GKE לבין Agent Substrate ב-GKE ולבחור ארכיטקטורה לעומסי העבודה של סוכני ה-AI, קראו את המאמר תכנון ארכיטקטורה לעומסי עבודה של סוכני AI ב-GKE.
במאמר מידע על Agent Sandbox ב-GKE מוסבר איך Agent Sandbox ב-GKE מבודד קוד לא מהימן שנוצר על ידי AI.
עלויות
Agent Sandbox ב-GKE היא תוכנה בקוד פתוח שאפשר להשתמש בה ללא עלות נוספת. התמחור של GKE חל על המשאבים שאתם יוצרים, כולל משאבי המחשוב שמשמשים את הבקר של Agent Sandbox.
כדי להימנע מחיובים מיותרים, חשוב להשבית את GKE או למחוק את הפרויקט אחרי שמסיימים את המשימות שבמסמך הזה.
לפני שמתחילים
-
בדף לבחירת הפרויקט במסוף Cloud de Confiance , בוחרים פרויקט ב- Cloud de Confiance או יוצרים אותו.
התפקידים שנדרשים כדי לבחור או ליצור פרויקט
- בחירת פרויקט: כדי לבחור פרויקט לא נדרש תפקיד IAM ספציפי – אתם יכולים לבחור כל פרויקט שקיבלתם בו תפקיד.
-
יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד "יצירת פרויקטים" (
roles/resourcemanager.projectCreator), שכולל את ההרשאהresourcemanager.projects.create. איך מקצים תפקידים?
מפעילים את Google Kubernetes Engine API, אם הוא עדיין לא מופעל.
התפקידים שנדרשים כדי להפעיל ממשקי API
כדי להפעיל ממשקי API, צריך את ההרשאה
serviceusage.services.enable. אם אתם יצרתם את הפרויקט, סביר להניח שכבר יש לכם את ההרשאה הזו דרך התפקיד "בעלים" (roles/owner). אחרת, אתם יכולים לקבל את ההרשאה הזו דרך התפקיד "אדמין בממשק 'שימוש בשירות'" (roles/serviceusage.serviceUsageAdmin). איך מקצים תפקידים-
מפעילים את Cloud Shell במסוף Cloud de Confiance .
הגדרה של משתני סביבה
כדי לפשט את הפקודות שאתם מריצים במסמך הזה, אתם יכולים להגדיר משתני סביבה ב-Cloud Shell. ב-Cloud Shell, מריצים את הפקודות הבאות כדי להגדיר את משתני הסביבה השימושיים הבאים:
export CLUSTER_NAME="agent-sandbox-cluster"
export LOCATION="us-central1"
export AGENT_SANDBOX_VERSION="v1.0.6"
export NODE_POOL_NAME="agent-sandbox-pool"
export MACHINE_TYPE="e2-standard-2"
הנה הסבר על משתני הסביבה האלה:
-
CLUSTER_NAME: השם של אשכול GKE, לדוגמהagent-sandbox-cluster. -
LOCATION: האזור או התחום ב- Cloud de Confiance by S3NS שבו נוצר אשכול GKE. אם יוצרים אשכול Autopilot, צריך להגדיר את האזור (לדוגמה,us-central1). אשכולות Autopilot הם תמיד אזוריים. אם יוצרים אשכול Standard, מגדירים את האזור (לדוגמה,us-central1-a). כדי להפחית את העלויות, במסמך הזה יוצרים אשכול אזורי שמשתמש בפחות צמתים מאשכול אזורי. -
AGENT_SANDBOX_VERSION: גרסת הבקר של Agent Sandbox בקוד פתוח שרוצים להתקין. במסמך הזה אנחנו משתמשים בגרסה 1.0.6. כדי לראות גרסאות אחרות, עברו אל דף הגרסאות של Agent Sandbox. -
NODE_POOL_NAME: השם של מאגר הצמתים שיריץ את הפודים של הסוכן, לדוגמהagent-sandbox-pool. המשתנה הזה נדרש רק אם יוצרים אשכול GKE Standard. -
MACHINE_TYPE: סוג המכונה של הצמתים במאגר הצמתים שמוגדר כברירת מחדל באשכול ובמאגר הצמתים של gVisor, לדוגמהe2-standard-2. למידע נוסף על סדרות שונות של מכונות ועל בחירה בין אפשרויות שונות, קראו את המדריך להשוואה בין משפחות של מכונות ומשאבים. המשתנה הזה נדרש רק אם יוצרים אשכול GKE Standard.
יצירת אשכול GKE
Agent Sandbox ב-GKE מבודד את עומסי העבודה של הסוכנים באמצעות GKE Sandbox עם gVisor או microVMs. אם לא תציינו סביבת זמן ריצה של GKE Sandbox (gVisor או microVMs), הפודים יפעלו בלי בידוד של הליבה, ולכן אל תשתמשו בהם כדי להריץ קוד לא מהימן. המסמך הזה משתמש ב-gVisor. באשכולות Autopilot, gVisor מופעל באופן אוטומטי. באשכולות Standard, יוצרים מאגר צמתים שמופעל בו gVisor. כדי להשתמש ב-microVM, קראו את המאמר הפעלת סוג ארגז החול microVM. מדיניות האבטחה המומלצת מאפשרת רק את gVisor, ולכן היא דוחה משאבי ארגז חול שמשתמשים ב-microVM.
טייס אוטומטי
כדי ליצור אשכול Autopilot, מוודאים שמשתנה הסביבה LOCATION מוגדר לאזור, כמו us-central1, ואז מריצים את הפקודה הבאה:
gcloud container clusters create-auto ${CLUSTER_NAME} \
--location=${LOCATION}
רגילה
כדי ליצור אשכול Standard, יוצרים את האשכול ומוסיפים מאגר צמתים שבו gVisor מופעל. כדי להפחית את העלויות, במאמר הזה יוצרים אשכול אזורי עם צומת אחד לכל מאגר.
מגדירים את משתנה הסביבה
LOCATIONלאזור, למשלus-central1-a:export LOCATION="us-central1-a"יוצרים את האשכול:
gcloud container clusters create ${CLUSTER_NAME} \ --location=${LOCATION} \ --machine-type=${MACHINE_TYPE} \ --num-nodes=1יוצרים מאגר צמתים נפרד שבו gVisor מופעל:
gcloud container node-pools create ${NODE_POOL_NAME} \ --cluster=${CLUSTER_NAME} \ --machine-type=${MACHINE_TYPE} \ --location=${LOCATION} \ --num-nodes=1 \ --image-type=cos_containerd \ --sandbox=type=gvisorכדי להשתמש במיקרו-VM במקום ב-gVisor, יוצרים את מאגר הצמתים כמו שמתואר בקטע הפעלת סוג ארגז החול של מיקרו-VM. בשאר המסמך נתייחס ל-gVisor.
כדי להשתמש באשכול Standard קיים, צריך לוודא שהאשכול כולל מאגר צמתים שמופעל בו gVisor. אם באשכול אין מאגר צמתים כזה, יוצרים אחד באמצעות הפקודה gcloud container node-pools create שלמעלה.
כדי לאפשר לכלי שורת הפקודה kubectl להתחבר לאשכול, צריך לקבל את פרטי הכניסה לאשכול:
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--location=${LOCATION}
התקנת Agent Sandbox
כדי להתקין את Agent Sandbox, צריך להחיל מניפסט של גרסה ממאגר Agent Sandbox ב-GitHub. המניפסט של sandbox-with-extensions.yaml מתקין את הבקר של Agent Sandbox ואת ה-CustomResourceDefinitions למשאב Sandbox ולמשאבי התוספים SandboxTemplate, SandboxClaim ו-SandboxWarmPool.
מחילים את המניפסט של הגרסה:
kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yamlהמניפסט יוצר את מרחב השמות
agent-sandbox-systemופורס את הבקר במרחב השמות הזה.מחכים עד שהבקר מוכן:
kubectl rollout status deployment/agent-sandbox-controller \ --namespace=agent-sandbox-system \ --timeout=120s
אפשר להתקין את Agent Sandbox גם באמצעות Helm. הוראות מפורטות מופיעות בקובץ README של תרשים Helm של Agent Sandbox.
אימות ההתקנה
מוודאים שה-CustomResourceDefinitions של Agent Sandbox מותקנים:
kubectl get crd \ sandboxes.agents.x-k8s.io \ sandboxtemplates.extensions.agents.x-k8s.io \ sandboxclaims.extensions.agents.x-k8s.io \ sandboxwarmpools.extensions.agents.x-k8s.ioבפלט מופיעה רשימה של ארבעת ה-CustomResourceDefinitions.
מוודאים שהבקר פועל:
kubectl get deployment agent-sandbox-controller \ --namespace=agent-sandbox-systemכשהבקר פועל, בעמודה
READYמוצג הערך1/1.
החלת מדיניות האבטחה המומלצת
כברירת מחדל, Agent Sandbox ב-GKE לא מגביל את ההגדרות של ה-Pods שמריצים את הסוכנים. כדי לאכוף את הגדרות הבידוד של פודים של סוכנים, צריך להחיל את המדיניות המומלצת secure-sandbox-policy ValidatingAdmissionPolicy ממאגר Agent Sandbox ב-GitHub. המדיניות הזו דוחה כל משאב של Sandbox שלא עומד בדרישות הפריסה של Agent Sandbox ב-GKE.
מחילים את המדיניות:
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-policy.yamlמחילים את קישור המדיניות. הקישור אוכף את המדיניות בכל מרחבי השמות, חוץ ממרחבי השמות של המערכת, כמו
kube-system:kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-binding.yaml
המדיניות מאמתת את המשאבים של ארגז החול. כשיוצרים משאב SandboxWarmPool או משאב SandboxClaim, הבקר יוצר משאבי Sandbox ממשאב SandboxTemplate. אם התבנית לא עומדת בדרישות, המדיניות דוחה את המשאב של Sandbox והשגיאה מופיעה ביומני הבקר. כדי לראות את היומנים, מריצים את הפקודה הבאה:
kubectl logs deployment/agent-sandbox-controller \
--namespace=agent-sandbox-system
המדיניות הזו בבעלותכם, ואתם יכולים לשנות אותה כך שתתאים לעומסי העבודה שלכם. מידע נוסף מופיע במאמר כללי מדיניות האבטחה של ארגז החול.
הדרישות לפריסת Agent Sandbox ב-GKE
אם אתם מחילים את מדיניות האבטחה המומלצת, המניפסטים של עומסי העבודה, כמו משאב Sandbox או SandboxTemplate, צריכים לכלול הגדרות אבטחה ותצורה ספציפיות. אם משאב של Sandbox לא עומד בדרישות האלה, בקר הקבלה דוחה אותו. הדרישות של הקונטיינר חלות על כל הקונטיינרים ב-Pod, כולל קונטיינרים של init וקונטיינרים זמניים.
הגדרה נדרשת
מניפסט הפריסה צריך לכלול את ההגדרות הבאות:
-
runtimeClassName: gvisor: הפעלת ה-Pod בסביבת זמן הריצה של gVisor ב-GKE Sandbox. המדיניות דוחה משאבים של ארגז חול שמשתמשים בכל סביבת זמן ריצה אחרת, כולל microVMs. -
automountServiceAccountToken: false: מונע מה-Pod לטעון באופן אוטומטי את אסימון ברירת המחדל של חשבון השירות. -
securityContext.runAsNonRoot: true: מוודא שהקונטיינר לא פועל כמשתמש Root. -
securityContext.capabilities.drop: ["ALL"]: הסרת כל היכולות של Linux מהקונטיינר. -
resources.limits: צריך לציין מגבלות על המעבד (CPU) ועל הזיכרון כדי למנוע תרחישים פוטנציאליים של התקפת מניעת שירות (DoS). -
nodeSelector: צריך לטרגט אתsandbox.gke.io/runtime: gvisor. tolerations: חייב לכלול toleration ל-taint שלsandbox.gke.io/runtime=gvisor:NoSchedule.
הגדרה אסורה
מניפסט הפריסה לא יכול לכלול אף אחד מהדברים הבאים:
-
hostNetwork: true,hostPID: trueאוhostIPC: true. privileged: trueבהקשרים של אבטחת קונטיינרים.procMount: Unmaskedבהקשרים של אבטחת קונטיינרים.-
HostPathכרכים. - יכולות נוספות (
capabilities.add). - ההגדרות של
hostPort. - sysctls בהתאמה אישית.
- נפחים צפויים של אסימונים או אישורים של חשבונות שירות.
פריסת הנתב של ארגז החול (אופציונלי)
Sandbox Router הוא שרת proxy ל-HTTP שמנתב בקשות מלקוחות, כמו לקוח Python של Agent Sandbox, לפודים שמריצים את הסוכנים. אם אתם מתכננים להשתמש בלקוח Python, למשל כמו שמתואר במאמר בידוד הרצת קוד AI באמצעות Agent Sandbox ב-GKE, פרסו את הנתב.
פורסים את הנתב במרחב השמות agent-sandbox-system. כברירת מחדל, מדיניות רשת ב-Kubernetes ש-Agent Sandbox ב-GKE יוצר לכל משאב SandboxTemplate מאפשרת תעבורת נתונים נכנסת לפודים של הסוכנים רק מהפודים של הנתב במרחב השמות הזה.
יוצרים את חשבון השירות של הנתב ואת הרשאות ה-RBAC שמאפשרות לנתב לחפש קבוצות Pod של סוכנים:
kubectl apply \ -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/serviceaccount.yaml \ -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/rbac.yamlפורסים את הנתב. הפקודה הבאה מגדירה את קובץ האימג' של הנתב לאותה גרסה של הבקר:
curl -sSL https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/deployment.yaml \ | sed "s|sandbox-router-go:latest|sandbox-router-go:${AGENT_SANDBOX_VERSION}|" \ | kubectl apply -f -יוצרים את השירות של הנתב:
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/service.yamlמחכים עד שהנתב יהיה מוכן:
kubectl rollout status deployment/sandbox-router \ --namespace=agent-sandbox-system \ --timeout=120s
הגדרת הנתב הזו מיועדת לפיתוח ולבדיקה. להגדרות ייצור, כמו TLS, ספירת רפליקות ומדיניות רשת ב-Kubernetes לנתב, קראו את הקובץ README של פריסת נתב Sandbox.
ייצוא מדדי בקר (אופציונלי)
הבקר של Agent Sandbox מייצא מדדי Prometheus בנתיב /metrics ביציאה metrics (יציאה 8080). כדי לאסוף את המדדים האלה באמצעות השירות המנוהל של Google Cloud ל-Prometheus ולשלוח שאילתות לגביהם ב-Cloud Monitoring, צריך להחיל משאב מותאם אישית של PodMonitoring.
כברירת מחדל, GKE מפעיל איסוף מנוהל באשכולות Autopilot שפועלים ב-GKE בגרסה 1.25 ואילך, ובאשכולות Standard שפועלים ב-GKE בגרסה 1.27 ואילך. אם לא הפעלתם את האיסוף המנוהל באשכול, תוכלו להיעזר במאמר הפעלה ידנית של איסוף מנוהל.
מכיוון שהמונים וההיסטוגרמות של Prometheus לא מתעדים פעילות שהתרחשה לפני תחילת האיסוף, צריך להחיל את המשאב PodMonitoring אחרי שמתקינים את הבקר, כדי ש-Cloud Monitoring יתעד אירועים מוקדמים של משאבי האשכול וארגז החול.
ב-Cloud Shell, יוצרים קובץ בשם
agent-sandbox-monitoring.yamlעם התוכן הבא:apiVersion: monitoring.googleapis.com/v1 kind: PodMonitoring metadata: name: agent-sandbox-controller namespace: agent-sandbox-system spec: selector: matchLabels: app: agent-sandbox-controller endpoints: - port: metrics path: /metrics interval: 30sמחילים את המניפסט:
kubectl apply -f agent-sandbox-monitoring.yaml
אחרי שמחילים את המשאב PodMonitoring, השירות המנוהל של Google Cloud ל-Prometheus אוסף את המדדים של הבקר כל 30 שניות. אתם יכולים לשלוח שאילתות על המדדים האלה באמצעות PromQL ב-Cloud Monitoring, דרך Metrics Explorer.
ב-Cloud Monitoring, השירות המנוהל של Google Cloud ל-Prometheus שומר את התווית namespace למרחב השמות של ה-Pod של הבקר שנאסף (agent-sandbox-system). במדדים שמגדירים תווית namespace משלהם, השירות המנוהל של Google Cloud ל-Prometheus משנה את השם של תווית המדד ל-exported_namespace. כדי לסנן או לקבץ מדדים לפי מרחב השמות של המשאב בארגז החול, משתמשים בתווית exported_namespace. מידע נוסף מופיע במאמר תוויות שמורות.
לדוגמה, אפשר לשלוח שאילתות לגבי המדדים הבאים:
agent_sandbox_build_info: מידע על גרסת ה-build של הבקר, כמו ה-commit והגרסה של Git.
agent_sandboxes: מספר המשאבים של Sandbox באשכול בנקודת זמן מסוימת. למדד הזה יש תוויות למוכנות, לתפוגה, לסוג ההפעלה, לבעלים, ליוצר, לתבנית ולמרחב השמות של המשאב בארגז החול (exported_namespace). לדוגמה, השאילתה הבאה ב-PromQL מקבצת את המשאבים בארגז החול לפי מרחב שמות ומוכנות:sum by (exported_namespace, ready_condition) (agent_sandboxes)
agent_sandbox_claim_controller_startup_latency_ms: היסטוגרמה שמודדת את זמן האחזור באלפיות השנייה, מהרגע שהבקר מזהה לראשונה משאב SandboxClaim ועד שהתביעה מגיעה לסטטוסReady. המדד הזה הוא היסטוגרמה של Prometheus, ולכן שאילתה של שם המדד הבסיסי לא מחזירה נתונים באופן ישיר. צריך לשלוח שאילתה לסדרות_bucket,_sumאו_count. לדוגמה, שאילתת ה-PromQL הבאה מחשבת את זמן האחזור של ההפעלה באחוזון ה-95 בחלון של חמש דקות:histogram_quantile( 0.95, sum by (le) ( rate(agent_sandbox_claim_controller_startup_latency_ms_bucket[5m]) ) )
למידע נוסף על מדדים מיוצאים ועל הרכיבים האופציונליים שהם תלויים בהם, ראו הפניית מדדי בקר.
פריסת סביבת ארגז חול (sandbox)
כדי לפרוס סביבת ארגז חול, מגדירים משאב SandboxTemplate ומשתמשים במשאב SandboxWarmPool כדי לשמור על משאבי ארגז חול שחוממו מראש. לאחר מכן, תוכלו לבקש משאב של ארגז חול מהמאגר החם הזה באמצעות משאב SandboxClaim. לחלופין, אתם יכולים ליצור משאב Sandbox ישירות, אבל בגישה הזו אין תמיכה במאגרים חמים.
SandboxTemplate, SandboxWarmPool, SandboxClaim ו-Sandbox הם משאבים בהתאמה אישית של Kubernetes.
מומלץ: ליצור משאבים מסוג SandboxTemplate ו-SandboxWarmPool
המשאב SandboxTemplate משמש כתוכנית שאפשר לעשות בה שימוש חוזר. המשאב SandboxWarmPool שומר על מספר מסוים של משאבי Sandbox שחוממו מראש עם Pods פועלים שמוכנים לתביעה. מאגר השרתים הזה מקצר את זמן האחזור בהפעלה.
כדי לפרוס סביבת ארגז חול באמצעות יצירת משאבים מסוג SandboxTemplate ו-SandboxWarmPool:
ב-Cloud Shell, יוצרים קובץ בשם
sandbox-template.yamlעם התוכן הבא:apiVersion: extensions.agents.x-k8s.io/v1beta1 kind: SandboxTemplate metadata: name: python-runtime-template namespace: default spec: podTemplate: metadata: labels: sandbox-type: python-runtime spec: runtimeClassName: gvisor # Required 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: runtime image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0 ports: - containerPort: 8888 resources: requests: cpu: "250m" memory: "512Mi" limits: cpu: "500m" memory: "1Gi" # Required securityContext: capabilities: drop: ["ALL"] # Required restartPolicy: OnFailureמחילים את המניפסט SandboxTemplate:
kubectl apply -f sandbox-template.yamlיוצרים קובץ בשם
sandbox-warmpool.yamlעם התוכן הבא:apiVersion: extensions.agents.x-k8s.io/v1beta1 kind: SandboxWarmPool metadata: name: python-runtime-warmpool namespace: default labels: app: python-runtime-warmpool spec: replicas: 2 sandboxTemplateRef: # This must match the name of the SandboxTemplate. name: python-runtime-templateמחילים את המניפסט SandboxWarmPool:
kubectl apply -f sandbox-warmpool.yamlמחכים עד שמשאבי ארגז החול של המאגר החם וה-Pods שלהם יהיו מוכנים:
kubectl wait sandboxwarmpool python-runtime-warmpool \ --for=jsonpath='{.status.readyReplicas}'=2 \ --timeout=600sאם יוצרים משאב SandboxClaim לפני שמשאבי ה-Sandbox של המאגר וה-Pods שלהם מוכנים, הבקר יוצר משאב Sandbox חדש לבקשה במקום להקצות אחד מהמאגר. באשכול Autopilot, יכול להיות שיעברו כמה דקות עד שה-Pods יהיו מוכנים, כי יכול להיות ש-GKE יצטרך ליצור בשבילם צמתים.
יצירת משאב SandboxClaim
המשאב SandboxClaim מבקש משאב של ארגז חול מהמאגר החם. בגלל שיצרתם מאגר חם, הבקר מקצה למשאב Sandbox מוכן (ול-Pod שפועל בו) מהמאגר את הבקשה, במקום ליצור משאב חדש.
כדי לבקש משאב של ארגז חול ממאגר חם על ידי יצירת משאב SandboxClaim, מבצעים את השלבים הבאים:
יוצרים קובץ בשם
sandbox-claim.yamlעם התוכן הבא:apiVersion: extensions.agents.x-k8s.io/v1beta1 kind: SandboxClaim metadata: name: sandbox-claim namespace: default spec: warmPoolRef: # This must match the name of the SandboxWarmPool. name: python-runtime-warmpoolמחילים את המניפסט SandboxClaim:
kubectl apply -f sandbox-claim.yamlמוודאים שהמשאב, התביעה והמאגר החם של Sandbox מוכנים:
kubectl get sandboxwarmpool,sandboxclaim,sandbox,pod
חלופה: יצירת משאב של ארגז חול באופן ישיר
אם אתם לא צריכים את זמני ההפעלה המהירים שמאגרים חמים מספקים, אתם יכולים לפרוס משאב Sandbox ישירות בלי להשתמש בתבניות.
כדי לפרוס סביבת ארגז חול באמצעות יצירה ישירה של משאב Sandbox, מבצעים את השלבים הבאים:
יוצרים קובץ בשם
sandbox.yamlעם התוכן הבא:apiVersion: agents.x-k8s.io/v1beta1 kind: Sandbox metadata: name: sandbox-example-2 spec: podTemplate: metadata: labels: sandbox: sandbox-example spec: runtimeClassName: gvisor restartPolicy: OnFailure automountServiceAccountToken: false # Required securityContext: runAsNonRoot: true # Required runAsUser: 1000 # Required if image defaults to root (for example, busybox) nodeSelector: sandbox.gke.io/runtime: gvisor tolerations: - key: "sandbox.gke.io/runtime" value: "gvisor" effect: "NoSchedule" # Required containers: - name: my-container image: busybox command: ["/bin/sh", "-c"] args: ["sleep 3600000; echo 'Container finished successfully'; exit 0"] securityContext: capabilities: drop: ["ALL"] # Required allowPrivilegeEscalation: false resources: limits: cpu: "100m" memory: "128Mi" # Requiredמחילים את המניפסט של ארגז החול:
kubectl apply -f sandbox.yamlמוודאים שמשאב ארגז החול פועל:
kubectl get sandbox
שדרוג Agent Sandbox
כדי לשדרג את Agent Sandbox, צריך להחיל את מניפסט הגרסה של הגרסה החדשה:
export AGENT_SANDBOX_VERSION="NEW_VERSION"
kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml
מחליפים את NEW_VERSION בגרסה שרוצים להתקין, כמו גרסה שמופיעה בדף הגרסאות של Agent Sandbox.
לפני השדרוג, כדאי לעיין בהערות המוצר של הגרסה החדשה. אם באשכול פועלת גרסה של Agent Sandbox שקודמת ל-1.0.0, צריך להעביר את המשאבים ל-API של v1beta1 לפני השדרוג, כי בגרסה 1.0.0 הוסר ה-API של v1alpha1. הוראות מפורטות זמינות במדריך להעברת נתונים (מיגרציה) של ה-API.
אם פרסתם את Sandbox Router או החלתם את מדיניות האבטחה המומלצת, חזרו על השלבים האלה בגרסה החדשה.
הסרת Agent Sandbox
בודקים אם יש משאבים של Agent Sandbox שעדיין בשימוש:
kubectl get sandboxes,sandboxclaims,sandboxwarmpools,sandboxtemplates \ --all-namespacesאם החלתם את מדיניות האבטחה המומלצת, מחקו את קישור המדיניות ואת המדיניות:
kubectl delete validatingadmissionpolicybinding secure-sandbox-binding kubectl delete validatingadmissionpolicy secure-sandbox-policyאם פרסתם את Sandbox Router, מחקו את משאבי ה-RBAC שלו ברמת האשכול:
kubectl delete -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/rbac.yamlהמשאבים האחרים של הנתב נמצאים במרחב השמות
agent-sandbox-system, שיימחק בשלב הבא.כדי למחוק את הבקר של Agent Sandbox, את מרחב השמות שלו ואת ה-CustomResourceDefinitions שלו, מחקו את המניפסט של הגרסה שהתקנתם:
kubectl delete -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml
מחיקת משאבים
כדי להימנע מחיובים בחשבון Cloud de Confiance by S3NS , צריך למחוק את אשכול GKE שיצרתם.
gcloud container clusters delete ${CLUSTER_NAME} \
--location=${LOCATION} \
--quiet
אם יצרתם אשכול במצב Autopilot, המיקום הוא האזור (לדוגמה, us-central1). אם יצרתם אשכול במצב Standard, המיקום הוא התחום (לדוגמה, us-central1-a).
המאמרים הבאים
- איך שומרים ומשחזרים את Agent Sandbox בסביבות GKE באמצעות תמונות מצב של Pod
- איך GKE Sandbox מבודד עומסי עבודה באמצעות gVisor או מכונות וירטואליות זעירות
- מידע נוסף על אבטחה ב-GKE
- פרויקט הקוד הפתוח של Agent Sandbox ב-GitHub.
- איך משתמשים ב-Kata Containers בקוד פתוח עם Agent Sandbox ב-GKE Kata Containers הוא לא מוצר של Cloud de Confiance . אם אתם מתקינים את התוכנה הזו ומשתמשים בה, אתם אחראים לניהול ולפתרון בעיות. התמיכה והסכמי ה-SLA של Google לא חלים על Kata Containers.