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

המסוף

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

   כניסה לדף Reservations

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

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

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

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

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

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

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

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

   • כדי להשתמש אוטומטית במכונות וירטואליות שמתאימות לפרטי הבקשה, מסמנים את האפשרות 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

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

   כניסה לדף Reservations

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

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

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

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

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

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

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

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

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

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

  • ‫NUMBER_OF_ACCELERATORS: מספר יחידות ה-GPU שרוצים להוסיף לכל מכונה וירטואלית (VM) שהוזמנה.

  • ‫ACCELERATOR_TYPE: דגם GPU נתמך למכונות וירטואליות מסוג N1. מוודאים שדגם ה-GPU שבחרתם זמין בתחום שבו אתם רוצים לשריין משאבים. אחרת, יצירת ההזמנה תיכשל.

• כדי לצרף דיסקים של SSD מקומיים לסוג מכונה שלא כולל דיסקים של 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

• כדי שמכונות ה-VM השמורות ישתמשו בפלטפורמת CPU מינימלית ספציפית במקום בפלטפורמת ה-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 זמינה באזור שבו אתם מזמינים משאבים, אפשר לראות את פלטפורמות ה-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 עם Cloud de Confiance by S3NS.

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 לכל מכונה וירטואלית מסוג 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"
      }
    }
  }
  

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

  • ‫NUMBER_OF_ACCELERATORS: מספר יחידות ה-GPU שרוצים להוסיף לכל מכונה וירטואלית (VM) שהוזמנה.

  • ‫ACCELERATOR_TYPE: דגם GPU נתמך למכונות וירטואליות מסוג N1. מוודאים שדגם ה-GPU שבחרתם זמין בתחום שבו אתם רוצים לשריין משאבים. אחרת, יצירת ההזמנה תיכשל.

• כדי לצרף דיסקים של 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

• כדי שמכונות ה-VM השמורות ישתמשו בפלטפורמת 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 זמינה באזור שבו אתם מזמינים משאבים, אפשר לראות את פלטפורמות ה-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בקשה לשיטה 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 בקשה לשיטה 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 שניות (יום אחד).