יצירת בקשה משותפת לשמירת מקום

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

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

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

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

התפקידים הנדרשים

כדי לקבל את ההרשאות שדרושות ליצירת הזמנות משותפות, צריך לבקש מהאדמין להקצות לכם את תפקידי ה-IAM הבאים:

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

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

ההרשאות הנדרשות

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

  • ‫compute.reservations.create בפרויקט
  • כדי לראות את כללי מדיניות הארגון: orgpolicy.policy.get בארגון
  • כדי לערוך את מדיניות הארגון: orgpolicy.policy.set בארגון
  • כדי לציין תבנית של הגדרות מכונה: compute.instanceTemplates.useReadOnly בתבנית של הגדרות המכונה

יכול להיות שתקבלו את ההרשאות האלה באמצעות תפקידים בהתאמה אישית או תפקידים מוגדרים מראש אחרים.

יצירת הזמנה משותפת

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

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

  • מומלץ: מציינים תבנית של הגדרות מכונה

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

  • ציון מכונה וירטואלית קיימת

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

  • ציון נכסים ישירות

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

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

ציון תבנית של הגדרות מכונה

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

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

  • יוצרים את המקום השמור באותו אזור ואותו תחום (zone) כמו המשאבים בתבנית של הגדרות מכונה. אם בתבנית של הגדרות מכונה מצוינים משאבים אזוריים או משאבים של תחום מוגדר, כמו סוג מכונה או נפח של דיסק אחסון מתמיד, השימוש בתבנית מוגבל למיקומים שבהם המשאבים האלה קיימים. לדוגמה, אם בתבנית של הגדרות המכונה ציינתם נפח קיים של Persistent Disk באזור us-central1-a, תוכלו ליצור את ההזמנה רק באותו אזור. כדי לבדוק אם תבנית קיימת מציינת משאבים שמקשרים את התבנית לאזור או לתחום מוגדר ספציפיים, צופים בפרטים של תבנית של הגדרות מכונה ומחפשים בתוכה הפניות למשאבים אזוריים או למשאבים של תחום מוגדר.

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

המסוף

  1. פותחים את הדף Reservations במסוף Google Cloud .

    כניסה לדף Reservations

  2. לוחצים על Create reservation (יצירת בקשה לשמירת מקום). ייפתח הדף Create a reservation.

  3. בשדה Name, נותנים שם לבקשה.

  4. ברשימות Region ו-Zone, בוחרים את האזור והתחום שבהם רוצים לשריין את המשאבים.

  5. בקטע Share type (סוג השיתוף):

    1. כדי לשתף את ההזמנה עם פרויקטים אחרים, בוחרים באפשרות Shared.

    2. לוחצים על Add projects (הוספת פרויקטים) ובוחרים את הפרויקטים מהארגון של הפרויקט הנוכחי שרוצים לשתף איתם את השריין. אפשר לבחור עד 100 פרויקטים לצרכנים.

  6. אופציונלי: כדי לאפשר למשימות אימון בהתאמה אישית או למשימות חיזוי ב-Vertex AI להשתמש בשמירת מקום למכונות וירטואליות של GPU, בקטע Google Cloud services בוחרים באפשרות Share reservation.

  7. בקטע Use with VM instance, בוחרים באחת מהאפשרויות הבאות:

    • כדי להשתמש אוטומטית במכונות וירטואליות שמתאימות לפרטי הבקשה, מסמנים את האפשרות Use reservation automatically.

    • כדי להשתמש במשאבים שמתאימים לפרטי הבקשה רק כשיוצרים מכונות וירטואליות שמיועדות ספציפית אליה (לפי שם), בוחרים באפשרות Select specific reservation.

  8. בקטע Resource details (פרטי המשאב), מבצעים את הפעולות הבאות:

    • בשדה Number of VM instances, כותבים כמה מכונות וירטואליות רוצים לשריין.

    • כדי לציין את ההגדרות של המכונה הווירטואלית באמצעות תבנית של הגדרות מכונה, בוחרים באפשרות Use instance template ואז בוחרים את התבנית של הגדרות המכונה ברשימה שמופיעה.

  9. בקטע Auto-delete, אפשר להפעיל את אפשרות המחיקה האוטומטית כדי ש-Compute Engine ימחק אוטומטית את הבקשה לשמירת מקום בתאריך ובשעה ספציפיים. מתי זה שימושי? למשל כשמתכננים להפסיק את השימוש במשאבים ששוריינו ורוצים למנוע חיובים לא נחוצים.

  10. לוחצים על Create כדי ליצור את הבקשה לשמירת מקום. ייפתח הדף Reservations. יכולות לעבור עד דקה עד שהבקשה תיווצר. כדי לראות מתי הבקשה תיווצר ב-Compute Engine, אתם יכולים לפתוח את רשימת הבקשות לשמירת מקום.

gcloud

כדי ליצור הקצאת מקום משותפת, משתמשים בפקודה gcloud compute reservations create עם הדגלים --share-setting=projects ו---share-with.

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

gcloud compute reservations create RESERVATION_NAME \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

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

  • ‫RESERVATION_NAME: השם של ההזמנה שרוצים ליצור.

  • ‫PROJECT_ID: מזהה הפרויקט שבו רוצים לשריין משאבים ושבו קיימת תבנית של הגדרות מכונה.

  • ‫CONSUMER_PROJECT_IDS: רשימה מופרדת בפסיקים של מזהי הפרויקטים שיכולים להשתמש בהזמנה הזו – לדוגמה, project-1,project-2. אפשר לכלול עד 100 פרויקטים לצרכנים. הפרויקטים האלה צריכים להיות באותו ארגון כמו הפרויקט של הבעלים. לא כוללים את פרויקט הבעלים. כברירת מחדל, כבר יש הרשאה להשתמש בהזמנה.

  • ‫INSTANCE_TEMPLATE_URL: כתובת ה-URL של תבנית של הגדרות מכונה קיימת, שחייבת להיות קיימת בפרויקט. מציינים אחד מהערכים הבאים:

    • לתבנית של הגדרות מכונה אזורית: projects/PROJECT_ID/regions/REGION/instanceTemplates/INSTANCE_TEMPLATE_NAME

    • לתבנית גלובלית של הגדרות מכונה: INSTANCE_TEMPLATE_NAME

  • ‫NUMBER_OF_VMS: מספר המכונות הווירטואליות שרוצים לשריין.

  • ‫ZONE: האזור שבו רוצים לשריין משאבים.

לדוגמה, כדי ליצור מקום שמור על ידי ציון תבנית של הגדרות מכונה גלובלית בתחום (zone) us-central1-a, לשתף את המקום השמור עם הפרויקטים project-1 ו-project-2, ולהזמין עשר מכונות וירטואליות שכל אחת מהן משתמשת במכונה עם קונפיגורציה מוגדרת (predefined) מסוג N2 עם 4 vCPU, מריצים את הפקודה הבאה:

gcloud compute reservations create my-reservation \
    --share-setting=projects \
    --share-with=project-1,project-2 \
    --source-instance-template=projects/example-project/global/example-instance-template \
    --vm-count=10 \
    --zone=us-central1-a

אפשר גם לבצע אחת או יותר מהפעולות הבאות:

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

    gcloud compute reservations create RESERVATION_NAME \
    --require-specific-reservation \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

  • כדי לאפשר למשימות אימון בהתאמה אישית או למשימות חיזוי ב-Vertex AI להשתמש בשמירת מקום למכונות וירטואליות של GPU, צריך לכלול את הדגל --reservation-sharing-policy עם הערך ALLOW_ALL.

    gcloud compute reservations create RESERVATION_NAME \
    --reservation-sharing-policy=ALLOW_ALL \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

  • כדי לאפשר ל-Compute Engine למחוק אוטומטית את הבקשה לשמירת מקום, בוחרים אחת מהשיטות הבאות:

    • כדי למחוק את הבקשה לשמירת מקום בתאריך ובשעה ספציפיים, משתמשים בפקודה gcloud beta compute reservations create עם הדגל --delete-at-time.

      gcloud beta compute reservations create RESERVATION_NAME \
    --delete-at-time=DELETE_AT_TIME \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

      מחליפים את DELETE_AT_TIME בתאריך ובשעה בפורמט של חותמת זמן RFC 3339, שצריכה להיות ככה:

      YYYY-MM-DDTHH:MM:SSOFFSET

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

      • ‫YYYY-MM-DD: תאריך בפורמט של שנה בת 4 ספרות, חודש בן 2 ספרות ויום בחודש בן 2 ספרות, מופרדים במקפים (-).

      • ‫HH:MM:SS: שעה בפורמט של שעה בת 2 ספרות בשיטת 24 שעות, דקות בנות 2 ספרות ושניות בנות 2 ספרות, מופרדות באמצעות נקודתיים (:).

      • ‫OFFSET: אזור הזמן בפורמט של היסט מהזמן האוניברסלי המתואם (UTC). לדוגמה, כדי להשתמש בשעון החוף המערבי (PST), מציינים -08:00. לחלופין, כדי לא להשתמש בהזחה, מציינים Z.

    • כדי למחוק את ההזמנה אחרי משך זמן מסוים, משתמשים בפקודה gcloud beta compute reservations create עם הדגל --delete-after-duration.

      gcloud beta compute reservations create RESERVATION_NAME \
    --delete-after-duration=DELETE_AFTER_DURATION \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

      מחליפים את DELETE_AFTER_DURATION במשך זמן בימים, בשעות, בדקות או בשניות. לדוגמה, מציינים 30m ל-30 דקות, או 1d2h3m4s ליום אחד, שעתיים, 3 דקות ו-4 שניות.

המשך 

import (
	"context"
	"fmt"
	"io"

	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// Creates shared reservation from given template in particular zone
func createSharedReservation(w io.Writer, client ClientInterface, projectID, baseProjectId, zone, reservationName, sourceTemplate string) error {
	// client, err := compute.NewReservationsRESTClient(ctx)
	// projectID := "your_project_id". Destination of sharing.
	// baseProjectId := "your_project_id2". Project where the reservation will be created.
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"
	// sourceTemplate: existing template path. Following formats are allowed:
	//  	- projects/{project_id}/global/instanceTemplates/{template_name}
	//  	- projects/{project_id}/regions/{region}/instanceTemplates/{template_name}
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/global/instanceTemplates/instanceTemplate
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/regions/{region}/instanceTemplates/instanceTemplate

	ctx := context.Background()

	shareSettings := map[string]*computepb.ShareSettingsProjectConfig{
		projectID: {ProjectId: proto.String(projectID)},
	}

	req := &computepb.InsertReservationRequest{
		Project: baseProjectId,
		ReservationResource: &computepb.Reservation{
			Name: proto.String(reservationName),
			Zone: proto.String(zone),
			SpecificReservation: &computepb.AllocationSpecificSKUReservation{
				Count:                  proto.Int64(2),
				SourceInstanceTemplate: proto.String(sourceTemplate),
			},
			ShareSettings: &computepb.ShareSettings{
				ProjectMap: shareSettings,
				ShareType:  proto.String("SPECIFIC_PROJECTS"),
			},
		},
		Zone: zone,
	}

	op, err := client.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create reservation: %w", err)
	}

	if op != nil {
		if err = op.Wait(ctx); err != nil {
			return fmt.Errorf("unable to wait for the operation: %w", err)
		}
	}

	fmt.Fprintf(w, "Reservation created\n")

	return nil
}

Java 

import com.google.cloud.compute.v1.AllocationSpecificSKUReservation;
import com.google.cloud.compute.v1.InsertReservationRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.Reservation;
import com.google.cloud.compute.v1.ReservationsClient;
import com.google.cloud.compute.v1.ShareSettings;
import com.google.cloud.compute.v1.ShareSettingsProjectConfig;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateSharedReservation {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // The ID of the project where you want to reserve resources
    // and where the instance template exists.
    // By default, no projects are allowed to create or modify shared reservations
    // in an organization. Add projects to the Shared Reservations Owner Projects
    // (compute.sharedReservationsOwnerProjects) organization policy constraint
    // to allow them to create and modify shared reservations.
    // For more information visit this page:
    // https://cloud.google.com/compute/docs/instances/reservations-shared#shared_reservation_constraint
    String projectId = "YOUR_PROJECT_ID";
    // Zone in which to reserve resources.
    String zone = "us-central1-a";
    // Name of the reservation to be created.
    String reservationName = "YOUR_RESERVATION_NAME";
    // The URI of the global instance template to be used for creating the reservation.
    String instanceTemplateUri = String.format(
        "projects/%s/global/instanceTemplates/%s", projectId, "YOUR_INSTANCE_TEMPLATE_NAME");
    // Number of instances for which capacity needs to be reserved.
    int vmCount = 3;

    createSharedReservation(projectId, zone, reservationName, instanceTemplateUri, vmCount);
  }

  // Creates a shared reservation with the given name in the given zone.
  public static Status createSharedReservation(
          String projectId, String zone,
          String reservationName, String instanceTemplateUri, int vmCount)
          throws ExecutionException, InterruptedException, TimeoutException, IOException {

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (ReservationsClient reservationsClient = ReservationsClient.create()) {
      ShareSettings shareSettings = ShareSettings.newBuilder()
              .setShareType(String.valueOf(ShareSettings.ShareType.SPECIFIC_PROJECTS))
              // The IDs of projects that can consume this reservation. You can include up to
              // 100 consumer projects. These projects must be in the same organization as
              // the owner project. Don't include the owner project.
              // By default, it is already allowed to consume the reservation.
              .putProjectMap("CONSUMER_PROJECT_1", ShareSettingsProjectConfig.newBuilder().build())
              .putProjectMap("CONSUMER_PROJECT_2", ShareSettingsProjectConfig.newBuilder().build())
              .build();

      Reservation reservationResource =
              Reservation.newBuilder()
                      .setName(reservationName)
                      .setZone(zone)
                      .setSpecificReservationRequired(true)
                      .setShareSettings(shareSettings)
                      .setSpecificReservation(
                              AllocationSpecificSKUReservation.newBuilder()
                                      .setCount(vmCount)
                                      .setSourceInstanceTemplate(instanceTemplateUri)
                                      .build())
                      .build();

      InsertReservationRequest request =
              InsertReservationRequest.newBuilder()
                      .setProject(projectId)
                      .setZone(zone)
                      .setReservationResource(reservationResource)
                      .build();

      Operation response = reservationsClient.insertAsync(request)
              .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Reservation creation failed!!" + response);
      }
      return response.getStatus();
    }
  }
}

Node.js 

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

/**
 * TODO(developer): Uncomment reservationsClient and zoneOperationsClient before running the sample.
 */
// Instantiate a reservationsClient
// reservationsClient = new computeLib.ReservationsClient();
// Instantiate a zoneOperationsClient
// zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// The ID of the project where you want to reserve resources and where the instance template exists.
const projectId = await reservationsClient.getProjectId();
// The zone in which to reserve resources.
const zone = 'us-central1-a';
// The name of the reservation to create.
const reservationName = 'reservation-01';
// The number of VMs to reserve.
const vmsNumber = 3;
// The name of an existing instance template.
const instanceTemplateName = 'global-instance-template-name';
// The location of the instance template.
const location = 'global';

async function callCreateComputeSharedReservation() {
  // Create reservation for 3 VMs in zone us-central1-a by specifying a instance template.
  const specificReservation = new compute.AllocationSpecificSKUReservation({
    count: vmsNumber,
    sourceInstanceTemplate: `projects/${projectId}/${location}/instanceTemplates/${instanceTemplateName}`,
  });

  // Create share settings. Share reservation with one customer project.
  const shareSettings = new compute.ShareSettings({
    shareType: 'SPECIFIC_PROJECTS',
    projectMap: {
      // The IDs of projects that can consume this reservation. You can include up to 100 consumer projects.
      // These projects must be in the same organization as the owner project.
      // Don't include the owner project. By default, it is already allowed to consume the reservation.
      consumer_project_id: {
        projectId: 'consumer_project_id',
      },
    },
  });

  // Create a reservation.
  const reservation = new compute.Reservation({
    name: reservationName,
    specificReservation,
    specificReservationRequired: true,
    shareSettings,
  });

  const [response] = await reservationsClient.insert({
    project: projectId,
    reservationResource: reservation,
    zone,
  });

  let operation = response.latestResponse;

  // Wait for the create reservation operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await zoneOperationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log(`Reservation: ${reservationName} created.`);
  return response;
}

return await callCreateComputeSharedReservation();

Python 

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def create_compute_shared_reservation(
    project_id: str,
    zone: str = "us-central1-a",
    reservation_name="your-reservation-name",
    shared_project_id: str = "shared-project-id",
) -> compute_v1.Reservation:
    """Creates a compute reservation in GCP.
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone to create the reservation.
        reservation_name (str): The name of the reservation to create.
        shared_project_id (str): The ID of the project that the reservation is shared with.
    Returns:
        Reservation object that represents the new reservation.
    """

    instance_properties = compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
        machine_type="n1-standard-1",
        # Optional. Specifies amount of local ssd to reserve with each instance.
        local_ssds=[
            compute_v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk(
                disk_size_gb=375, interface="NVME"
            ),
        ],
    )

    reservation = compute_v1.Reservation(
        name=reservation_name,
        specific_reservation=compute_v1.AllocationSpecificSKUReservation(
            count=3,  # Number of resources that are allocated.
            # If you use source_instance_template, you must exclude the instance_properties field.
            # It can be a full or partial URL.
            # source_instance_template="projects/[PROJECT_ID]/global/instanceTemplates/my-instance-template",
            instance_properties=instance_properties,
        ),
        share_settings=compute_v1.ShareSettings(
            share_type="SPECIFIC_PROJECTS",
            project_map={
                shared_project_id: compute_v1.ShareSettingsProjectConfig(
                    project_id=shared_project_id
                )
            },
        ),
    )

    # Create a client
    client = compute_v1.ReservationsClient()

    operation = client.insert(
        project=project_id,
        zone=zone,
        reservation_resource=reservation,
    )
    wait_for_extended_operation(operation, "Reservation creation")

    reservation = client.get(
        project=project_id, zone=zone, reservation=reservation_name
    )
    shared_project = next(iter(reservation.share_settings.project_map.values()))

    print("Name: ", reservation.name)
    print("STATUS: ", reservation.status)
    print("SHARED PROJECT: ", shared_project)
    # Example response:
    # Name:  your-reservation-name
    # STATUS:  READY
    # SHARED PROJECT:  project_id: "123456789012"

    return reservation

REST

כדי ליצור הזמנה משותפת, שולחים בקשת POST ל-method‏ reservations.insert. בגוף הבקשה, כוללים את הפרטים הבאים:

  • השדה projectMap.

  • השדה shareType מוגדר ל-SPECIFIC_PROJECTS.

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  }
}

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

  • ‫PROJECT_ID: מזהה הפרויקט שבו רוצים לשריין משאבים ושבו קיימת תבנית של הגדרות מכונה.

  • ‫ZONE: האזור שבו רוצים לשריין משאבים.

  • ‫RESERVATION_NAME: השם של ההזמנה שרוצים ליצור.

  • ‫CONSUMER_PROJECT_ID_1 ו-CONSUMER_PROJECT_ID_2: מזהי הפרויקטים שיכולים להשתמש בהזמנה הזו. אפשר לכלול עד 100 פרויקטים לצרכן. הפרויקטים האלה צריכים להיות באותו ארגון כמו הפרויקט של הבעלים. לא כוללים את פרויקט הבעלים. כברירת מחדל, כבר מותר להשתמש במשאבים שהוקצו מראש.

  • ‫NUMBER_OF_VMS: מספר המכונות הווירטואליות שרוצים לשמור.

  • ‫INSTANCE_TEMPLATE_URL: כתובת ה-URL של תבנית של הגדרות מכונה קיימת, שחייבת להיות קיימת בפרויקט. מציינים אחד מהערכים הבאים:

    • לתבנית של הגדרות מכונה אזורית: projects/PROJECT_ID/regions/REGION/instanceTemplates/INSTANCE_TEMPLATE_NAME

    • לתבנית גלובלית של הגדרות מכונה: INSTANCE_TEMPLATE_NAME

לדוגמה, כדי ליצור מקום שמור ל-10 מכונות וירטואליות באזור us-central1-a באמצעות ציון תבנית גלובלית של הגדרות מכונה, ולשתף את המקום השמור עם הפרויקטים project-1 ו-project-2, שולחים את בקשת ה-POST הבאה:

POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations

{
  "name": "my-reservation",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "project-1": {
        "projectId": "project-1"
      },
      "project-2": {
        "projectId": "project-2"
      }
    }
  },
  "specificReservation": {
    "count": "10",
    "sourceInstanceTemplate": "example-instance-template"
  }
}

אפשר גם לבצע אחת או יותר מהפעולות הבאות:

  • כדי לציין שרק מכונות וירטואליות שמיועדות ספציפית לשריין הזה יכולות להשתמש בו, צריך לכלול את השדה specificReservationRequired בגוף הבקשה ולהגדיר את השדה ל-true.

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

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  },
  "specificReservationRequired": true
}

  • כדי לאפשר למשימות אימון בהתאמה אישית או למשימות חיזוי ב-Vertex AI להשתמש במכונות וירטואליות של GPU שהוקצו, צריך לכלול את השדה serviceShareType ולהגדיר אותו לערך ALLOW_ALL.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "reservationSharingPolicy": {
    "serviceShareType": "ALLOW_ALL"
  },
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  }
}

  • כדי לאפשר ל-Compute Engine למחוק אוטומטית את הבקשה לשמירת מקום, בוחרים אחת מהשיטות הבאות:

    • כדי למחוק את הבקשה לשמירת מקום בתאריך ובשעה מסוימים, שולחים בקשת POST אל ה-method‏ beta.reservations.insert. בגוף הבקשה, כוללים את השדה deleteAtTime.

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

      POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAtTime": "DELETE_AT_TIME",
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  }
}

      מחליפים את DELETE_AT_TIME בתאריך ובשעה בפורמט של חותמת זמן RFC 3339, שצריך להיות כזה:

      YYYY-MM-DDTHH:MM:SSOFFSET

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

      • ‫YYYY-MM-DD: תאריך בפורמט של שנה בת 4 ספרות, חודש בן 2 ספרות ויום בחודש בן 2 ספרות, מופרדים במקפים (-).

      • ‫HH:MM:SS: שעה בפורמט של 2 ספרות (בפורמט של 24 שעות), דקות בפורמט של 2 ספרות ושניות בפורמט של 2 ספרות, מופרדות בנקודתיים (:).

      • ‫OFFSET: אזור הזמן בפורמט של היסט מהזמן האוניברסלי המתואם (UTC). לדוגמה, כדי להשתמש בשעון החוף המערבי (PST), מציינים -08:00. לחלופין, כדי לא להשתמש בהזחה, מציינים Z.

    • כדי למחוק את ההזמנה אחרי פרק זמן מסוים, שולחים POST בקשה אל ה-method‏ beta.reservations.insert. בגוף הבקשה, כוללים את השדה deleteAfterDuration.

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

      POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAfterDuration": {
    "seconds": "DELETE_AFTER_DURATION"
  },
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  }
}

      מחליפים את DELETE_AFTER_DURATION במשך הזמן בשניות. לדוגמה, מציינים 86400 ל-86,400 שניות (יום אחד).

ציון מכונה וירטואלית קיימת

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

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

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

  1. פותחים את הדף Reservations במסוף Google Cloud .

    כניסה לדף Reservations

  2. לוחצים על Create reservation (יצירת בקשה לשמירת מקום). ייפתח הדף Create a reservation.

  3. בשדה Name, נותנים שם לבקשה.

  4. ברשימות Region ו-Zone, בוחרים את האזור והתחום שבהם רוצים לשריין את המשאבים.

  5. בקטע Share type (סוג השיתוף):

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

    2. לוחצים על Add projects ובוחרים את הפרויקטים מהארגון של הפרויקט הנוכחי שאיתם רוצים לשתף את ההזמנה. אפשר לבחור עד 100 פרויקטים לצרכנים.

  6. אופציונלי: כדי לאפשר למשימות אימון בהתאמה אישית או למשימות חיזוי ב-Vertex AI להשתמש בשמירת מקום למכונות וירטואליות של GPU, בקטע Google Cloud services בוחרים באפשרות Share reservation.

  7. בקטע Use with VM instance, בוחרים באחת מהאפשרויות הבאות:

    • כדי להשתמש אוטומטית במכונות וירטואליות שמתאימות לפרטי הבקשה, מסמנים את האפשרות Use reservation automatically.

    • כדי להשתמש במשאבים שמתאימים לפרטי הבקשה רק כשיוצרים מכונות וירטואליות שמיועדות ספציפית אליה (לפי שם), בוחרים באפשרות Select specific reservation.

  8. בקטע Resource details (פרטי המשאב), מבצעים את הפעולות הבאות:

    • בשדה Number of VM instances מקלידים את מספר המכונות הווירטואליות שרוצים לשריין.

    • כדי לציין את ההגדרות של המכונות הווירטואליות באמצעות מכונה וירטואלית להשוואה, בוחרים באפשרות Use existing VM ואז בוחרים את המכונה הווירטואלית מהרשימה שמופיעה.

  9. בקטע Auto-delete, אפשר להפעיל את אפשרות המחיקה האוטומטית כדי ש-Compute Engine ימחק אוטומטית את הבקשה לשמירת מקום בתאריך ובשעה ספציפיים. מתי זה שימושי? למשל כשמתכננים להפסיק את השימוש במשאבים ששוריינו ורוצים למנוע חיובים לא נחוצים.

  10. לוחצים על Create כדי ליצור את הבקשה לשמירת מקום. ייפתח הדף Reservations. יכולות לעבור עד דקה עד שהבקשה תיווצר. כדי לראות מתי הבקשה תיווצר ב-Compute Engine, אתם יכולים לפתוח את רשימת הבקשות לשמירת מקום.

ציון מאפיינים ישירות

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

המסוף

  1. פותחים את הדף Reservations במסוף Google Cloud .

    כניסה לדף Reservations

  2. לוחצים על Create reservation. ייפתח הדף Create a reservation.

  3. בשדה Name, נותנים שם לבקשה.

  4. ברשימות Region ו-Zone, בוחרים את האזור והתחום שבהם רוצים לשריין את המשאבים.

  5. בקטע Share type (סוג השיתוף):

    1. כדי לשתף את ההזמנה עם פרויקטים אחרים, בוחרים באפשרות Shared.

    2. לוחצים על Add projects (הוספת פרויקטים) ובוחרים את הפרויקטים מהארגון של הפרויקט הנוכחי שרוצים לשתף איתם את השריין. אפשר לבחור עד 100 פרויקטים לצרכנים.

  6. אופציונלי: כדי לאפשר למשימות אימון בהתאמה אישית או למשימות חיזוי ב-Vertex AI להשתמש בשמירת מקום למכונות וירטואליות של GPU, בקטע Google Cloud services בוחרים באפשרות Share reservation.

  7. בקטע Use with VM instance, בוחרים אחת מהאפשרויות הבאות:

    • כדי להשתמש אוטומטית במכונות וירטואליות שמתאימות לפרטי הבקשה, מסמנים את האפשרות Use reservation automatically.

    • כדי להשתמש במשאבים שמתאימים לפרטי הבקשה רק כשיוצרים מכונות וירטואליות שמיועדות ספציפית אליה (לפי שם), בוחרים באפשרות Select specific reservation.

  8. בקטע Resource details (פרטי המשאב), מבצעים את הפעולות הבאות:

    • בשדה Number of VM instances, כותבים כמה מכונות וירטואליות רוצים לשריין.

    • מציינים את סדרת המכונות ואת סוג המכונה שרוצים לשמור.

  9. בקטע Auto-delete, אפשר להפעיל את אפשרות המחיקה האוטומטית כדי ש-Compute Engine ימחק אוטומטית את הבקשה לשמירת מקום בתאריך ובשעה ספציפיים. מתי זה שימושי? למשל כשמתכננים להפסיק את השימוש במשאבים ששוריינו ורוצים למנוע חיובים לא נחוצים.

  10. לוחצים על Create כדי ליצור את הבקשה לשמירת מקום. ייפתח הדף Reservations. הבקשה תיווצר תוך כדקה. כדי לראות מתי הבקשה תיווצר ב-Compute Engine, אתם יכולים לפתוח את רשימת הבקשות לשמירת מקום.

gcloud

כדי ליצור הקצאת מקום משותפת, משתמשים בפקודה gcloud compute reservations create עם הדגלים --share-setting=projects ו---share-with.

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

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

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

  • ‫RESERVATION_NAME: השם של ההזמנה שרוצים ליצור.

  • ‫MACHINE_TYPE: סוג המכונה לשימוש בכל מכונה וירטואלית.

  • ‫CONSUMER_PROJECT_IDS: רשימה מופרדת בפסיקים של מזהי הפרויקטים שיכולים להשתמש בהזמנה הזו – לדוגמה, project-1,project-2. אפשר לכלול עד 100 פרויקטים לצרכנים. הפרויקטים האלה צריכים להיות באותו ארגון כמו פרויקט הבעלים. לא כוללים את פרויקט הבעלים. כברירת מחדל, כבר יש הרשאה להשתמש בהזמנה.

  • ‫NUMBER_OF_VMS: מספר המכונות הווירטואליות שרוצים לשריין.

  • ‫ZONE: האזור שבו רוצים לשריין משאבים.

לדוגמה, כדי ליצור מקום שמור באזור us-central1-a ל-10 מכונות וירטואליות שכל אחת מהן משתמשת במכונה עם קונפיגורציה מוגדרת (predefined) מסוג N2 עם 4 vCPU, ולשתף את המקום השמור עם הפרויקטים project-1 ו-project-2, מריצים את הפקודה הבאה:

gcloud compute reservations create my-reservation \
    --machine-type=n2-standard-4 \
    --share-setting=projects \
    --share-with=project-1,project-2 \
    --vm-count=10 \
    --zone=us-central1-a

אפשר גם לבצע אחת או יותר מהפעולות הבאות:

  • כדי לצרף יחידות GPU למכונות וירטואליות מסוג N1 שהוזמנו, צריך לכלול את הדגל --accelerator.

    gcloud compute reservations create RESERVATION_NAME \
    --accelerator=count=NUMBER_OF_ACCELERATORS,type=ACCELERATOR_TYPE
    --machine-type=MACHINE_TYPE \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

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

  • כדי לצרף דיסקים מסוג Local SSD לסוג מכונה שלא כולל דיסקים מסוג Local SSD כברירת מחדל, צריך לכלול את הדגל --local-ssd. אפשר לצרף רק דיסקים מסוג Local SSD בנפח של 375GB.

    gcloud compute reservations create RESERVATION_NAME \
    --local-ssd=count=NUMBER_OF_LOCAL_SSD_DISKS,size=375,interface=INTERFACE_TYPE \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

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

    • ‫NUMBER_OF_LOCAL_SSD_DISKS: מספר דיסקי ה-SSD המקומיים לצירוף.

    • ‫INTERFACE_TYPE: סוג ממשק הדיסק שבו רוצים להשתמש בכל דיסק SSD מקומי, ושסוג המכונה שצוין תומך בו. מציינים אחד מהערכים הבאים:

      • לממשק הדיסק NVME: ‏nvme

      • לממשק דיסק SCSI: ‏ scsi

  • כדי שהמכונות הווירטואליות השמורות ישתמשו בפלטפורמת CPU מינימלית ספציפית במקום בפלטפורמת המעבד שמוגדרת כברירת מחדל באזור, צריך לכלול את הדגל --min-cpu-platform.

    gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --min-cpu-platform="MIN_CPU_PLATFORM" \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

    מחליפים את MIN_CPU_PLATFORM בפלטפורמת CPU מינימלית. כדי לוודא שפלטפורמת מעבד זמינה באזור שבו אתם מזמינים משאבים, אפשר לראות את פלטפורמות המעבד הזמינות לפי אזור.

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

    gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --require-specific-reservation \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

  • כדי לאפשר למשימות אימון בהתאמה אישית או למשימות חיזוי ב-Vertex AI להשתמש במכונות וירטואליות של GPU ששמורות, צריך להוסיף את הדגל --reservation-sharing-policy עם הערך ALLOW_ALL.

    gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --reservation-sharing-policy=ALLOW_ALL \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

  • כדי לאפשר ל-Compute Engine למחוק אוטומטית את הבקשה לשמירת מקום, בוחרים באחת מהשיטות הבאות:

    • כדי למחוק את הבקשה לשמירת מקום בתאריך ובשעה ספציפיים, משתמשים בפקודה gcloud beta compute reservations create עם הדגל --delete-at-time.

      gcloud beta compute reservations create RESERVATION_NAME \
    --delete-at-time=DELETE_AT_TIME \
    --machine-type=MACHINE_TYPE \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

      מחליפים את DELETE_AT_TIME בתאריך ובשעה בפורמט של חותמת זמן RFC 3339, שצריכה להיות ככה:

      YYYY-MM-DDTHH:MM:SSOFFSET

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

      • ‫YYYY-MM-DD: תאריך בפורמט של שנה בת 4 ספרות, חודש בן 2 ספרות ויום בחודש בן 2 ספרות, מופרדים במקפים (-).

      • ‫HH:MM:SS: שעה בפורמט של שעה בת 2 ספרות בשיטת 24 שעות, דקות בנות 2 ספרות ושניות בנות 2 ספרות, מופרדות באמצעות נקודתיים (:).

      • ‫OFFSET: אזור הזמן בפורמט של היסט מהזמן האוניברסלי המתואם (UTC). לדוגמה, כדי להשתמש בשעון החוף המערבי (PST), מציינים את הערך -08:00. לחלופין, כדי לא להשתמש בהזחה, מציינים Z.

    • כדי למחוק את ההזמנה אחרי משך זמן מסוים, משתמשים בפקודה gcloud beta compute reservations create עם הדגל --delete-after-duration.

      gcloud beta compute reservations create RESERVATION_NAME \
    --delete-after-duration=DELETE_AFTER_DURATION \
    --machine-type=MACHINE_TYPE \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

      מחליפים את DELETE_AFTER_DURATION במשך זמן בימים, בשעות, בדקות או בשניות. לדוגמה, מציינים 30m ל-30 דקות, או 1d2h3m4s ליום אחד, שעתיים, 3 דקות ו-4 שניות.

Terraform

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

  • מגדירים את השדה share_type לערך SPECIFIC_PROJECTS.
  • בבלוק project_map, מציינים את מזהי הפרויקטים של הפרויקטים שרוצים לשתף איתם את ההזמנה הזו.

מידע נוסף על השימוש ב-Terraform זמין במאמר שימוש ב-Terraform עם Google Cloud.

REST

כדי ליצור בקשה לשמירת מקום משותפת, שולחים בקשת POST אל ה-method‏ reservations.insert. בגוף הבקשה, כוללים את הפרטים הבאים:

  • השדה projectMap.

  • השדה shareType מוגדר ל-SPECIFIC_PROJECTS.

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

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

  • ‫PROJECT_ID: מזהה הפרויקט שבו רוצים לשריין משאבים.

  • ‫ZONE: האזור שבו רוצים לשמור את המשאבים.

  • ‫RESERVATION_NAME: השם של ההזמנה שרוצים ליצור.

  • ‫CONSUMER_PROJECT_ID_1 ו-CONSUMER_PROJECT_ID_2: מזהי הפרויקטים שיכולים להשתמש בהזמנה הזו. אפשר לכלול עד 100 פרויקטים לצרכן. הפרויקטים האלה צריכים להיות באותו ארגון כמו פרויקט הבעלים. לא כוללים את פרויקט הבעלים. כברירת מחדל, כבר מותר להשתמש בהזמנה.

  • ‫NUMBER_OF_VMS: מספר המכונות הווירטואליות שרוצים לשמור.

  • ‫MACHINE_TYPE: סוג המכונה לשימוש בכל מכונה וירטואלית.

לדוגמה, כדי ליצור מקום שמור על ידי ציון תבנית של הגדרות מכונה גלובלית בתחום (zone) us-central1-a, לשתף את המקום השמור עם הפרויקטים project-1 ו-project-2, ולהזמין עשר מכונות וירטואליות שכל אחת מהן משתמשת במכונה עם קונפיגורציה מוגדרת (predefined) מסוג N2 עם 4 vCPU, שולחים את הבקשה הבאה POST:

POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations

{
  "name": "my-reservation",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "project-1": {
        "projectId": "project-1"
      },
      "project-2": {
        "projectId": "project-2"
      }
    }
  },
  "specificReservation": {
    "count": "10",
    "instanceProperties": {
      "machineType": "n2-standard-4",
    }
  }
}

אפשר גם לבצע אחת או יותר מהפעולות הבאות:

  • כדי לצרף יחידות GPU למכונות וירטואליות מסוג N1 שהוזמנו, צריך לכלול את השדה guestAccelerators בגוף הבקשה.

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

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "guestAccelerators": [
        {
          "acceleratorCount": NUMBER_OF_ACCELERATORS,
          "acceleratorType": "ACCELERATOR_TYPE"
        }
      ],
      "machineType": "MACHINE_TYPE"
    }
  }
}

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

  • כדי לצרף דיסקים מסוג SSD מקומי לסוג מכונה שלא כולל דיסקים מסוג SSD מקומי כברירת מחדל, צריך לכלול את השדה localSsds בגוף הבקשה. אפשר לצרף רק דיסקים מקומיים מסוג SSD בנפח של 375 GB.

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

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "localSsds": [
        {
          "diskSizeGb": "375",
          "interface": "INTERFACE_TYPE"
        },
        {
          "diskSizeGb": "375",
          "interface": "INTERFACE_TYPE"
        }
      ],
      "machineType": "MACHINE_TYPE"
    }
  }
}

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

    • לממשק הדיסק NVME: ‏ NVME

    • לממשק דיסק SCSI: ‏ SCSI

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

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

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE",
      "minCpuPlatform": "MIN_CPU_PLATFORM"
    }
  }
}

    מחליפים את MIN_CPU_PLATFORM בפלטפורמת CPU מינימלית. כדי לוודא שפלטפורמת מעבד זמינה באזור שבו אתם מזמינים משאבים, אפשר לראות את פלטפורמות המעבד הזמינות לפי אזור.

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

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

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  },
  "specificReservationRequired": true
}

  • כדי לאפשר למשימות אימון בהתאמה אישית או למשימות חיזוי ב-Vertex AI להשתמש בשמירת מקום למכונות וירטואליות של GPU, צריך לכלול את השדה serviceShareType ולהגדיר אותו לערך ALLOW_ALL.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "reservationSharingPolicy": {
    "serviceShareType": "ALLOW_ALL"
  },
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

  • כדי לאפשר ל-Compute Engine למחוק אוטומטית את הבקשה לשמירת מקום, בוחרים אחת מהשיטות הבאות:

    • כדי למחוק את הבקשה לשמירת מקום בתאריך ובשעה מסוימים, שולחים בקשת POST אל ה-method‏ beta.reservations.insert. בגוף הבקשה, כוללים את השדה deleteAtTime.

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

      POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAtTime": "DELETE_AT_TIME",
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

      מחליפים את DELETE_AT_TIME בתאריך ובשעה בפורמט של חותמת זמן RFC 3339, שצריכה להיות ככה:

      YYYY-MM-DDTHH:MM:SSOFFSET

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

      • ‫YYYY-MM-DD: תאריך בפורמט של שנה בת 4 ספרות, חודש בן 2 ספרות ויום בחודש בן 2 ספרות, מופרדים במקפים (-).

      • ‫HH:MM:SS: שעה בפורמט של שעה בת 2 ספרות בשיטת 24 שעות, דקות בנות 2 ספרות ושניות בנות 2 ספרות, מופרדות באמצעות נקודתיים (:).

      • ‫OFFSET: אזור הזמן בפורמט של היסט מזמן אוניברסלי מתואם (UTC). לדוגמה, כדי להשתמש בשעון החוף המערבי (PST), מציינים -08:00. לחלופין, כדי לא להשתמש בהיסט, מציינים Z.

    • כדי למחוק את ההזמנה אחרי פרק זמן מסוים, שולחים POST בקשה אל ה-method‏ beta.reservations.insert. בגוף הבקשה, כוללים את השדה deleteAfterDuration.

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

      POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAfterDuration": {
    "seconds": "DELETE_AFTER_DURATION"
  },
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

      מחליפים את DELETE_AFTER_DURATION במשך זמן בשניות. לדוגמה, מציינים 86400 ל-86,400 שניות (יום אחד).

פתרון בעיות

איך פותרים בעיות ביצירת הזמנות

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