Ajouter un disque SSD local à votre VM

Les disques SSD locaux sont conçus pour certains cas d'utilisation précis de stockage, par exemple les mises en cache, ou pour les traitements temporaires. Les disques SSD locaux étant situés sur la machine physique sur laquelle s'exécute votre VM, ils sont obligatoirement créés en même temps que la VM. Ils ne peuvent pas être utilisés en tant que disques de démarrage.

Pour la série de machines de troisième génération, une quantité définie de disques SSD locaux est ajoutée à la VM lors de sa création. Le seul moyen d'ajouter du stockage SSD local à ces VM est le suivant :

Pour les machines C3 et C3D, le stockage SSD local n'est disponible qu'avec certains types de machines, tels que c3-standard-88-lssd.
Pour les séries de machines ultra Z3, A3 et A2, chaque type de machine est fourni avec un stockage SSD local.

Pour les types de machines M3, première et deuxième génération, vous devez spécifier des disques SSD locaux lors de la création de la VM.

Après avoir créé un disque SSD local, vous devez le formater et l'installer pour pouvoir l'utiliser.

Pour en savoir plus sur la quantité de stockage SSD local disponible avec différents types de machines et le nombre de disques SSD locaux que vous pouvez associer à une VM, consultez les pages suivantes : Choisir un nombre valide de disques SSD locaux.

Avant de commencer

Consultez les limites applicables aux disques SSD locaux avant d'en utiliser.
Consultez les scénarios de persistance des données pour les disques SSD locaux.
Si vous ajoutez des disques SSD locaux aux instances de machines virtuelles (VM) auxquelles des GPU sont associés, consultez la section Disponibilité des disques SSD locaux par régions et zones GPU.
Si ce n'est pas déjà fait, configurez l'authentification. L'authentification est le processus permettant de valider votre identité pour accéder aux services et aux API Google Cloud. Pour exécuter du code ou des exemples depuis un environnement de développement local, vous pouvez vous authentifier auprès de Compute Engine comme suit :

Select the tab for how you plan to use the samples on this page:
Console

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud
1. Install the Google Cloud CLI, then initialize it by running the following command:
  gcloud init
  Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
2. Set a default region and zone.

Créer une VM avec un disque SSD local

Vous pouvez créer une VM avec le stockage sur disque SSD local à l'aide de la console Google Cloud, de gcloud CLI ou de l'API Compute Engine.

Console

Accédez à la page Créer une instance.

Accéder à Créer une instance
Spécifiez le nom, la région et la zone de la VM. Vous pouvez également ajouter des tags ou des libellés.
Dans la section Configuration de la machine, choisissez la famille de machines contenant votre type de machine cible.
Sélectionnez une série dans la liste Série, puis choisissez le type de machine.
- Pour les séries de machines C3 et C3D de troisième génération, choisissez un type de machine se terminant par -lssd.
- Pour les machines ultra Z3, A3 et A2, chaque type de machine est fourni avec un stockage SSD local.
- Pour les séries de machines M3 ou de première et deuxième génération, procédez comme suit après avoir sélectionné le type de machine :
  1. Développez la section Options avancées.
  2. Développez Disques, cliquez sur Ajouter un disque SSD local et procédez comme suit :
    1. Sur la page Configurer le disque SSD local, choisissez le type d'interface du disque.
    2. Sélectionnez le nombre de disques souhaité dans la liste Capacité du disque.
    3. Cliquez sur Enregistrer.
Poursuivez le processus de création de la VM.
Après avoir créé la VM avec des disques SSD locaux, vous devez formater et installer chaque disque pour pouvoir utiliser les disques.

gcloud

Pour les séries de machines ultra Z3, A3 et A2, pour créer une VM à laquelle sont associés des disques SSD locaux, créez une VM utilisant l'un des types de machines disponibles pour cette série en suivant les instructions pour créer une instance.
Pour les séries de machines C3 ou C3D, pour créer une VM avec des disques SSD locaux associés, suivez les instructions permettant de créer une instance, mais spécifiez un type d'instance qui inclut des disques SSD locaux (-lssd).

Par exemple, vous pouvez créer une VM C3 avec deux partitions SSD locales utilisant l'interface de disque NVMe comme suit :
```
gcloud compute instances create example-c3-instance \
   --zone ZONE \
   --machine-type c3-standard-8-lssd \
   --image-project IMAGE_PROJECT \
   --image-family IMAGE_FAMILY
```
Pour les séries de machines M3, première et deuxième génération, pour créer une VM avec des disques SSD locaux associés, suivez les instructions pour créer une instance, mais utilisez l'option --local-ssd pour créer et associer un disque SSD local. Pour créer plusieurs partitions SSD locales, ajoutez d'autres occurrences de l'option --local-ssd. Vous pouvez également définir des valeurs pour l'interface et le nom de disque correspondant à chaque occurrence de --local-ssd.

Par exemple, vous pouvez créer une VM M3 avec quatre disques SSD locaux et spécifier le type d'interface du disque comme suit :
```
gcloud compute instances VM_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
```

Remplacez les éléments suivants :

VM_NAME : le nom de la nouvelle VM
ZONE : zone dans laquelle créer la VM. Cette option est facultative si vous avez configuré la propriété compute/zone de gcloud CLI ou la variable d'environnement CLOUDSDK_COMPUTE_ZONE.
INTERFACE_TYPE : type d'interface de disque que vous souhaitez utiliser pour le disque SSD local. Spécifiez nvme si vous créez une VM M3 ou si votre image de disque de démarrage inclut des pilotes optimisés pour NVMe. Spécifiez scsi pour les autres images.
DEVICE-NAME (facultatif) : nom indiquant le nom du disque à utiliser dans le lien symbolique du système d'exploitation invité.
IMAGE_FAMILY : l'une des familles d'images disponibles que vous souhaitez installer sur le disque de démarrage.
IMAGE_PROJECT : projet d'image auquel cette famille d'images appartient.

Si nécessaire, vous pouvez associer des disques SSD locaux à une VM de première ou de deuxième génération en combinant nvme et scsi pour différentes partitions. Les performances du disque nvme dépendent de l'image de disque de démarrage utilisée par votre instance. Les VM de troisième génération ne sont compatibles qu'avec l'interface de disque NVMe.

Après avoir créé une VM avec un disque SSD local, vous devez formater et installer chaque disque avant de pouvoir l'utiliser.

Terraform

Pour créer une VM avec des disques SSD locaux associés, vous pouvez utiliser la ressource google_compute_instance.

compute/local_ssd/main.tf

Afficher sur GitHub Commentaires


# 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 {}
  }
}

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de base.

Pour générer le code Terraform, vous pouvez utiliser le composant Code équivalent dans la console Google Cloud.

Dans Google Cloud Console, accédez à la page Instances de VM.
Accéder à la page "Instances de VM"
Cliquez sur Créer une instance.
Spécifiez les paramètres souhaités.
En haut ou en bas de la page, cliquez sur Code équivalent, puis sur l'onglet Terraform pour afficher le code Terraform.

Go

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go décrites dans le Guide de démarrage rapide de Compute Engine à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Go Compute Engine.

Pour vous authentifier auprès de Compute Engine, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"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-10",
	}
	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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le Guide de démarrage rapide de Compute Engine à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Java Compute Engine.

Afficher sur GitHub Commentaires


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 10 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-10");
    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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python décrites dans le Guide de démarrage rapide de Compute Engine à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Python Compute Engine.

Afficher sur GitHub Commentaires

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-10")
    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

Utilisez instances.insert method pour créer une VM à partir d'une famille d'images ou d'une version spécifique d'une image de système d'exploitation.

Pour les séries de machines ultra Z3, A3 et A2, pour créer une VM à laquelle sont associés des disques SSD locaux, créez une VM utilisant l'un des types de machines disponibles pour cette série.

Pour les séries de machines C3 ou C3D, pour créer une VM avec des disques SSD locaux associés, spécifiez un type d'instance incluant des disques SSD locaux (-lssd).

Voici un exemple de charge utile de requête permettant de créer une VM C3 avec un disque de démarrage Ubuntu et deux disques SSD locaux :

{
 "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"
}
 ]
}

Pour les séries de machines M3, première et deuxième génération, pour créer une VM avec des disques SSD locaux associés, vous pouvez ajouter des disques SSD locaux lors de la création de la VM à l'aide de la propriété initializeParams. Vous devez indiquer les propriétés ci-dessous :

diskType : définie sur "local SSD"
autoDelete : définie sur "true"
type : définie sur "SCRATCH"

Les propriétés suivantes ne peuvent pas être utilisées avec les disques SSD locaux :

diskName
sourceImage
diskSizeGb

Voici un exemple de charge utile de requête permettant de créer une VM M3 avec un disque de démarrage et quatre disques SSD locaux :

{
 "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"
    }
 ]
}

Après avoir créé un disque SSD local, vous devez le formater et l'installer pour pouvoir l'utiliser.

Pour en savoir plus sur la création d'une instance à l'aide de REST, consultez la documentation sur l'API Compute Engine.

Formater et installer un disque SSD local

Vous pouvez formater et installer chaque disque SSD local individuellement, ou combiner plusieurs disques SSD locaux en un seul volume logique.

Formater et installer des partitions SSD locales individuelles

Le moyen le plus simple d'associer des disques SSD locaux à votre instance consiste à formater et à installer chaque disque avec une seule partition. Vous pouvez également combiner plusieurs partitions en un seul volume logique.

Instances Linux

Formatez et installez le nouveau disque SSD local sur votre instance Linux. Vous êtes libre d'utiliser la configuration et le format de partition de votre choix. Dans l'exemple ci-dessous, nous allons créer une seule partition ext4.

Accédez à la page des instances de VM.
Accéder à la page Instances de VM
Cliquez sur le bouton SSH à côté du nom de l'instance à laquelle est associé le nouveau disque SSD local. Le navigateur ouvre une connexion de terminal vers l'instance.
Dans le terminal, utilisez la commande find pour identifier le disque SSD local que vous souhaitez installer.
```
$ find /dev/ | grep google-local-nvme-ssd
```
Des noms standards tels que google-local-ssd-0 sont attribués aux disques SSD locaux en mode SCSI. Les disques SSD locaux en mode NVMe disposent de noms tels que google-local-nvme-ssd-0, comme dans le résultat suivant:
```
 $ find /dev/ | grep google-local-nvme-ssd

 /dev/disk/by-id/google-local-nvme-ssd-0
```
Formatez le disque SSD local en appliquant le système de fichiers ext4. Cette commande supprime toutes les données du disque SSD local.
```
$ sudo mkfs.ext4 -F /dev/disk/by-id/[SSD_NAME]
```
Remplacez [SSD_NAME] par l'ID du disque SSD local que vous souhaitez formater. Par exemple, spécifiez google-local-nvme-ssd-0 pour formater le premier disque SSD local NVMe sur l'instance.
Exécutez la commande mkdir pour créer un répertoire dans lequel vous allez installer le disque.
```
$ sudo mkdir -p /mnt/disks/[MNT_DIR]
```
Remplacez [MNT_DIR] par le chemin d'accès au répertoire dans lequel vous souhaitez installer votre disque SSD local.
Installez le disque SSD local sur la VM.
```
$ sudo mount /dev/[SSD_NAME] /mnt/disks/[MNT_DIR]
```
Remplacez les éléments suivants :
- [SSD_NAME] : ID du disque SSD local que vous souhaitez installer.
- [MNT_DIR] : répertoire dans lequel vous souhaitez installer le disque SSD local.
Configurez l'accès en lecture et en écriture au disque. Dans l'exemple ci-dessous, nous allons accorder à tous les utilisateurs un accès en écriture au disque.
```
$ sudo chmod a+w /mnt/disks/[MNT_DIR]
```
Remplacez [MNT_DIR] par le répertoire dans lequel vous avez installé votre disque SSD local.

Vous pouvez éventuellement ajouter le disque SSD local au fichier /etc/fstab afin qu'il soit installé de nouveau automatiquement au redémarrage de l'instance. Cette entrée ne préserve pas les données de votre disque SSD local si l'instance s'arrête. Pour en savoir plus, consultez la section Persistance des données des disques SSD locaux.

Lorsque vous spécifiez l'entrée dans le fichier /etc/fstab, veillez à inclure l'option nofail afin que l'instance puisse continuer à démarrer même si le disque SSD local n'est pas présent. Par exemple, si vous prenez un instantané du disque de démarrage et que vous créez une instance sans lui associer de disques persistants, l'instance peut continuer son processus de démarrage sans s'interrompre indéfiniment.

Créez l'entrée /etc/fstab. Exécutez la commande blkid pour rechercher l'UUID du système de fichiers du disque et modifiez le fichier /etc/fstab afin d'inclure cet UUID avec les options d'installation. Vous pouvez effectuer cette étape via une seule commande.

Par exemple, pour un disque SSD local en mode NVMe, utilisez la commande suivante :
```
$ 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
```
Pour un disque SSD local en mode non-NVMe tel que SCSI, utilisez la commande suivante :
```
$ 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
```
Remplacez [MNT_DIR] par le répertoire dans lequel vous avez installé votre disque SSD local.
Utilisez la commande cat suivante pour vérifier que les entrées /etc/fstab sont correctes :
```
$ cat /etc/fstab
```

Si vous créez un instantané à partir du disque de démarrage de cette instance et que vous l'utilisez pour créer une instance distincte ne disposant pas de disques SSD locaux, modifiez le fichier /etc/fstab et supprimez l'entrée correspondant à ce disque SSD local. Même si vous définissez l'option nofail, vous devez synchroniser le fichier /etc/fstab avec les partitions associées à votre instance et supprimer ces entrées avant de créer l'instantané du disque de démarrage.

Instances Windows

Utilisez l'outil Gestion du disque de Windows pour formater et installer un disque SSD local sur une instance Windows.

Connectez-vous à l'instance via RDP. Dans l'exemple ci-dessous, vous allez accéder à la page Instances de VM et cliquer sur le bouton RDP à côté du nom de l'instance à laquelle les disques SSD locaux sont associés. Après avoir saisi votre nom d'utilisateur et votre mot de passe, une fenêtre s'ouvre, affichant l'interface graphique de votre serveur.
Faites un clic droit sur le bouton "Démarrer" de Windows, puis sélectionnez Disk Management (Gestion du disque).
Si vous n'avez pas encore initialisé le disque SSD local, l'outil vous invite à sélectionner un schéma de partitionnement pour les nouvelles partitions. Sélectionnez GPT, puis cliquez sur OK.
Une fois que le disque SSD local est initialisé, faites un clic droit sur l'espace disque non alloué, puis sélectionnez New Simple Volume (Nouveau volume simple).
Suivez les instructions de l'écran New Simple Volume Wizard (Assistant Création d'un volume simple) pour configurer le nouveau volume. Vous pouvez utiliser le format de partition de votre choix. Toutefois, dans l'exemple ci-dessous, nous allons sélectionner NTFS. Cochez la case Perform a quick format (Effectuer un formatage rapide) pour accélérer le processus de formatage.
Une fois que vous avez achevé les étapes de l'assistant et que le formatage du volume est terminé, vérifiez que l'état du nouveau disque SSD local est défini sur Healthy (Sain).

Et voilà ! Vous pouvez maintenant enregistrer des fichiers sur le disque SSD local.

Formater et installer plusieurs partitions SSD locales sous la forme d'un seul volume logique

Contrairement aux disques SSD persistants, les disques SSD locaux que vous associez à l'instance ont chacun une capacité fixe de 375 Go. Si vous souhaitez combiner plusieurs partitions SSD locales en un seul volume logique, vous devez définir vous-même la gestion du volume sur ces partitions.

Instances Linux

Utilisez mdadm pour créer une baie de disques RAID 0. Dans l'exemple ci-dessous, la baie de disques est formatée avec un unique système de fichiers ext4. Vous pouvez toutefois utiliser le système de fichiers de votre choix.

Accédez à la page des instances de VM.
Accéder à la page Instances de VM
Cliquez sur le bouton SSH à côté du nom de l'instance à laquelle est associé le nouveau disque SSD local. Le navigateur ouvre une connexion de terminal vers l'instance.
Dans le terminal, installez l'outil mdadm. Le processus d'installation de mdadm inclut une invite utilisateur qui interrompt les scripts. Vous devez donc exécuter ce processus manuellement.

Debian et Ubuntu :
```
$ sudo apt update && sudo apt install mdadm --no-install-recommends
```
CentOS et RHEL :
```
$ sudo yum install mdadm -y
```
SLES et openSUSE :
```
$ sudo zypper install -y mdadm
```
Exécutez la commande find pour identifier tous les disques SSD locaux que vous souhaitez installer ensemble.

Dans l'exemple ci-dessous, l'instance comporte huit partitions SSD locales en mode NVMe :
```
$  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 ne garantit pas d'ordre particulier. Ce n'est pas un problème si les disques sont répertoriés dans un ordre différent, à condition que le nombre de lignes de sortie corresponde au nombre attendu de partitions SSD. Des noms standards tels que google-local-ssd sont attribués aux disques SSD locaux en mode SCSI. Les disques SSD locaux en mode NVMe disposent de noms tels que google-local-nvme-ssd.

Utilisez mdadm pour combiner plusieurs disques SSD locaux dans une baie unique nommée /dev/md0. Dans l'exemple ci-dessous, huit disques SSD locaux en mode NVMe sont fusionnés. Pour les disques SSD locaux en mode SCSI, spécifiez les noms obtenus à l'aide de la commande 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.

Vous pouvez confirmer les détails du tableau avec mdadm --detail. L'ajout de l'option --prefer=by-id permet de répertorier les appareils à l'aide des chemins d'accès /dev/disk/by-id.

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

La sortie doit ressembler à ce qui suit pour chaque appareil du tableau.

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

Formatez l'ensemble de la baie de disques /dev/md0 en utilisant le système de fichiers ext4.
Avertissement : Cette commande supprime toutes les données des disques SSD locaux.
```
$ sudo mkfs.ext4 -F /dev/md0
```
Créez un répertoire dans lequel vous pouvez installer /dev/md0. Pour cet exemple, créez le répertoire /mnt/disks/ssd-array :
```
$ sudo mkdir -p /mnt/disks/[MNT_DIR]
```
Remplacez [MNT_DIR] par le répertoire dans lequel vous souhaitez installer votre baie de disques durs SSD locaux.
Installez la baie /dev/md0 dans le répertoire /mnt/disks/ssd-array :
```
$ sudo mount /dev/md0 /mnt/disks/[MNT_DIR]
```
Remplacez [MNT_DIR] par le répertoire dans lequel vous souhaitez installer votre baie de disques durs SSD locaux.
Configurez l'accès en lecture et en écriture au disque. Dans l'exemple ci-dessous, nous allons accorder à tous les utilisateurs un accès en écriture au disque.
```
$ sudo chmod a+w /mnt/disks/[MNT_DIR]
```
Remplacez [MNT_DIR] par le répertoire dans lequel vous avez installé votre baie de disques SSD locaux.

Lorsque vous spécifiez l'entrée dans le fichier /etc/fstab, veillez à inclure l'option nofail afin que l'instance puisse continuer à démarrer même si le disque SSD local n'est pas présent. Par exemple, si vous créez un instantané du disque de démarrage et que vous créez une instance sans lui associer de disque SSD local, l'exécution de l'instance n'est pas interrompue indéfiniment, et le processus de démarrage peut se poursuivre.

Créez l'entrée /etc/fstab. Exécutez la commande blkid pour rechercher l'UUID du système de fichiers du disque et modifiez le fichier /etc/fstab afin d'inclure cet UUID avec les options d'installation. Spécifiez l'option nofail pour permettre au système de démarrer même si le disque SSD local n'est pas disponible. Vous pouvez effectuer cette étape via une seule commande. Exemple :
```
$ 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
```
Remplacez [MNT_DIR] par le répertoire dans lequel vous avez installé votre baie de disques SSD locaux.
Si vous utilisez un nom d'appareil tel que /dev/md0 dans le fichier /etc/fstab au lieu de l'UUID, vous devez modifier le fichier /etc/mdadm/mdadm.conf pour vous assurer que la baie de disques est réassemblée automatiquement au démarrage. Pour ce faire, procédez comme suit :
1. Assurez-vous que la baie de disques est analysée et réassemblée automatiquement au démarrage.
```
$ sudo mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf
```
2. Mettez à jour initramfs afin que la baie de disques soit disponible lors du processus d'amorçage.
```
$ sudo update-initramfs -u
```
Utilisez la commande cat suivante pour vérifier que les entrées /etc/fstab sont correctes :
```
$ cat /etc/fstab
```

Instances Windows

Utilisez l'outil Gestion du disque de Windows pour formater et installer une baie de disques SSD locaux sur une instance Windows.

Connectez-vous à l'instance via RDP. Dans l'exemple ci-dessous, vous allez accéder à la page Instances de VM et cliquer sur le bouton RDP à côté du nom de l'instance à laquelle les disques SSD locaux sont associés. Après avoir saisi votre nom d'utilisateur et votre mot de passe, une fenêtre s'ouvre, affichant l'interface graphique de votre serveur.
Faites un clic droit sur le bouton "Démarrer" de Windows, puis sélectionnez Disk Management (Gestion du disque).
Si vous n'avez pas encore initialisé le disque SSD local, l'outil vous invite à sélectionner un schéma de partitionnement pour les nouvelles partitions. Sélectionnez GPT, puis cliquez sur OK.
Une fois que le disque SSD local est initialisé, faites un clic droit sur l'espace disque non alloué, puis sélectionnez New Striped Volume (Nouveau volume agrégé par bandes).
Sélectionnez les partitions SSD locales à inclure dans la baie de disques agrégés par bandes. Pour cet exemple, sélectionnez toutes les partitions pour les combiner en un seul disque SSD local.
Suivez les instructions de la fenêtre New Striped Volume Wizard (Assistant Création de volume agrégé par bandes) pour configurer le nouveau volume. Vous pouvez utiliser le format de partition de votre choix. Toutefois, dans l'exemple ci-dessous, nous allons sélectionner NTFS. Cochez la case Perform a quick format (Effectuer un formatage rapide) pour accélérer le processus de formatage.
Une fois que vous avez achevé les étapes de l'assistant et que le formatage du volume est terminé, vérifiez que l'état du nouveau disque SSD local est défini sur Healthy (Sain).

Vous pouvez maintenant enregistrer des fichiers sur le disque SSD local.

Étapes suivantes

En savoir plus sur les noms d'appareils de votre VM.