將本機 SSD 磁碟新增至運算執行個體

本機 SSD 磁碟是專為快取或暫存處理空間等暫存用途而設計，由於本機 SSD 磁碟位於運作 Compute Engine 執行個體的實體機器上，因此僅可在建立運算執行個體的過程中，建立本機 SSD 磁碟。本機 SSD 磁碟無法做為開機裝置。

對於支援本機 SSD 磁碟的第 3 代機器系列和後續版本 (不含 G4 和 M3)，當您建立執行個體時，Compute Engine 會自動連結特定數量的本機 SSD 磁碟。這些機器系列提供本機 SSD 儲存空間的方式如下：

• H4D、C4、C4A、C4D、C3 和 C3D：對於這些機器系列，本機 SSD 儲存空間僅適用於以 -lssd 結尾的機器類型，例如 c3-standard-88-lssd。
• Z3、A4X Max、A4X、A4、A3 和 A2 Ultra 機器系列：這些機器系列的每個機型都隨附本機 SSD 儲存空間。

對於支援本機 SSD 磁碟的 G4、M3、第一代和第二代機器類型，您必須在建立運算執行個體時，指定要附加的本機 SSD 磁碟數量。

建立本機 SSD 磁碟後，您必須先格式化並掛接裝置，方可使用。

如要瞭解各種機型可用的本機 SSD 儲存空間大小，以及可附加至運算執行個體的本機 SSD 磁碟數量，請參閱「選擇有效的本機 SSD 磁碟數量」。

事前準備

• 使用本機 SSD 磁碟前，請先查看本機 SSD 的限制。
• 請查看本機 SSD 磁碟的資料保存情境。
• 如要將本機 SSD 磁碟新增至已附加 GPU 的運算執行個體，請參閱 本機 SSD 磁碟可用性。
• 如果尚未設定驗證，請先完成設定。 驗證可確認您的身分，以便存取 Google Cloud 服務和 API。如要從本機開發環境執行程式碼或範例，請選取下列其中一個選項，向 Compute Engine 進行驗證：

  選取這個頁面上的分頁，瞭解如何使用範例：

  控制台

  使用 Google Cloud 控制台存取 Google Cloud 服務和 API 時，無須設定驗證。

  gcloud

  1. 安裝 Google Cloud CLI。 完成後，執行下列指令來初始化 Google Cloud CLI：

     gcloud init

     若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

     注意：如果您已經安裝 gcloud CLI，請務必執行 gcloud components update，確認您安裝的是最新版本。
• 設定預設地區和區域。

Terraform

如要在本機開發環境中使用本頁的 Terraform 範例，請安裝並初始化 gcloud CLI，然後使用您的使用者憑證設定應用程式預設憑證。

1. 安裝 Google Cloud CLI。

2. 若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

3. 如果您使用本機殼層，請為使用者帳戶建立本機驗證憑證：

   gcloud auth application-default login

   如果您使用 Cloud Shell，則不需要執行這項操作。

   如果系統傳回驗證錯誤，且您使用外部識別資訊提供者 (IdP)，請確認您已 使用聯合身分登入 gcloud CLI。

詳情請參閱 這篇文章，瞭解如何設定本機開發環境的驗證機制。

Go

如要在本機開發環境中使用本頁的 Go 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

1. 安裝 Google Cloud CLI。

2. 若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

3. 如果您使用本機殼層，請為使用者帳戶建立本機驗證憑證：

   gcloud auth application-default login

   如果您使用 Cloud Shell，則不需要執行這項操作。

   如果系統傳回驗證錯誤，且您使用外部識別資訊提供者 (IdP)，請確認您已 使用聯合身分登入 gcloud CLI。

詳情請參閱 這篇文章，瞭解如何設定本機開發環境的驗證機制。

Java

如要在本機開發環境中使用本頁面的 Java 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

1. 安裝 Google Cloud CLI。

2. 若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

3. 如果您使用本機殼層，請為使用者帳戶建立本機驗證憑證：

   gcloud auth application-default login

   如果您使用 Cloud Shell，則不需要執行這項操作。

   如果系統傳回驗證錯誤，且您使用外部識別資訊提供者 (IdP)，請確認您已 使用聯合身分登入 gcloud CLI。

詳情請參閱 這篇文章，瞭解如何設定本機開發環境的驗證機制。

Python

如要在本機開發環境中使用本頁的 Python 範例，請安裝並初始化 gcloud CLI，然後使用您的使用者憑證設定應用程式預設憑證。

1. 安裝 Google Cloud CLI。

2. 若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

3. 如果您使用本機殼層，請為使用者帳戶建立本機驗證憑證：

   gcloud auth application-default login

   如果您使用 Cloud Shell，則不需要執行這項操作。

   如果系統傳回驗證錯誤，且您使用外部識別資訊提供者 (IdP)，請確認您已 使用聯合身分登入 gcloud CLI。

詳情請參閱 這篇文章，瞭解如何設定本機開發環境的驗證機制。

REST

如要在本機開發環境中使用本頁的 REST API 範例，請使用您提供給 gcloud CLI 的憑證。

安裝 Google Cloud CLI。

若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

詳情請參閱 Google Cloud 驗證說明文件中的「使用 REST 進行驗證」。

建立具有本機 SSD 磁碟的運算執行個體

您可以使用Google Cloud console、gcloud CLI 或 Compute Engine API，建立具有本機 SSD 儲存空間的運算執行個體。

控制台

1. 前往「Create an instance」(建立執行個體) 頁面。

   前往「建立執行個體」

2. 指定運算執行個體的名稱、地區和區域。視需要新增標記或標籤。

3. 在「Machine configuration」(機器設定) 區段中，選擇包含目標機型的機器家族。

4. 從「系列」清單中選取系列，然後選擇機型。

   • 如果是 H4D、C4、C4A、C4D、C3 和 C3D，請選擇結尾為 -lssd 的機型。
   • Z3、A4X Max、A4X、A4、A3 和 A2 Ultra 機型都隨附本機 SSD 儲存空間。
   • 如果是 G4、M3，或第一代和第二代機器系列，請在選取機型後執行下列操作：
     1. 展開「Advanced options」(進階選項) 區段。
     2. 展開「Disks」(磁碟)，按一下「Add Local SSD」(新增本機 SSD)，然後執行下列操作：
        1. 在「設定本機 SSD」頁面中，選擇磁碟介面類型。
        2. 從「磁碟容量」清單中選取所需磁碟數量。
        3. 按一下 [儲存]。

5. 繼續執行運算執行個體建立程序。

6. 建立含有本機 SSD 磁碟的執行個體後，您必須先格式化並掛接每個裝置，才能使用磁碟。

gcloud

• 如要為 Z3、A4X Max、A4X、A4、A3 和 A2 Ultra 機器系列建立已連結本機 SSD 磁碟的運算執行個體，請按照建立執行個體的操作說明，建立使用該系列任何可用機型的執行個體。

• 如要為 H4D、C4、C4A、C4D、C3 和 C3D 系列機型建立已連結本機 SSD 磁碟的運算執行個體，請按照建立執行個體的操作說明，並指定結尾為 -lssd 的機型。

  舉例來說，您可以建立具有兩部本機 SSD 磁碟的 C3 執行個體，並使用 NVMe 磁碟介面，如下所示：

  gcloud compute instances create example-c3-instance \
     --zone ZONE \
     --machine-type c3-standard-8-lssd \
     --image-project IMAGE_PROJECT \
     --image-family IMAGE_FAMILY
  

• 如要為 G4、M3 和第一代/第二代機器系列建立已連接本機 SSD 磁碟的運算執行個體，請按照建立執行個體的操作說明，但使用 --local-ssd 標記建立及連接本機 SSD 磁碟。如要建立多個本機 SSD 磁碟，請新增其他 --local-ssd 旗標。 或者也可以設定介面的值，以及每個 --local-ssd 旗標的裝置名稱。

  舉例來說，您可以建立具有四個本機 SSD 磁碟的 M3 執行個體，並指定磁碟介面類型，如下所示：

  gcloud compute instances create INSTANCE_NAME \
     --machine-type m3-ultramem-64 \
     --zone ZONE \
     --local-ssd interface=INTERFACE_TYPE,device-name=DEVICE-NAME \
     --local-ssd interface=INTERFACE_TYPE,device-name=DEVICE-NAME \
     --local-ssd interface=INTERFACE_TYPE,device-name=DEVICE-NAME \
     --local-ssd interface=INTERFACE_TYPE \
     --image-project IMAGE_PROJECT \
     --image-family IMAGE_FAMILY
  

更改下列內容：

• INSTANCE_NAME：新運算執行個體的名稱
• ZONE：要建立執行個體的可用區。如果您已設定 gcloud CLI compute/zone 屬性或 CLOUDSDK_COMPUTE_ZONE 環境變數，則不一定要使用這個旗標。
• INTERFACE_TYPE：您要用於本機 SSD 磁碟的磁碟介面類型。如果您要建立 G4 或 M3 執行個體，或是開機磁碟映像檔具有最佳化 NVMe 驅動程式，請指定 nvme。為其他圖片指定 scsi。
• DEVICE-NAME：選用：名稱，指出要在客層作業系統符號連結 (符號連結) 中使用的磁碟名稱。
• IMAGE_FAMILY：要安裝在開機磁碟上的可用映像檔系列
• IMAGE_PROJECT：映像檔系列所屬的映像檔專案

您可以將本機 SSD 磁碟連接至使用第一代或第二代機型建立的運算執行個體，在不同的分區上一併使用 nvme 和 scsi。nvme 裝置的效能取決於執行個體的開機磁碟映像檔。第三代和後續的運算執行個體僅支援 NVMe 磁碟介面。

建立含有本機 SSD 磁碟的運算執行個體後，您必須先格式化並掛接每個裝置，方可使用。

Terraform

如要建立已連接本機 SSD 磁碟的運算執行個體，可以使用 google_compute_instance 資源。

# Create a VM with a local SSD for temporary storage use cases

resource "google_compute_instance" "default" {
  name         = "my-vm-instance-with-scratch"
  machine_type = "n2-standard-8"
  zone         = "us-central1-a"

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

  # Local SSD interface type; NVME for image with optimized NVMe drivers or SCSI
  # Local SSD are 375 GiB in size
  scratch_disk {
    interface = "SCSI"
  }

  network_interface {
    network = "default"
    access_config {}
  }
}

如要瞭解如何套用或移除 Terraform 設定，請參閱「基本 Terraform 指令」。

如要產生 Terraform 程式碼，可以使用 Google Cloud 控制台中的「對等程式碼」元件。

1. 前往 Google Cloud 控制台的「VM instances」(VM 執行個體) 頁面。

   前往 VM 執行個體

2. 點選「建立執行個體」。
3. 指定所需參數。
4. 按一下頁面頂端或底部的「對等程式碼」，然後點選「Terraform」分頁標籤，即可查看 Terraform 程式碼。

Go

Go

在試用這個範例之前，請先按照「使用用戶端程式庫的 Compute Engine 快速入門導覽課程」中的 Go 設定說明操作。詳情請參閱 Compute Engine Go API 參考文件。

如要向 Compute Engine 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證作業」。

import (
	"context"
	"fmt"
	"io"

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

// createWithLocalSSD creates a new VM instance with Debian 10 operating system and a local SSD attached.
func createWithLocalSSD(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"

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

	imagesClient, err := compute.NewImagesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewImagesRESTClient: %w", err)
	}
	defer imagesClient.Close()

	// List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details.
	newestDebianReq := &computepb.GetFromFamilyImageRequest{
		Project: "debian-cloud",
		Family:  "debian-12",
	}
	newestDebian, err := imagesClient.GetFromFamily(ctx, newestDebianReq)
	if err != nil {
		return fmt.Errorf("unable to get image from family: %w", err)
	}

	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: newestDebian.SelfLink,
						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()),
				},
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskType: proto.String(fmt.Sprintf("zones/%s/diskTypes/local-ssd", zone)),
					},
					AutoDelete: proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_SCRATCH.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 快速入門導覽課程」中的 Java 設定說明操作。詳情請參閱 Compute Engine Java API 參考文件。

如要向 Compute Engine 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證作業」。

import com.google.cloud.compute.v1.AttachedDisk;
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.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.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateWithLocalSsd {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // projectId: project ID or project number of the Cloud project you want to use.
    String projectId = "your-project-id";
    // zone: name of the zone to create the instance in. For example: "us-west3-b"
    String zone = "zone-name";
    // instanceName: name of the new virtual machine (VM) instance.
    String instanceName = "instance-name";

    createWithLocalSsd(projectId, zone, instanceName);
  }

  // Create a new VM instance with Debian 11 operating system and SSD local disk.
  public static void createWithLocalSsd(String projectId, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {

    int diskSizeGb = 10;
    boolean boot = true;
    boolean autoDelete = true;
    String diskType = String.format("zones/%s/diskTypes/pd-standard", zone);
    // Get the latest debian image.
    Image newestDebian = getImageFromFamily("debian-cloud", "debian-11");
    List<AttachedDisk> disks = new ArrayList<>();

    // Create the disks to be included in the instance.
    disks.add(
        createDiskFromImage(diskType, diskSizeGb, boot, newestDebian.getSelfLink(), autoDelete));
    disks.add(createLocalSsdDisk(zone));

    // Create the instance.
    Instance instance = createInstance(projectId, zone, instanceName, disks);

    if (instance != null) {
      System.out.printf("Instance created with local SSD: %s", instance.getName());
    }

  }

  // Retrieve the newest image that is part of a given family in a project.
  // Args:
  //    projectId: 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.
  private static Image getImageFromFamily(String projectId, String family) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `imagesClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ImagesClient imagesClient = ImagesClient.create()) {
      // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
      return imagesClient.getFromFamily(projectId, family);
    }
  }

  // Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
  // source for the new disk.
  //
  // Args:
  //    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"
  //
  //    diskSizeGb: size of the new disk in gigabytes.
  //
  //    boot: boolean flag indicating whether this disk should be used as a
  //    boot disk of an instance.
  //
  //    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}"
  //
  //    autoDelete: boolean flag indicating whether this disk should be deleted
  //    with the VM that uses it.
  private static AttachedDisk createDiskFromImage(String diskType, int diskSizeGb, boolean boot,
      String sourceImage, boolean autoDelete) {

    AttachedDiskInitializeParams attachedDiskInitializeParams =
        AttachedDiskInitializeParams.newBuilder()
            .setSourceImage(sourceImage)
            .setDiskSizeGb(diskSizeGb)
            .setDiskType(diskType)
            .build();

    AttachedDisk bootDisk = AttachedDisk.newBuilder()
        .setInitializeParams(attachedDiskInitializeParams)
        // Remember to set auto_delete to True if you want the disk to be deleted when you delete
        // your VM instance.
        .setAutoDelete(autoDelete)
        .setBoot(boot)
        .build();

    return bootDisk;
  }

  // Create an AttachedDisk object to be used in VM instance creation. The created disk contains
  // no data and requires formatting before it can be used.
  // Args:
  //    zone: The zone in which the local SSD drive will be attached.
  private static AttachedDisk createLocalSsdDisk(String zone) {

    AttachedDiskInitializeParams attachedDiskInitializeParams =
        AttachedDiskInitializeParams.newBuilder()
            .setDiskType(String.format("zones/%s/diskTypes/local-ssd", zone))
            .build();

    AttachedDisk disk = AttachedDisk.newBuilder()
        .setType(AttachedDisk.Type.SCRATCH.name())
        .setInitializeParams(attachedDiskInitializeParams)
        .setAutoDelete(true)
        .build();

    return disk;
  }

  // Send an instance creation request to the Compute Engine API and wait for it to complete.
  // Args:
  //    projectId: 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"
  //    instanceName: 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.
  private static Instance createInstance(String projectId, String zone, String instanceName,
      List<AttachedDisk> disks)
      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. After completing all of your requests, call
    // the `instancesClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      // 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"
      String typeName = "n1-standard-1";
      String machineType = String.format("zones/%s/machineTypes/%s", zone, typeName);

      // networkLink: 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.
      String networkLink = "global/networks/default";

      // Collect information into the Instance object.
      Instance instance = Instance.newBuilder()
          .setName(instanceName)
          .setMachineType(machineType)
          .addNetworkInterfaces(NetworkInterface.newBuilder().setName(networkLink).build())
          .addAllDisks(disks)
          .build();

      Operation response = instancesClient.insertAsync(projectId, zone, instance)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Instance creation failed ! ! " + response);
      }
      System.out.println("Operation Status: " + response.getStatus());
      return instancesClient.get(projectId, zone, instanceName);
    }

  }

}

Python

Python

在試用這個範例之前，請先按照「使用用戶端程式庫的 Compute Engine 快速入門導覽課程」中的 Python 設定說明操作。詳情請參閱 Compute Engine Python API 參考文件。

如要向 Compute Engine 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證作業」。

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 local_ssd_disk(zone: str) -> compute_v1.AttachedDisk():
    """
    Create an AttachedDisk object to be used in VM instance creation. The created disk contains
    no data and requires formatting before it can be used.

    Args:
        zone: The zone in which the local SSD drive will be attached.

    Returns:
        AttachedDisk object configured as a local SSD disk.
    """
    disk = compute_v1.AttachedDisk()
    disk.type_ = compute_v1.AttachedDisk.Type.SCRATCH.name
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.disk_type = f"zones/{zone}/diskTypes/local-ssd"
    disk.initialize_params = initialize_params
    disk.auto_delete = True
    return 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_with_ssd(
    project_id: str, zone: str, instance_name: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with Debian 10 operating system and SSD local 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.

    Returns:
        Instance object.
    """
    newest_debian = get_image_from_family(project="debian-cloud", family="debian-12")
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [
        disk_from_image(disk_type, 10, True, newest_debian.self_link, True),
        local_ssd_disk(zone),
    ]
    instance = create_instance(project_id, zone, instance_name, disks)
    return instance

REST

使用 instances.insert method 從映像檔系列或特定版本的作業系統映像檔建立運算執行個體。

• 如要為 Z3、A4X Max、A4X、A4、A3 和 A2 Ultra 機器系列建立已連結本機 SSD 磁碟的運算執行個體，請建立使用該系列任何可用機器類型的執行個體。

• 如要為 H4D、C4、C4A、C4D、C3 和 C3D 機器系列建立已連結本機 SSD 磁碟的運算執行個體，請指定以 -lssd 結尾的執行個體類型。

  以下是範例要求酬載，會建立具有 Ubuntu 開機磁碟和兩個本機 SSD 磁碟的 C3 執行個體：

  {
   "machineType":"zones/us-central1-c/machineTypes/c3-standard-8-lssd",
   "name":"c3-with-local-ssd",
   "disks":[
      {
         "type":"PERSISTENT",
         "initializeParams":{
            "sourceImage":"projects/ubuntu-os-cloud/global/images/family/ubuntu-2204-lts"
         },
         "boot":true
      }
   ],
   "networkInterfaces":[
      {
         "network":"global/networks/default"
  }
   ]
  }
  

• 如果是 G4、M3，以及第 1 代和第 2 代機器系列，如要建立已連結本機 SSD 磁碟的運算執行個體，可以在建立執行個體時使用 initializeParams 屬性新增本機 SSD 磁碟。請務必提供下列屬性：

  • diskType：設為本機 SSD
  • autoDelete：設定為 true。
  • type：設為 SCRATCH。

  本機 SSD 磁碟無法使用下列屬性：

  • diskName
  • sourceImage 屬性
  • diskSizeGb

  在以下的範例要求酬載中，會建立具有開機磁碟和四個本機 SSD 磁碟的 M3 執行個體：

  {
   "machineType":"zones/us-central1-f/machineTypes/m3-ultramem-64",
   "name":"local-ssd-instance",
   "disks":[
      {
       "type":"PERSISTENT",
       "initializeParams":{
          "sourceImage":"projects/ubuntu-os-cloud/global/images/family/ubuntu-2204-lts"
       },
       "boot":true
      },
      {
         "type":"SCRATCH",
         "initializeParams":{
            "diskType":"zones/us-central1-f/diskTypes/local-ssd"
         },
         "autoDelete":true,
         "interface": "NVME"
      },
      {
         "type":"SCRATCH",
         "initializeParams":{
            "diskType":"zones/us-central1-f/diskTypes/local-ssd"
         },
         "autoDelete":true,
         "interface": "NVME"
      },
      {
         "type":"SCRATCH",
         "initializeParams":{
            "diskType":"zones/us-central1-f/diskTypes/local-ssd"
         },
         "autoDelete":true,
         "interface": "NVME"
      },
      {
         "type":"SCRATCH",
         "initializeParams":{
            "diskType":"zones/us-central1-f/diskTypes/local-ssd"
         },
         "autoDelete":true,
         "interface": "NVME"
      },
   ],
   "networkInterfaces":[
      {
         "network":"global/networks/default"
      }
   ]
  }
  

建立本機 SSD 磁碟後，您必須先格式化並掛接每個裝置，方可使用。

如要進一步瞭解如何使用 REST 建立執行個體，請參閱 Compute Engine API。

格式化及掛接本機 SSD 磁碟

您可以個別格式化及掛接每個本機 SSD 磁碟，也可以將多個本機 SSD 磁碟合併成單一邏輯磁碟區。

格式化並掛接個別的本機 SSD 磁碟

如要將本機 SSD 磁碟連接至運算執行個體，最簡單的方式就是透過單一磁碟分區來格式化和掛接每部裝置。或者也可以將多個分區合併為單一邏輯磁碟區。

Linux 執行個體

在 Linux 執行個體上格式化和掛接新的本機 SSD 磁碟。可使用任何您需要的磁碟分區格式與配置。這個範例會建立單一的 ext4 磁碟分區。

1. 前往「VM instances」(VM 執行個體) 頁面。

   前往 VM 執行個體

2. 按一下具有新連接本機 SSD 的執行個體旁邊的「SSH」SSH按鈕。瀏覽器會開啟對於執行個體的終端機連線。

3. 在終端機中，使用 find 指令識別想要掛接的本機 SSD 磁碟。

   $ find /dev/ | grep google-local-nvme-ssd
   

   處於 SCSI 模式的本機 SSD 磁碟會具有類似 google-local-ssd-0 的標準名稱。處於 NVMe 模式的本機 SSD 磁碟會具有類似 google-local-nvme-ssd-0 的名稱，如以下輸出內容所示：

    $ find /dev/ | grep google-local-nvme-ssd
   
    /dev/disk/by-id/google-local-nvme-ssd-0
   

4. 以 ext4 檔案系統格式化本機 SSD 磁碟。此指令會刪除本機 SSD 磁碟中的全部現有資料。

   $ sudo mkfs.ext4 -F /dev/disk/by-id/[SSD_NAME]
   

   將 [SSD_NAME] 替換為您要格式化本機 SSD 磁碟的 ID。例如，指定 google-local-nvme-ssd-0 可格式化執行個體上的第一個 NVMe 本機 SSD 磁碟。

5. 使用 mkdir 指令建立目錄，您可在其中掛接裝置。

   $ sudo mkdir -p /mnt/disks/[MNT_DIR]
   

   將 [MNT_DIR] 替換為要掛接本機 SSD 磁碟的目錄路徑。

6. 將本機 SSD 磁碟掛接至運算執行個體。

   $ sudo mount /dev/disk/by-id/[SSD_NAME] /mnt/disks/[MNT_DIR]
   

   更改下列內容：

   • [SSD_NAME]：要掛接的本機 SSD 磁碟 ID。
   • [MNT_DIR]：要掛接本機 SSD 磁碟的目錄。

7. 設定對裝置的讀取與寫入存取權。在此範例中，授予所有使用者對裝置的寫入存取權。

   $ sudo chmod a+w /mnt/disks/[MNT_DIR]
   

   將 [MNT_DIR] 替換為您掛接本機 SSD 磁碟的目錄。

也可以選擇將本機 SSD 磁碟新增至 /etc/fstab 檔案，讓裝置在執行個體重新啟動時自動重新掛接。若執行個體停止，則此項目不會在本機 SSD 磁碟上保存資料。如需完整詳細資料，請參閱「本機 SSD 資料保存」一文。

指定項目 /etc/fstab 檔案時，請務必加入 nofail 選項，讓執行個體即使在無本機 SSD 時仍可繼續啟動。舉例來說，如果您要建立開機磁碟的快照，並建立不含本機 SSD 磁碟的新執行個體，這時執行個體仍可繼續執行啟動程序，而不會永久暫停。

1. 建立 /etc/fstab 項目。請使用 blkid 指令在裝置上尋找檔案系統的 UUID，並透過掛接選項編輯 /etc/fstab 檔案，以加入該 UUID。您可透過單一指令完成這個步驟。

   舉例來說，如要使用 NVMe 模式的本機 SSD，請使用下列指令：

   $ echo UUID=`sudo blkid -s UUID -o value /dev/disk/by-id/google-local-nvme-ssd-0` /mnt/disks/[MNT_DIR] ext4 discard,defaults,nofail 0 2 | sudo tee -a /etc/fstab
   

   如要使用非 NVMe 模式 (例如 SCSI) 的本機 SSD，請使用下列指令：

   $ echo UUID=`sudo blkid -s UUID -o value /dev/disk/by-id/google-local-ssd-0` /mnt/disks/[MNT_DIR] ext4 discard,defaults,nofail 0 2 | sudo tee -a /etc/fstab
   

   將 [MNT_DIR] 替換為您掛接本機 SSD 的目錄。

2. 使用 cat 指令驗證 /etc/fstab 項目是否正確：

   $ cat /etc/fstab
   

如果您是以這個執行個體的開機磁碟來建立快照，並使用該快照建立不含本機 SSD 磁碟的獨立執行個體，請編輯 /etc/fstab 檔案，並移除這個本機 SSD 磁碟的項目。即使已有 nofail 選項，也請將 /etc/fstab 檔案與連接至執行個體的磁碟分割區保持同步處理，並在建立開機磁碟快照前移除這些項目。

Windows 執行個體

使用 Windows 磁碟管理工具，即可在 Windows 執行個體上格式化和掛接本機 SSD 磁碟。

1. 請透過遠端桌面協定連結到執行個體。在本範例中，請前往「VM instances」(VM 執行個體) 頁面，然後在已連接本機 SSD 磁碟的執行個體旁，按一下「RDP」RDP按鈕。輸入使用者名稱和密碼後，會開啟一個伺服器桌面介面視窗。

2. 在 Windows [Start] (開始) 按鈕上按一下滑鼠右鍵，然後選取 [Disk Management] (磁碟管理)。

   

3. 若之前尚未初始化本機 SSD 磁碟，此工具會提示您選取新磁碟區的分區配置。請選取 [GPT]，然後按一下 [OK] (確定)。

   

4. 本機 SSD 磁碟初始化後，請在未配置的磁碟空間上按一下滑鼠右鍵，然後選取「新增簡單磁碟區」。

   

5. 請按照「New Simple Volume Wizard」(新增簡單磁碟區精靈) 中的操作說明，設定新的磁碟區。您可以使用任何想要的磁碟分區格式，但在此範例中請選取 NTFS。此外，也請勾選 [Perform a quick format] (執行快速格式化)，以加速執行格式化程序。

   

6. 結束精靈並完成磁碟區格式化作業後，請檢查新的本機 SSD 磁碟，確認其是否處於 Healthy 狀態。

   

大功告成！現在已可將檔案寫入至本機 SSD 磁碟。

格式化多個本機 SSD 磁碟，並掛接至單一邏輯磁碟區

與 Google Cloud Hyperdisk 和永久磁碟磁區不同，本機 SSD 磁碟每個磁碟的容量固定，如要將多個本機 SSD 磁碟合併為單一邏輯磁碟區，您必須自行定義這些分區的磁碟區管理。

注意： 由於基礎硬體設定的緣故，對全體本機 SSD 磁碟使用同位或鏡像 RAID 層級，並不會提供任何實際可靠性或備援上的優點。請使用 RAID 0，以發揮本機 SSD 陣列的最佳效能和最大容量。

Linux 執行個體

使請用 mdadm 建立 RAID 0 陣列。本範例會透過單一 ext4 檔案系統將陣列格式化，但您可套用任何偏好的檔案系統。

注意： 雖然可建立 /etc/fstab 項目，以在執行個體重新啟動時自動掛接本機 SSD 磁碟，但其不允許透過停止或先占來保存本機 SSD 磁碟上的資料。

1. 前往「VM instances」(VM 執行個體) 頁面。

   前往 VM 執行個體

2. 按一下具有新連接本機 SSD 磁碟的執行個體旁邊的「SSH」SSH按鈕。瀏覽器會開啟對於執行個體的終端機連線。

3. 在終端機中，安裝 mdadm 工具。這個 mdadm 安裝程序包含會停止指令碼的使用者提示，因此請手動執行這個程序。

   Debian 與 Ubuntu：

   $ sudo apt update && sudo apt install mdadm --no-install-recommends
   

   CentOS 與 RHEL：

   $ sudo yum install mdadm -y
   

   SLES 與 openSUSE：

   $ sudo zypper install -y mdadm
   

4. 請使用 find 指令識別想要一同掛接的所有本機 SSD 磁碟。

   在本範例中，執行個體具有八個處於 NVMe 模式的本機 SSD 分割區：

   $  find /dev/ | grep google-local-nvme-ssd
   
    /dev/disk/by-id/google-local-nvme-ssd-7
    /dev/disk/by-id/google-local-nvme-ssd-6
    /dev/disk/by-id/google-local-nvme-ssd-5
    /dev/disk/by-id/google-local-nvme-ssd-4
    /dev/disk/by-id/google-local-nvme-ssd-3
    /dev/disk/by-id/google-local-nvme-ssd-2
    /dev/disk/by-id/google-local-nvme-ssd-1
    /dev/disk/by-id/google-local-nvme-ssd-0
   

   find 不保證排序。只要輸出行的數量與預期的 SSD 磁碟數量相符，裝置的列出順序不同也沒關係。處於 SCSI 模式的本機 SSD 磁碟會具有類似 google-local-ssd 的標準名稱。處於 NVMe 模式的本機 SSD 磁碟會具有類似 google-local-nvme-ssd 的名稱。

5. 請使用 mdadm 將多個本機 SSD 磁碟合併至名為 /dev/md0 的單一陣列。本範例會合併處於 NVMe 模式的八個本機 SSD 磁碟。至於處於 SCSI 模式的本機 SSD 磁碟，請指定您以 find 指令取得的名稱：

   $ sudo mdadm --create /dev/md0 --level=0 --raid-devices=8 \
    /dev/disk/by-id/google-local-nvme-ssd-0 \
    /dev/disk/by-id/google-local-nvme-ssd-1 \
    /dev/disk/by-id/google-local-nvme-ssd-2 \
    /dev/disk/by-id/google-local-nvme-ssd-3 \
    /dev/disk/by-id/google-local-nvme-ssd-4 \
    /dev/disk/by-id/google-local-nvme-ssd-5 \
    /dev/disk/by-id/google-local-nvme-ssd-6 \
    /dev/disk/by-id/google-local-nvme-ssd-7
   
   mdadm: Defaulting to version 1.2 metadata
   mdadm: array /dev/md0 started.
   
   

   您可以使用 mdadm --detail 確認陣列的詳細資料。新增 --prefer=by-id 旗標會列出使用 /dev/disk/by-id 路徑的裝置。

    sudo mdadm --detail --prefer=by-id /dev/md0
    

   陣列中的每個裝置輸出內容應類似如下：

    ...
    Number   Major   Minor   RaidDevice State
       0      259      0         0      active sync   /dev/disk/by-id/google-local-nvme-ssd-0
    ...
    

6. 請以 ext4 檔案系統將整個 /dev/md0 陣列格式化。

   注意： 此指令會刪除本機 SSD 磁碟中的所有現有資料。

   $ sudo mkfs.ext4 -F /dev/md0
   

7. 請建立可掛接 /dev/md0 的目錄。在此範例中，會建立 /mnt/disks/ssd-array 目錄：

   $ sudo mkdir -p /mnt/disks/[MNT_DIR]
   

   將 [MNT_DIR] 替換為要掛接本機 SSD 陣列的目錄。

8. 將 /dev/md0 陣列掛接至 /mnt/disks/ssd-array 目錄：

   $ sudo mount /dev/md0 /mnt/disks/[MNT_DIR]
   

   將 [MNT_DIR] 替換為要掛接本機 SSD 陣列的目錄。

9. 設定對裝置的讀取與寫入存取權。在此範例中，授予所有使用者對裝置的寫入存取權。

   $ sudo chmod a+w /mnt/disks/[MNT_DIR]
   

   將 [MNT_DIR] 替換為您掛接本機 SSD 陣列的所在目錄。

也可以選擇將本機 SSD 磁碟新增至 /etc/fstab 檔案，讓裝置在執行個體重新啟動時自動重新掛接。若執行個體停止，則此項目不會在本機 SSD 磁碟上保存資料。詳情請參閱本機 SSD 資料保存一文。

指定項目 /etc/fstab 檔案時，請務必加入 nofail 選項，讓執行個體即使在無本機 SSD 磁碟時仍可繼續啟動。舉例來說，如果您擷取開機磁碟的快照並新建未附加任何本機 SSD 磁碟的執行個體，則該執行個體可以無限期持續執行啟動程序。

1. 建立 /etc/fstab 項目。請使用 blkid 指令在裝置上尋找檔案系統的 UUID，並透過掛接選項編輯 /etc/fstab 檔案，以加入該 UUID。指定 nofail 選項以允許系統啟動，即使本機 SSD 磁碟無法使用也允許。或者，可用單一指令完成此步驟。例如：

   $ echo UUID=`sudo blkid -s UUID -o value /dev/md0` /mnt/disks/[MNT_DIR] ext4 discard,defaults,nofail 0 2 | sudo tee -a /etc/fstab
   

   將 [MNT_DIR] 替換為您掛接本機 SSD 陣列的所在目錄。

2. 如果您在 /etc/fstab 檔案中使用 /dev/md0 等裝置名稱，而非 UUID，則需要編輯 /etc/mdadm/mdadm.conf 檔案，確保陣列會在開機時自動重新組裝。如要這樣做，請完成下列兩個步驟：

   1. 確認磁碟陣列會在開機時自動掃描及重新組裝。

      $ sudo mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf
      

   2. 更新 initramfs，讓陣列在提早啟動程序中可用。

      $ sudo update-initramfs -u
      

3. 使用 cat 指令驗證 /etc/fstab 項目是否正確：

   $ cat /etc/fstab
   

如果您是以這個執行個體的開機磁碟來建立快照，並使用該快照建立不含本機 SSD 磁碟的獨立執行個體，請編輯 /etc/fstab 檔案，並移除這個本機 SSD 磁碟陣列的項目。即使已有 nofail 選項，也請將 /etc/fstab 檔案與連接至執行個體的磁碟分割區保持同步處理，並在建立開機磁碟快照前移除這些項目。

Windows 執行個體

使用 Windows 磁碟管理工具，即可在 Windows 執行個體上格式化和掛接本機 SSD 磁碟陣列。

1. 請透過遠端桌面協定連結到執行個體。在本範例中，請前往「VM instances」(VM 執行個體) 頁面，然後在已連接本機 SSD 磁碟的執行個體旁，按一下「RDP」RDP按鈕。輸入使用者名稱和密碼後，會開啟一個伺服器桌面介面視窗。

2. 在 Windows [Start] (開始) 按鈕上按一下滑鼠右鍵，然後選取 [Disk Management] (磁碟管理)。

   

3. 若之前尚未初始化本機 SSD 磁碟，此工具會提示您選取新磁碟區的分區配置。請選取 [GPT]，然後按一下 [OK] (確定)。

   

4. 本機 SSD 磁碟初始化後，請在未配置的磁碟空間上按一下滑鼠右鍵，然後選取「新增等量磁碟區」。

   

5. 選取要加入等量陣列的本機 SSD 磁碟。在本範例中，請選取要合併至單一本機 SSD 磁碟的所有分區。

   

6. 請按照「New Striped Volume Wizard」(新增等量磁碟區精靈) 中的操作說明，設定新磁碟區。您可以使用任何想要的磁碟分區格式，但在此範例中請選取 NTFS。此外，也請勾選 [Perform a quick format] (執行快速格式化)，以加速執行格式化程序。

   

7. 結束精靈並完成磁碟區格式化作業後，請檢查新的本機 SSD 磁碟，確認其是否處於 Healthy 狀態。

   

現在已可將檔案寫入至本機 SSD 磁碟。

後續步驟

• 進一步瞭解運算執行個體的裝置名稱。
• 瞭解如何基準化本機 SSD 磁碟的效能