Ajouter un disque SSD local à votre instance de calcul

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 instance Compute Engine, ils ne peuvent être créés qu'en même temps que l'instance de calcul. Les disques SSD locaux ne peuvent pas être utilisés comme périphériques de démarrage.

Pour les séries de machines de troisième génération et ultérieures compatibles avec les disques SSD locaux (à l'exception des séries G4 et M3), Compute Engine associe automatiquement un nombre spécifique de disques SSD locaux lorsque vous créez votre instance. Ces séries de machines offrent un stockage SSD local de différentes manières :

  • H4D, C4, C4A, C4D, C3 et C3D : pour ces séries de machines, le stockage SSD local n'est disponible qu'avec les types de machines qui se terminent par -lssd, comme c3-standard-88-lssd.
  • Séries de machines Z3, A4X Max, A4X, A4, A3 et A2 Ultra : pour ces séries de machines, chaque type de machine est fourni avec un stockage SSD local.

Pour les types de machines G4, M3, de première et de deuxième génération compatibles avec les disques SSD locaux, vous devez spécifier le nombre de disques SSD locaux à associer lorsque vous créez l'instance de calcul.

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 instance de calcul, consultez Choisir un nombre valide de disques SSD locaux.

Avant de commencer

Créer une instance de calcul avec des disques SSD locaux

Vous pouvez créer une instance de calcul avec un stockage SSD local à l'aide deGoogle Cloud console, de gcloud CLI ou de l'API Compute Engine.

Console

  1. Accéder à la page Créer une instance.

    Accéder à la page Créer une instance

  2. Spécifiez le nom, la région et la zone de votre instance de calcul. Vous pouvez également ajouter des tags ou des libellés.

  3. Dans la section Configuration de la machine, choisissez la famille de machines qui contient le type de machine cible.

  4. Sélectionnez une série dans la liste Série, puis choisissez le type de machine.

    • Pour H4D, C4, C4A, C4D, C3 et C3D, choisissez un type de machine se terminant par -lssd.
    • Pour les machines ultra Z3, A4X Max, A4X, A4, A3 et A2, chaque type de machine est fourni avec un stockage SSD local.
    • Pour les séries de machines G4, 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 de disque.
        2. Sélectionnez le nombre de disques souhaité dans la liste Capacité du disque.
        3. Cliquez sur Enregistrer.

  5. Poursuivez le processus de création de l'instance de calcul.

  6. Après avoir créé l'instance avec des disques SSD locaux, vous devez formater et installer chaque périphérique pour pouvoir utiliser les disques.

gcloud

  • Pour les séries de machines Z3, A4X Max, A4X, A4, A3 et A2 Ultra, pour créer une instance de calcul à laquelle sont associés des disques SSD locaux, créez une instance 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 H4D, C4, C4A, C4D, C3 et C3D, pour créer une instance de calcul avec des disques SSD locaux associés, suivez les instructions permettant de créer une instance, et spécifiez un type de machine se terminant par -lssd.

    Par exemple, vous pouvez créer une instance C3 avec deux disques SSD locaux 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 G4, M3, première et deuxième génération, pour créer une instance de calcul avec des disques SSD locaux associés, suivez les instructions permettant de 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 instance M3 avec quatre disques SSD locaux et spécifier le type d'interface du disque comme suit :

    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

Remplacez les éléments suivants :

  • INSTANCE_NAME : nom de la nouvelle instance de calcul
  • ZONE : zone dans laquelle créer l'instance. 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. Si vous créez une instance G4 ou M3, ou si votre image de disque de démarrage inclut des pilotes optimisés pour NVMe, spécifiez 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.

Vous pouvez associer des disques SSD locaux à une instance de calcul créée à l'aide d'un type de machine de première ou 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 instances de calcul de troisième génération et ultérieures ne sont compatibles qu'avec l'interface de disque NVMe.

Après avoir créé une instance de calcul avec des disques SSD locaux, vous devez formater et installer chaque périphérique pour pouvoir l'utiliser.

Terraform

Pour créer une instance de calcul avec des disques SSD locaux associés, vous pouvez utiliser la ressource 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 {}
  }
}

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

Pour générer le code Terraform, vous pouvez utiliser le composant Code équivalent dans la console Google Cloud .
  1. Dans la console Google Cloud , accédez à la page Instances de VM.

    Accéder à la page "Instances de VM"

  2. Cliquez sur Créer une instance.
  3. Spécifiez les paramètres souhaités.
  4. En haut ou en bas de la page, cliquez sur Code équivalent, puis sur l'onglet Terraform pour afficher le code Terraform.

Go

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 les bibliothèques clientes. 

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

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.

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 les bibliothèques clientes. 


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

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.

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 les bibliothèques clientes. 

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

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

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

  • Pour les séries de machines H4D, C4, C4A, C4D, C3 et C3D, pour créer une instance de calcul avec des disques SSD locaux associés, spécifiez un type d'instance se terminant par -lssd.

    Voici un exemple de charge utile de requête permettant de créer une instance 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 G4, M3, première et deuxième générations, afin de créer une instance de calcul avec des disques SSD locaux associés, vous pouvez ajouter des disques SSD locaux lors de la création de l'instance à l'aide de la propriété initializeParams. Vous devez également fournir les propriétés suivantes :

    • 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 instance 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 disques SSD locaux individuels

Le moyen le plus simple d'associer des disques SSD locaux à votre instance de calcul 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 pouvez utiliser la configuration et le format de partition de votre choix. Dans l'exemple ci-dessous, nous allons créer une seule partition ext4.

  1. Accédez à la page "Instances de VM".

    Accéder à la page Instances de VM

  2. 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.

  3. Dans le terminal, exécutez 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

  4. Formatez le disque SSD local avec un 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.

  5. 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.

  6. Installez le disque SSD local sur l'instance de calcul.

    $ sudo mount /dev/disk/by-id/[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.

  7. 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.

  1. 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.

  2. 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.

  1. 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.

  2. Faites un clic droit sur le bouton "Démarrer" de Windows, puis sélectionnez Disk Management (Gestion du disque).

    Sélectionner l&#39;outil Gestion du disque de Windows dans le menu contextuel du bouton Démarrer de Windows.

  3. 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.

    Sélectionner un schéma de partition dans la fenêtre d&#39;initialisation du disque.

  4. 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).

    Créer un volume simple à partir du disque associé.

  5. 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.

    Sélectionner le type de format de partition dans l&#39;Assistant Création d&#39;un volume simple.

  6. 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).

    Afficher la liste des disques reconnus par Windows et vérifier que l&#39;état du disque dur SSD local est &quot;Sain&quot;.

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

Formater et installer plusieurs disques SSD locaux dans un seul volume logique

Contrairement aux volumes Google Cloud Hyperdisk et Persistent Disk, les disques SSD locaux ont une capacité fixe pour chaque disque que vous associez à l'instance. Si vous souhaitez combiner plusieurs disques SSD locaux 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.

  1. Accédez à la page "Instances de VM".

    Accéder à la page Instances de VM

  2. Cliquez sur le bouton SSH à côté de l'instance à laquelle est associé le nouveau disque SSD local. Le navigateur ouvre une connexion de terminal vers l'instance.

  3. 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

  4. 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 disques SSD. Les disques SSD locaux en mode SCSI ont des noms standards tels que google-local-ssd. Les disques SSD locaux en mode NVMe ont des noms tels que google-local-nvme-ssd.

  5. 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

    Le résultat 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
 ...

  6. Formatez l'ensemble de la baie de disques /dev/md0 en utilisant le système de fichiers ext4.

    $ sudo mkfs.ext4 -F /dev/md0

  7. 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.

  8. 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.

  9. 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.

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 SSD locaux, l'instance peut continuer son processus de démarrage sans s'interrompre indéfiniment.

  1. 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.

  2. 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

  3. 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 tableau de disques SSD locaux. 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 une baie de disques SSD locaux sur une instance Windows.

  1. 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.

  2. Faites un clic droit sur le bouton "Démarrer" de Windows, puis sélectionnez Disk Management (Gestion du disque).

    Sélectionner l&#39;outil Gestion du disque de Windows dans le menu contextuel du bouton Démarrer de Windows.

  3. Si vous n'avez pas encore initialisé les disques SSD locaux, l'outil vous invite à sélectionner un schéma de partitionnement pour les nouvelles partitions. Sélectionnez GPT, puis cliquez sur OK.

    Sélectionner un schéma de partition dans la fenêtre d&#39;initialisation du disque.

  4. 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).

    Création d&#39;un volume agrégé par bandes à partir du disque associé.

  5. Sélectionnez les disques SSD locaux à 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.

    Sélection des partitions SSD locales à inclure dans la baie de disques.

  6. 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.

    Sélectionner le type de format de partition dans l&#39;Assistant Création de volume agrégé par bandes.

  7. 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).

    Afficher la liste des disques reconnus par Windows et vérifier que l&#39;état du disque dur SSD local est &quot;Sain&quot;.

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

Étapes suivantes