במסמך הזה מפורטות הטמעות לדוגמה לניהול האחסון של Agent Sandbox ב-GKE, בהתאם לצרכים של מחזור החיים של נתוני הסוכנים.
בהתאם לצרכים של מחזור החיים של נתוני הנציגים, בוחרים באחת מההגדרות הבאות:
מידע נוסף על בחירת פתרון אחסון זמין במאמר בחירת אחסון לעומסי עבודה של סוכני AI.
במסמך הבא נעשה שימוש ב-StorageClass של dynamic-rwo לבחירה אוטומטית של סוג הדיסק כדי להקצות דיסקים שתואמים לסוגי המכונות של הצמתים שבהם מתוזמן Agent Sandbox ב-Pod של GKE. כדי לוודא ש-GKE מקצה נפחי Hyperdisk Balanced לאחסון של הסוכנים, צריך לתזמן את Agent Sandbox בפודים של GKE בצמתים של משפחות מכונות תואמות, כמו N4. אחרת, GKE חוזר ל-pd-balanced.
במסמך הזה מוסבר איך להטמיע את מצב הגישה לנתונים סביבת עבודה פרטית מבודדת באמצעות גישת ReadWriteOnce (RWO). במצב הזה, הסוכן מתחיל לפעול עם ספריית אחסון פרטית ומבודדת, שיש לו גישת קריאה וכתיבה בלעדית אליה.
אלא אם צוין אחרת, ההטמעות לדוגמה במסמך הזה משתמשות ביצירה ישירה של ארגז חול, שמתאימה לסוכנים שיכולים להתמודד עם זמן אחזור של כמה שניות בהפעלה. כדי להשיג זמן אחזור של פחות משנייה בהפעלה של סביבות עבודה עם שמירת מצב או שחזור לנקודה בזמן, צריך להשתמש ב-Agent Sandbox במאגרים חמים של GKE. כדי לקשר אחסון ל-Warm Pool Pod שנתבע, נדרשים סקריפטים בהתאמה אישית ו-DaemonSet עם הרשאות. בדוגמה הזו ב-GitHub מוסבר איך להטמיע את קובץ העזר.
מצבי גישה חלופיים
כדי לתמוך במצבי גישה חלופיים, אתם יכולים לשנות את הגדרות הנפח ותמונת המצב בהגדרות האישיות:
- סביבת עבודה משותפת: משנים את
accessModesל-ReadWriteManyומשתמשים ב-StorageClass עם יכולת RWX, כמו Filestore Multishares (Enterprise) (enterprise-multishare-rwx). - סביבת עבודה מסתעפת לניתוח: טעינת תיקיית התבנית במצב קריאה בלבד ומתן גישה לטיוטה נפרדת שניתן לכתוב בה. בתבנית הבסיס, צריך להשתמש באחסון שתומך בכמה קבצים מצורפים לקריאה בלבד, כמו Hyperdisk ML עם מצב גישה
ReadOnlyMany(ROX) או Filestore Multishares עם מצב גישה RWX.
לפני שמתחילים
מוודאים שיש לכם אשכול GKE שמותקן בו הבקר של Agent Sandbox. אם לא, צריך לבצע רק את השלבים בקטעים הבאים במאמר התקנת Agent Sandbox ב-GKE, ואז לחזור למסמך הזה:
אם השלמתם את החלק פריסת סביבת ארגז חול במסמך הזה, מחקו את המשאבים לדוגמה שנוצרו כדי שלצמתים יהיה מספיק קיבולת לארגזי החול במסמך הזה:
kubectl delete sandboxclaim sandbox-claim --ignore-not-found
kubectl delete sandboxwarmpool python-runtime-warmpool --ignore-not-found
kubectl delete sandbox sandbox-example-2 --ignore-not-found
הגדרת סביבת עבודה עם שמירת מצב
התבנית הזו מאפשרת לשמור את המצב האחרון של קובצי הנציג. היא שימושית כשהסוכן צריך לשמור את המצב כשהסשן של הסוכן מושהה או מסתיים (Agent Sandbox נמחק), ולשחזר את הנתונים מהמצב האחרון כשהסשן של הסוכן מופעל (Agent Sandbox נוצר מחדש).
ההטמעה של קובץ העזר בקטע הזה משתמשת ביצירה ישירה של ארגז חול, והיא רלוונטית לסוכנים שיכולים להתמודד עם זמן אחזור של כמה שניות בהפעלה.
בגישה הזו משתמשים במשאבים רגילים של PersistentVolumeClaim (PVC) ב-GKE כדי לקשר ארגז חול ל-PVC קיים שמכיל את נתוני המשתמש.
רצף האירועים בתבנית של סביבת עבודה עם שמירת מצב:
- הקצאה: האדמין או כלי הניהול מקצים באופן ידני PVC פרטי לכל סשן של נציג באמצעות מזהה דטרמיניסטי (לדוגמה,
pvc-agent-1). - הפניה: במשאב
Sandbox, משתמשים בשדהpersistentVolumeClaimבבלוקvolumesכדי לציין את ה-claimNameהמדויק של אמצעי האחסון הקיים. - זמן אחזור: כשיוצרים את ארגז החול, GKE צריך לצרף באופן דינמי את הדיסק של Compute Engine למכונה הווירטואלית של הצומת, מה שגורם לעיכוב רגיל של כמה שניות.
- שמירה: כשמסיימים את הסשן (מוחקים את המשאב
Sandbox), GKE מנתק את הדיסק אבל לא משמיד את ה-PVC, כדי שהמצב האחרון יישמר לסשן הבא.
כדי להגדיר סביבת עבודה עם שמירת מצב ששומרת נתונים בין סשנים, מבצעים את השלבים בסעיפי המשנה הבאים.
הקצאת סביבת עבודה קבועה (PVC)
יוצרים PersistentVolumeClaim (PVC) פרטי שמשתמש במזהה דטרמיניסטי, כמו pvc-agent-1.
שומרים את המניפסט הבא בתור
pvc-agent-1.yaml:apiVersion: v1 kind: PersistentVolumeClaim metadata: name: pvc-agent-1 # Derived directly from the deterministic assignment ID namespace: default spec: accessModes: - ReadWriteOnce storageClassName: dynamic-rwo # Selects disk type compatible with the node machine family resources: requests: storage: 10Giמחילים את המניפסט:
kubectl apply -f pvc-agent-1.yaml
מכיוון שמחלקת האחסון משתמשת בקישור דינמי של נפח, הדיסק עדיין לא מחובר לאף צומת. הוא נשאר במצב Pending עד שמתזמנים Pod שמבקש אותו.
פריסת Agent Sandbox
פורסים את המשאב המותאם אישית של Sandbox, תוך הפניה ל-PVC הדטרמיניסטי.
שומרים את המניפסט הבא בתור
sandbox-agent-1.yaml:apiVersion: agents.x-k8s.io/v1beta1 kind: Sandbox metadata: name: sandbox-agent-1 # Traceable sandbox name namespace: default spec: podTemplate: spec: runtimeClassName: gvisor # Required automountServiceAccountToken: false # Required securityContext: runAsNonRoot: true # Required runAsUser: 1000 fsGroup: 1000 # Grant group access to the volume nodeSelector: sandbox.gke.io/runtime: gvisor # Required tolerations: - key: "sandbox.gke.io/runtime" value: "gvisor" effect: "NoSchedule" # Required containers: - name: agent image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0 ports: - containerPort: 8888 volumeMounts: - name: workspace-disk mountPath: /workspace # Mounts the private disk into the container resources: limits: cpu: "500m" memory: "1Gi" # Required securityContext: capabilities: drop: ["ALL"] # Required volumes: - name: workspace-disk persistentVolumeClaim: claimName: pvc-agent-1 # Binds this specific Sandbox to Agent 1's PVC restartPolicy: OnFailureמחילים את המניפסט:
kubectl apply -f sandbox-agent-1.yamlמחכים עד שארגז החול יהיה מוכן:
kubectl wait sandbox sandbox-agent-1 \ --for=condition=Ready \ --timeout=300sGKE מאמת את קיבולת הצומת ומצרף את הדיסק, פעולה שנמשכת כמה שניות. הקונטיינר מאתחל בתוך ליבת gVisor של מרחב המשתמש. באשכול Autopilot, יכול להיות שיעברו כמה דקות עד שארגז החול יהיה מוכן, כי יכול להיות ש-GKE יצטרך ליצור בשבילו צומת.
כתיבת נתונים מהסוכן
כדי לדמות סוכן AI פעיל שמבצע שינויים בקבצים בסביבת העבודה שלו, כותבים קובץ טקסט בדיסק שנטען.
# Set the active Pod name
POD_NAME=sandbox-agent-1
# Write a state file to the persistent directory
kubectl exec ${POD_NAME} -- sh -c "echo 'Workspace State Saved - Agent 1' > /workspace/modified_data.txt"
# Confirm the file exists on the disk
kubectl exec ${POD_NAME} -- cat /workspace/modified_data.txt
לסיים את הסשן עם הנציג
כדי לדמות צמצום אנכי בהתאם לעומס או סיום של הסשן כשהסוכן לא פעיל, מוחקים את המשאב Sandbox אבל שומרים את האחסון הבסיסי.
kubectl delete sandbox sandbox-agent-1
GKE מבטל את הטעינה של הדיסק ומנתק אותו. ה-PVC של pvc-agent-1 נשאר, והנתונים נשמרים.
הפעלה מחדש של הסשן עם הנציג
כדי להפעיל מחדש את הסשן, פורסים מחדש משאב Sandbox חדש שמפנה לאותו PVC, ואז ממתינים עד שארגז החול יהיה מוכן:
kubectl apply -f sandbox-agent-1.yaml
kubectl wait sandbox sandbox-agent-1 \
--for=condition=Ready \
--timeout=300s
הדיסק מחובר מחדש (מה שגורם לעיכוב בחיבור) והקונטיינר מופעל.
אימות שמירת הנתונים
בודקים את קונטיינר ארגז החול החדש שנוצר כדי לוודא שהנתונים מהסשן הקודם נשמרו.
# Set the active Pod name of the new session
NEW_POD_NAME=sandbox-agent-1
# Read the file from the newly booted sandbox
kubectl exec ${NEW_POD_NAME} -- cat /workspace/modified_data.txt
הפלט אמור להציג את Workspace State Saved - Agent 1.
מחיקת משאבים
מוחקים את Agent Sandbox ואת בקשת הנפח הקבוע (PVC) שמשויכת אליו:
kubectl delete sandbox sandbox-agent-1
kubectl delete pvc pvc-agent-1
הגדרת שחזור לנקודת זמן והעברת בעלות
התבנית הזו מתאימה לשכפול של מערכי נתונים כדי להריץ ניסויים מקבילים, לניפוי באגים או לעבודה עצמאית. סביבת העבודה של הסוכן מאותחלת ממערך נתונים היסטורי (או ממצב משותף), והשינויים הבאים נשמרים בשכבה נפרדת ופרטית שניתן לכתוב בה, בלי לשנות את התבנית הבסיסית.
ההטמעה של קובץ העזר בקטע הזה משתמשת ביצירה ישירה של ארגז חול, והיא רלוונטית לסוכנים שיכולים להתמודד עם זמן אחזור של כמה שניות בהפעלה. הגישה הזו מסתמכת על התזמור כדי להקצות באופן דינמי PersistentVolumeClaims (PVCs) חדשים מ-VolumeSnapshots היסטוריים לפני הפעלת סשן חדש של ארגז חול.
יצירת VolumeSnapshotClass
יוצרים VolumeSnapshotClass שמציין את מנהל ההתקן של CSI ואת מדיניות המחיקה.
ב-Hyperdisk, צריך להשתמש במנהל ההתקן pd.csi.storage.gke.io.
שומרים את המניפסט הבא בתור
1-snapshot-class.yaml:apiVersion: snapshot.storage.k8s.io/v1 kind: VolumeSnapshotClass metadata: name: standard-rwo-snapshot driver: pd.csi.storage.gke.io deletionPolicy: Deleteמחילים את המניפסט:
kubectl apply -f 1-snapshot-class.yaml
הקצאת סביבת העבודה הראשונית
יוצרים ווליום שבו הסוכן יבצע את העבודה הראשונית שלו.
שומרים את המניפסט הבא בתור
2-source-pvc.yaml:apiVersion: v1 kind: PersistentVolumeClaim metadata: name: agent-source-pvc spec: accessModes: ["ReadWriteOnce"] storageClassName: dynamic-rwo resources: requests: storage: 10Giמחילים את המניפסט:
kubectl apply -f 2-source-pvc.yaml
יצירת נתוני מצב
פורסים Pod של ארגז חול כדי לכתוב נתונים לנפח האחסון.
שומרים את המניפסט הבא בתור
3-source-sandbox.yaml:apiVersion: agents.x-k8s.io/v1beta1 kind: Sandbox metadata: name: agent-session-v1 namespace: default spec: podTemplate: spec: runtimeClassName: gvisor automountServiceAccountToken: false # Required securityContext: runAsNonRoot: true # Required runAsUser: 1000 fsGroup: 1000 # Grant group access to the volume nodeSelector: sandbox.gke.io/runtime: gvisor # Required tolerations: - key: "sandbox.gke.io/runtime" value: "gvisor" effect: "NoSchedule" # Required containers: - name: agent image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0 ports: - containerPort: 8888 volumeMounts: - name: workspace mountPath: /workspace resources: limits: cpu: "500m" memory: "1Gi" # Required securityContext: capabilities: drop: ["ALL"] # Required volumes: - name: workspace persistentVolumeClaim: claimName: agent-source-pvc restartPolicy: OnFailureמחילים את המניפסט:
kubectl apply -f 3-source-sandbox.yamlמחכים עד שארגז החול יהיה מוכן, ואז כותבים קובץ תמונת מצב. הפקודה
syncמרוקנת את הכתיבה לדיסק, כך שהתמונה של המצב הנוכחי בקטע הבא כוללת את תוכן הקובץ:kubectl wait sandbox agent-session-v1 \ --for=condition=Ready \ --timeout=300s POD_NAME=agent-session-v1 kubectl exec ${POD_NAME} -- sh -c "echo 'Point-in-Time Snapshot - v1' > /workspace/state.txt && sync"
העברת המצב ההיסטורי לארכיון (CSI VolumeSnapshot)
מפעילים VolumeSnapshot של CSI כדי להקפיא את המצב הנוכחי. כשיוצרים קובץ snapshot, חשוב לפעול לפי השיטות המומלצות ליצירת קובצי snapshot של דיסקים.
שומרים את המניפסט הבא בתור
4-volume-snapshot.yaml:apiVersion: snapshot.storage.k8s.io/v1 kind: VolumeSnapshot metadata: name: agent-session-v1-snapshot spec: volumeSnapshotClassName: standard-rwo-snapshot source: persistentVolumeClaimName: agent-source-pvcמחילים את המניפסט:
kubectl apply -f 4-volume-snapshot.yamlמחכים עד שהתמונה תהיה מוכנה לשימוש:
kubectl wait volumesnapshot agent-session-v1-snapshot \ --for=jsonpath='{.status.readyToUse}'=true \ --timeout=600s
שחזור אמצעי האחסון מתמונת המצב
פורסים PVC חדש עם dataSource שמצביע על ה-CSI VolumeSnapshot.
שומרים את המניפסט הבא בתור
5-restored-pvc.yaml:apiVersion: v1 kind: PersistentVolumeClaim metadata: name: agent-restored-pvc spec: accessModes: ["ReadWriteOnce"] storageClassName: dynamic-rwo dataSource: name: agent-session-v1-snapshot kind: VolumeSnapshot apiGroup: snapshot.storage.k8s.io resources: requests: storage: 10Giמחילים את המניפסט:
kubectl apply -f 5-restored-pvc.yaml
הפעלת הסשן המשוחזר של Agent Sandbox
מקצים משאב Sandbox חדש שמפנה ל-PVC ששוחזר.
שומרים את המניפסט הבא בתור
6-restored-sandbox.yaml:apiVersion: agents.x-k8s.io/v1beta1 kind: Sandbox metadata: name: agent-session-v2-restored namespace: default spec: podTemplate: spec: runtimeClassName: gvisor automountServiceAccountToken: false # Required securityContext: runAsNonRoot: true # Required runAsUser: 1000 fsGroup: 1000 # Grant group access to the volume nodeSelector: sandbox.gke.io/runtime: gvisor # Required tolerations: - key: "sandbox.gke.io/runtime" value: "gvisor" effect: "NoSchedule" # Required containers: - name: agent image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0 ports: - containerPort: 8888 volumeMounts: - name: workspace mountPath: /workspace resources: limits: cpu: "500m" memory: "1Gi" # Required securityContext: capabilities: drop: ["ALL"] # Required volumes: - name: workspace persistentVolumeClaim: claimName: agent-restored-pvc restartPolicy: OnFailureמחילים את המניפסט:
kubectl apply -f 6-restored-sandbox.yamlמחכים עד שארגז החול יהיה מוכן:
kubectl wait sandbox agent-session-v2-restored \ --for=condition=Ready \ --timeout=600sיכול להיות שייקח יותר זמן עד שארגז החול הזה יהיה מוכן, בהשוואה לארגז החול המקורי, כי GKE יוצר את הדיסק שלו מה-snapshot אחרי שה-snapshot מוכן.
אימות של שמירה ושחזור
מוודאים שהסוכן יכול לקרוא את הנתונים ההיסטוריים.
NEW_POD_NAME=agent-session-v2-restored
kubectl exec ${NEW_POD_NAME} -- cat /workspace/state.txt
הפלט הצפוי: Point-in-Time Snapshot - v1
מחיקת משאבים
מוחקים את ה-Agent Sandboxes, ה-PVC וה-VolumeSnapshot:
kubectl delete sandbox agent-session-v1
kubectl delete sandbox agent-session-v2-restored
kubectl delete pvc agent-source-pvc
kubectl delete pvc agent-restored-pvc
kubectl delete volumesnapshot agent-session-v1-snapshot
kubectl delete volumesnapshotclass standard-rwo-snapshot
הגדרת סביבת עבודה זמנית
השתמשו בתבנית של סביבת עבודה זמנית כשסוכן צריך נפח אחסון לקבצים זמניים בזמן שהוא פעיל. אין צורך לשמור נתונים כשמוחקים את Agent Sandbox.
הגדרה עם הפעלה תוך פחות משנייה
כדי להקצות מראש נפחים ריקים ברקע, אתם יכולים להשתמש ב-Agent Sandbox במאגרים חמים של GKE.
הגדרת המשאב SandboxTemplate
מגדירים את הגיבוי של האחסון הזמני בבלוק volumeClaimTemplate.
שומרים את המניפסט הבא בתור
stateless-template.yaml:apiVersion: extensions.agents.x-k8s.io/v1beta1 kind: SandboxTemplate metadata: name: stateless-sandbox-template namespace: default spec: podTemplate: spec: runtimeClassName: gvisor automountServiceAccountToken: false securityContext: runAsNonRoot: true runAsUser: 1000 fsGroup: 1000 # Grant group access to the volume nodeSelector: sandbox.gke.io/runtime: gvisor tolerations: - key: "sandbox.gke.io/runtime" value: "gvisor" effect: "NoSchedule" containers: - name: agent image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0 ports: - containerPort: 8888 volumeMounts: - name: ephemeral-disk mountPath: /workspace resources: limits: cpu: "500m" memory: "1Gi" # Required securityContext: capabilities: drop: ["ALL"] # Required volumeClaimTemplates: - metadata: name: ephemeral-disk spec: accessModes: ["ReadWriteOnce"] storageClassName: dynamic-rwo # Selects disk type compatible with node machine family resources: requests: storage: 10Gi
הפעלת המשאב SandboxWarmPool
שומרים את המניפסט הבא בתור
stateless-warmpool.yaml:apiVersion: extensions.agents.x-k8s.io/v1beta1 kind: SandboxWarmPool metadata: name: stateless-warmpool namespace: default spec: replicas: 2 # Keep two standby Pods with pre-attached empty disks sandboxTemplateRef: name: stateless-sandbox-templateמחילים את שני המניפסטים:
kubectl apply -f stateless-template.yaml kubectl apply -f stateless-warmpool.yamlמחכים עד שארגזי החול של המאגר החם יהיו מוכנים:
kubectl wait sandboxwarmpool stateless-warmpool \ --for=jsonpath='{.status.readyReplicas}'=2 \ --timeout=600sאם יוצרים משאב
SandboxClaimלפני שארגזי החול של המאגר מוכנים, יכול להיות שהבקר ייצור ארגז חול חדש לבקשה במקום להקצות אחד מהמאגר. באשכול Autopilot, יכול להיות שיעברו כמה דקות עד שארגזי החול יהיו מוכנים, כי יכול להיות ש-GKE יצטרך ליצור בשבילם צמתים.
יצירת משאב SandboxClaim
מגדירים משאב SandboxClaim שמופעל כשמשתמש מתחיל סשן.
שומרים את המניפסט הבא בתור
stateless-sandbox-claim.yaml:apiVersion: extensions.agents.x-k8s.io/v1beta1 kind: SandboxClaim metadata: name: agent-1-claim spec: warmPoolRef: name: stateless-warmpoolמחילים את המניפסט:
kubectl apply -f stateless-sandbox-claim.yaml
אימות ביצוע תוך פחות משנייה
מחכים עד שהבקשה תהיה מוכנה, מתעדים את השם של Agent Sandbox Pod ואז מוודאים שהספרייה /workspace נטענה ומוכנה לשימוש מיידי:
kubectl wait sandboxclaim agent-1-claim --for=condition=Ready --timeout=300s
export POD_NAME=$(kubectl get sandboxclaim agent-1-claim -o jsonpath='{.status.sandbox.name}')
kubectl exec ${POD_NAME} -- ls -la /workspace
לסיים את הסשן עם הסוכן
כדי לסיים את הסשן של הנציג, מוחקים את המשאב SandboxClaim. מחיקת ה-claim תמחק גם את ה-sandbox שנתבע ואת אמצעי האחסון שלו:
kubectl delete sandboxclaim agent-1-claim
מחיקת משאבים
מוחקים את המשאבים SandboxWarmPool ו-SandboxTemplate:
kubectl delete sandboxwarmpool stateless-warmpool
kubectl delete sandboxtemplate stateless-sandbox-template
הגדרה עם הפעלה של כמה שניות
כדי להטמיע סביבת עבודה זמנית שיכולה להתמודד עם זמן אחזור של כמה שניות, צריך ליצור את Agent Sandbox באופן ישיר בלי מאגר חם.
הגדרת Agent Sandbox ללא שמירת מצב
שומרים את המניפסט הבא בתור
sandbox-direct-stateless.yaml:apiVersion: agents.x-k8s.io/v1beta1 kind: Sandbox metadata: name: sandbox-direct-stateless namespace: default spec: podTemplate: spec: runtimeClassName: gvisor automountServiceAccountToken: false securityContext: runAsNonRoot: true runAsUser: 1000 fsGroup: 1000 # Grant group access to the volume nodeSelector: sandbox.gke.io/runtime: gvisor tolerations: - key: "sandbox.gke.io/runtime" value: "gvisor" effect: "NoSchedule" containers: - name: agent image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0 ports: - containerPort: 8888 volumeMounts: - name: ephemeral-disk mountPath: /workspace resources: limits: cpu: "500m" memory: "1Gi" # Required securityContext: capabilities: drop: ["ALL"] # Required restartPolicy: OnFailure volumeClaimTemplates: - metadata: name: ephemeral-disk spec: accessModes: ["ReadWriteOnce"] storageClassName: dynamic-rwo resources: requests: storage: 10Gi
פריסת Agent Sandbox
כדי להקצות את הדיסק באופן דינמי ולצרף אותו לצומת המתוזמן, מחילים את המניפסט:
kubectl apply -f sandbox-direct-stateless.yaml
אימות זמן האחזור של ההפעלה והביצוע
עוקבים אחרי הסטטוס של ה-Pod כדי לראות את העיכוב בצירוף לפני שה-Pod עובר למצב Running:
kubectl get pods -w
כשה-Pod פועל, מקישים על Control+C כדי להפסיק את הצפייה.
מתעדים את שם ה-Pod ומוודאים שהספרייה /workspace זמינה:
POD_NAME=sandbox-direct-stateless
kubectl exec ${POD_NAME} -- ls -la /workspace
סיום הסשן עם הסוכן
מוחקים את המשאב Sandbox כדי לסיים באופן אוטומטי את ה-Pod ולהשמיד את האחסון הזמני שלו:
kubectl delete sandbox sandbox-direct-stateless
המאמרים הבאים
- מידע נוסף על Agent Sandbox ב-GKE
- מידע נוסף על בידוד הרצת קוד של AI באמצעות Agent Sandbox ב-GKE
- איך שומרים ומשחזרים את Agent Sandbox בסביבות GKE באמצעות קובצי Snapshot של Pod