Añadir un SSD local a una VM

Estas SSD se han diseñado para casos de almacenamiento provisional, como en caché o en un espacio de procesamiento temporal. Como las SSDs locales se encuentran en la máquina física en la que se ejecuta tu máquina virtual, solo se pueden crear durante el proceso de creación de la máquina virtual. Los SSD locales no se pueden usar como dispositivos de arranque.

En las series de máquinas de tercera generación y posteriores, se añade una cantidad determinada de discos SSD locales a la VM cuando la creas. La única forma de añadir almacenamiento en SSD local a estas VMs es la siguiente:

  • En el caso de C4, C4D, C3 y C3D, el almacenamiento SSD local solo está disponible con determinados tipos de máquinas, como c3-standard-88-lssd.
  • En las series de máquinas Z3, A4, A4X, A3 y A2 Ultra, todos los tipos de máquinas incluyen almacenamiento en SSD local.

En el caso de los tipos de máquina M3 y de primera y segunda generación, debes especificar discos SSD locales al crear la VM.

Después de crear un disco SSD local, debes formatear y montar el dispositivo para poder usarlo.

Para obtener información sobre la cantidad de almacenamiento SSD local disponible con varios tipos de máquinas y el número de discos SSD locales que puedes conectar a una VM, consulta Elegir un número válido de SSDs locales.

Antes de empezar

  • Consulta las limitaciones de los SSD locales antes de usarlos.
  • Consulta los escenarios de persistencia de datos de los discos SSD locales.
  • Si vas a añadir SSDs locales a instancias de máquinas virtuales (VM) que tengan GPUs conectadas, consulta Disponibilidad de SSDs locales por regiones y zonas de GPU.
  • Si aún no lo has hecho, configura la autenticación. La autenticación verifica tu identidad para acceder a Google Cloud servicios y APIs. Para ejecutar código o ejemplos desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:

    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. Instala Google Cloud CLI. Después de la instalación, inicializa la CLI de Google Cloud ejecutando el siguiente comando: 

      gcloud init

      Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

    2. Set a default region and zone.

    Terraform

    Para usar las muestras de Terraform de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      Instala Google Cloud CLI.

      Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

      If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

    Para obtener más información, consulta Set up authentication for a local development environment.

    Go

    Para usar las Go muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      Instala Google Cloud CLI.

      Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

      If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

    Para obtener más información, consulta Set up authentication for a local development environment.

    Java

    Para usar las Java muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      Instala Google Cloud CLI.

      Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

      If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

    Para obtener más información, consulta Set up authentication for a local development environment.

    Python

    Para usar las Python muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      Instala Google Cloud CLI.

      Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

      If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

    Para obtener más información, consulta Set up authentication for a local development environment.

    REST

    Para usar las muestras de la API REST de esta página en un entorno de desarrollo local, debes usar las credenciales que proporciones a la CLI de gcloud.

      Instala Google Cloud CLI.

      Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

    Para obtener más información, consulta el artículo Autenticarse para usar REST de la documentación sobre autenticación de Google Cloud .

Crear una VM con un SSD local

Puedes crear una VM con almacenamiento en disco SSD local mediante la Google Cloud console, la CLI de gcloud o la API de Compute Engine.

Consola

  1. Ve a la página Crear una instancia.

    Ir a Crear una instancia

  2. Especifica el nombre, la región y la zona de la VM. De forma opcional, añade etiquetas.

  3. En la sección Configuración de la máquina, elige la familia de máquinas que contenga el tipo de máquina de destino.

  4. Selecciona una serie de la lista Serie y, a continuación, elige el tipo de máquina.

    • En el caso de C4, C4D, C3 y C3D, elige un tipo de máquina que termine en -lssd.
    • En el caso de Z3, A4, A4X, A3 y A2 Ultra, todos los tipos de máquinas incluyen almacenamiento SSD local.
    • En el caso de las series de máquinas M3 o de primera y segunda generación, después de seleccionar el tipo de máquina, haz lo siguiente:
      1. Expande la sección Opciones avanzadas.
      2. Expande Discos, haz clic en Añadir SSD local y haz lo siguiente:
        1. En la página Configurar SSD local, elija el tipo de interfaz de disco.
        2. En la lista Capacidad del disco, selecciona el número de discos que quieras.
        3. Haz clic en Guardar.

  5. Continúa con el proceso de creación de la VM.

  6. Después de crear la VM con discos SSD locales, debes formatear y montar cada dispositivo para poder usar los discos.

gcloud

  • En el caso de las series de máquinas Z3, A4, A4X, A3 y A2 Ultra, para crear una VM con discos SSD locales conectados, crea una VM que utilice cualquiera de los tipos de máquinas disponibles de esa serie siguiendo las instrucciones para crear una instancia.

  • En las series de máquinas C4, C4D, C3 y C3D, para crear una VM con discos SSD locales conectados, sigue las instrucciones para crear una instancia, pero especifica un tipo de instancia que incluya discos SSD locales (-lssd).

    Por ejemplo, puedes crear una VM C3 con dos particiones de SSD local que usen la interfaz de disco NVMe de la siguiente manera:

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

  • En las series de máquinas M3 y de primera y segunda generación, para crear una VM con discos SSD locales conectados, sigue las instrucciones para crear una instancia, pero usa la marca --local-ssd para crear y conectar un disco SSD local. Para crear varios discos SSD locales, añade más marcas --local-ssd. También puedes definir valores para la interfaz y el nombre del dispositivo de cada marca --local-ssd.

    Por ejemplo, puedes crear una VM M3 con cuatro discos SSD locales y especificar el tipo de interfaz de disco de la siguiente manera:

    gcloud compute instances create 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

Haz los cambios siguientes:

  • VM_NAME: nombre de la nueva VM
  • ZONE: la zona en la que se creará la VM. Esta marca es opcional si ha configurado la propiedad compute/zone de gcloud CLI o la variable de entorno CLOUDSDK_COMPUTE_ZONE.
  • INTERFACE_TYPE: el tipo de interfaz de disco que quieres usar para el dispositivo SSD local. Especifica nvme si vas a crear una VM M3 o si tu imagen de disco de arranque tiene controladores NVMe optimizados. Especifica scsi para otras imágenes.
  • DEVICE-NAME: opcional. Nombre que indica el nombre del disco que se va a usar en el sistema operativo invitado enlace simbólico (symlink).
  • IMAGE_FAMILY: una de las familias de imágenes disponibles que quieras instalar en el disco de arranque
  • IMAGE_PROJECT: el proyecto de imagen al que pertenece la familia de imágenes

Si es necesario, puedes conectar SSDs locales a una VM de primera o segunda generación usando una combinación de nvme y scsi para diferentes particiones. El rendimiento del dispositivo nvme depende de la imagen del disco de arranque de tu instancia. Las VMs de tercera generación solo admiten la interfaz de disco NVMe.

Después de crear una VM con SSD local, debes formatear y montar cada dispositivo para poder usarlo.

Terraform

Para crear una VM con discos SSD locales conectados, puedes usar el recurso 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 {}
  }
}

Para saber cómo aplicar o quitar una configuración de Terraform, consulta Comandos básicos de Terraform.

Para generar el código de Terraform, puedes usar el componente Código equivalente de la Google Cloud consola.
  1. En la consola de Google Cloud , ve a la página Instancias de VM.

    Ir a Instancias de VM

  2. Haz clic en Crear instancia.
  3. Especifica los parámetros que quieras.
  4. En la parte superior o inferior de la página, haz clic en Código equivalente y, a continuación, en la pestaña Terraform para ver el código de Terraform.

Go

Go

Antes de probar este ejemplo, sigue las Goinstrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local. 

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

Antes de probar este ejemplo, sigue las Javainstrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local. 


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

Antes de probar este ejemplo, sigue las Pythoninstrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local. 

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

Usa instances.insert method para crear una VM a partir de una familia de imágenes o de una versión específica de una imagen de sistema operativo.

  • En el caso de las series de máquinas Z3, A4, A4X, A3 y A2 Ultra, para crear una VM con discos SSD locales conectados, crea una VM que utilice cualquiera de los tipos de máquinas disponibles de esa serie.

  • En las series de máquinas C4, C4D, C3 y C3D, para crear una VM con discos SSD locales conectados, especifica un tipo de instancia que incluya discos SSD locales (-lssd).

    A continuación, se muestra un ejemplo de carga útil de solicitud que crea una VM C3 con un disco de arranque de Ubuntu y dos discos SSD locales:

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

  • En las series de máquinas M3 y de primera y segunda generación, para crear una VM con discos SSD locales conectados, puedes añadir dispositivos SSD locales durante la creación de la VM mediante la propiedad initializeParams. También debe proporcionar las siguientes propiedades:

    • diskType: elija SSD local.
    • autoDelete: se asigna el valor true
    • type: se ha definido como SCRATCH

    Las siguientes propiedades no se pueden usar con dispositivos SSD local:

    • diskName
    • sourceImage propiedad
    • diskSizeGb

    A continuación, se muestra un ejemplo de carga útil de solicitud que crea una VM M3 con un disco de arranque y cuatro discos SSD locales:

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

Después de crear un disco SSD local, debes formatear y montar cada dispositivo para poder usarlo.

Para obtener más información sobre cómo crear una instancia mediante REST, consulta la API de Compute Engine.

Formatear y montar una unidad SSD local

Puedes formatear y montar cada disco SSD local de forma individual o combinar varios discos SSD locales en un único volumen lógico.

Formatear y montar particiones de SSD locales individuales

La forma más sencilla de conectar SSDs locales a tu instancia es formatear y montar cada dispositivo con una sola partición. También puedes combinar varias particiones en un único volumen lógico.

Instancias de Linux

Formatea y monta el nuevo SSD local en tu instancia de Linux. Puedes usar cualquier formato y configuración de partición que necesites. En este ejemplo, crearemos una sola partición ext4.

  1. Ve a la página Instancias de VM.

    Ir a instancias de VM

  2. Haz clic en el botón SSH situado junto a la instancia que tiene el nuevo SSD local adjunto. El navegador abre una conexión de terminal a la instancia.

  3. En el terminal, usa el comando find para identificar la unidad SSD local que quieras montar.

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

    Las SSDs locales en modo SCSI tienen nombres estándar, como google-local-ssd-0. Las unidades SSD locales en modo NVMe tienen nombres como google-local-nvme-ssd-0, tal como se muestra en el siguiente resultado:

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

 /dev/disk/by-id/google-local-nvme-ssd-0

  4. Formatea el SSD local con un sistema de archivos ext4. Este comando elimina todos los datos del SSD local.

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

    Sustituye [SSD_NAME] por el ID del SSD local que quieras formatear. Por ejemplo, especifica google-local-nvme-ssd-0 para dar formato al primer SSD local NVMe de la instancia.

  5. Usa el comando mkdir para crear un directorio en el que puedas montar el dispositivo.

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

    Sustituye [MNT_DIR] por la ruta del directorio en el que quieras montar tu disco SSD local.

  6. Monta el SSD local en la VM.

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

    Haz los cambios siguientes:

    • [SSD_NAME]: el ID del SSD local que quieras montar.
    • [MNT_DIR]: el directorio en el que quieres montar tu SSD local.

  7. Configura el acceso de lectura y escritura al dispositivo. En este ejemplo, se concede acceso de escritura al dispositivo a todos los usuarios.

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

    Sustituye [MNT_DIR] por el directorio en el que has montado tu SSD local.

Opcionalmente, puedes añadir el SSD local al archivo /etc/fstab para que el dispositivo se vuelva a montar automáticamente cuando se reinicie la instancia. Esta entrada no conserva los datos de tu SSD local si la instancia se detiene. Para obtener más información, consulta Persistencia de datos de SSD local.

Cuando especifiques el archivo /etc/fstab, asegúrate de incluir la opción nofail para que la instancia pueda seguir arrancando aunque no esté presente el SSD local. Por ejemplo, si haces una captura del disco de arranque y creas una instancia sin ningún disco SSD local conectado, la instancia puede continuar con el proceso de inicio y no se detendrá indefinidamente.

  1. Crea la entrada /etc/fstab. Usa el comando blkid para buscar el UUID del sistema de archivos del dispositivo y edita el archivo /etc/fstab para incluir ese UUID con las opciones de montaje. Puedes completar este paso con un solo comando.

    Por ejemplo, para un SSD local en modo NVMe, usa el siguiente comando:

    $ 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

    Para un SSD local en un modo que no sea NVMe, como SCSI, usa el siguiente comando:

    $ 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

    Sustituye [MNT_DIR] por el directorio en el que has montado tu SSD local.

  2. Usa el comando cat para verificar que las entradas de /etc/fstab son correctas:

    $ cat /etc/fstab

Si creas una instantánea del disco de arranque de esta instancia y la usas para crear otra instancia que no tenga unidades SSD locales, edita el archivo /etc/fstab y elimina la entrada de esta unidad SSD local. Aunque tengas la opción nofail activada, mantén el archivo /etc/fstab sincronizado con las particiones conectadas a tu instancia y elimina estas entradas antes de crear la instantánea del disco de arranque.

Instancias de Windows

Usa la herramienta Administración de discos de Windows para formatear y montar un SSD local en una instancia de Windows.

  1. Conéctate a la instancia mediante RDP. En este ejemplo, ve a la página Instancias de VM y haz clic en el botón RDP situado junto a la instancia que tiene las SSD locales conectadas. Después de introducir tu nombre de usuario y contraseña, se abrirá una ventana con la interfaz de escritorio de tu servidor.

  2. Haz clic con el botón derecho en el botón Inicio de Windows y selecciona Administración de discos.

    Seleccionando la herramienta Administrador de discos de Windows en el menú que aparece al hacer clic con el botón derecho en el botón Inicio de Windows.

  3. Si no has inicializado el SSD local antes, la herramienta te pedirá que selecciones un esquema de partición para las nuevas particiones. Selecciona GPT y haz clic en Aceptar.

    Seleccionar un esquema de partición en la ventana de inicialización del disco.

  4. Una vez que se haya inicializado el SSD local, haz clic con el botón derecho en el espacio de disco no asignado y selecciona Nuevo volumen simple.

    Crear un nuevo volumen simple a partir del disco conectado.

  5. Sigue las instrucciones del Asistente para nuevo volumen simple para configurar el nuevo volumen. Puedes usar el formato de partición que quieras, pero en este ejemplo selecciona NTFS. También puedes consultar la sección Realizar un formato rápido para acelerar el proceso de formato.

    Selección del tipo de formato de partición en el Asistente para crear un nuevo volumen simple.

  6. Una vez que hayas completado el asistente y el volumen haya terminado de formatearse, comprueba el nuevo SSD local para asegurarte de que tiene el estado Healthy.

    Consulta la lista de discos que reconoce Windows y comprueba que el SSD local tenga el estado Correcto.

Eso es todo. Ahora puedes escribir archivos en el SSD local.

Formatear y montar varias particiones de SSD local en un único volumen lógico

A diferencia de los SSD persistentes, los SSD locales tienen una capacidad fija de 375 GB por cada dispositivo que conectes a la instancia. Si quieres combinar varias particiones de SSD local en un único volumen lógico, debes definir la gestión de volúmenes en estas particiones.

Instancias de Linux

Usa mdadm para crear un array RAID 0. En este ejemplo, se da formato a la matriz con un solo sistema de archivos ext4, pero puedes aplicar el que prefieras.

  1. Ve a la página Instancias de VM.

    Ir a instancias de VM

  2. Haz clic en el botón SSH situado junto a la instancia que tiene el nuevo SSD local adjunto. El navegador abre una conexión de terminal a la instancia.

  3. En el terminal, instala la herramienta mdadm. El proceso de instalación de mdadm incluye una petición al usuario que detiene las secuencias de comandos, por lo que debes ejecutar este proceso manualmente.

    Debian y Ubuntu: 

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

    CentOS y RHEL: 

    $ sudo yum install mdadm -y

    SLES y openSUSE: 

    $ sudo zypper install -y mdadm

  4. Usa el comando find para identificar todas las unidades SSD locales que quieras montar juntas.

    En este ejemplo, la instancia tiene ocho particiones de SSD local en modo 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 no garantiza un orden. No importa si los dispositivos se muestran en un orden diferente, siempre que el número de líneas de salida coincida con el número esperado de particiones SSD. Las SSDs locales en modo SCSI tienen nombres estándar, como google-local-ssd. Las unidades SSD locales en modo NVMe tienen nombres como google-local-nvme-ssd.

  5. Usa mdadm para combinar varias unidades SSD locales en un solo array llamado /dev/md0. En este ejemplo se combinan ocho dispositivos SSD locales en modo NVMe. En el caso de los dispositivos SSD local en modo SCSI, especifica los nombres que has obtenido con el comando 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.

    Puedes confirmar los detalles de la matriz con mdadm --detail. Si añades la marca --prefer=by-id, se mostrarán los dispositivos que usan las rutas /dev/disk/by-id.

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

    La salida debería ser similar a la siguiente para cada dispositivo de la matriz. 

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

  6. Formatea la matriz /dev/md0 completa con un sistema de archivos ext4.

    $ sudo mkfs.ext4 -F /dev/md0

  7. Crea un directorio en el que puedas montar /dev/md0. En este ejemplo, crea el directorio /mnt/disks/ssd-array:

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

    Sustituye [MNT_DIR] por el directorio en el que quieras montar tu array de SSD local.

  8. Monta la matriz /dev/md0 en el directorio /mnt/disks/ssd-array:

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

    Sustituye [MNT_DIR] por el directorio en el que quieras montar tu array de SSD local.

  9. Configura el acceso de lectura y escritura al dispositivo. En este ejemplo, se concede acceso de escritura al dispositivo a todos los usuarios.

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

    Sustituye [MNT_DIR] por el directorio en el que has montado tu array SSD local.

Opcionalmente, puedes añadir el SSD local al archivo /etc/fstab para que el dispositivo se vuelva a montar automáticamente cuando se reinicie la instancia. Esta entrada no conserva los datos de tu SSD local si la instancia se detiene. Para obtener más información, consulta Persistencia de datos de SSD local.

Cuando especifiques el archivo /etc/fstab, asegúrate de incluir la opción nofail para que la instancia pueda seguir arrancando aunque no esté presente el SSD local. Por ejemplo, si haces una captura del disco de arranque y creas una instancia sin ninguna unidad SSD local conectada, la instancia puede continuar con el proceso de inicio y no se detendrá indefinidamente.

  1. Crea la entrada /etc/fstab. Usa el comando blkid para buscar el UUID del sistema de archivos del dispositivo y edita el archivo /etc/fstab para incluir ese UUID con las opciones de montaje. Especifica la opción nofail para permitir que el sistema arranque aunque el SSD local no esté disponible.Puedes completar este paso con un solo comando. Por ejemplo:

    $ 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

    Sustituye [MNT_DIR] por el directorio en el que has montado tu array SSD local.

  2. Si usas un nombre de dispositivo como /dev/md0 en el archivo /etc/fstab en lugar del UUID, debes editar el archivo /etc/mdadm/mdadm.conf para asegurarte de que el array se vuelva a ensamblar automáticamente al arrancar. Para ello, sigue estos dos pasos:

    1. Asegúrate de que el conjunto de discos se analice y se vuelva a montar automáticamente al arrancar. 
      $ sudo mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf
    2. Actualiza initramfs para que la matriz esté disponible durante el proceso de arranque inicial. 
      $ sudo update-initramfs -u

  3. Usa el comando cat para verificar que las entradas de /etc/fstab son correctas:

    $ cat /etc/fstab

Si creas una instantánea del disco de arranque de esta instancia y la usas para crear otra instancia que no tenga unidades SSD locales, edita el archivo /etc/fstab y elimina la entrada de esta matriz de unidades SSD locales. Aunque tengas la opción nofail activada, mantén el archivo /etc/fstab sincronizado con las particiones conectadas a tu instancia y elimina estas entradas antes de crear la instantánea del disco de arranque.

Instancias de Windows

Usa la herramienta Administración de discos de Windows para formatear y montar un array de SSDs locales en una instancia de Windows.

  1. Conéctate a la instancia mediante RDP. En este ejemplo, ve a la página Instancias de VM y haz clic en el botón RDP situado junto a la instancia que tiene las SSD locales conectadas. Después de introducir tu nombre de usuario y contraseña, se abrirá una ventana con la interfaz de escritorio de tu servidor.

  2. Haz clic con el botón derecho en el botón Inicio de Windows y selecciona Administración de discos.

    Seleccionando la herramienta Administrador de discos de Windows en el menú que aparece al hacer clic con el botón derecho en el botón Inicio de Windows.

  3. Si no has inicializado las unidades SSD locales antes, la herramienta te pedirá que selecciones un esquema de partición para las nuevas particiones. Selecciona GPT y haz clic en Aceptar.

    Seleccionar un esquema de partición en la ventana de inicialización del disco.

  4. Una vez que se haya inicializado el SSD local, haz clic con el botón derecho en el espacio de disco no asignado y selecciona Nuevo volumen seccionado.

    Crear un nuevo volumen seccionado a partir del disco conectado.

  5. Selecciona las particiones de SSD local que quieras incluir en el array segmentado. En este ejemplo, selecciona todas las particiones para combinarlas en una sola unidad SSD local.

    Seleccionar las particiones de SSD local que se incluirán en el array.

  6. Sigue las instrucciones del Asistente para crear volúmenes rayados para configurar el nuevo volumen. Puedes usar el formato de partición que quieras, pero en este ejemplo selecciona NTFS. También puedes consultar la sección Realizar un formato rápido para acelerar el proceso de formato.

    Selección del tipo de formato de partición en el Asistente para crear volumen seccionado.

  7. Una vez que hayas completado el asistente y el volumen haya terminado de formatearse, comprueba el nuevo SSD local para asegurarte de que tiene el estado Healthy.

    Consulta la lista de discos que reconoce Windows y comprueba que el SSD local tenga el estado Correcto.

Ahora puedes escribir archivos en el SSD local.

Siguientes pasos