הוספת דיסקים ממאגר Hyperdisk למכונות וירטואליות

במאמר הזה מוסבר איך ליצור דיסקים במאגר.

אתם יכולים ליצור דיסק במאגר ואז לצרף אותו למכונה וירטואלית (VM), או ליצור דיסקים במאגר כשאתם יוצרים מכונה וירטואלית.

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

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

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

כדי לקבל את ההרשאות שדרושות ליצירת דיסק Hyperdisk Balanced או Hyperdisk Throughput במאגר, בקשו מהאדמין להקצות לכם את התפקידים הבאים ב-IAM בפרויקט:

  • אדמין מכונות של Compute ‏(v1) ‏(roles/compute.instanceAdmin.v1)
  • כדי להתחבר למכונה וירטואלית שיכולה לפעול כחשבון שירות: משתמש בחשבון שירות (גרסה 1) (התפקיד roles/iam.serviceAccountUser)

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

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

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

כדי ליצור דיסק מסוג Hyperdisk Balanced או Hyperdisk Throughput במאגר, צריך את ההרשאות הבאות:

  • כדי ליצור דיסקים במאגר ולצרף אותם למכונה וירטואלית:
    • compute.disks.create בפרויקט
    • ‫compute.instances.attachDisk במכונה הווירטואלית
    • compute.disks.use בווליום שרוצים לצרף למכונה הווירטואלית
    • compute.storagePools.use במאגר שבו יוצרים דיסקים
  • כדי לפרמט ולטעון את אמצעי האחסון המצורף: ‫compute.instances.setMetadata במכונה הווירטואלית

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

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

מגבלות

מגבלות על הוספת דיסקים למאגר:

  • אפשר ליצור רק דיסקים מסוג Hyperdisk Balanced במאגר Hyperdisk Balanced, ורק דיסקים מסוג Hyperdisk Throughput במאגר Hyperdisk Throughput.
  • אפשר ליצור במאגר רק דיסקים חדשים באותו פרויקט ובאותו אזור.
  • מאגרים לא תומכים בדיסקים אזוריים.
  • אי אפשר להעביר דיסקים אל מאגר או מחוץ לו, אלא צריך ליצור מחדש את הדיסק מתמונת מצב רגילה. מידע נוסף זמין במאמר שינוי סוג הדיסק.
  • כדי ליצור דיסקים לאתחול במאגר, צריך להשתמש ב-Hyperdisk Balanced Storage Pool או ב-Hyperdisk Balanced Exapool.

מגבלות ספציפיות למאגרי אחסון:

  • אפשר ליצור עד 10,000 דיסקים ב-Storage Pool.

מגבלות ספציפיות ל-Exapools:

  • אפשר ליצור עד 500,000 דיסקים ב-Exapool.

אפשרויות ניהול ההרשאות

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

הקצאת קיבולת דיסק

אם אתם משתמשים ב-Exapool או ב-Storage Pool מתקדם, אתם יכולים ליצור דיסקים ב-Storage Pool בגודל מצטבר שחורג מהקיבולת שהוקצתה ל-Storage Pool. הקיבולת של המאגר שנעשה בה שימוש מוגדרת לפי סך כל הנתונים שבשימוש, ולא לפי נפח האחסון שהקציתם. אתם יכולים להקצות דיסקים עם קיבולת מצטברת של עד פי 5 או פי 50 מהקיבולת שהוקצתה למאגר קיבולת מתקדם או ל-Hyperdisk Exapool, בהתאמה.

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

ביצועי ההקצאה

אם אתם משתמשים ב-Exapool או ב-Storage Pool מתקדם, אתם יכולים ליצור דיסקים במאגר עם כמות מצטברת של IOPS ותפוקה שחורגים מהביצועים שהוקצו למאגר. הביצועים של המאגר שבהם נעשה שימוש מוגדרים לפי סך הביצועים שבהם משתמשים הדיסקים, ולא לפי כמות הביצועים שהוקצו לכל דיסק.

  • ב-Storage Pools, אתם יכולים להקצות דיסקים עם ביצועים מצטברים של עד 500% מהביצועים שהוקצו למאגר Advanced performance.

  • ב-Exapools, אפשר להקצות דיסקים עם ביצועים מצטברים של עד פי 50 מביצועי הכתיבה שהוקצו למאגר.

אם אתם יוצרים דיסקים במאגר ביצועים רגיל, ה-IOPS או קצב הנתונים שאתם מקצים לדיסק חייבים להיות נמוכים מה-IOPS או מקצב הנתונים שזמינים במאגר Hyperdisk Storage Pool. הקצב הזמין של פעולות הקלט/פלט לשנייה או של התפוקה הוא הכמות שהוקצתה למאגר, פחות הכמות שנוצלה בכל הדיסקים שנוצרו במאגר.

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

דוגמה

נניח שיש לכם Hyperdisk Balanced Storage Pool עם 100,000 פעולות IOPS שהוקצו.

עם הקצאת ביצועים רגילה:

  • כשיוצרים דיסקים מסוג Hyperdisk Balanced ב-Storage Pool, אפשר להקצות עד 100,000 פעולות קלט/פלט לשנייה (IOPS) במצטבר.
  • אתם מחויבים על 100,000 פעולות ה-IOPS של הביצועים שהוקצו ל-Hyperdisk Balanced Storage Pool.

  • בדומה לדיסקים שנוצרו מחוץ למאגר אחסון, דיסקים מסוג Hyperdisk Balanced במאגרי אחסון בביצועים רגילים מוקצים באופן אוטומטי עם עד 3,000 פעולות IOPS בסיסיות וקצב העברת נתונים בסיסי של ‎140MiB/s. הביצועים הבסיסיים האלה לא נכללים בביצועים שהוקצו ל-Storage Pool. רק כשמוסיפים דיסקים ל-Storage Pool עם ביצועים שהוקצו שגבוהים מהביצועים הבסיסיים, הם נספרים כחלק מהביצועים שהוקצו ל-Storage Pool. לדוגמה:

    • דיסק שהוקצו לו 3,000 IOPS משתמש ב-0 IOPS של המאגר, ולמאגר עדיין יש 100,000 IOPS שהוקצו וזמינים לדיסקים אחרים.
    • דיסק שהוקצו לו 13,000 IOPS משתמש ב-10,000 IOPS של המאגר, ובמאגר נשארו 90,000 IOPS שהוקצו ואפשר להקצות אותם לדיסקים אחרים ב-Storage Pool.

עם הקצאת ביצועים מתקדמת:

  • כשיוצרים דיסקים ב-Storage Pool, אפשר להקצות עד 500,000 IOPS של ביצועי Hyperdisk מצטברים.
  • אתם מחויבים על 100,000 פעולות IOPS שהוקצו על ידי Storage Pool.
  • אם יוצרים דיסק אחד (Disk1) ב-Storage Pool עם 5,000 IOPS, לא צורכים IOPS מה-IOPS שהוקצו ל-Storage Pool. עם זאת, כמות ה-IOPS שאפשר להקצות לדיסקים חדשים שנוצרו ב-Storage Pool היא עכשיו 495,000.
  • אם Disk1 מתחיל לקרוא ולכתוב נתונים, ומשתמש ב-5,000 IOPS לכל היותר בדקה נתונה, אז 5,000 IOPS נצרכים מ-IOPS שהוקצו ל-Storage Pool. כל דיסק אחר שנוצר באותו Storage Pool יכול להשתמש ב-95,000 IOPS לכל היותר באותה דקה, בלי להיתקל בתחרות על משאבים.

יצירת דיסקים במאגר

אפשר ליצור דיסק במאגר באמצעות מסוף Google Cloud ,‏ Google Cloud CLI או REST.

המסוף

במסוף Google Cloud , אתם יכולים ליצור דיסק חדש במאגר דרך הדף Storage pools או דרך הדף Disks.

בדף Storage pools:

  1. נכנסים לדף Storage pools במסוף Google Cloud .

    נכנסים לדף Storage pools.

  2. לוחצים על הכרטיסייה Exapools או Storage Pools.

  3. לוחצים על שם המאגר שבו רוצים ליצור דיסק.

  4. בדף Manage storage pool, לוחצים על ‎+Create New Disk.

  5. בחלונית Add new disk, מזינים Name לדיסק.

  6. מציינים או משנים את הערכים שאתם לא רוצים להשתמש בהם כברירת מחדל.

  7. כשמסיימים להגדיר את מאפייני הדיסק, לוחצים על Save.

  8. בדף Manage storage pool, הדיסק החדש אמור להופיע בקטע Storage pool disks.

בדף Create Disk:

  1. במסוף Google Cloud , נכנסים לדף Disks > Create a disk.

    כניסה לדף Create a disk

  2. מזינים שם לדיסק.

  3. בוחרים את האזור שבו נמצא המאגר שבו רוצים ליצור את הדיסק.

  4. בשדה Disk type, בוחרים את סוג הדיסק שתואם למאגר, Hyperdisk Throughput או Hyperdisk Balanced.

  5. משנים את הערכים בשדות Size,‏ Provisioned IOPS ו-Provisioned Throughput לפי הצורך.

  6. בקטע Storage pool, בוחרים באפשרות Enable storage pool ובוחרים את שם המאגר שבו רוצים ליצור את הדיסק. ברשימה מופיעים רק מאגרים שקיימים באזור שנבחר.

  7. כשמסיימים להזין את פרטי הדיסק, לוחצים על Create.

gcloud

כדי ליצור דיסק אחד או יותר במאגר, משתמשים בפקודה gcloud compute disks create.

gcloud compute disks create DISK_NAME \
    --zone=ZONE \
    --storage-pool=STORAGE_POOL_NAME \
    --size=SIZE \
    --type=DISK_TYPE \
    --provisioned-iops=PROVISIONED_IOPS \
    --provisioned-throughput=PROVISIONED_THROUGHPUT

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

  • ‫DISK_NAME: שם ייחודי לדיסק. כדי ליצור כמה דיסקים עם אותם מאפיינים, אפשר לספק רשימה של שמות דיסקים שמופרדים ברווחים.
  • ‫ZONE: האזור שבו נוצר המאגר. צריך לציין את הערך הזה בפורמט של אזור-תחום, לדוגמה us-central1-a.
  • ‫STORAGE_POOL_NAME: שם המאגר שבו רוצים ליצור את הדיסק
  • ‫SIZE: אופציונלי: הקיבולת שהוקצתה לדיסק החדש. הערך חייב להיות מספר שלם ואחריו יחידת מידה: GB לגיביבייט או TB לטביבייט. אם לא מציינים גודל, ערך ברירת המחדל הוא 100GB.
  • ‫DISK_TYPE: סוג הדיסק שרוצים ליצור. הסוג צריך להיות זהה לסוג של Hyperdisk Storage Pool, כלומר hyperdisk-balanced או hyperdisk-throughput.
  • ‫PROVISIONED_IOPS: אופציונלי: ה-IOPS להקצאה לדיסק. אפשר להשתמש בדגל הזה רק עם דיסקים מסוג Hyperdisk Balanced.
  • ‫PROVISIONED_THROUGHPUT: אופציונלי: קצב העברת הנתונים ב-MiB לשנייה להקצאה לדיסק.

REST

כדי ליצור דיסק אחד או יותר במאגר, יוצרים POST באמצעות ה-method‏ disks.insert. כוללים את המאפיינים name,‏ sizeGb,‏ type,‏ storagePool,‏ provisionedIops ו-provisionedThroughput. כדי ליצור את הדיסק הזה כדיסק ריק ולא מעוצב שאינו דיסק אתחול, אל תציינו תמונת מקור או קובץ snapshot של מקור.

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

{
    "name": "DISK_NAME",
    "description": "DESCRIPTION",
    "type": "https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/DISK_TYPE",
    "sizeGb": "DISK_SIZE",
    "storagePool": "STORAGE_POOL_NAME",
    "provisionedIops": "IOPS_LIMIT",
    "provisionedThroughput": "THROUGHPUT_LIMIT",
}

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

  • ‫PROJECT_ID: מזהה הפרויקט
  • ‫ZONE: האזור שבו נמצא המאגר, לדוגמה us-central1-a. זה האזור שבו הדיסק ייווצר.
  • ‫DISK_NAME: שם ייחודי לדיסק.
  • ‫DESCRIPTION: אופציונלי: מחרוזת טקסט שמתארת את הדיסק.
  • ‫DISK_TYPE: סוג הדיסק, שחייב להתאים לסוג המאגר. אפשר להשתמש ב-hyperdisk-throughput או ב-hyperdisk-balanced.
  • ‫DISK_SIZE: אופציונלי: הגודל של הדיסק החדש. הערך חייב להיות מספר שלם ואחריו יחידת מידה: GB לגיביבייט או TB לטביבייט. אם לא מציינים גודל, ערך ברירת המחדל הוא 100GB.
  • ‫STORAGE_POOL_NAME: שם המאגר שבו רוצים ליצור את הדיסק.
  • ‫IOPS_LIMIT: אופציונלי: ה-IOPS להקצאה לדיסק. אפשר להשתמש בדגל הזה רק עם דיסקים מסוג Hyperdisk Balanced.
  • ‫THROUGHPUT_LIMIT: אופציונלי: קצב העברת הנתונים ב-MiB לשנייה שיוקצה לדיסק.

המשך 


// createDiskInStoragePool creates a new Hyperdisk in the specified storage pool.
func createDiskInStoragePool(w io.Writer, projectId, zone, diskName, storagePoolName, diskType string) error {
	// Example usage:
	//   projectID := "your_project_id"
	//   zone := "europe-central2-b"
	//   diskName := "your_disk_name"
	//   storagePoolName := "https://www.googleapis.com/compute/v1/projects/your_project_id/zones/europe-central2-b/storagePools/your_storage_pool"
	//   diskType := "zones/europe-central2-b/diskTypes/hyperdisk-balanced"

	ctx := context.Background()
	client, err := compute.NewDisksRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewDisksRESTClient: %v", err)
	}
	defer client.Close()

	// Create the disk resource
	disk := &computepb.Disk{
		Name:                  proto.String(diskName),
		Type:                  proto.String(diskType),
		SizeGb:                proto.Int64(50),
		Zone:                  proto.String(zone),
		StoragePool:           proto.String(storagePoolName),
		ProvisionedIops:       proto.Int64(10000),
		ProvisionedThroughput: proto.Int64(1024),
	}

	// Create the insert disk request
	req := &computepb.InsertDiskRequest{
		Project:      projectId,
		Zone:         zone,
		DiskResource: disk,
	}

	// Send the insert disk request
	op, err := client.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("Insert disk request failed: %v", err)
	}

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

	fmt.Fprintf(w, "Disk created in storage pool: %v\n", disk.Name)
	return nil
}

Java 


import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.InsertDiskRequest;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateDiskInStoragePool {
  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone in which you want to create the disk.
    String zone = "europe-central2-b";
    // Name of the disk you want to create.
    String diskName = "YOUR_DISK_NAME";
    // Link to the storagePool you want to use. Use format :
    // https://www.googleapis.com/compute/v1/projects/%s/zones/%s/storagePools/%s"
    String storagePoolName = "YOUR_STORAGE_POOL_LINK";
    // The type of disk you want to create. This value uses the following format:
    // "zones/{zone}/diskTypes/(hyperdisk-balanced|hyperdisk-throughput)".
    // For example: "zones/us-west3-b/diskTypes/hyperdisk-balanced"
    String diskType = String.format("zones/%s/diskTypes/hyperdisk-balanced", zone);
    // Size of the new disk in gigabytes.
    long diskSizeGb = 10;
    // Optional: the IOPS to provision for the disk.
    // You can use this flag only with Hyperdisk Balanced disks.
    long provisionedIops = 3000;
    // Optional: the throughput in mebibyte (MB) per second to provision for the disk.
    long provisionedThroughput = 140;

    createDiskInStoragePool(projectId, zone, diskName, storagePoolName, diskType,
            diskSizeGb, provisionedIops, provisionedThroughput);
  }

  // Creates a hyperdisk in the storage pool
  public static Disk createDiskInStoragePool(String projectId, String zone, String diskName,
                                             String storagePoolName, String diskType,
                                             long diskSizeGb, long iops, long throughput)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // 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 (DisksClient client = DisksClient.create()) {
      // Create a disk.
      Disk disk = Disk.newBuilder()
              .setZone(zone)
              .setName(diskName)
              .setType(diskType)
              .setSizeGb(diskSizeGb)
              .setStoragePool(storagePoolName)
              .setProvisionedIops(iops)
              .setProvisionedThroughput(throughput)
              .build();

      InsertDiskRequest request = InsertDiskRequest.newBuilder()
              .setProject(projectId)
              .setZone(zone)
              .setDiskResource(disk)
              .build();

      // Wait for the insert disk operation to complete.
      Operation operation = client.insertAsync(request).get(1, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Disk creation failed!");
        throw new Error(operation.getError().toString());
      }

      // Wait for server update
      TimeUnit.SECONDS.sleep(10);

      Disk hyperdisk = client.get(projectId, zone, diskName);

      System.out.printf("Hyperdisk '%s' has been created successfully", hyperdisk.getName());

      return hyperdisk;
    }
  }
}

Node.js 

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

// Instantiate a diskClient
const disksClient = new computeLib.DisksClient();
// Instantiate a zoneOperationsClient
const zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await disksClient.getProjectId();

// The zone where your VM and new disk are located.
// zone = 'us-central1-a';

// The name of the new disk
// diskName = 'disk-from-pool-name';

// The name of the storage pool
// storagePoolName = 'storage-pool-name';

// Link to the storagePool you want to use. Use format:
// https://www.googleapis.com/compute/v1/projects/{projectId}/zones/{zone}/storagePools/{storagePoolName}
const storagePool = `https://www.googleapis.com/compute/v1/projects/${projectId}/zones/${zone}/storagePools/${storagePoolName}`;
// The type of disk. This value uses the following format:
// "zones/{zone}/diskTypes/(hyperdisk-balanced|hyperdisk-extreme|hyperdisk-ml|hyperdisk-throughput)".
// For example: "zones/us-west3-b/diskTypes/hyperdisk-balanced"
const diskType = `zones/${zone}/diskTypes/hyperdisk-balanced`;
// Size of the new disk in gigabytes.
const diskSizeGb = 10;
// Optional: For Hyperdisk Balanced or Hyperdisk Extreme disks,
// this is the number of I/O operations per second (IOPS) that the disk can handle.
const provisionedIops = 3000;
// Optional: For Hyperdisk Balanced or Hyperdisk Throughput volumes,
// this is an integer that represents the throughput,
// measured in MiB per second, that the disk can handle.
const provisionedThroughput = 140;

async function callCreateComputeHyperdiskFromPool() {
  // Create a disk
  const disk = new compute.Disk({
    sizeGb: diskSizeGb,
    name: diskName,
    type: diskType,
    zone,
    storagePool,
    provisionedIops,
    provisionedThroughput,
  });

  const [response] = await disksClient.insert({
    project: projectId,
    zone,
    diskResource: disk,
  });

  let operation = response.latestResponse;

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

  console.log(`Disk: ${diskName} created.`);
}

await callCreateComputeHyperdiskFromPool();

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

יצירת מכונה וירטואלית (VM) שמשתמשת בדיסקים במאגר

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

יצירת דיסק אתחול למכונה וירטואלית במאגר

כדי ליצור VM שמשתמש בדיסק אתחול במאגר, קודם צריך ליצור Hyperdisk Balanced Storage Pool או Hyperdisk Balanced Exapool. אחר כך תוכלו ליצור מכונה באמצעות סוג מכונה שתומך בדיסקים של Hyperdisk Balanced. סוג המכונה, סוג הדיסק והמאגר צריכים להיות זמינים באזור שבחרתם.

המסוף

  1. נכנסים לדף VM instances במסוף Google Cloud .

    כניסה לדף VM instances

  2. לוחצים על Create Instance.

  3. נותנים שם למכונה.

  4. מגדירים את האזור לאותו אזור שבו נמצא המאגר.

  5. בוחרים סוג מכונה שתומך ב-Hyperdisk Balanced, למשל H3.

  6. בקטע דיסק אתחול לוחצים על Change.

  7. בחלונית Boot disk, מגדירים את Boot disk type ל-Hyperdisk Balanced.

  8. מגדירים את המאפיינים של הדיסק.

  9. מרחיבים את הקטע הצגת הגדרות מתקדמות.

  10. בקטע מאגר אחסון, לוחצים על הפעלת מאגר האחסון.

  11. בוחרים מהרשימה את המאגר שבו רוצים ליצור את הדיסק.

  12. כשמסיימים להגדיר את הדיסק, לוחצים על Select.

  13. מסיימים להגדיר את המאפיינים של ה-VM.

  14. לוחצים על יצירה.

    המסוף יוצר את ה-VM באזור שצוין, ויוצר את דיסק האתחול במאגר שנבחר.

gcloud

כדי ליצור את דיסק האתחול של VM חדש במאגר, משתמשים בפקודה gcloud compute instances create וכוללים את המאפיין storage-pool של דיסק האתחול.

gcloud compute instances create VM_NAME \
    --zone=ZONE \
    --machine-type=MACHINE_TYPE \
    --create-disk=boot=yes,type=hyperdisk-balanced,size=DISK_SIZE,provisioned-throughput=THROUGHPUT, \
    provisioned-iops=IOPS,image=projects/IMAGE_PROJECT/global/images/IMAGE, \
    storage-pool=STORAGE_POOL_NAME

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

  • ‫VM_NAME: שם המכונה הווירטואלית.
  • ‫ZONE: האזור והתחום שבהם רוצים ליצור את המכונה הווירטואלית, בפורמט us-central1-a.
  • ‫MACHINE_TYPE: סוג המכונה של ה-VM, לדוגמה m3-ultramem-32.
  • ‫DISK_SIZE: הגודל של דיסק האתחול ב-GiB
  • ‫THROUGHPUT: קצב העברת הנתונים שיוקצה לדיסק
  • ‫IOPS: מספר פעולות הקלט/פלט לשנייה (IOPS) שצריך להקצות לדיסק
  • ‫IMAGE_PROJECT: הפרויקט שמכיל את קובץ האימג'
  • ‫IMAGE: מציינים אחת מהאפשרויות הבאות:
    • גרסה ספציפית של קובץ האימג' של מערכת ההפעלה, לדוגמה debian-12-bookworm-v20240213.
    • משפחת תמונות, בפורמט family/IMAGE_FAMILY. כך המכונה נוצרת מקובץ אימג' של מערכת ההפעלה העדכני ביותר, שלא הוצא משימוש. לדוגמה, אם מציינים את family/debian-12, ‏Compute Engine יוצר מכונה וירטואלית באמצעות הגרסה העדכנית של קובץ האימג' של מערכת ההפעלה במשפחת קובצי האימג' debian-12. למידע נוסף על השימוש במשפחות של קובצי אימג', ראו שיטות מומלצות למשפחות של קובצי אימג'.
  • ‫STORAGE_POOL_NAME: השם של מאגר האחסון שבו רוצים ליצור את הדיסק החדש.

REST

כדי ליצור את דיסק האתחול של מכונה וירטואלית חדשה במאגר, צריך ליצור בקשת POST ל-method instances.insert ולכלול את המאפיין storagePool של דיסק האתחול.

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

{
   "name": "VM_NAME",
   "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
   "disks": [
      {
         "deviceName": "BOOT_DISK_DEVICE_NAME",
         "initializeParams": {
            "diskSizeGb": "DISK_SIZE",
            "diskType": "DISK_TYPE",
            "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
            "boot": true,
            "provisionedIops": "IOPS_LIMIT",
            "provisionedThroughput": "THROUGHPUT_LIMIT",
            "storagePool": "POOL_URL"
         }
      }
   ]
}

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

  • ‫PROJECT_ID: מזהה הפרויקט
  • ‫ZONE: האזור שבו נמצא המאגר, לדוגמה us-central1-a. זהו האזור שבו נוצרים ה-VM ודיסק האתחול.
  • ‫VM_NAME: שם המכונה הווירטואלית.
  • ‫MACHINE_TYPE: סוג המכונה של ה-VM, לדוגמה m3-ultramem-32.
  • ‫BOOT_DISK_DEVICE_NAME: שם המכשיר של דיסק האתחול
  • ‫DISK_SIZE: הגודל של דיסק האתחול ב-GiB
  • ‫DISK_TYPE: סוג הדיסק, שצוין כ-URI
  • ‫IMAGE_PROJECT: הפרויקט שמכיל את קובץ האימג'
  • ‫IMAGE: מציינים אחת מהאפשרויות הבאות:
    • גרסה ספציפית של קובץ האימג' של מערכת ההפעלה, לדוגמה debian-12-bookworm-v20240213.
    • משפחת תמונות, בפורמט family/IMAGE_FAMILY. כך המכונה נוצרת מקובץ אימג' של מערכת ההפעלה העדכני ביותר, שלא הוצא משימוש. לדוגמה, אם מציינים את family/debian-12, ‏Compute Engine יוצר מכונה וירטואלית באמצעות הגרסה העדכנית של קובץ האימג' של מערכת ההפעלה במשפחת קובצי האימג' debian-12. למידע נוסף על השימוש במשפחות של קובצי אימג', ראו שיטות מומלצות למשפחות של קובצי אימג'.
  • ‫IOPS_LIMIT: מספר פעולות הקלט/פלט לשנייה (IOPS) שצריך להקצות לדיסק
  • ‫THROUGHPUT_LIMIT: קצב העברת הנתונים שיוקצה לדיסק
  • ‫POOL_URL: Storage Pool שבו נוצר הדיסק החדש. אפשר לציין כתובת URL חלקית או מלאה של המשאב. לדוגמה, אלה ערכים תקינים:
    • https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/storagePools/STORAGE_POOL_NAME
    • projects/PROJECT_ID/zones/ZONE/storagePools/STORAGE_POOL_NAME
    • zones/ZONE/storagePools/STORAGE_POOL_NAME

יצירת דיסקים נוספים במאגר במהלך יצירת VM

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

המסוף

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

  1. נכנסים לדף VM instances במסוף Google Cloud .

    כניסה לדף VM instances

  2. לוחצים על Create Instance.

  3. נותנים שם למכונה הווירטואלית.

  4. מגדירים את האזור לאותו אזור שבו נמצא המאגר.

  5. בוחרים סוג מכונה שתומך בסוג הדיסק שבו משתמש המאגר.

  6. מרחיבים את הקטע אפשרויות מתקדמות.

  7. מרחיבים את האפשרות Disks.

  8. לוחצים על Add new disk.

  9. בחלונית Add new disk, מזינים את פרטי הדיסק. מגדירים את Disk type כך שיתאים לסוג המאגר.

  10. בקטע Storage Pool, בוחרים באפשרות Enable storage pool.

  11. בשדה Select a storage pool, בוחרים את מאגר האחסון שבו רוצים ליצור את הדיסק.

  12. כשמסיימים להגדיר את הדיסק, לוחצים על Save.

  13. מסיימים להגדיר את המאפיינים של ה-VM.

  14. לוחצים על יצירה.

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

gcloud

אפשר ליצור דיסקים חדשים במאגר במהלך יצירת ה-VM, באמצעות הפקודה gcloud compute instances create וציון המאפיין storage-pool של הדיסק.

gcloud compute instances create VM_NAME \
    --zone=ZONE \
    --machine-type=MACHINE_TYPE \
    --create-disk=auto-delete=yes,boot=yes,device-name=BOOT_DISK_DEVICE_NAME,image=IMAGE_NAME, \
    size=BOOT_DISK_SIZE,type=BOOT_DISK_TYPE
    --create-disk=auto-delete=yes,boot=no,device-name=DATA_DISK_DEVICE_NAME,size=DATA_DISK_SIZE, \
    type=DATA_DISK_TYPE,provisioned-iops=IOPS,provisioned-throughput=THROUGHPUT, \
    storage_pool=STORAGE_POOL_NAME

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

  • ‫VM_NAME: השם של ה-VM
  • ‫ZONE: האזור שבו יוצרים את המכונה הווירטואלית, לדוגמה us-central1-a
  • ‫MACHINE_TYPE: סוג המכונה של ה-VM
  • ‫BOOT_DISK_DEVICE_NAME: שם המכשיר של דיסק האתחול
  • ‫IMAGE_NAME: השם של קובץ האימג' של מערכת ההפעלה שרוצים להתקין בדיסק האתחול, לדוגמה debian-12-bookworm-v20240213
  • ‫BOOT_DISK_SIZE: הגודל של דיסק האתחול ב-GiB
  • ‫BOOT_DISK_TYPE: סוג הדיסק
  • DATA_DISK_DEVICE_NAME: שם התקן הדיסק של דיסק הנתונים
  • ‫DATA_DISK_SIZE: גודל דיסק הנתונים, ב-GiB
  • ‫DATA_DISK_TYPE: סוג דיסק הנתונים, hyperdisk-balanced או hyperdisk-throughput
  • ‫IOPS: מספר פעולות הקלט/פלט לשנייה (IOPS) שצריך להקצות לדיסק
  • THROUGHPUT: קצב העברת הנתונים שיוקצה לדיסק
  • ‫STORAGE_POOL_NAME: השם הייחודי של המאגר שבו רוצים ליצור את הדיסק

REST

כדי ליצור דיסקים חדשים במאגר במהלך יצירת המכונה הווירטואלית, שולחים בקשת POST ל-instances.insert method וכוללים את המאפיין storagePool לדיסקים הנוספים.

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

{
   "name": "VM_NAME",
   "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
   "disks": [
      {
        "initializeParams":{
            "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE"
        },
        "boot":true
      },
      {
        "deviceName": "DEVICE_NAME",
        "boot":false,
        "initializeParams": {
           "diskSizeGb": "DISK_SIZE",
           "diskType": "DISK_TYPE",
           "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
           "provisionedIops": "IOPS_LIMIT",
           "provisionedThroughput": "THROUGHPUT_LIMIT",
           "storagePool": "POOL_URL"
        }
      }
   ]
}

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

  • ‫PROJECT_ID: מזהה הפרויקט
  • ‫ZONE: האזור שבו נמצא המאגר, לדוגמה us-central1-a. זהו האזור שבו נוצרים ה-VM ודיסק האתחול.
  • ‫VM_NAME: שם המכונה הווירטואלית.
  • ‫MACHINE_TYPE: סוג המכונה של ה-VM, לדוגמה m3-ultramem-32.
  • ‫IMAGE_PROJECT: הפרויקט שמכיל את קובץ האימג'
  • ‫IMAGE: מציינים אחת מהאפשרויות הבאות:
    • גרסה ספציפית של קובץ האימג' של מערכת ההפעלה, לדוגמה debian-12-bookworm-v20240213.
    • משפחת תמונות, בפורמט family/IMAGE_FAMILY. כך המכונה נוצרת מקובץ אימג' של מערכת ההפעלה העדכני ביותר, שלא הוצא משימוש. לדוגמה, אם מציינים את family/debian-12, ‏Compute Engine יוצר מכונה וירטואלית באמצעות הגרסה העדכנית של קובץ האימג' של מערכת ההפעלה במשפחת קובצי האימג' debian-12. למידע נוסף על השימוש במשפחות של קובצי אימג', ראו שיטות מומלצות למשפחות של קובצי אימג'.
  • ‫DEVICE_NAME: שם המכשיר של דיסק הנתונים
  • ‫DISK_SIZE: הגודל של דיסק הנתונים ב-GiB
  • ‫DISK_TYPE: סוג הדיסק, שצוין כ-URI
  • ‫IOPS_LIMIT: מספר פעולות הקלט/פלט לשנייה (IOPS) שצריך להקצות לדיסק
  • ‫THROUGHPUT_LIMIT: קצב העברת הנתונים שיוקצה לדיסק
  • ‫POOL_URL: Storage Pool שבו נוצר הדיסק החדש. אפשר לציין כתובת URL חלקית או מלאה של המשאב. לדוגמה, אלה ערכים תקינים:
    • https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/storagePools/STORAGE_POOL_NAME
    • projects/PROJECT_ID/zones/ZONE/storagePools/STORAGE_POOL_NAME
    • zones/ZONE/storagePools/STORAGE_POOL_NAME

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

התבניות של הגדרות המכונה שמשמשות ליצירת קבוצות מופעי מכונה מנוהלים (MIG) יכולות להכיל את המידע על המאגר. הדיסקים שנוצרו באמצעות תבנית של הגדרות מכונה ממוקמים במאגר שצוין.

המסוף

  1. במסוף Google Cloud , נכנסים לדף תבניות של הגדרות מכונה.

    כניסה לדף Instance templates

  2. לוחצים על Create Instance Template.

  3. מזינים שם לתבנית של הגדרות המכונה.

  4. בוחרים באפשרות Regional למיקום, ובשדה Region בוחרים את האזור שבו נמצא המאגר.

  5. בוחרים סוג מכונה שתומך ב-Hyperdisk Balanced, למשל C3.

  6. בקטע דיסק אתחול לוחצים על Change.

  7. בחלונית Boot disk, מגדירים את Boot disk type ל-Hyperdisk Balanced.

  8. מגדירים את המאפיינים של הדיסק.

  9. מרחיבים את הקטע הצגת הגדרות מתקדמות.

  10. בקטע מאגר אחסון, לוחצים על הפעלת מאגר האחסון.

  11. בוחרים מהרשימה את המאגר שבו רוצים ליצור את הדיסק.

  12. כשמסיימים להגדיר את הדיסק, לוחצים על Select.

  13. מסיימים להגדיר את המאפיינים של ה-VM.

  14. לוחצים על יצירה.

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

gcloud

כדי לציין בתבנית של הגדרות מכונה שדיסק האתחול ייווצר במאגר, משתמשים בפקודה gcloud compute instance-templates create וכוללים את המאפיין storage-pool של דיסק האתחול.

gcloud compute instance-templates create TEMPLATE_NAME \
    --instance-template-region=REGION \
    --machine-type=MACHINE_TYPE \
    --create-disk=boot=yes,type=hyperdisk-balanced,size=DISK_SIZE,provisioned-throughput=THROUGHPUT, \
    provisioned-iops=IOPS,image=projects/IMAGE_PROJECT/global/images/IMAGE, \
    storage-pool=STORAGE_POOL_NAME

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

  • ‫TEMPLATE_NAME: השם של התבנית של הגדרות המכונה.
  • ‫REGION: האזור שבו רוצים ליצור את התבנית של הגדרות המכונה האזורית. האזור חייב להכיל את התחום שבו נמצא המאגר.
  • ‫MACHINE_TYPE: סוג המכונה שבה משתמשים כשיוצרים את המכונה הווירטואלית, לדוגמה h3-standard-88.
  • ‫DISK_SIZE: גודל הדיסק ב-GiB
  • ‫THROUGHPUT: קצב העברת הנתונים שיוקצה לדיסק
  • ‫IOPS: מספר פעולות הקלט/פלט לשנייה (IOPS) שצריך להקצות לדיסק
  • ‫IMAGE_PROJECT: הפרויקט שמכיל את קובץ האימג'
  • ‫IMAGE: מציינים אחת מהאפשרויות הבאות:
    • גרסה ספציפית של קובץ האימג' של מערכת ההפעלה, לדוגמה debian-12-bookworm-v20240213.
    • משפחת תמונות, בפורמט family/IMAGE_FAMILY. כך המכונה נוצרת מקובץ אימג' של מערכת ההפעלה העדכני ביותר, שלא הוצא משימוש. לדוגמה, אם מציינים את family/debian-12, ‏Compute Engine יוצר מכונה וירטואלית באמצעות הגרסה העדכנית של קובץ האימג' של מערכת ההפעלה במשפחת קובצי האימג' debian-12. למידע נוסף על השימוש במשפחות של קובצי אימג', ראו שיטות מומלצות למשפחות של קובצי אימג'.
  • ‫STORAGE_POOL_NAME: השם של מאגר האחסון שבו רוצים ליצור את הדיסק החדש.

REST

כדי ליצור את דיסק האתחול של מכונה וירטואלית חדשה במאגר, צריך ליצור בקשת POST ל-method instances.insert ולכלול את המאפיין storagePool של דיסק האתחול.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates
{
   "name": "VM_NAME",
   "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
   "disks": [
      {
         "deviceName": "BOOT_DISK_DEVICE_NAME",
         "initializeParams": {
            "diskSizeGb": "DISK_SIZE",
            "diskType": "DISK_TYPE",
            "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
            "boot": true,
            "provisionedIops": "IOPS_LIMIT",
            "provisionedThroughput": "THROUGHPUT_LIMIT",
            "storagePool": "POOL_URL"
         }
      }
   ]
}

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

  • ‫PROJECT_ID: מזהה הפרויקט
  • ‫VM_NAME: שם המכונה הווירטואלית.
  • ‫ZONE: האזור שבו נמצא המאגר, לדוגמה us-central1-a. זהו האזור שבו נוצרים ה-VM ודיסק האתחול.
  • ‫MACHINE_TYPE: סוג המכונה של ה-VM, לדוגמה m3-ultramem-32.
  • ‫BOOT_DISK_DEVICE_NAME: שם המכשיר של דיסק האתחול
  • ‫DISK_SIZE: הגודל של דיסק האתחול ב-GiB
  • ‫DISK_TYPE: סוג הדיסק, שצוין כ-URI
  • ‫IMAGE_PROJECT: הפרויקט שמכיל את קובץ האימג'
  • ‫IMAGE: מציינים אחת מהאפשרויות הבאות:
    • גרסה ספציפית של קובץ האימג' של מערכת ההפעלה, לדוגמה debian-12-bookworm-v20240213.
    • משפחת תמונות, בפורמט family/IMAGE_FAMILY. כך המכונה נוצרת מקובץ אימג' של מערכת ההפעלה העדכני ביותר, שלא הוצא משימוש. לדוגמה, אם מציינים את family/debian-12, ‏ Compute Engine יוצר מכונה באמצעות הגרסה העדכנית של קובץ האימג' של מערכת ההפעלה במשפחת קובצי האימג' debian-12. למידע נוסף על השימוש במשפחות של קובצי אימג', ראו שיטות מומלצות למשפחות של קובצי אימג'.
  • ‫IOPS_LIMIT: מספר פעולות הקלט/פלט לשנייה (IOPS) שצריך להקצות לדיסק
  • ‫THROUGHPUT_LIMIT: קצב העברת הנתונים שיוקצה לדיסק
  • ‫POOL_URL: Storage Pool שבו נוצר הדיסק החדש. אפשר לציין כתובת URL חלקית או מלאה של המשאב. לדוגמה, אלה ערכים תקינים:
    • https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/storagePools/STORAGE_POOL_NAME
    • projects/PROJECT_ID/zones/ZONE/storagePools/STORAGE_POOL_NAME
    • zones/ZONE/storagePools/STORAGE_POOL_NAME