ניהול האחסון של Agent Sandbox ב-GKE

במסמך הזה מפורטות הטמעות לדוגמה לניהול האחסון של 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, ואז לחזור למסמך הזה:

  1. הגדרה של משתני סביבה
  2. יצירת אשכול GKE
  3. התקנת Agent Sandbox
  4. החלת מדיניות האבטחה המומלצת

אם השלמתם את החלק פריסת סביבת ארגז חול במסמך הזה, מחקו את המשאבים לדוגמה שנוצרו כדי שלצמתים יהיה מספיק קיבולת לארגזי החול במסמך הזה:

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 קיים שמכיל את נתוני המשתמש.

רצף האירועים בתבנית של סביבת עבודה עם שמירת מצב:

  1. הקצאה: האדמין או כלי הניהול מקצים באופן ידני PVC פרטי לכל סשן של נציג באמצעות מזהה דטרמיניסטי (לדוגמה, pvc-agent-1).
  2. הפניה: במשאב Sandbox, משתמשים בשדה persistentVolumeClaim בבלוק volumes כדי לציין את ה-claimName המדויק של אמצעי האחסון הקיים.
  3. זמן אחזור: כשיוצרים את ארגז החול, GKE צריך לצרף באופן דינמי את הדיסק של Compute Engine למכונה הווירטואלית של הצומת, מה שגורם לעיכוב רגיל של כמה שניות.
  4. שמירה: כשמסיימים את הסשן (מוחקים את המשאב Sandbox), GKE מנתק את הדיסק אבל לא משמיד את ה-PVC, כדי שהמצב האחרון יישמר לסשן הבא.

כדי להגדיר סביבת עבודה עם שמירת מצב ששומרת נתונים בין סשנים, מבצעים את השלבים בסעיפי המשנה הבאים.

הקצאת סביבת עבודה קבועה (PVC)

יוצרים PersistentVolumeClaim‏ (PVC) פרטי שמשתמש במזהה דטרמיניסטי, כמו pvc-agent-1.

  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
    
  2. מחילים את המניפסט:

    kubectl apply -f pvc-agent-1.yaml
    

מכיוון שמחלקת האחסון משתמשת בקישור דינמי של נפח, הדיסק עדיין לא מחובר לאף צומת. הוא נשאר במצב Pending עד שמתזמנים Pod שמבקש אותו.

פריסת Agent Sandbox

פורסים את המשאב המותאם אישית של Sandbox, תוך הפניה ל-PVC הדטרמיניסטי.

  1. שומרים את המניפסט הבא בתור 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
    
  2. מחילים את המניפסט:

    kubectl apply -f sandbox-agent-1.yaml
    
  3. מחכים עד שארגז החול יהיה מוכן:

    kubectl wait sandbox sandbox-agent-1 \
        --for=condition=Ready \
        --timeout=300s
    

    ‫GKE מאמת את קיבולת הצומת ומצרף את הדיסק, פעולה שנמשכת כמה שניות. הקונטיינר מאתחל בתוך ליבת 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. שומרים את המניפסט הבא בתור 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
    
  2. מחילים את המניפסט:

    kubectl apply -f 1-snapshot-class.yaml
    

הקצאת סביבת העבודה הראשונית

יוצרים ווליום שבו הסוכן יבצע את העבודה הראשונית שלו.

  1. שומרים את המניפסט הבא בתור 2-source-pvc.yaml:

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: agent-source-pvc
    spec:
      accessModes: ["ReadWriteOnce"]
      storageClassName: dynamic-rwo
      resources:
        requests:
          storage: 10Gi
    
  2. מחילים את המניפסט:

    kubectl apply -f 2-source-pvc.yaml
    

יצירת נתוני מצב

פורסים Pod של ארגז חול כדי לכתוב נתונים לנפח האחסון.

  1. שומרים את המניפסט הבא בתור 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
    
  2. מחילים את המניפסט:

    kubectl apply -f 3-source-sandbox.yaml
    
  3. מחכים עד שארגז החול יהיה מוכן, ואז כותבים קובץ תמונת מצב. הפקודה 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 של דיסקים.

  1. שומרים את המניפסט הבא בתור 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
    
  2. מחילים את המניפסט:

    kubectl apply -f 4-volume-snapshot.yaml
    
  3. מחכים עד שהתמונה תהיה מוכנה לשימוש:

    kubectl wait volumesnapshot agent-session-v1-snapshot \
        --for=jsonpath='{.status.readyToUse}'=true \
        --timeout=600s
    

שחזור אמצעי האחסון מתמונת המצב

פורסים PVC חדש עם dataSource שמצביע על ה-CSI VolumeSnapshot.

  1. שומרים את המניפסט הבא בתור 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
    
  2. מחילים את המניפסט:

    kubectl apply -f 5-restored-pvc.yaml
    

הפעלת הסשן המשוחזר של Agent Sandbox

מקצים משאב Sandbox חדש שמפנה ל-PVC ששוחזר.

  1. שומרים את המניפסט הבא בתור 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
    
  2. מחילים את המניפסט:

    kubectl apply -f 6-restored-sandbox.yaml
    
  3. מחכים עד שארגז החול יהיה מוכן:

    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.

  1. שומרים את המניפסט הבא בתור 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

  1. שומרים את המניפסט הבא בתור 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
    
  2. מחילים את שני המניפסטים:

    kubectl apply -f stateless-template.yaml
    kubectl apply -f stateless-warmpool.yaml
    
  3. מחכים עד שארגזי החול של המאגר החם יהיו מוכנים:

    kubectl wait sandboxwarmpool stateless-warmpool \
        --for=jsonpath='{.status.readyReplicas}'=2 \
        --timeout=600s
    

    אם יוצרים משאב SandboxClaim לפני שארגזי החול של המאגר מוכנים, יכול להיות שהבקר ייצור ארגז חול חדש לבקשה במקום להקצות אחד מהמאגר. באשכול Autopilot, יכול להיות שיעברו כמה דקות עד שארגזי החול יהיו מוכנים, כי יכול להיות ש-GKE יצטרך ליצור בשבילם צמתים.

יצירת משאב SandboxClaim

מגדירים משאב SandboxClaim שמופעל כשמשתמש מתחיל סשן.

  1. שומרים את המניפסט הבא בתור stateless-sandbox-claim.yaml:

    apiVersion: extensions.agents.x-k8s.io/v1beta1
    kind: SandboxClaim
    metadata:
      name: agent-1-claim
    spec:
      warmPoolRef:
        name: stateless-warmpool
    
  2. מחילים את המניפסט:

    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 ללא שמירת מצב

  1. שומרים את המניפסט הבא בתור 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

המאמרים הבאים