התקנת Agent Sandbox ב-GKE

במאמר הזה מוסבר איך להתקין את הבקר של 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 או למחוק את הפרויקט אחרי שמסיימים את המשימות שבמסמך הזה.

לפני שמתחילים

  1. בדף לבחירת הפרויקט במסוף Cloud de Confiance , בוחרים פרויקט ב- Cloud de Confiance או יוצרים אותו.

    התפקידים שנדרשים כדי לבחור או ליצור פרויקט

    • בחירת פרויקט: כדי לבחור פרויקט לא נדרש תפקיד IAM ספציפי – אתם יכולים לבחור כל פרויקט שקיבלתם בו תפקיד.
    • יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד "יצירת פרויקטים" (roles/resourcemanager.projectCreator), שכולל את ההרשאה resourcemanager.projects.create. איך מקצים תפקידים?

    כניסה לדף לבחירת הפרויקט

  2. מוודאים שהחיוב מופעל בפרויקט ב- Cloud de Confiance .

  3. מפעילים את Google Kubernetes Engine API, אם הוא עדיין לא מופעל.

    התפקידים שנדרשים כדי להפעיל ממשקי API

    כדי להפעיל ממשקי API, צריך את ההרשאה serviceusage.services.enable. אם אתם יצרתם את הפרויקט, סביר להניח שכבר יש לכם את ההרשאה הזו דרך התפקיד "בעלים" (roles/owner). אחרת, אתם יכולים לקבל את ההרשאה הזו דרך התפקיד "אדמין בממשק 'שימוש בשירות'" (roles/serviceusage.serviceUsageAdmin). איך מקצים תפקידים

    להפעלת ה-API

  4. מפעילים את Cloud Shell במסוף Cloud de Confiance .

    הפעלת Cloud Shell

הגדרה של משתני סביבה

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

  1. מגדירים את משתנה הסביבה LOCATION לאזור, למשל us-central1-a:

    export LOCATION="us-central1-a"
    
  2. יוצרים את האשכול:

    gcloud container clusters create ${CLUSTER_NAME} \
        --location=${LOCATION} \
        --machine-type=${MACHINE_TYPE} \
        --num-nodes=1
    
  3. יוצרים מאגר צמתים נפרד שבו 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.

  1. מחילים את המניפסט של הגרסה:

    kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml
    

    המניפסט יוצר את מרחב השמות agent-sandbox-system ופורס את הבקר במרחב השמות הזה.

  2. מחכים עד שהבקר מוכן:

    kubectl rollout status deployment/agent-sandbox-controller \
        --namespace=agent-sandbox-system \
        --timeout=120s
    

אפשר להתקין את Agent Sandbox גם באמצעות Helm. הוראות מפורטות מופיעות בקובץ README של תרשים Helm של Agent Sandbox.

אימות ההתקנה

  1. מוודאים שה-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.

  2. מוודאים שהבקר פועל:

    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.

  1. מחילים את המדיניות:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-policy.yaml
    
  2. מחילים את קישור המדיניות. הקישור אוכף את המדיניות בכל מרחבי השמות, חוץ ממרחבי השמות של המערכת, כמו 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 מאפשרת תעבורת נתונים נכנסת לפודים של הסוכנים רק מהפודים של הנתב במרחב השמות הזה.

  1. יוצרים את חשבון השירות של הנתב ואת הרשאות ה-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
    
  2. פורסים את הנתב. הפקודה הבאה מגדירה את קובץ האימג' של הנתב לאותה גרסה של הבקר:

    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 -
    
  3. יוצרים את השירות של הנתב:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/service.yaml
    
  4. מחכים עד שהנתב יהיה מוכן:

    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 יתעד אירועים מוקדמים של משאבי האשכול וארגז החול.

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

    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 שומר על מספר מסוים של משאבי Sandbox שחוממו מראש עם Pods פועלים שמוכנים לתביעה. מאגר השרתים הזה מקצר את זמן האחזור בהפעלה.

כדי לפרוס סביבת ארגז חול באמצעות יצירת משאבים מסוג SandboxTemplate ו-SandboxWarmPool:

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

    kubectl apply -f sandbox-template.yaml
    
  3. יוצרים קובץ בשם 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
    
  4. מחילים את המניפסט SandboxWarmPool:

    kubectl apply -f sandbox-warmpool.yaml
    
  5. מחכים עד שמשאבי ארגז החול של המאגר החם וה-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, מבצעים את השלבים הבאים:

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

    kubectl apply -f sandbox-claim.yaml
    
  3. מוודאים שהמשאב, התביעה והמאגר החם של Sandbox מוכנים:

    kubectl get sandboxwarmpool,sandboxclaim,sandbox,pod
    

חלופה: יצירת משאב של ארגז חול באופן ישיר

אם אתם לא צריכים את זמני ההפעלה המהירים שמאגרים חמים מספקים, אתם יכולים לפרוס משאב Sandbox ישירות בלי להשתמש בתבניות.

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

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

    kubectl apply -f sandbox.yaml
    
  3. מוודאים שמשאב ארגז החול פועל:

    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

  1. בודקים אם יש משאבים של Agent Sandbox שעדיין בשימוש:

    kubectl get sandboxes,sandboxclaims,sandboxwarmpools,sandboxtemplates \
        --all-namespaces
    
  2. אם החלתם את מדיניות האבטחה המומלצת, מחקו את קישור המדיניות ואת המדיניות:

    kubectl delete validatingadmissionpolicybinding secure-sandbox-binding
    kubectl delete validatingadmissionpolicy secure-sandbox-policy
    
  3. אם פרסתם את 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, שיימחק בשלב הבא.

  4. כדי למחוק את הבקר של 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).

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