GKE Sandbox

קונטיינרים שמריצים קוד לא ידוע או לא מהימן באשכולות של Google Kubernetes Engine ‏(GKE) הם סיכון אבטחה פוטנציאלי לליבת המארח של הצמתים. כדי להגן על הליבה של המארח מפני האיומים האלה, אפשר לבודד את הקוד מהליבה. במאמר הזה מוסבר איך GKE Sandbox יוצר את שכבת הבידוד הזו באמצעות טכנולוגיות כמו gVisor ו-microVMs.

המסמך הזה מיועד למומחי אבטחה שרוצים לצמצם את שטח המתקפה בצמתים של GKE ולהגן על הצמתים מפני קוד לא מהימן. אתם כבר אמורים להכיר את הנושאים הבאים:

מידע על הרצה בארגז חול ב-GKE

סביבת זמן הריצה של קונטיינרים שמותקנת בצמתים, כמו containerd, מספקת רמה מסוימת של בידוד בין התהליכים של הקונטיינר לבין הליבה שפועלת בצומת. עם זאת, סביבת זמן הריצה של הקונטיינר פועלת בדרך כלל כמשתמש עם הרשאות בצומת, ויש לה גישה לרוב הקריאות למערכת בליבה של המארח.

ב-Kubernetes וב-GKE, ארגז חול מבודד קונטיינרים שפועלים כדי להגביל את ההשפעה הפוטנציאלית של ניצול לרעה או שגיאות שמשפיעות על קונטיינרים אחרים או על זמן הריצה של הקונטיינר. אתם יכולים להריץ קונטיינרים בארגזי חול כדי להגן על הליבה של המכונה הבסיסית של Compute Engine מפני קוד לא מהימן או לא ידוע. ארגז חול הוא גם אמצעי הגנה טוב לעומק, שמונע מעומסי עבודה אחרים להשפיע על קונטיינרים בעלי ערך גבוה. אתם יכולים להריץ עומסי עבודה בארגזי חול באמצעות GKE Sandbox.

איומים פוטנציאליים

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

  • ארגונים שמאפשרים למשתמשים להעלות ולהריץ קוד, כמו ספקי SaaS וספקי אירוח באינטרנט.
  • סוכני AI שיוצרים ומריצים קוד, בדרך כלל בלי פיקוח.

טכנולוגיות ארגז החול שבהן משתמש GKE Sandbox עוזרות לצמצם את ההשפעה הפוטנציאלית הבאה של פריצות בקונטיינר:

  • קוד זדוני או פגום שגורם לקריסה של ליבת המארח ולהשבתת הצומת.
  • דיירים זדוניים ששולפים נתונים של דייר אחר שנמצאים בזיכרון או בדיסק.
  • עומסי עבודה לא מהימנים שניגשים לשירותי Google Cloud אחרים או למטא-נתונים של אשכולות.

טכנולוגיות של ארגז חול ב-GKE

ב-GKE Sandbox יש תמיכה בטכנולוגיות הבאות של ארגז חול, שכל אחת מהן משתמשת בגישה שונה לבידוד עומסי עבודה ומתאימה לתרחישי שימוש שונים:

  • gVisor: הטמעה מחדש של ה-API של ליבת Linux בסביבת המשתמש, שלא דורשת הרשאות מורחבות. ליבת מרחב המשתמש וסביבת זמן הריצה של הקונטיינר מטמיעות מחדש את רוב קריאות המערכת ומספקות להן שירות בשם ליבת המארח. הגישה הישירה לליבת המארח מוגבלת. למידע נוסף על אופן הפעולה של ליבת האורח, קראו את מדריך הארכיטקטורה של gVisor.

  • ‫MicroVMs: מכונות וירטואליות קלות שמריצות ליבה ומערכת הפעלה מלאות של Linux. כל Pod פועל ב-microVM משלו, שמספק בידוד קפדני מ-Pods אחרים ומצומת המארח. ב-GKE Sandbox נעשה שימוש בתוכנת הקוד הפתוח Kata Containers ובצג המכונה הווירטואלית (VMM) של Cloud Hypervisor כדי ליצור ולנהל מכונות microVM.

בטבלה הבאה מפורטים ההבדלים העיקריים בין מכונות מיקרו-וירטואליות לבין gVisor. המידע הזה יעזור לכם לבחור את טכנולוגיית ארגז החול שמתאימה לתרחיש לדוגמה שלכם.
תכונה MicroVMs gVisor
גישה לליבה (kernel) ליבת Linux מלאה קבוצת משנה של קריאות מערכת (syscalls) של ליבת Linux
רמת הבידוד וירטואליזציה מלאה של חומרה עם ליבת אורח ייעודית יירוט של Syscall בקרנל של מרחב המשתמשים
תקורה של מעבד (CPU) וזיכרון תקורה קבועה של ‎250 mCPU ו-‎130 MiB זיכרון לכל Pod תקורה דינמית עם זיכרון בסיס נמוך לקרנל של מרחב המשתמשים
שעת התחלה בערך שנייה או שתיים פחות מ-100 אלפיות השנייה
הגדרת צומת GKE נדרשים צומתי GKE Standard עם וירטואליזציה בתצורה מקוננת מופעלת זמין במאגרי צמתים של GKE Standard ובצמתים של GKE Autopilot. מופעל כברירת מחדל באשכולות GKE Autopilot.
תמיכה בתמונות של צמתים מערכת הפעלה שמותאמת לקונטיינרים (cos_containerd) או Ubuntu מערכת הפעלה שמותאמת לקונטיינרים (cos_containerd) בלבד
תאימות לסוג המכונה נתמך על ידי סדרות מכונות x86 שתומכות בווירטואליזציה בתצורה מקוננת (לא נתמך במכונות וירטואליות מסוג E2 או Arm) נתמך ברוב המעבדים מסוג x86, בארכיטקטורת Arm ובסוגי מכונות עם מאיצים
תמיכה במאיצים אין תמיכה במעבדי GPU או TPU. תמיכה בדגמי GPU ספציפיים ובגרסאות TPU ספציפיות.
תרחישים לדוגמה
  • סוכני AI שיוצרים ומריצים קוד בלי פיקוח
  • קוד אוטונומי שפועל בדפדפנים, כמו Puppeteer
  • עומסי עבודה שצריכים גישה לליבה המלאה של Linux
  • עומסי עבודה שיוצרים נפח גדול של קריאות מערכת עם תקורה נמוכה, כמו מספר גדול של פעולות קלט/פלט קטנות
  • אפליקציות לא מהימנות או של צד שלישי שמשתמשות בסביבות זמן ריצה כמו Rust,‏ Java,‏ Python,‏ PHP,‏ Node.js או Golang
  • ממשקי קצה, מטמונים או שרתי proxy של שרתי אינטרנט
  • אפליקציות שמעבדות מדיה או נתונים חיצוניים באמצעות מעבדים (CPU)
  • עומסי עבודה שדורשים שימוש אינטנסיבי ב-GPU וב-TPU
  • עומסי עבודה של הסקת מסקנות באמצעות AI שמעבדים קלט שרירותי או מריצים קוד
  • עומסי עבודה של אימון שמעבדים מודלים וקבוצות נתונים גדולות של צד שלישי

אם אתם מריצים עומסי עבודה של סוכני AI שמריצים קוד לא מהימן, אתם יכולים להשתמש במכונות מיקרו-וירטואליות או ב-gVisor עם Agent Substrate ב-GKE או עם Agent Sandbox ב-GKE. כדי להשוות בין המודלים האלה של תזמור, קראו את המאמר תכנון ארכיטקטורה לעומסי עבודה של סוכני AI ב-GKE.

כדי להחליט אילו אפליקציות להריץ בסוג מסוים של ארגז חול, כדאי לקרוא את המגבלות.

איך מבקשים ארגזי חול

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

  1. כדי להפעיל טכנולוגיית ארגז חול בצמתים, אפשר להשתמש ב-ComputeClasses כדי ליצור את הצמתים באופן אוטומטי או ליצור מאגרי צמתים באופן ידני.
  2. מבקשים ארגז חול לפודים באמצעות ה-RuntimeClass המתאים לסוג ארגז החול, כמו gvisor או microvm. מידע נוסף זמין במאמר הקשחת הבידוד של עומסי העבודה באמצעות GKE Sandbox.

‫GKE מתזמן את ה-Pods בצמתים שמשתמשים בטכנולוגיית ארגז החול המבוקשת, ואז מפעיל את האפליקציה בארגז החול. אפשר להריץ Pods שלא מבקשים ארגזי חול בצמתים שבהם GKE Sandbox מופעל, באמצעות בוררי צמתים וסבילות. זה שימושי לעומסי עבודה מהימנים, כמו כלי מעקב שרוצים להריץ בכל צומת.

המלצות אבטחה נוספות

כשמשתמשים ב-GKE Sandbox, מומלץ גם לפעול לפי ההמלצות הבאות:

  • מגדירים מגבלות משאבים לכל הקונטיינרים שפועלים בארגז חול. כך אפשר להגן מפני הסיכון שאפליקציה פגומה או זדונית תמנע מהצומת משאבים ותשפיע לרעה על אפליקציות אחרות או על תהליכי מערכת שפועלים בצומת.

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

מגבלות

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

מעבדי GPU ב-GKE Sandbox

אתם יכולים להריץ עומסי עבודה של GPU בארגזי חול באמצעות gVisor. הכלי gVisor לא מפחית את כל נקודות החולשה של מנהלי ההתקנים של NVIDIA, אבל הוא שומר על ההגנה מפני נקודות חולשה בליבת Linux. אל תשתמשו בשיתוף זמן של GPU בפודים בארגז חול, כי ה-GPU לא מבודד לגמרי בין הפודים. מידע נוסף על האופן שבו gVisor מגן על עומסי עבודה של GPU זמין במדריך התמיכה ב-GPU.

המגבלות הבאות חלות על עומסי עבודה של GPU ב-GKE Sandbox:

  • מכונות מיקרו-VM לא תומכות במעבדי GPU.
  • המגבלות הבאות חלות על gVisor:
    • יש תמיכה רק בעומסי עבודה של CUDA.
    • רק חלק מהדגמים הזמינים של GPU נתמכים. מידע נוסף מופיע במאמר תמיכה במודלים של GPU.
    • בכל גרסה של GKE יש תמיכה רק בגרסאות latest ו-default של מנהלי ההתקנים של NVIDIA. יכול להיות שגרסאות אחרות של מנהלי התקנים לא יפעלו.
    • לא כל תכונות ה-GPU נתמכות, כמו RDMA או IMEX. בהתאם לצרכים של הלקוחות, יכול להיות ש-gVisor יתמוך בתכונות ספציפיות במקרים מסוימים. כדי לבקש תמיכה בתכונה ספציפית, פתחו בקשת תמיכה או הגישו בקשה להוספת תכונה ב-gVisor.

תמיכה במודלים של GPU

בטבלה הבאה מתוארת התמיכה במודלים שונים של GPU ב-GKE Sandbox:

דגם תצוגה מקדימה תמיכה ב-GA הערות
  • NVIDIA RTX PRO 6000
  • סוגי מכונות עם GPU אחד או יותר: ‎1.34.1-gke.2037001 ואילך
  • סוגי מכונות עם פחות מ-GPU אחד: לא נתמכים
  • - -
  • NVIDIA GB200
  • NVIDIA B200
  • NVIDIA H200 141GB
  • ‫1.34.0-gke.1713000 ואילך
  • - -
  • NVIDIA H100 80GB
  • NVIDIA A100 80GB
  • NVIDIA A100 40GB
  • NVIDIA L4
  • NVIDIA T4
  • -
  • ‫1.29.15-gke.1134000 ואילך
  • ‫1.30.11-gke.1093000 ואילך
  • ‫1.31.7-gke.1149000 ואילך
  • ‫1.32.2-gke.1182003 ואילך
  • נתמך מאז ההשקה הראשונית.
  • NVIDIA V100
  • ‫NVIDIA P100 (מתקרב לסיום התמיכה)
  • לא נתמך לא נתמך ה-V100 וה-P100 משתמשים במנהלי התקנים קנייניים ולא נתמכים.
  • NVIDIA T4 VWS
  • NVIDIA L4 VWS
  • - - ‫GKE Sandbox לא תומך בסוגי הצמתים של Windows או Ubuntu, שנדרשים לצמתים של תחנות עבודה וירטואליות.

    יחידות TPU בארגז החול של GKE

    בגרסה 1.31.3-gke.1111001 של GKE ואילך, אתם יכולים להריץ עומסי עבודה של TPU בארגזי חול באמצעות gVisor. gVisor לא מפחית את כל נקודות החולשה של מנהלי ההתקנים של TPU, אבל שומר על ההגנה מפני נקודות חולשה בליבת Linux. במדריך לתמיכה ב-TPU מוסבר איך פרויקט gVisor מגן על עומסי עבודה של TPU.

    המגבלות הבאות חלות על עומסי עבודה של TPU ב-GKE Sandbox:

    • מכונות מיקרו-VM לא תומכות ב-TPU.
    • ‫gVisor תומך בגרסאות הבאות של TPU:

      • V4pod
      • V4lite
      • V5litepod
      • V5pod
      • V6e

    הגדרת הצומת

    המגבלות הבאות חלות על הצמתים שמשתמשים ב-GKE Sandbox:

    • ‫gVisor ו-microVMs תומכים רק בצומתי Linux. אין תמיכה בצומתי Windows Server.
    • ‫gVisor תומך רק בתמונת הצומת של מערכת הפעלה שמותאמת לקונטיינרים. מכונות MicroVM תומכות בתמונות של צמתים של מערכת הפעלה שמותאמת לקונטיינרים ושל Ubuntu.
    • כדי להשתמש במכונות וירטואליות זעירות, צריך להפעיל וירטואליזציה בתצורה מקוננת בצמתים. כל הדרישות והמגבלות של וירטואליזציה בתצורה מקוננת חלות גם כאן.
    • באשכולות Standard, אי אפשר להפעיל את GKE Sandbox במאגר ברירת המחדל של הצמתים. באשכול חייב להיות תמיד לפחות מאגר צמתים אחד שלא משתמש ב-GKE Sandbox. מאגר הצמתים הזה חייב להכיל לפחות צומת אחד, גם אם כל עומסי העבודה נמצאים בארגז חול. המגבלה הזו קיימת כדי להפריד בין שירותי המערכת לבין עומסי עבודה לא מהימנים.

    גישה למטא-נתונים של אשכולות

    אם הצמתים משתמשים בסוג ארגז החול gVisor, לפודים בצמתים אין גישה למטא-נתונים של האשכול ברמת מערכת ההפעלה של הצומת. בנוסף, פודים לא יכולים לגשת לשירותי Google Cloud, אלא אם משתמשים באיחוד זהויות של עומסי עבודה ל-GKE כדי להקצות תפקידים לזהויות של הפודים.

    המגבלה הזו לא חלה על סוג ארגז החול microVM. כדי למנוע גישה למטא-נתונים של אשכולות מ-Pods ב-microVMs, צריך להשתמש ב-NetworkPolicy שדוחה תעבורת נתונים יוצאת אל 169.254.169.252/32 ביציאה 988, או באשכולות שמשתמשים ב-GKE Dataplane V2, אל 169.254.169.254/32 ביציאה 80.

    יכול להיות ש-SMT מושבת

    הגדרות של ריבוי-תהליכים בו-זמני (SMT, שנקרא גם Hyper-Threading במעבדי Intel) משמשות לצמצום נקודות חולשה בערוצים צדדיים, שמנצלות את העובדה שתהליכים חולקים את מצב הליבה, כמו נקודות חולשה של דגימת נתונים של מיקרו-ארכיטקטורה (MDS).

    כדי לצמצם את ההשפעה של התקפות ערוץ צדדי, gVisor משתמש ב-Linux Core Scheduling. הגדרות ה-SMT לא השתנו מערכי ברירת המחדל. תזמון הליבה של Linux חל רק על Pods שפועלים בארגזי חול של gVisor.

    הגדרת ברירת המחדל של SMT או Hyper-Threading לסוג מכונה תלויה במידת הפגיעות של המכונה ל-MDS, באופן הבא:

    • פודים של Autopilot שמשתמשים ב-Scale-Out ComputeClass: SMT תמיד מושבת.
    • סוגי מכונות שמשתמשים במעבדי Intel: כברירת מחדל, Hyper-Threading מושבת.
    • סוגי מכונות שמשתמשות במעבדי AMD: SMT מופעל כברירת מחדל.
    • סוגי מכונות שמשתמשים רק בשרשור אחד לכל ליבה, כמו מעבדי Arm: אין תמיכה ב-SMT. כל המעבדים הווירטואליים שביקשתם מוצגים.

    הפעלת SMT

    במאגרי צמתים רגילים של GKE, אתם יכולים להפעיל SMT אם הוא מושבת כברירת מחדל בסוג המכונה שבחרתם. החיוב הוא על כל vCPU, גם אם מפעילים את ה-SMT וגם אם לא. למידע נוסף, קראו את המאמר תמחור כשמשנים את מספר הליכי המשנה לכל ליבה. כדי לשנות את הגדרת ה-SMT, מבצעים אחת מהפעולות הבאות:

    • מגדירים את הדגל --threads-per-core כשיוצרים מאגר צמתים של GKE Sandbox שמשתמש ב-gVisor:

      gcloud container node-pools create smt-enabled \
          --cluster=CLUSTER_NAME \
          --location=LOCATION \
          --machine-type=MACHINE_TYPE \
          --threads-per-core=2 \
          --sandbox=type=gvisor
      
      • ‫CLUSTER_NAME: השם של אשכול קיים שבו רוצים ליצור את מאגר הצמתים החדש.
      • ‫LOCATION: האזור או התחום של האשכול ב-Compute Engine.
      • ‫MACHINE_TYPE: סוג המכונה.
    • כדי להפעיל SMT במאגר צמתים קיים, משתמשים ב-DaemonSet:

      1. מוסיפים את תווית הצומת cloud.google.com/gke-smt-disabled=false למאגר צמתים קיים שמשתמש ב-gVisor:

        gcloud container node-pools update NODE_POOL_NAME \
            --cluster=CLUSTER_NAME \
            --location=LOCATION \
            --node-labels=cloud.google.com/gke-smt-disabled=false
        

        מחליפים את מה שכתוב בשדות הבאים:

        • ‫NODE_POOL_NAME: השם של מאגר הצמתים הקיים.
        • ‫CLUSTER_NAME: השם של אשכול קיים שבו רוצים ליצור את מאגר הצמתים החדש.
        • ‫LOCATION: האזור או התחום של האשכול ב-Compute Engine.
      2. פורסים את ה-DaemonSet. ה-DaemonSet פועל רק בצמתים עם התווית cloud.google.com/gke-smt-disabled=false.

        kubectl create -f \
            https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-node-tools/master/disable-smt/gke/enable-smt.yaml
        
      3. מוודאים שהפודים של DaemonSet פועלים.

        kubectl get pods --selector=name=enable-smt -n kube-system
        

        הפלט אמור להיראות כך:

        NAME               READY     STATUS    RESTARTS   AGE
        enable-smt-2xnnc   1/1       Running   0          6m
        
      4. מוודאים שהערך SMT has been enabled מופיע ביומנים של ה-Pods:

        kubectl logs enable-smt-2xnnc enable-smt -n kube-system
        

    יכולות

    רלוונטי לאשכולות רגילים

    כברירת מחדל, הקונטיינר לא יכול לפתוח שקעים גולמיים, כדי לצמצם את הפוטנציאל להתקפות זדוניות. כלים מסוימים שקשורים לרשת, כמו ping ו-tcpdump, יוצרים שקעים גולמיים כחלק מהפעולה המרכזית שלהם. כדי להפעיל שקעים גולמיים, צריך להוסיף באופן מפורש את היכולת NET_RAW להקשר האבטחה של הקונטיינר:

    spec:
      containers:
      - name: my-container
        securityContext:
          capabilities:
            add: ["NET_RAW"]
    

    אם אתם משתמשים ב-GKE Autopilot, Google Cloud מונע מכם להוסיף את ההרשאה NET_RAW לקונטיינרים בגלל ההשלכות של היכולת הזו על האבטחה.

    תלויות חיצוניות

    רלוונטי לאשכולות במצב Autopilot ובמצב Standard

    קוד לא מהימן שפועל בתוך ארגז החול עשוי לקבל גישה לשירותים חיצוניים כמו שרתי מסדי נתונים, ממשקי API, קונטיינרים אחרים ומנהלי התקנים של CSI. השירותים האלה פועלים מחוץ לגבולות של ארגז החול וצריך להגן עליהם בנפרד. תוקף יכול לנסות לנצל נקודות חולשה בשירותים האלה כדי לפרוץ את ארגז החול. חשוב להביא בחשבון את הסיכון וההשפעה של הגישה לשירותים האלה באמצעות הקוד שפועל בתוך ארגז החול, ולנקוט את האמצעים הנדרשים כדי לאבטח אותם.

    זה כולל הטמעות של מערכת קבצים לנפחי קונטיינרים כמו ext4 ומנהלי התקנים של CSI. מנהלי התקנים של CSI פועלים מחוץ לבידוד של ארגז החול, ויכול להיות שיש להם גישה עם הרשאות למארח ולשירותים. ניצול לרעה של מנהלי ההתקנים האלה יכול להשפיע על הליבה (kernel) של המארח ולפגוע בצומת כולו. כדי לצמצם את החשיפה במקרה של ניצול לרעה, מומלץ להריץ את מנהל ההתקן של CSI בתוך קונטיינר עם כמות ההרשאות המינימלית הנדרשת. ב-GKE Sandbox אפשר להשתמש במנהל ההתקן של ה-CSI של Persistent Disk ב-Compute Engine.

    תכונות לא תואמות

    המגבלות הבאות על תכונות חלות על GKE Sandbox:

    • המגבלות הבאות חלות גם על ארגזי חול של gVisor וגם על ארגזי חול של microVM:

      • אי אפשר להשתמש ב-Cloud Service Mesh בארגזי חול באשכולות Autopilot.
      • מודולים של אבטחת ליבת Linux, כמו seccomp,‏ AppArmor,‏ SELinux, הדגל No New Privileges, הפצת טעינה דו-כיוונית והקשר האבטחה של Pod ב-procMount, לא נתמכים ב-Pods בארגז חול.
      • אין תמיכה במדדי שימוש בזיכרון ברמת הקונטיינר. עם זאת, יש תמיכה בשימוש בזיכרון של Pod.
      • כלים שמתחברים לליבת ה-Linux המארחת כדי לעקוב אחרי פעילות הקונטיינר (כמו זיהוי איומים בקונטיינר של Security Command Center, ‏ Falco או Tetragon) לא יכולים לראות קריאות למערכת שבוצעו בתוך קונטיינרים בארגז חול ב-gVisor או בארגזי חול של microVM, או להתריע עליהן. בארגזי חול של microVM, אתם יכולים להריץ כלי מעקב של eBPF כקונטיינר משני (sidecar) עם הרשאות בתוך ה-Pod, כדי לעקוב אחרי ליבת האורח של ה-microVM.
    • המגבלות הבאות חלות רק על ארגזי חול של gVisor:

      • אין תמיכה בקונטיינרים שמשתמשים במצב הרשאות.
      • אי אפשר להשתמש ב-Raw block volumes.
      • אין תמיכה בהעברה ליציאה אחרת, למשל באמצעות kubectl port-forward.
      • אי אפשר להשתמש באחסון Hostpath.
      • אי אפשר להגדיר פרמטרים של ליבת sysctl.
      • מגבלות המעבד (CPU) והזיכרון חלות רק על Pods עם מחלקות QoS מסוג Guaranteed או Burstable, ורק כשמגבלות המעבד (CPU) והזיכרון צוינו לכל הקונטיינרים ב-Pod.
      • תכונות סטרימינג של טלמטריה של שקע דומיין של Unix‏ (UDS) בהתאמה אישית, seccheck ו-pod-init-config בקוד פתוח של gVisor לא נתמכות ולא ניתנות להגדרה במאגרי צמתים של GKE Sandbox.
    • המגבלות הבאות חלות רק על ארגזי חול של microVM:

      • אין תמיכה בפודים שמשתמשים בהגדרה hostNetwork: true. פודים שפועלים בארגז חול של microVM ומשתמשים בהגדרה hostNetwork: true לא יכולים לגשת למשאבים מחוץ לפוד.
      • כל כלי האבחון שמסתמכים על מעקב ברמת השקע יכולים לגשת רק לממשקי הרשת שמחוברים ל-microVM.

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