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

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

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

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

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

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

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

  • Compute Instance Admin (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 עם קיבולת מתקדמת, אתם יכולים ליצור דיסקים ב-Pool עם גודל מצטבר שגדול מהקיבולת שהוקצתה ל-Pool. הקיבולת בשימוש של המאגר מוגדרת לפי סך הנתונים בשימוש ולא לפי נפח האחסון שהקציתם. אפשר להקצות דיסקים עם קיבולת מצטברת של עד פי 5 או פי 50 מהקיבולת שהוקצתה למאגר קיבולת מתקדם או ל-Hyperdisk Exapool, בהתאמה.

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

ביצועים שהוקצו

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

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

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

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

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

דוגמה

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

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

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

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

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

עם הקצאת משאבים מתקדמת לשיפור הביצועים:

  • כשיוצרים דיסקים ב-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.

בדף מאגרי אחסון:

  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. בוחרים את התחום (zone) שמכיל את המאגר שבו רוצים ליצור את הדיסק.

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

  5. משנים את הערכים בשדות גודל, 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 לטביבייט. אם לא מציינים גודל, המערכת משתמשת בערך ברירת המחדל של 100 GB.
  • ‫DISK_TYPE: סוג הדיסק שרוצים ליצור. הסוג הזה צריך להיות זהה לסוג של Hyperdisk Storage Pool, כלומר hyperdisk-balanced או hyperdisk-throughput.
  • ‫PROVISIONED_IOPS: אופציונלי: מספר ה-IOPS להקצאה לדיסק. אפשר להשתמש בדגל הזה רק עם דיסקים מסוג Hyperdisk Balanced.
  • ‫PROVISIONED_THROUGHPUT: אופציונלי: התפוקה ב-MiB/s שמוקצית לדיסק.

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 לטביבייט. אם לא מציינים גודל, המערכת משתמשת בערך ברירת המחדל של 100 GB.
  • ‫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();

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

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

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

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

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

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

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

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

gcloud

אתם יכולים ליצור את דיסק האתחול למכונה וירטואלית חדשה במאגר באמצעות הפקודה 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: שם ה-VM.
  • ‫ZONE: האזור והאזור שבו יוצרים את המכונה הווירטואלית, בפורמט us-central1-a.
  • ‫MACHINE_TYPE: סוג המכונה של המכונה הווירטואלית, לדוגמה, m3-ultramem-32.
  • ‫DISK_SIZE: הגודל של דיסק האתחול ב-GiB
  • ‫THROUGHPUT: קצב העברת הנתונים (throughput) שיוקצה לדיסק
  • ‫IOPS: מספר ה-IOPS להקצאה לדיסק
  • ‫IMAGE_PROJECT: הפרויקט שמכיל את התמונה
  • ‫IMAGE: מציינים אחת מהאפשרויות הבאות:
    • גרסה ספציפית של קובץ אימג' של מערכת ההפעלה – לדוגמה, debian-12-bookworm-v20240213.
    • משפחת תמונות, שצריכה להיות בפורמט family/IMAGE_FAMILY. הפעולה הזו יוצרת את המכונה מקובץ האימג' העדכני ביותר של מערכת ההפעלה, שלא הוצא משימוש. לדוגמה, אם מציינים family/debian-12, ‏ Compute Engine יוצר מכונת VM באמצעות הגרסה העדכנית של קובץ אימג' של מערכת ההפעלה במשפחת התמונות 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_NAME: שם המכונה הווירטואלית.
  • ‫MACHINE_TYPE: סוג המכונה של המכונה הווירטואלית, לדוגמה, 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 יוצר מכונת VM באמצעות הגרסה העדכנית של קובץ אימג' של מערכת ההפעלה במשפחת התמונות debian-12. למידע נוסף על השימוש במשפחות של קובצי אימג', ראו שיטות מומלצות למשפחות של קובצי אימג'.
  • ‫IOPS_LIMIT: מספר ה-IOPS להקצאה לדיסק
  • ‫THROUGHPUT_LIMIT: קצב העברת הנתונים (throughput) שיוקצה לדיסק
  • ‫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. בחלונית הוספת דיסק חדש, מזינים את פרטי הדיסק. מגדירים את סוג הדיסק בהתאם לסוג המאגר.

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

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

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

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

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

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

gcloud

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

REST

אפשר ליצור דיסקים חדשים במאגר במהלך יצירת מכונה וירטואלית על ידי יצירת בקשה POSTלשיטה 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": [
      {
        "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_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: קצב העברת הנתונים (throughput) שיוקצה לדיסק
  • ‫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. נכנסים לדף Instance templates במסוף 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. כשמסיימים להגדיר את הדיסק, לוחצים על בחירה.

  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 יוצר מכונת VM באמצעות הגרסה העדכנית של קובץ אימג' של מערכת ההפעלה במשפחת התמונות debian-12. למידע נוסף על השימוש במשפחות של קובצי אימג', ראו שיטות מומלצות למשפחות של קובצי אימג'.
  • ‫STORAGE_POOL_NAME: השם של מאגר האחסון שבו רוצים ליצור את הדיסק החדש.

REST

אפשר ליצור את דיסק האתחול למכונה וירטואלית חדשה במאגר על ידי יצירת בקשת POST לשיטה 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: שם ה-VM.
  • ‫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: קצב העברת הנתונים (throughput) שיוקצה לדיסק
  • ‫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