‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

יצירת מכונה מקובץ אימג' בהתאמה אישית

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

מופע מכיל bootloader, מערכת קבצים של אתחול וקובץ אימג' של מערכת ההפעלה. אתם יכולים ליצור תמונות בהתאמה אישית מדיסקים, תמונות, תמונות מצב או תמונות שמאוחסנות ב-Cloud Storage, ולהשתמש בתמונות האלה כדי ליצור מכונות וירטואליות. כברירת מחדל, תמונה בהתאמה אישית שייכת רק לפרויקט שבו היא נוצרה.

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

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

כשמשתמשים במסוף Google Cloud כדי לגשת לשירותים Google Cloud ולממשקי ה-API, לא צריך להגדיר אימות.
gcloud
1. התקינו את ה-CLI של Google Cloud. אחר כך, מאתחלים את ה-CLI של Google Cloud באמצעות הפקודה הבאה:
  gcloud init
  אם אתם משתמשים בספק זהויות חיצוני (IdP), קודם אתם צריכים להיכנס ל-CLI של gcloud באמצעות המאגר המאוחד לניהול זהויות.
  
  הערה: אם התקנתם את ה-CLI של gcloud, השתמשו בפקודה gcloud components update כדי לבדוק אם הגרסה העדכנית מותקנת.
הגדרת אזור ותחום כברירת מחדל

REST

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

התקינו את ה-CLI של Google Cloud.

אם אתם משתמשים בספק זהויות חיצוני (IdP), קודם אתם צריכים להיכנס ל-CLI של gcloud באמצעות המאגר המאוחד לניהול זהויות.

מידע נוסף מופיע במאמר אימות לשימוש ב-REST במסמכי האימות של Google Cloud .

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

כדי לקבל את ההרשאות שנדרשות ליצירת מכונה מתמונה בהתאמה אישית, צריך לבקש מהאדמין להקצות לכם ב-IAM את התפקיד אדמין מכונות של Compute ‏ (v1) (roles/compute.instanceAdmin.v1) בפרויקט. כדי לקרוא הסבר על מתן תפקידים, ראו איך מנהלים את הגישה ברמת הפרויקט, התיקייה והארגון.

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

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

כדי ליצור מכונה מאימג' בהתאמה אישית, צריך את ההרשאות הבאות:

‫compute.instances.create בפרויקט
כדי להשתמש באימג' בהתאמה אישית ליצירת המכונה: compute.images.useReadOnly באימג'

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

יצירת מכונה מקובץ אימג' בהתאמה אישית

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

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

המסוף

נכנסים לדף Create an instance במסוף Google Cloud .

כניסה לדף Create an instance

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

הדף Create an instance מופיע ובו החלונית Machine configuration.
בחלונית Machine configuration:
1. בשדה Name (שם), מציינים שם למופע. מידע נוסף זמין במאמר מוסכמות למתן שמות למשאבים.
2. אופציונלי: בשדה Zone, בוחרים תחום למכונה הזו.
  
  ברירת המחדל היא Any (כל). אם לא תשנו את ברירת המחדל, Google תבחר בשבילכם אזור באופן אוטומטי על סמך סוג המכונה והזמינות שלה.
3. בוחרים את משפחת המכונות של המופע. ב Google Cloud מסוף יוצגו סדרות המכונות שזמינות למשפחת המכונות שבחרתם. אלו האפשרויות הזמינות למשפחות מכונות:
  - לשימוש כללי
  - אופטימיזציה של מחשוב
  - אופטימיזציה של הזיכרון
  - אופטימיזציה של האחסון
  - אופטימיזציה של הרשת
  - ‫GPUs
  - TPUs
4. בעמודה סדרה, בוחרים את סדרת המכונות של המופע.
  
  אם בחרתם באפשרות GPUs כמשפחת המכונות בשלב הקודם, עכשיו בוחרים את סוג ה-GPU הרצוי. סדרת המכונות נבחרת אוטומטית לפי סוג ה-GPU שנבחר.
5. בקטע Machine type, בוחרים את סוג המכונה עבור המופע.
בתפריט הניווט, לוחצים על מערכת הפעלה ואחסון. בחלונית Operating system and storage שמופיעה, מגדירים את דיסק האתחול באופן הבא:
1. לוחצים על Change. מופיעה החלונית דיסק אתחול עם הכרטיסייה Public images.
2. לוחצים על תמונות בהתאמה אישית. מופיעה הכרטיסייה תמונות מותאמות אישית.
3. כדי לבחור את פרויקט התמונה, לוחצים על Change ואז בוחרים את הפרויקט שמכיל את התמונה.
4. ברשימה Image, בוחרים את התמונה שרוצים לייבא.
5. ברשימה Boot disk type בוחרים את סוג דיסק האתחול.
6. בשדה Size (GB), מציינים את הגודל של דיסק האתחול.
7. אופציונלי: לדיסקים של מערכת ההפעלה מסוג Hyperdisk Balanced, מציינים ערכים בשדות Provisioned IOPS ו-Provisioned throughput.
8. אופציונלי: כדי לראות אפשרויות הגדרה מתקדמות, מרחיבים את הקטע Show advanced configurations.
9. כדי לאשר את האפשרויות של דיסק האתחול ולחזור לחלונית מערכת ההפעלה והאחסון, לוחצים על בחירה.
בתפריט הניווט, לוחצים על Networking (רשת). בחלונית Networking שמופיעה, מבצעים את הפעולות הבאות:
1. עוברים לקטע Firewall.
2. כדי לאפשר תעבורת HTTP או HTTPS למופע, בוחרים באפשרות Allow HTTP traffic או Allow HTTPS traffic.
  
  ‫Compute Engine מוסיף תג רשת למופע ויוצר את כלל חומת האש המתאים לתעבורת נתונים נכנסת, שמאפשר את כל התעבורה הנכנסת ב-tcp:80 (HTTP) או ב-tcp:443 (HTTPS). תג הרשת משייך את כלל חומת האש למופע. מידע נוסף זמין בסקירה הכללית של הכללים של חומת האש במאמרי העזרה של Cloud Next Generation Firewall.
אופציונלי: מציינים אפשרויות הגדרה אחרות. מידע נוסף מופיע במאמר אפשרויות הגדרה במהלך יצירת מכונה.
כדי ליצור את המכונה ולהפעיל אותה, לוחצים על Create.

gcloud

במסוף Google Cloud , מפעילים את Cloud Shell.

הפעלת Cloud Shell

בחלק התחתון של Google Cloud המסוף יתחיל סשן של Cloud Shell ותופיע הודעה של שורת הפקודה. Cloud Shell היא סביבת מעטפת שבה ה-CLI של Google Cloud מותקן ומוגדרים ערכים לפרויקט הקיים. הסשן יופעל תוך כמה שניות.
מריצים את הפקודה gcloud compute instances create כדי ליצור מכונה עם אימג' בהתאמה אישית:
```
gcloud compute instances create VM_NAME \
    --image-project IMAGE_PROJECT \
    IMAGE_FLAG \
    --subnet SUBNET \
    --zone ZONE
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫VM_NAME: השם של ה-VM
- ‫IMAGE_PROJECT: המזהה של Google Cloud הפרויקט שמכיל את התמונה
- ‫IMAGE_FLAG: מציינים אחת מהאפשרויות הבאות:
  - משתמשים בדגל --image IMAGE_NAME כדי לציין תמונה בהתאמה אישית.
    לדוגמה, --image my-debian-image-v2.
  - אם יצרתם את התמונות המותאמות אישית כחלק ממשפחת תמונות מותאמות אישית, צריך להשתמש בדגל --image-family IMAGE_FAMILY_NAME כדי לציין את משפחת התמונות המותאמות אישית.
    הפעולה הזו יוצרת את המכונה הווירטואלית מהתמונה העדכנית ביותר של מערכת ההפעלה ומהגרסה העדכנית ביותר של מערכת ההפעלה במשפחת התמונות המותאמות אישית. לדוגמה, אם מציינים --image-family my-debian-family,‏ Compute Engine יוצר מכונה וירטואלית מתמונת מערכת ההפעלה העדכנית ביותר במשפחת התמונות המותאמת אישית my-debian-family.
  הערה: אם לא מציינים תמונה, למשל debian-10 ו-debian-cloud, ‏ Compute Engine משתמש במשפחת התמונות ובפרויקט שמוגדרים כברירת מחדל.
- ‫SUBNET: אם רשת המשנה והמופע נמצאים באותו פרויקט, מחליפים את SUBNET בשם של רשת משנה שנמצאת באותו אזור כמו המופע.
- ‫ZONE: האזור של המכונה הווירטואלית

Terraform

כדי ליצור את קוד Terraform, אפשר להשתמש ברכיב Equivalent code במסוף Google Cloud .

נכנסים לדף VM instances במסוף Google Cloud .
לדף VM Instances
לוחצים על Create instance.
מציינים את הפרמטרים הרצויים.
בחלק העליון או התחתון של הדף, לוחצים על קוד מקביל ואז על הכרטיסייה Terraform כדי לראות את קוד Terraform.

המשך

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

כדי לבצע אימות ב-Compute Engine, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

import (
	"context"
	"fmt"
	"io"

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

// createInstanceFromCustomImage creates a new VM instance with custom image used as its boot disk.
func createInstanceFromCustomImage(w io.Writer, projectID, zone, instanceName, customImageLink string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// customImageLink := "projects/project_name/global/images/image_name"

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: proto.String(customImageLink),
						DiskType:    proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String("global/networks/default"),
				},
			},
		},
	}

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

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

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

	return nil
}

Java

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

כדי לבצע אימות ב-Compute Engine, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDisk.Type;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.Image;
import com.google.cloud.compute.v1.ImagesClient;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.Vector;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstancesAdvanced {

  /**
   * Create an AttachedDisk object to be used in VM instance creation. Uses an image as the source
   * for the new disk.
   *
   * @param diskType the type of disk you want to create. This value uses the following format:
   * "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)". For example:
   * "zones/us-west3-b/diskTypes/pd-ssd"
   * @param diskSizeGb size of the new disk in gigabytes
   * @param boot boolean flag indicating whether this disk should be used as a boot disk of an
   * instance
   * @param sourceImage source image to use when creating this disk. You must have read access to
   * this disk. This can be one of the publicly available images or an image from one of your
   * projects. This value uses the following format:
   * "projects/{project_name}/global/images/{image_name}"
   * @return AttachedDisk object configured to be created using the specified image.
   */
  private static AttachedDisk diskFromImage(String diskType, int diskSizeGb, boolean boot,
      String sourceImage) {
    AttachedDisk disk =
        AttachedDisk.newBuilder()
            .setBoot(boot)
            // Remember to set auto_delete to True if you want the disk to be deleted when
            // you delete your VM instance.
            .setAutoDelete(true)
            .setType(Type.PERSISTENT.toString())
            .setInitializeParams(
                AttachedDiskInitializeParams.newBuilder()
                    .setSourceImage(sourceImage)
                    .setDiskSizeGb(diskSizeGb)
                    .setDiskType(diskType)
                    .build())
            .build();
    return disk;
  }


  /**
   * Send an instance creation request to the Compute Engine API and wait for it to complete.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @param disks a list of compute_v1.AttachedDisk objects describing the disks you want to attach
   * to your new instance.
   * @param machineType machine type of the VM being created. This value uses the following format:
   * "zones/{zone}/machineTypes/{type_name}".
   * For example: "zones/europe-west3-c/machineTypes/f1-micro"
   * @param network name of the network you want the new instance to use. For example:
   * "global/networks/default" represents the network named "default", which is created
   * automatically for each project.
   * @param subnetwork name of the subnetwork you want the new instance to use. This value uses the
   * following format: "regions/{region}/subnetworks/{subnetwork_name}"
   * @return Instance object.
   */
  private static Instance createWithDisks(String project, String zone, String instanceName,
      Vector<AttachedDisk> disks, String machineType, String network, String subnetwork)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    try (InstancesClient instancesClient = InstancesClient.create()) {
      // Use the network interface provided in the networkName argument.
      NetworkInterface networkInterface;
      if (subnetwork != null) {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).setSubnetwork(subnetwork)
            .build();
      } else {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).build();
      }

      machineType = String.format("zones/%s/machineTypes/%s", zone, machineType);

      // Bind `instanceName`, `machineType`, `disk`, and `networkInterface` to an instance.
      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addAllDisks(disks)
              .addNetworkInterfaces(networkInterface)
              .build();

      System.out.printf("Creating instance: %s at %s ", instanceName, zone);

      // Insert the instance in the specified project and zone.
      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstanceResource(instanceResource).build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);

      // Wait for the operation to complete.
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance creation failed ! ! " + response);
        return null;
      }
      System.out.println("Operation Status: " + response.getStatus());

      return instancesClient.get(project, zone, instanceName);
    }
  }

  /**
   * Create a new VM instance with custom image used as its boot disk.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @param customImage link to the custom image you want to use in the form of:
   * "projects/{project_name}/global/images/{image_name}"
   * @return Instance object.
   */
  public static Instance createFromCustomImage(String project, String zone, String instanceName,
      String customImage)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String diskType = String.format("zones/%s/diskTypes/pd-standard", zone);
    Vector<AttachedDisk> disks = new Vector<>();
    disks.add(diskFromImage(diskType, 10, true, customImage));
    return createWithDisks(project, zone, instanceName, disks, "n1-standard-1",
        "global/networks/default", null);
  }

Node.js

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Node.jsהוראות ההגדרה שבמדריך למתחילים של Compute Engine באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של Compute Engine Node.js API.

כדי לבצע אימות ב-Compute Engine, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';
// const customImageLink = 'projects/YOUR_PROJECT/global/images/YOUR_IMAGE_NAME';

const compute = require('@google-cloud/compute');

// Creates a new VM instance with custom image used as its boot disk.
async function createInstanceFromCustomImage() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.insert({
    project: projectId,
    zone,
    instanceResource: {
      name: instanceName,
      disks: [
        {
          initializeParams: {
            diskSizeGb: '10',
            sourceImage: customImageLink,
            diskType: `zones/${zone}/diskTypes/pd-standard`,
          },
          autoDelete: true,
          boot: true,
          type: 'PERSISTENT',
        },
      ],
      machineType: `zones/${zone}/machineTypes/n1-standard-1`,
      networkInterfaces: [
        {
          name: 'global/networks/default',
        },
      ],
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

  console.log('Instance created.');
}

createInstanceFromCustomImage();

Python

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

כדי לבצע אימות ב-Compute Engine, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

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


def get_image_from_family(project: str, family: str) -> compute_v1.Image:
    """
    Retrieve the newest image that is part of a given family in a project.

    Args:
        project: project ID or project number of the Cloud project you want to get image from.
        family: name of the image family you want to get image from.

    Returns:
        An Image object.
    """
    image_client = compute_v1.ImagesClient()
    # List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
    newest_image = image_client.get_from_family(project=project, family=family)
    return newest_image


def disk_from_image(
    disk_type: str,
    disk_size_gb: int,
    boot: bool,
    source_image: str,
    auto_delete: bool = True,
) -> compute_v1.AttachedDisk:
    """
    Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
    source for the new disk.

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        source_image: source image to use when creating this disk. You must have read access to this disk. This can be one
            of the publicly available images or an image from one of your projects.
            This value uses the following format: "projects/{project_name}/global/images/{image_name}"
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created using the specified image.
    """
    boot_disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = source_image
    initialize_params.disk_size_gb = disk_size_gb
    initialize_params.disk_type = disk_type
    boot_disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    boot_disk.auto_delete = auto_delete
    boot_disk.boot = boot
    return boot_disk


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_instance(
    project_id: str,
    zone: str,
    instance_name: str,
    disks: list[compute_v1.AttachedDisk],
    machine_type: str = "n1-standard-1",
    network_link: str = "global/networks/default",
    subnetwork_link: str = None,
    internal_ip: str = None,
    external_access: bool = False,
    external_ipv4: str = None,
    accelerators: list[compute_v1.AcceleratorConfig] = None,
    preemptible: bool = False,
    spot: bool = False,
    instance_termination_action: str = "STOP",
    custom_hostname: str = None,
    delete_protection: bool = False,
) -> compute_v1.Instance:
    """
    Send an instance creation request to the Compute Engine API and wait for it to complete.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new instance.
        machine_type: machine type of the VM being created. This value uses the
            following format: "zones/{zone}/machineTypes/{type_name}".
            For example: "zones/europe-west3-c/machineTypes/f1-micro"
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"
        internal_ip: internal IP address you want to assign to the new instance.
            By default, a free address from the pool of available internal IP addresses of
            used subnet will be used.
        external_access: boolean flag indicating if the instance should have an external IPv4
            address assigned.
        external_ipv4: external IPv4 address to be assigned to this instance. If you specify
            an external IP address, it must live in the same region as the zone of the instance.
            This setting requires `external_access` to be set to True to work.
        accelerators: a list of AcceleratorConfig objects describing the accelerators that will
            be attached to the new instance.
        preemptible: boolean value indicating if the new instance should be preemptible
            or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
        spot: boolean value indicating if the new instance should be a Spot VM or not.
        instance_termination_action: What action should be taken once a Spot VM is terminated.
            Possible values: "STOP", "DELETE"
        custom_hostname: Custom hostname of the new VM instance.
            Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
        delete_protection: boolean value indicating if the new virtual machine should be
            protected against deletion or not.
    Returns:
        Instance object.
    """
    instance_client = compute_v1.InstancesClient()

    # Use the network interface provided in the network_link argument.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network_link
    if subnetwork_link:
        network_interface.subnetwork = subnetwork_link

    if internal_ip:
        network_interface.network_i_p = internal_ip

    if external_access:
        access = compute_v1.AccessConfig()
        access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
        access.name = "External NAT"
        access.network_tier = access.NetworkTier.PREMIUM.name
        if external_ipv4:
            access.nat_i_p = external_ipv4
        network_interface.access_configs = [access]

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    instance.network_interfaces = [network_interface]
    instance.name = instance_name
    instance.disks = disks
    if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
        instance.machine_type = machine_type
    else:
        instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"

    instance.scheduling = compute_v1.Scheduling()
    if accelerators:
        instance.guest_accelerators = accelerators
        instance.scheduling.on_host_maintenance = (
            compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
        )

    if preemptible:
        # Set the preemptible setting
        warnings.warn(
            "Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
        )
        instance.scheduling = compute_v1.Scheduling()
        instance.scheduling.preemptible = True

    if spot:
        # Set the Spot VM setting
        instance.scheduling.provisioning_model = (
            compute_v1.Scheduling.ProvisioningModel.SPOT.name
        )
        instance.scheduling.instance_termination_action = instance_termination_action

    if custom_hostname is not None:
        # Set the custom hostname for the instance
        instance.hostname = custom_hostname

    if delete_protection:
        # Set the delete protection bit
        instance.deletion_protection = True

    # Prepare the request to insert an instance.
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    # Wait for the create operation to complete.
    print(f"Creating the {instance_name} instance in {zone}...")

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

    print(f"Instance {instance_name} created.")
    return instance_client.get(project=project_id, zone=zone, instance=instance_name)


def create_from_custom_image(
    project_id: str, zone: str, instance_name: str, custom_image_link: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with custom image used as its boot disk.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        custom_image_link: link to the custom image you want to use in the form of:
            "projects/{project_name}/global/images/{image_name}"

    Returns:
        Instance object.
    """
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [disk_from_image(disk_type, 10, True, custom_image_link, True)]
    instance = create_instance(project_id, zone, instance_name, disks)
    return instance

REST

תהליך יצירת מכונה עם קובץ אימג' בהתאמה אישית בממשק ה-API זהה לתהליך יצירת מכונה עם קובץ אימג' שזמין לציבור.

כדי ליצור את המכונה מאימג' בהתאמה אישית, משתמשים בmethod‏ instances.insert.

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

{
   "machineType":"zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE",
   "name":"VM_NAME",
   
   "disks":[
      {
         "initializeParams":{
            "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE"
         },
         "boot":true
      }
   ],
   
   
   "networkInterfaces":[
      {
         "network":"global/networks/NETWORK_NAME"
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}

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

‫PROJECT_ID: המזהה של הפרויקט שבו רוצים ליצור את המכונה הווירטואלית
‫ZONE: האזור שבו רוצים ליצור את המכונה הווירטואלית
‫MACHINE_TYPE_ZONE: האזור שמכיל את סוג המכונה שרוצים להשתמש בו למכונה הווירטואלית החדשה
‫MACHINE_TYPE: סוג המכונה, מוגדר מראש או מותאם אישית, של המכונה הווירטואלית החדשה
‫VM_NAME: name of the new VM
‫IMAGE_PROJECT: שם הפרויקט שמכיל את התמונה המותאמת אישית
‫IMAGE: מציינים אחת מהאפשרויות הבאות:
- ‫IMAGE: השם של התמונה המותאמת אישית. לדוגמה: "sourceImage": "projects/my-project-1234/global/images/my-debian-image-v2".
- ‫IMAGE_FAMILY: אם יצרתם את התמונות המותאמות אישית כחלק מקבוצת תמונות מותאמות אישית, צריך לציין את קבוצת התמונות המותאמות אישית הזו.
  כך נוצרת מכונה וירטואלית מהתמונה העדכנית ביותר של מערכת ההפעלה, שלא הוצאה משימוש, במשפחת התמונות המותאמות אישית. לדוגמה, אם מציינים את הערך "sourceImage": "projects/my-project-1234/global/images/family/my-debian-family",‏ Compute Engine יוצר מכונה וירטואלית מהגרסה האחרונה של תמונת מערכת ההפעלה במשפחת תמונות my-debian-family בהתאמה אישית.
‫NETWORK_NAME: רשת ה-VPC שבה רוצים להשתמש עבור מכונת ה-VM. אפשר לציין default כדי להשתמש ברשת ברירת המחדל.
‫ENABLE_SECURE_BOOT: אופציונלי: אם בחרתם תמונה שתומכת בתכונות של מכונה וירטואלית מוגנת,‏ Compute Engine מפעיל כברירת מחדל את מודול הפלטפורמה הווירטואלית המהימנה (vTPM) ואת המעקב אחר השלמות. ב-Compute Engine, האפשרות Secure Boot לא מופעלת כברירת מחדל.

אם מציינים true בשביל enableSecureBoot, ‏ Compute Engine יוצר מכונה וירטואלית עם כל שלושת התכונות של מכונה וירטואלית מוגנת. אחרי שמערכת Compute Engine מפעילה את המכונה הווירטואלית, כדי לשנות את האפשרויות של מכונה וירטואלית מוגנת, צריך להפסיק את המכונה הווירטואלית.

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

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

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

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

המסוף

gcloud

REST

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

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

יצירת מכונה מקובץ אימג' בהתאמה אישית

המסוף

gcloud

Terraform

המשך

Java

Node.js

Python

REST

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

יצירת מכונה מקובץ אימג' בהתאמה אישית