Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

שימוש במשאבים שמורים של תחום מוגדר

טייס אוטומטי רגילה

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

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

הדף הזה מיועד לאנשים הבאים:

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

מידע על צריכת הזמנות ב-GKE

בעזרת שמירת מקום ב-Compute Engine, אתם יכולים להקצות תצורות חומרה ספציפיות ב Google Cloud אזורים, באופן מיידי או במועד עתידי שאתם קובעים. אחרי זה תוכלו להשתמש בקיבולת השמורה הזו ב-GKE.

בהתאם למצב הפעולה של GKE, אפשר להשתמש בסוגי ההזמנות הבאים:

מצב טייס אוטומטי: רק להזמנות ספציפיות.
מצב רגיל: הזמנות ספציפיות או כל הזמנה תואמת.

כדי להשתמש בהזמנות ליצירת משאבים, צריך לציין העדפה להזמנה, כמו any או specific.

אפשרויות לניצול הזמנות ב-GKE

ב-GKE אפשר להשתמש בהזמנות ישירות בעומסי עבודה ספציפיים באמצעות nodeSelector של Kubernetes במניפסט של עומס העבודה, או באמצעות יצירה של מאגרי צמתים במצב רגיל שמשתמשים בהזמנה. בדף הזה נסביר איך לבחור ישירות הזמנות במשאבים ספציפיים.

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

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

מידע נוסף זמין במאמר שימוש בהזמנות של Compute Engine בדף 'מידע על מחלקות מותאמות אישית של מחשוב'.

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

לפני שמתחילים, חשוב לוודא שביצעתם את הפעולות הבאות:

מפעילים את ממשק ה-API של Google Kubernetes Engine.

הפעלת Google Kubernetes Engine API

אם רוצים להשתמש ב-CLI של Google Cloud למשימה הזו, צריך להתקין ואז להפעיל את ה-CLI של gcloud. אם התקנתם בעבר את ה-CLI של gcloud, מריצים את הפקודה gcloud components update כדי לקבל את הגרסה העדכנית. יכול להיות שגרסאות קודמות של ה-CLI של gcloud לא יתמכו בהרצת הפקודות שמופיעות במסמך הזה.
הערה: אם כבר התקנתם את ה-CLI של gcloud, הקפידו להגדיר את compute/region המאפיין. אם אתם משתמשים בעיקר באשכולות אזוריים, הגדירו במקום זאת את compute/zone. אם מגדירים מיקום ברירת מחדל, אפשר להימנע משגיאות ב-CLI של gcloud כמו השגיאה הבאה: One of [--zone, --region] must be supplied: Please specify location. יכול להיות שתצטרכו לציין את המיקום בפקודות מסוימות אם המיקום של האשכול שונה מברירת המחדל שהגדרתם.

שימוש בהזמנות של קיבולת באשכולות Autopilot

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

ההזמנות האלה עומדות בדרישות להנחות גמישות תמורת התחייבות לשימוש ב-Compute. כדי להשתמש בהזמנות של קיבולת, צריך להשתמש במחלקת המחשוב Accelerator או במחלקת המחשוב Performance.

לפני שמתחילים, צריך ליצור אשכול Autopilot עם הגרסאות הבאות:
- כדי להשתמש במאיצים שמורים, כמו מעבדי GPU: גרסה 1.28.6-gke.1095000 ואילך
- כדי להריץ Pods בסדרת מכונות ספציפית, כשכל Pod נמצא בצומת משלו: גרסה 1.28.6-gke.1369000 ואילך או גרסה 1.29.1-gke.1575000 ואילך.

יצירת הזמנות של קיבולת ל-Autopilot

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

כל אחד מסוגי ה-GPU הבאים:
- ‫nvidia-gb200: NVIDIA GB200 (תצוגה מקדימה)
- ‫nvidia-b200: NVIDIA B200 ‏ (180GB)
- ‫nvidia-h200-141gb: NVIDIA H200 (141GB)
- ‫nvidia-h100-mega-80gb: NVIDIA H100 Mega (80GB)
- ‫nvidia-h100-80gb: NVIDIA H100 (80GB)
- ‫nvidia-a100-80gb: NVIDIA A100 (80GB)
- ‫nvidia-tesla-a100: NVIDIA A100 (40GB)
- ‫nvidia-rtx-pro-6000: NVIDIA RTX PRO 6000
- ‫nvidia-l4: NVIDIA L4
- ‫nvidia-tesla-t4: NVIDIA T4
כל אחד מסוגי ה-TPU הבאים:
- ‫tpu7x: Ironwood (TPU7x)
- ‫tpu-v6e-slice: TPU v6e slice
- ‫tpu-v5p-slice: פרוסת TPU v5p
- ‫tpu-v5-lite-podslice: TPU v5 lite podslice
- ‫tpu-v4-lite-device: מכשיר TPU v4 lite
- ‫tpu-v4-podslice: TPU v4 podslice
- ‫tpu-v3-device: מכשיר TPU v3
- ‫tpu-v3-slice: TPU v3 podslice

מידע על יצירת בקשה לשמירת מקום זמין במשאבים הבאים. ההזמנה צריכה לעמוד בדרישות הבאות:

סוגי המכונות, סוגי המאיצים וכמויות המאיצים תואמים למה שעומסי העבודה שלכם יצרכו.
ההזמנה משתמשת בסוג הצריכה ספציפי. לדוגמה, ב-CLI של gcloud, צריך לציין את האפשרות --require-specific-reservation כשיוצרים את ההזמנה.
איך יוצרים הזמנה לפרויקט יחיד
איך יוצרים הזמנה משותפת

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

שימוש בשריון ספציפי באותו פרויקט ב-Autopilot

בקטע הזה מוסבר איך לצרוך מקום שמור ספציפי שנמצא באותו פרויקט כמו האשכול. אפשר להשתמש ב-kubectl או ב-Terraform.

kubectl

שומרים את קובץ המניפסט הבא בשם specific-autopilot.yaml. במניפסט הזה יש בוררי צמתים שצורכים הזמנה ספציפית. אפשר להשתמש במכונות וירטואליות או במאיצים.

מכונות וירטואליות
```
  apiVersion: v1
  kind: Pod
  metadata:
    name: specific-same-project-pod
  spec:
    nodeSelector:
      cloud.google.com/compute-class: Performance
      cloud.google.com/machine-family: MACHINE_SERIES
      cloud.google.com/reservation-name: RESERVATION_NAME
      cloud.google.com/reservation-affinity: "specific"
    containers:
    - name: my-container
      image: "k8s.gcr.io/pause"
      resources:
        requests:
          cpu: 2
          memory: "4Gi"
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫MACHINE_SERIES: סדרת מכונות שמכילה את סוג המכונה של המכונות הווירטואליות בהזמנת הקיבולת הספציפית שלכם. לדוגמה, אם ההזמנה היא עבור c3-standard-4סוגי מכונות, מציינים c3 בשדה MACHINE_SERIES.
- ‫RESERVATION_NAME: השם של הזמנת הקיבולת ב-Compute Engine.
מאיצי GPU
```
  apiVersion: v1
  kind: Pod
  metadata:
    name: specific-same-project-pod
  spec:
    nodeSelector:
      cloud.google.com/gke-accelerator: ACCELERATOR
      cloud.google.com/reservation-name: RESERVATION_NAME
      cloud.google.com/reservation-affinity: "specific"
    containers:
    - name: my-container
      image: "k8s.gcr.io/pause"
      resources:
        requests:
          cpu: 12
          memory: "50Gi"
          ephemeral-storage: "200Gi"
        limits:
          nvidia.com/gpu: QUANTITY
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫ACCELERATOR: המאיץ שהזמנתם בהזמנת הקיבולת של Compute Engine. הערך חייב להיות אחד מהערכים הבאים:
  - ‫nvidia-gb200: NVIDIA GB200 (תצוגה מקדימה)
  - ‫nvidia-b200: NVIDIA B200 ‏ (180GB)
  - ‫nvidia-h200-141gb: NVIDIA H200 (141GB)
  - ‫nvidia-h100-mega-80gb: NVIDIA H100 Mega (80GB)
  - ‫nvidia-h100-80gb: NVIDIA H100 (80GB)
  - ‫nvidia-a100-80gb: NVIDIA A100 (80GB)
  - ‫nvidia-tesla-a100: NVIDIA A100 (40GB)
  - ‫nvidia-rtx-pro-6000: NVIDIA RTX PRO 6000
  - ‫nvidia-l4: NVIDIA L4
  - ‫nvidia-tesla-t4: NVIDIA T4
- ‫RESERVATION_NAME: השם של הזמנת הקיבולת ב-Compute Engine.
- ‫QUANTITY: מספר המעבדים הגרפיים לצירוף לקונטיינר. צריך לציין כמות נתמכת של ה-GPU שצוין, כפי שמתואר במאמר בנושא כמויות נתמכות של GPU.
TPU Accelerators
```
  apiVersion: v1
  kind: Pod
  metadata:
    name: specific-same-project-pod
  spec:
    nodeSelector:
      cloud.google.com/gke-tpu-accelerator: ACCELERATOR
      cloud.google.com/gke-tpu-topology: TOPOLOGY
      cloud.google.com/reservation-name: RESERVATION_NAME
      cloud.google.com/reservation-affinity: "specific"
    containers:
    - name: my-container
      image: "k8s.gcr.io/pause"
      resources:
        requests:
          cpu: 12
          memory: "50Gi"
          ephemeral-storage: "200Gi"
        limits:
          google.com/tpu: QUANTITY
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫ACCELERATOR: המאיץ שהזמנתם בהזמנת הקיבולת של Compute Engine. חייב להיות אחד מהערכים הבאים:
  - ‫tpu7x: Ironwood (TPU7x)
  - ‫tpu-v6e-slice: TPU v6e slice
  - ‫tpu-v5p-slice: פרוסת TPU v5p
  - ‫tpu-v5-lite-podslice: TPU v5 lite podslice
  - ‫tpu-v4-lite-device: מכשיר TPU v4 lite
  - ‫tpu-v4-podslice: TPU v4 podslice
  - ‫tpu-v3-device: מכשיר TPU v3
  - ‫tpu-v3-slice: TPU v3 podslice
- ‫TOPOLOGY: טופולוגיית ה-TPU.
- ‫RESERVATION_NAME: השם של הזמנת הקיבולת ב-Compute Engine.
- ‫QUANTITY: מספר יחידות ה-TPU לצירוף לקונטיינר. צריך להתאים לטופולוגיית ה-TPU.

פורסים את ה-Pod:

kubectl apply -f specific-autopilot.yaml

התכונה 'טייס אוטומטי' משתמשת בקיבולת השמורה בהזמנה שצוינה כדי להקצות צומת חדש להצבת ה-Pod.

Terraform

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

resource "kubernetes_pod_v1" "default_pod" {
  metadata {
    name = "specific-same-project-pod"
  }

  spec {
    node_selector = {
      "cloud.google.com/compute-class"        = "Performance"
      "cloud.google.com/machine-family"       = "c3"
      "cloud.google.com/reservation-name"     = google_compute_reservation.specific_pod.name
      "cloud.google.com/reservation-affinity" = "specific"
    }

    container {
      name  = "my-container"
      image = "registry.k8s.io/pause"

      resources {
        requests = {
          cpu               = 2
          memory            = "8Gi"
          ephemeral-storage = "1Gi"
        }
      }

      security_context {
        allow_privilege_escalation = false
        run_as_non_root            = false

        capabilities {
          add  = []
          drop = ["NET_RAW"]
        }
      }
    }

    security_context {
      run_as_non_root     = false
      supplemental_groups = []

      seccomp_profile {
        type = "RuntimeDefault"
      }
    }
  }

  depends_on = [
    google_compute_reservation.specific_pod
  ]
}

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

resource "kubernetes_pod_v1" "default_accelerator" {
  metadata {
    name = "specific-same-project-accelerator"
  }

  spec {
    node_selector = {
      "cloud.google.com/compute-class"        = "Accelerator"
      "cloud.google.com/gke-accelerator"      = "nvidia-l4"
      "cloud.google.com/reservation-name"     = google_compute_reservation.specific_accelerator.name
      "cloud.google.com/reservation-affinity" = "specific"
    }

    container {
      name  = "my-container"
      image = "registry.k8s.io/pause"

      resources {
        requests = {
          cpu               = 2
          memory            = "7Gi"
          ephemeral-storage = "1Gi"
          "nvidia.com/gpu"  = 1

        }
        limits = {
          "nvidia.com/gpu" = 1
        }
      }

      security_context {
        allow_privilege_escalation = false
        run_as_non_root            = false

        capabilities {
          add  = []
          drop = ["NET_RAW"]
        }
      }
    }

    security_context {
      run_as_non_root     = false
      supplemental_groups = []

      seccomp_profile {
        type = "RuntimeDefault"
      }
    }
  }

  depends_on = [
    google_compute_reservation.specific_accelerator
  ]
}

מידע נוסף על שימוש ב-Terraform זמין במאמר תמיכה ב-Terraform ל-GKE.

שימוש בהזמנה משותפת ספציפית ב-Autopilot

בקטע הזה נעשה שימוש במונחים הבאים:

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

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

יוצרים תפקיד IAM בהתאמה אישית שמכיל את ההרשאה compute.reservations.list בפרויקט הבעלים:
```
gcloud iam roles create ROLE_NAME \
    --project=OWNER_PROJECT_ID \
    --permissions='compute.reservations.list'
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫ROLE_NAME: שם התפקיד החדש.
- ‫OWNER_PROJECT_ID: מזהה הפרויקט שמכיל את הזמנת הקיבולת.
נותנים לסוכן השירות של GKE בפרויקט הצרכן גישה לרשימת ההזמנות המשותפות בפרויקט הבעלים:
```
gcloud projects add-iam-policy-binding OWNER_PROJECT_ID \
    --project=OWNER_PROJECT_ID \
    --member=serviceAccount:service-CONSUMER_PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com \
    --role='projects/OWNER_PROJECT_ID/roles/ROLE_NAME'
```
מחליפים את CONSUMER_PROJECT_NUMBER במספר הפרויקט המספרי של פרויקט הצרכן. כדי למצוא את המספר הזה, אפשר לעיין במאמר זיהוי פרויקטים במאמרי העזרה של מנהל המשאבים.
שומרים את קובץ המניפסט הבא בשם shared-autopilot.yaml. במניפסט הזה יש nodeSelectors שמנחים את GKE להשתמש בהזמנה משותפת ספציפית.
מכונות וירטואליות
```
apiVersion: v1
kind: Pod
metadata:
  name: performance-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: Performance
    cloud.google.com/machine-family: MACHINE_SERIES
    cloud.google.com/reservation-name: RESERVATION_NAME
    cloud.google.com/reservation-project: OWNER_PROJECT_ID
    cloud.google.com/reservation-affinity: "specific"
  containers:
  - name: my-container
    image: "k8s.gcr.io/pause"
    resources:
      requests:
        cpu: 2
        memory: "4Gi"
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫MACHINE_SERIES: סדרת מכונות שמכילה את סוג המכונה של המכונות הווירטואליות בהזמנת הקיבולת הספציפית שלכם. לדוגמה, אם ההזמנה היא ל-c3-standard-4 סוגי מכונות, צריך לציין c3 בשדה MACHINE_SERIES.
- ‫RESERVATION_NAME: השם של הזמנת הקיבולת ב-Compute Engine.
- ‫OWNER_PROJECT_ID: מזהה הפרויקט שמכיל את הזמנת הקיבולת.
מאיצי GPU
```
apiVersion: v1
kind: Pod
metadata:
  name: specific-same-project-pod
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: ACCELERATOR
    cloud.google.com/reservation-name: RESERVATION_NAME
    cloud.google.com/reservation-project: OWNER_PROJECT_ID
    cloud.google.com/reservation-affinity: "specific"
  containers:
  - name: my-container
    image: "k8s.gcr.io/pause"
    resources:
      requests:
        cpu: 12
        memory: "50Gi"
        ephemeral-storage: "200Gi"
      limits:
        nvidia.com/gpu: QUANTITY
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫ACCELERATOR: המאיץ שהזמנתם בהזמנת הקיבולת של Compute Engine. צריך להזין אחד מהערכים הבאים:
  - ‫nvidia-gb200: NVIDIA GB200 (תצוגה מקדימה)
  - ‫nvidia-b200: NVIDIA B200 ‏ (180GB)
  - ‫nvidia-h200-141gb: NVIDIA H200 (141GB)
  - ‫nvidia-h100-mega-80gb: NVIDIA H100 Mega (80GB)
  - ‫nvidia-h100-80gb: NVIDIA H100 (80GB)
  - ‫nvidia-a100-80gb: NVIDIA A100 (80GB)
  - ‫nvidia-tesla-a100: NVIDIA A100 (40GB)
  - ‫nvidia-rtx-pro-6000: NVIDIA RTX PRO 6000
  - ‫nvidia-l4: NVIDIA L4
  - ‫nvidia-tesla-t4: NVIDIA T4
- ‫RESERVATION_NAME: השם של הזמנת הקיבולת ב-Compute Engine.
- ‫OWNER_PROJECT_ID: מזהה הפרויקט שמכיל את הזמנת הקיבולת.
- ‫QUANTITY: מספר יחידות ה-GPU לצירוף לקונטיינר. הכמות חייבת להיות כמות נתמכת עבור ה-GPU שצוין, כפי שמתואר במאמר כמויות נתמכות של GPU.
מאיצי TPU
```
apiVersion: v1
kind: Pod
metadata:
  name: specific-shared-project-pod
spec:
  nodeSelector:
    cloud.google.com/gke-tpu-accelerator: ACCELERATOR
    cloud.google.com/gke-tpu-topology: TOPOLOGY
    cloud.google.com/reservation-name: RESERVATION_NAME
    cloud.google.com/reservation-project: OWNER_PROJECT_ID
    cloud.google.com/reservation-affinity: "specific"
  containers:
  - name: my-container
    image: "k8s.gcr.io/pause"
    resources:
      requests:
        cpu: 12
        memory: "50Gi"
        ephemeral-storage: "200Gi"
      limits:
        google.com/tpu: QUANTITY
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫ACCELERATOR: המאיץ שהזמנתם בהזמנת הקיבולת של Compute Engine. חייב להיות אחד מהערכים הבאים:
  - ‫tpu7x: Ironwood (TPU7x)
  - ‫tpu-v6e-slice: TPU v6e slice
  - ‫tpu-v5p-slice: פרוסת TPU v5p
  - ‫tpu-v5-lite-podslice: TPU v5 lite podslice
  - ‫tpu-v4-lite-device: מכשיר TPU v4 lite
  - ‫tpu-v4-podslice: TPU v4 podslice
  - ‫tpu-v3-device: מכשיר TPU v3
  - ‫tpu-v3-slice: TPU v3 podslice
- ‫TOPOLOGY: טופולוגיית ה-TPU.
- ‫RESERVATION_NAME: השם של הזמנת הקיבולת ב-Compute Engine.
- ‫OWNER_PROJECT_ID: מזהה הפרויקט שמכיל את הזמנת הקיבולת.
- ‫QUANTITY: מספר יחידות ה-TPU לצירוף לקונטיינר. צריך להתאים לטופולוגיית ה-TPU.
פורסים את ה-Pod:
```
kubectl apply -f shared-autopilot.yaml
```

התכונה 'טייס אוטומטי' משתמשת בקיבולת השמורה בהזמנה שצוינה כדי להקצות צומת חדש להצבת ה-Pod.

שימוש בבלוק ספציפי של הזמנה ב-Autopilot

בקטע הזה מוסבר איך לצרוך בלוק ספציפי של מקום שמור, שנמצא באותו פרויקט כמו האשכול או בפרויקט משותף. התכונה הזו זמינה רק למאיצים ספציפיים. אתם יכולים להשתמש ב-kubectl כדי להגדיר את ה-Pod כך שישתמש בבלוק של ההזמנה.

שומרים את קובץ המניפסט הבא בשם reservation-block-autopilot.yaml. במניפסט הזה יש בוררי צמתים שצורכים הזמנה ספציפית.

פרויקט מקומי
```
apiVersion: v1
kind: Pod
metadata:
  name: specific-same-project-pod
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: ACCELERATOR
    cloud.google.com/reservation-name: RESERVATION_NAME
    cloud.google.com/reservation-affinity: "specific"
    cloud.google.com/reservation-blocks: RESERVATION_BLOCKS_NAME
  
  containers:
  - name: my-container
    image: "k8s.gcr.io/pause"
    resources:
      requests:
        cpu: 12
        memory: "50Gi"
        ephemeral-storage: "200Gi"
      limits:
        nvidia.com/gpu: QUANTITY
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫ACCELERATOR: המאיץ שהזמנתם בהזמנת הקיבולת של Compute Engine. חייב להיות אחד מהערכים הבאים:
  - ‫nvidia-b200: NVIDIA B200 (180GB)
  - ‫nvidia-h200-141gb: NVIDIA H200 (141GB)
- ‫RESERVATION_NAME: השם של הזמנת הקיבולת ב-Compute Engine.
- ‫RESERVATION_BLOCKS_NAME: השם של בלוק הזמנת הקיבולת ב-Compute Engine.
- ‫QUANTITY: מספר המעבדים הגרפיים לצירוף לקונטיינר. צריך לציין כמות נתמכת של ה-GPU שצוין, כפי שמתואר במאמר בנושא כמויות נתמכות של GPU.
להזמנות שנמצאות בבעלות של פרויקט אחר, מוסיפים את cloud.google.com/reservation-project: OWNER_PROJECT_ID לשדה spec.nodeSelector. מחליפים את OWNER_PROJECT_ID במזהה הפרויקט שהזמנת הקיבולת שייכת לו.
פורסים את ה-Pod:
```
kubectl apply -f reservation-block-autopilot.yaml
```
ב-Autopilot נעשה שימוש בקיבולת השמורה בבלוק ההזמנה שצוין כדי להקצות צומת חדש להצבת ה-Pod.

שימוש בתת-בלוק ספציפי של הזמנה ב-Autopilot

בקטע הזה מוסבר איך לצרוך תת-בלוק ספציפי של הזמנת קיבולת שנמצא באותו פרויקט כמו האשכול שלכם או בפרויקט משותף.

שומרים את מניפסט ComputeClass הבא בשם reservation-sub-block-computeclass.yaml:
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: specific-reservation-subblock
spec:
  nodePoolAutoCreation:
    enabled: true
  priorities:
  - gpu:
      type: ACCELERATOR_TYPE
      count: ACCELERATOR_COUNT
    reservations:
      affinity: Specific
      specific:
      - name: RESERVATION_NAME
        project: RESERVATION_PROJECT_ID
        reservationBlock:
          name: RESERVATION_BLOCK_NAME
          reservationSubBlock:
            name: RESERVATION_SUB_BLOCK_NAME
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫ACCELERATOR_TYPE: המאיץ שהזמנתם בהזמנת הקיבולת של Compute Engine. הערך הזה חייב להיות nvidia-gb200.
- ‫ACCELERATOR_COUNT: מספר המאיצים לצירוף לכל צומת. הערך הזה צריך להיות כמות נתמכת עבור סוג המאיץ שצוין. מידע נוסף מופיע במאמר בנושא כמויות נתמכות של GPU.
- ‫RESERVATION_NAME: השם של הזמנת הקיבולת ב-Compute Engine.
- ‫RESERVATION_PROJECT_ID: מזהה הפרויקט של הפרויקט שבבעלותו נמצאת הזמנת הקיבולת.
- ‫RESERVATION_BLOCK_NAME: השם של בלוק הזמנת הקיבולת ב-Compute Engine.
- ‫RESERVATION_SUB_BLOCK_NAME: השם של תת-הבלוק של הזמנת הקיבולת ב-Compute Engine.

שומרים את מניפסט ה-Pod הבא בשם reservation-sub-block-pod.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: reservation-sub-block-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: specific-reservation-subblock
  containers:
  - name: my-container
    image: "k8s.gcr.io/pause"
    resources:
      requests:
        cpu: 12
        memory: "50Gi"
        ephemeral-storage: "200Gi"
      limits:
        nvidia.com/gpu: CONTAINER_GPU_COUNT

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

פורסים את ה-Pod:
```
kubectl apply -f reservation-sub-block-pod.yaml
```
התכונה Autopilot משתמשת בקיבולת השמורה בתת-הבלוק של ההזמנה שצוינה כדי להקצות צומת חדש להפעלת ה-Pod.

פתרון בעיות שקשורות לשימוש בהזמנות ב-Autopilot

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

שימוש במכונות וירטואליות שמורות ב-GKE Standard

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

Consuming any matching reservations

אפשר ליצור הזמנה ומופעים כדי להשתמש בהזמנה באמצעות ה-CLI של gcloud או Terraform.

gcloud

כדי להשתמש אוטומטית בכל ההזמנות התואמות, מגדירים את דגל ההזמנה ל---reservation-affinity=any. ‫any הוא ערך ברירת המחדל שמוגדר ב-Compute Engine, ולכן אפשר להשמיט לגמרי את הדגל של שיוך המקום השמור.

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

יצירת הזמנה של שלוש מכונות וירטואליות:
```
gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE --vm-count=3
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫RESERVATION_NAME: השם של ההזמנה שרוצים ליצור.
- ‫MACHINE_TYPE: סוג המכונה (השם בלבד) שרוצים להשתמש בה להזמנה. לדוגמה, n1-standard-2.

מוודאים שההזמנה נוצרה בהצלחה:

gcloud compute reservations describe RESERVATION_NAME

יצירת אשכול עם צומת אחד כדי לצרוך כל בקשה לשמירת מקום שתואמת:
```
gcloud container clusters create CLUSTER_NAME \
    --machine-type=MACHINE_TYPE --num-nodes=1 \
    --reservation-affinity=any
```
מחליפים את CLUSTER_NAME בשם של האשכול שרוצים ליצור.
יוצרים מאגר צמתים עם שלושה צמתים כדי לצרוך כל הזמנה תואמת:
```
gcloud container node-pools create NODEPOOL_NAME \
    --cluster CLUSTER_NAME --num-nodes=3 \
    --machine-type=MACHINE_TYPE --reservation-affinity=any
```
מחליפים את NODEPOOL_NAME בשם של מאגר הצמתים שרוצים ליצור.

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

Terraform

כדי ליצור הזמנה של שלוש מכונות וירטואליות באמצעות Terraform, אפשר להיעזר בדוגמה הבאה:

resource "google_compute_reservation" "any_reservation" {
  name = "any-reservation"
  zone = "us-central1-a"

  specific_reservation {
    count = 3

    instance_properties {
      machine_type = "e2-medium"
    }
  }
}

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

resource "google_container_cluster" "default" {
  name     = "gke-standard-zonal-cluster"
  location = "us-central1-a"

  initial_node_count = 1

  node_config {
    machine_type = "e2-medium"

    reservation_affinity {
      consume_reservation_type = "ANY_RESERVATION"
    }
  }

  depends_on = [
    google_compute_reservation.any_reservation
  ]
}

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

resource "google_container_node_pool" "any_node_pool" {
  name     = "gke-standard-zonal-any-node-pool"
  cluster  = google_container_cluster.default.name
  location = google_container_cluster.default.location

  initial_node_count = 3
  node_config {
    machine_type = "e2-medium"

    reservation_affinity {
      consume_reservation_type = "ANY_RESERVATION"
    }
  }
}

מידע נוסף על שימוש ב-Terraform זמין במאמר תמיכה ב-Terraform ל-GKE.

שימוש במקום שמור לפרויקט מסוים

כדי להשתמש בהזמנה ספציפית, מגדירים את דגל השיוך להזמנה לערך --reservation-affinity=specific ומזינים את השם של ההזמנה הספציפית. במצב הזה, המכונות צריכות לקחת קיבולת מההזמנה שצוינה באזור. הבקשה נכשלת אם אין מספיק קיבולת במקום השמור.

כדי ליצור הזמנה ומופעים לשימוש בהזמנה ספציפית, מבצעים את השלבים הבאים. אפשר להשתמש ב-CLI של gcloud או ב-Terraform.

gcloud

יצירת הזמנה ספציפית לשלושה מופעים של מכונות וירטואליות:
```
gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE --vm-count=3 \
    --require-specific-reservation
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫RESERVATION_NAME: השם של ההזמנה שרוצים ליצור.
- ‫MACHINE_TYPE: סוג המכונה (השם בלבד) שרוצים להשתמש בה להזמנה. לדוגמה, n1-standard-2.
יוצרים מאגר צמתים עם צומת יחיד כדי להשתמש במקום שמור ספציפי לפרויקט יחיד:
```
gcloud container node-pools create NODEPOOL_NAME \
    --cluster CLUSTER_NAME \
    --machine-type=MACHINE_TYPE --num-nodes=1 \
    --reservation-affinity=specific --reservation=RESERVATION_NAME
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫NODEPOOL_NAME: השם של מאגר הצמתים שרוצים ליצור.
- ‫CLUSTER_NAME: השם של האשכול שיצרתם.

Terraform

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

resource "google_compute_reservation" "specific_reservation" {
  name = "specific-reservation"
  zone = "us-central1-a"

  specific_reservation {
    count = 1

    instance_properties {
      machine_type = "e2-medium"
    }
  }

  specific_reservation_required = true
}

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

resource "google_container_node_pool" "specific_node_pool" {
  name     = "gke-standard-zonal-specific-node-pool"
  cluster  = google_container_cluster.default.name
  location = google_container_cluster.default.location

  initial_node_count = 1
  node_config {
    machine_type = "e2-medium"

    reservation_affinity {
      consume_reservation_type = "SPECIFIC_RESERVATION"
      key                      = "compute.googleapis.com/reservation-name"
      values                   = [google_compute_reservation.specific_reservation.name]
    }
  }

  depends_on = [
    google_compute_reservation.specific_reservation
  ]
}

מידע נוסף על שימוש ב-Terraform זמין במאמר תמיכה ב-Terraform ל-GKE.

שימוש בהזמנה משותפת ספציפית

כדי ליצור הזמנה משותפת ספציפית ולנצל אותה, מבצעים את השלבים הבאים. אפשר להשתמש ב-CLI של gcloud או ב-Terraform.

פועלים לפי השלבים במאמר ניהול יצירת הזמנות משותפות.

gcloud

כדי ליצור הזמנה משותפת ספציפית:
```
gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE --vm-count=3 \
    --zone=ZONE \
    --require-specific-reservation \
    --project=OWNER_PROJECT_ID \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫RESERVATION_NAME: השם של ההזמנה שרוצים ליצור.
- ‫MACHINE_TYPE: השם של סוג המכונה שרוצים להשתמש בה להזמנה. לדוגמה, n1-standard-2.
- ‫OWNER_PROJECT_ID: מזהה הפרויקט שבו רוצים ליצור את השרייןג הזה של ההזמנה. אם לא מציינים את הדגל --project, ‏ GKE משתמש בפרויקט הנוכחי כפרויקט הבעלים כברירת מחדל.
- ‫CONSUMER_PROJECT_IDS: רשימה מופרדת בפסיקים של מזהי הפרויקטים שרוצים לשתף איתם את ההזמנה הזו. לדוגמה: project-1,project-2. אפשר לכלול 1 עד 100 פרויקטים לצרכן. הפרויקטים האלה צריכים להיות באותו ארגון כמו פרויקט הבעלים. אל תכללו את OWNER_PROJECT_ID, כי המערכת יכולה להשתמש בהזמנה הזו כברירת מחדל.

שימוש בהזמנה המשותפת:

  gcloud container node-pools create NODEPOOL_NAME \
      --cluster CLUSTER_NAME \
      --machine-type=MACHINE_TYPE --num-nodes=1 \
      --reservation-affinity=specific \
      --reservation=projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME

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

‫NODEPOOL_NAME: השם של מאגר הצמתים שרוצים ליצור.
‫CLUSTER_NAME: השם של האשכול שיצרתם.

Terraform

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

resource "google_compute_reservation" "specific_reservation" {
  name = "specific-reservation"
  zone = "us-central1-a"

  specific_reservation {
    count = 1

    instance_properties {
      machine_type = "e2-medium"
    }
  }

  specific_reservation_required = true
}

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

resource "google_container_node_pool" "specific_node_pool" {
  name     = "gke-standard-zonal-specific-node-pool"
  cluster  = google_container_cluster.default.name
  location = google_container_cluster.default.location

  initial_node_count = 1
  node_config {
    machine_type = "e2-medium"

    reservation_affinity {
      consume_reservation_type = "SPECIFIC_RESERVATION"
      key                      = "compute.googleapis.com/reservation-name"
      values                   = [google_compute_reservation.specific_reservation.name]
    }
  }

  depends_on = [
    google_compute_reservation.specific_reservation
  ]
}

מידע נוסף על שימוש ב-Terraform זמין במאמר תמיכה ב-Terraform ל-GKE.

שיקולים נוספים לגבי צריכה מהזמנה ספציפית

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

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

שימוש בשמירת מקום ב-GPU

כדי ליצור מאגר צמתים רגיל שמשתמש בהזמנת GPU, או שמשתמש בהזמנה כלשהי שבה הקיבולת נמצאת באזור אחד, צריך לציין את הדגל --node-locations כשמוסיפים מאגר צמתים. כשיוצרים אשכול אזורי במסלול הרגיל או אשכול רב-אזורי במסלול הרגיל, ציון מיקומי הצמתים מבטיח ש-GKE ייצור צמתים רק באזור שבו יש לכם קיבולת GPU שמורה.

הוראות מפורטות ליצירת מאגר צמתים שמשתמש ביחידות GPU זמינות במאמר יצירת מאגר צמתים של GPU.

שימוש בהזמנות של TPU

כדי ליצור מאגר צמתים רגיל שצורכת הזמנת TPU, צריך לציין את הדגל --node-locations כשמוסיפים מאגר צמתים. כשיוצרים אשכול אזורי במסלול הרגיל או אשכול רב-אזורי במסלול הרגיל, ציון מיקומי הצמתים מבטיח ש-GKE ייצור צמתים רק באזור שבו הזמנתם קיבולת TPU.

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

כשמשתמשים ב-TPU ב-GKE,‏ SPECIFIC הוא הערך הנתמך היחיד לסימון --reservation-affinity.

הוראות מפורטות ליצירת מאגר צמתים שמשתמש ב-TPU זמינות במאמר בנושא יצירת מאגר צמתים של TPU.

יצירת צמתים בלי להשתמש בהזמנות

כדי למנוע באופן מפורש שימוש במשאבים מכל שריון, מגדירים את ההעדפה ל---reservation-affinity=none.

יצירת אשכול שלא יצרוך שום הזמנה:
```
gcloud container clusters create CLUSTER_NAME --reservation-affinity=none
```
מחליפים את CLUSTER_NAME בשם של האשכול שרוצים ליצור.
יוצרים מאגר צמתים שלא יצרוך שום הזמנה:
```
gcloud container node-pools create NODEPOOL_NAME \
    --cluster CLUSTER_NAME \
    --reservation-affinity=none
```
מחליפים את NODEPOOL_NAME בשם של מאגר הצמתים שרוצים ליצור.

הזמנות זמינות בין אזורים

כשמשתמשים במאגרי צמתים שפועלים בכמה אזורים עם הזמנות שלא שוות בין האזורים, אפשר להשתמש בדגל --location_policy=ANY. כך מוודאים שכאשר מוסיפים צמתים חדשים לאשכול, הם נוצרים באזור שעדיין יש בו הזמנות שלא נעשה בהן שימוש.

סידור וארגון

כדי להימנע מחיובים בחשבון לחיוב ב-Cloud על המשאבים שבהם השתמשתם בדף הזה:

כדי למחוק את האשכולות שיצרתם, מריצים את הפקודה הבאה לכל אחד מהאשכולות:
```
gcloud container clusters delete CLUSTER_NAME
```
כדי למחוק את ההזמנות שיצרתם, מריצים את הפקודה הבאה לכל אחת מההזמנות:
```
gcloud compute reservations delete RESERVATION_NAME
```

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

מידע על צריכת הזמנות ב-GKE

אפשרויות לניצול הזמנות ב-GKE

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

שימוש בהזמנות של קיבולת באשכולות Autopilot

יצירת הזמנות של קיבולת ל-Autopilot

שימוש בשריון ספציפי באותו פרויקט ב-Autopilot

kubectl

Terraform

שימוש בהזמנה משותפת ספציפית ב-Autopilot

מכונות וירטואליות

מאיצי GPU

מאיצי TPU

שימוש בבלוק ספציפי של הזמנה ב-Autopilot

שימוש בתת-בלוק ספציפי של הזמנה ב-Autopilot

פתרון בעיות שקשורות לשימוש בהזמנות ב-Autopilot

שימוש במכונות וירטואליות שמורות ב-GKE Standard

Consuming any matching reservations

gcloud

Terraform

שימוש במקום שמור לפרויקט מסוים

gcloud

Terraform

שימוש בהזמנה משותפת ספציפית

gcloud

Terraform

שיקולים נוספים לגבי צריכה מהזמנה ספציפית

שימוש בשמירת מקום ב-GPU

שימוש בהזמנות של TPU

יצירת צמתים בלי להשתמש בהזמנות

הזמנות זמינות בין אזורים

סידור וארגון

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

שימוש במשאבים שמורים של תחום מוגדר