Agrega una SSD local a tu VM

Las SSD locales se diseñaron para casos de uso de almacenamiento temporal, como caché o espacio provisorio para el procesamiento. Debido a que las SSD locales se encuentran en la máquina física en la que se ejecuta tu VM, solo pueden crearse durante el proceso de creación de la VM. Las SSD locales no se pueden usar como dispositivos de inicio.

En la serie de máquinas de tercera generación, se agrega una cantidad determinada de discos SSD locales a la VM cuando la creas. La única forma de agregar almacenamiento SSD local a estas VMs es la siguiente:

En C3 y C3D, el almacenamiento SSD local está disponible solo con ciertos tipos de máquinas, como c3-standard-88-lssd.
En las series de máquinas Z3, A3 y A2 ultra, todos los tipos de máquinas incluyen almacenamiento SSD local.

En los tipos de máquinas M3, de primera y segunda generación, debes especificar discos SSD locales cuando crees la VM.

Una vez creado la SSD local, debes formatear y activar el dispositivo antes de poder usarlo.

Para obtener información sobre la cantidad de almacenamiento SSD local disponible con varios tipos de máquinas y la cantidad de discos SSD locales que puedes conectar a una VM, consulta los siguientes vínculos: Elige una cantidad válida de SSD locales.

Antes de comenzar

Consulta las limitaciones de SSD locales antes de usarlos.
Revisa las situaciones de persistencia de datos para discos SSD locales.
Si agregas SSD locales a instancias de máquinas virtuales (VM) que tienen GPU conectadas, consulta la disponibilidad de SSD locales por regiones y zonas de GPU.
Si aún no lo hiciste, configura la autenticación. La autenticación es el proceso mediante el cual se verifica tu identidad para acceder a los servicios y las API de Google Cloud. Para ejecutar código o muestras desde un entorno de desarrollo local, puedes autenticarte en Compute Engine de la siguiente manera.

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

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

Crea una VM con una SSD local

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

Console

Ir a la página Crear una instancia

Ir a Crear una instancia
Especifica el nombre, la región y la zona para la VM. De forma opcional, agrega etiquetas.
En la sección Configuración de la máquina, elige la familia de máquinas que contiene el tipo de máquina de destino.
Elige una serie de la lista Series y elige el tipo de máquina.
- En la serie de máquinas de tercera generación C3 y C3D, elige un tipo de máquina que termine en -lssd.
- En el caso de Z3, A3 y A2 ultra, todos los tipos de máquinas incluyen almacenamiento SSD local.
- En las series de máquinas M3 o de primera y segunda generación, después de elegir el tipo de máquina, haz lo siguiente:
  1. Expanda la sección Opciones avanzadas.
  2. Expande Discos, haz clic en Agregar SSD local y haz lo siguiente:
    1. En la página Configurar SSD local, elige el tipo de interfaz de disco.
    2. Elige la cantidad de discos que deseas de la lista Capacidad de disco.
    3. Haz clic en Guardar.
Continúa con el proceso de creación de VM.
Después de crear la VM con discos SSD locales, debes formatear y activar cada dispositivo antes de poder usar los discos.

gcloud

Para las series de máquinas Z3, A3 y A2 ultra, para crear una VM con discos SSD locales conectados, crea una VM que use cualquiera de los tipos de máquinas disponibles para esa serie mediante las siguientes instrucciones: Crea una instancia.
En las series de máquinas C3 o C3D, a fin de crear una VM con discos SSD locales conectados, sigue las instrucciones para crear una instancia, pero especifica un tipo de instancia que incluya los discos SSD locales (-lssd).

Por ejemplo, puedes crear una VM C3 con dos particiones SSD locales 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
```
Para las series de máquinas M3 y de primera y segunda generación, a fin de 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 varias particiones SSD locales, agrega más marcas --local-ssd. De manera opcional, también puedes configurar valores de 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 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
```

Reemplaza lo siguiente:

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

Si es necesario, puedes conectar SSD locales a una VM de primera o segunda generación con 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 activar cada dispositivo antes de 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 {}
  }
}

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

Para generar el código de Terraform, puedes usar el componente Código equivalente en la consola de Google Cloud.

En la consola de Google Cloud, ve a la página Instancias de VM.
Ir a Instancias de VM
Haz clic en Crear instancia.
Especifica los parámetros que desees.
En la parte superior o inferior de la página, haz clic en Código equivalente y, luego, en la pestaña Terraform para ver el código de Terraform.

Go

Antes de probar esta muestra, sigue las instrucciones de configuración de Go en la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Go de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para 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

Antes de probar esta muestra, sigue las instrucciones de configuración de Java en la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Java de Compute Engine.


import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.Image;
import com.google.cloud.compute.v1.ImagesClient;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateWithLocalSsd {

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

    createWithLocalSsd(projectId, zone, instanceName);
  }

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

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

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

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

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

  }

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

  // Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
  // source for the new disk.
  //
  // Args:
  //    diskType: the type of disk you want to create. This value uses the following format:
  //        "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
  //        For example: "zones/us-west3-b/diskTypes/pd-ssd"
  //
  //    diskSizeGb: size of the new disk in gigabytes.
  //
  //    boot: boolean flag indicating whether this disk should be used as a
  //    boot disk of an instance.
  //
  //    sourceImage: source image to use when creating this disk.
  //    You must have read access to this disk. This can be one of the publicly available images
  //    or an image from one of your projects.
  //    This value uses the following format: "projects/{project_name}/global/images/{image_name}"
  //
  //    autoDelete: boolean flag indicating whether this disk should be deleted
  //    with the VM that uses it.
  private static AttachedDisk createDiskFromImage(String diskType, int diskSizeGb, boolean boot,
      String sourceImage, boolean autoDelete) {

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

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

    return bootDisk;
  }

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

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

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

    return disk;
  }

  // Send an instance creation request to the Compute Engine API and wait for it to complete.
  // Args:
  //    projectId: project ID or project number of the Cloud project you want to use.
  //    zone: name of the zone to create the instance in. For example: "us-west3-b"
  //    instanceName: name of the new virtual machine (VM) instance.
  //    disks: a list of compute.v1.AttachedDisk objects describing the disks
  //           you want to attach to your new instance.
  private static Instance createInstance(String projectId, String zone, String instanceName,
      List<AttachedDisk> disks)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `instancesClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      // machineType: machine type of the VM being created. This value uses the
      // following format: "zones/{zone}/machineTypes/{type_name}".
      // For example: "zones/europe-west3-c/machineTypes/f1-micro"
      String typeName = "n1-standard-1";
      String machineType = String.format("zones/%s/machineTypes/%s", zone, typeName);

      // networkLink: name of the network you want the new instance to use.
      // For example: "global/networks/default" represents the network
      // named "default", which is created automatically for each project.
      String networkLink = "global/networks/default";

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

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

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

  }

}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración de Python en la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Python de Compute Engine.

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def get_image_from_family(project: str, family: str) -> compute_v1.Image:
    """
    Retrieve the newest image that is part of a given family in a project.

    Args:
        project: project ID or project number of the Cloud project you want to get image from.
        family: name of the image family you want to get image from.

    Returns:
        An Image object.
    """
    image_client = compute_v1.ImagesClient()
    # List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
    newest_image = image_client.get_from_family(project=project, family=family)
    return newest_image


def disk_from_image(
    disk_type: str,
    disk_size_gb: int,
    boot: bool,
    source_image: str,
    auto_delete: bool = True,
) -> compute_v1.AttachedDisk:
    """
    Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
    source for the new disk.

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        source_image: source image to use when creating this disk. You must have read access to this disk. This can be one
            of the publicly available images or an image from one of your projects.
            This value uses the following format: "projects/{project_name}/global/images/{image_name}"
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created using the specified image.
    """
    boot_disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = source_image
    initialize_params.disk_size_gb = disk_size_gb
    initialize_params.disk_type = disk_type
    boot_disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    boot_disk.auto_delete = auto_delete
    boot_disk.boot = boot
    return boot_disk


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

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

    Returns:
        AttachedDisk object configured as a local SSD disk.
    """
    disk = compute_v1.AttachedDisk()
    disk.type_ = compute_v1.AttachedDisk.Type.SCRATCH.name
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.disk_type = f"zones/{zone}/diskTypes/local-ssd"
    disk.initialize_params = initialize_params
    disk.auto_delete = True
    return disk


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def create_instance(
    project_id: str,
    zone: str,
    instance_name: str,
    disks: list[compute_v1.AttachedDisk],
    machine_type: str = "n1-standard-1",
    network_link: str = "global/networks/default",
    subnetwork_link: str = None,
    internal_ip: str = None,
    external_access: bool = False,
    external_ipv4: str = None,
    accelerators: list[compute_v1.AcceleratorConfig] = None,
    preemptible: bool = False,
    spot: bool = False,
    instance_termination_action: str = "STOP",
    custom_hostname: str = None,
    delete_protection: bool = False,
) -> compute_v1.Instance:
    """
    Send an instance creation request to the Compute Engine API and wait for it to complete.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new instance.
        machine_type: machine type of the VM being created. This value uses the
            following format: "zones/{zone}/machineTypes/{type_name}".
            For example: "zones/europe-west3-c/machineTypes/f1-micro"
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"
        internal_ip: internal IP address you want to assign to the new instance.
            By default, a free address from the pool of available internal IP addresses of
            used subnet will be used.
        external_access: boolean flag indicating if the instance should have an external IPv4
            address assigned.
        external_ipv4: external IPv4 address to be assigned to this instance. If you specify
            an external IP address, it must live in the same region as the zone of the instance.
            This setting requires `external_access` to be set to True to work.
        accelerators: a list of AcceleratorConfig objects describing the accelerators that will
            be attached to the new instance.
        preemptible: boolean value indicating if the new instance should be preemptible
            or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
        spot: boolean value indicating if the new instance should be a Spot VM or not.
        instance_termination_action: What action should be taken once a Spot VM is terminated.
            Possible values: "STOP", "DELETE"
        custom_hostname: Custom hostname of the new VM instance.
            Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
        delete_protection: boolean value indicating if the new virtual machine should be
            protected against deletion or not.
    Returns:
        Instance object.
    """
    instance_client = compute_v1.InstancesClient()

    # Use the network interface provided in the network_link argument.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network_link
    if subnetwork_link:
        network_interface.subnetwork = subnetwork_link

    if internal_ip:
        network_interface.network_i_p = internal_ip

    if external_access:
        access = compute_v1.AccessConfig()
        access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
        access.name = "External NAT"
        access.network_tier = access.NetworkTier.PREMIUM.name
        if external_ipv4:
            access.nat_i_p = external_ipv4
        network_interface.access_configs = [access]

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    instance.network_interfaces = [network_interface]
    instance.name = instance_name
    instance.disks = disks
    if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
        instance.machine_type = machine_type
    else:
        instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"

    instance.scheduling = compute_v1.Scheduling()
    if accelerators:
        instance.guest_accelerators = accelerators
        instance.scheduling.on_host_maintenance = (
            compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
        )

    if preemptible:
        # Set the preemptible setting
        warnings.warn(
            "Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
        )
        instance.scheduling = compute_v1.Scheduling()
        instance.scheduling.preemptible = True

    if spot:
        # Set the Spot VM setting
        instance.scheduling.provisioning_model = (
            compute_v1.Scheduling.ProvisioningModel.SPOT.name
        )
        instance.scheduling.instance_termination_action = instance_termination_action

    if custom_hostname is not None:
        # Set the custom hostname for the instance
        instance.hostname = custom_hostname

    if delete_protection:
        # Set the delete protection bit
        instance.deletion_protection = True

    # Prepare the request to insert an instance.
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    # Wait for the create operation to complete.
    print(f"Creating the {instance_name} instance in {zone}...")

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

    print(f"Instance {instance_name} created.")
    return instance_client.get(project=project_id, zone=zone, instance=instance_name)


def create_with_ssd(
    project_id: str, zone: str, instance_name: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with Debian 10 operating system and SSD local disk.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.

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

REST

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 las series de máquinas Z3, A3 y A2 ultra, para crear una VM con discos SSD locales conectados, crea una VM que use cualquiera de los tipos de máquinas disponibles para esa serie.

En la serie de máquinas C3 o C3D, para crear una VM con discos SSD locales conectados, especifica un tipo de instancia que incluya discos SSD locales (-lssd).

Esta es muestra una carga útil de muestra de la solicitud de muestra 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 agregar dispositivos SSD locales durante la creación de la VM con la propiedad initializeParams. También debes proporcionar las siguientes propiedades:

diskType: Establecer en SSD local
autoDelete: establecer en verdadero
type: Establecer en SCRATCH

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

diskName
Propiedad sourceImage
diskSizeGb

Esta es una carga útil de la solicitud de muestra 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"
    }
 ]
}

Una vez creado la SSD local, debes formatear y activar cada dispositivo antes de poder usarlo.

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

Da formato a un dispositivo SSD local y actívalo

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

Da formato a las particiones SSD locales individuales y actívalas

La forma más fácil de conectar SSD locales a tu instancia es formatear y activar cada dispositivo con una sola partición. Otra opción es combinar varias particiones en un solo volumen lógico.

Instancias de Linux

Formatea y activa el nuevo SSD local en tu instancia de Linux. Puedes usar cualquier formato y configuración de partición que necesites. Para este ejemplo, debes crear una única partición ext4.

Ve a la página Instancias de VM.
Ir a Instancias de VM
Haz clic en el botón SSH al lado de la instancia que tiene la SSD local nuevo conectado. El navegador abre una conexión de terminal a la instancia.
En el terminal, usa el comando find para identificar el SSD local que quieres activar.
```
$ find /dev/ | grep google-local-nvme-ssd
```
Las SSD locales en modo SCSI tienen nombres estándar, como google-local-ssd-0. Las 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
```
Formatea el SSD local con un sistema de archivos ext4. Este comando borra todos los datos existentes del SSD local.
```
$ sudo mkfs.ext4 -F /dev/disk/by-id/[SSD_NAME]
```
Reemplaza [SSD_NAME] por el ID de la unidad SSD local que quieres formatear. Por ejemplo, especifica google-local-nvme-ssd-0 para dar formato al primer SSD local NVMe en la instancia.
Usa el comando mkdir para crear un directorio en el que puedas activar el dispositivo.
```
$ sudo mkdir -p /mnt/disks/[MNT_DIR]
```
Reemplaza [MNT_DIR] por la ruta de acceso del directorio en el que deseas activar tu disco SSD local.
Activa el SSD local en la VM.
```
$ sudo mount /dev/[SSD_NAME] /mnt/disks/[MNT_DIR]
```
Reemplaza lo siguiente:
- [SSD_NAME]: Es el ID del SSD local que quieres activar.
- [MNT_DIR]: El directorio en el que deseas activar la SSD local.
Configura el acceso de lectura y escritura al dispositivo. En este ejemplo, se debe otorgar acceso de escritura al dispositivo para todos los usuarios.
```
$ sudo chmod a+w /mnt/disks/[MNT_DIR]
```
Reemplaza [MNT_DIR] por el directorio en el que activaste el SSD local.

De forma opcional, puedes agregar la SSD local al archivo /etc/fstab para que el dispositivo se vuelva a activar de forma automática cuando se reinicie la instancia. Esta entrada no conserva los datos de tu SSD local si la instancia se detiene. Consulta Persistencia de datos de SSD locales para obtener detalles completos.

Cuando especifiques el archivo de entrada /etc/fstab, asegúrate de incluir la opción nofail para que la instancia pueda continuar arrancando, incluso si la SSD local no está presente. Por ejemplo, si tomas una instantánea del disco de arranque y creas una instancia nueva sin ninguna SSD local conectada, la instancia puede continuar el proceso de inicio y no detenerse indefinidamente.

Crea la entrada /etc/fstab. Usa el comando blkid para buscar el UUID para el sistema de archivos en el dispositivo y edita el archivo /etc/fstab si quieres incluir ese UUID con las opciones de activación. Puedes completar este paso con un solo comando.

Por ejemplo, para una 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 una 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
```
Reemplaza [MNT_DIR] por el directorio en el que activaste el SSD local.
Usa el comando cat para verificar que tus entradas /etc/fstab sean correctas:
```
$ cat /etc/fstab
```

Si creas una instantánea desde el disco de arranque de esta instancia y la usas para crear una instancia separada que no tenga SSD locales, edita el archivo /etc/fstab y quita la entrada para este SSD local. Incluso con la opción nofail establecida, debes mantener el archivo /etc/fstab en sincronización con las particiones conectadas a tu instancia y quitar estas entradas antes de crear la instantánea del disco de arranque.

Instancias de Windows

Usa las herramientas de administración de discos de Windows para formatear y activar una SSD local en una instancia de Windows.

Conéctate a la instancia a través de RDP. Para este ejemplo, ve a la página de instancias de VM y haz clic en el botón RDP al lado de la instancia que tiene las SSD locales conectados. Después de ingresar tu nombre de usuario y contraseña, se abre una ventana con la interfaz de escritorio de tu servidor.
Haz clic derecho en el botón Inicio de Windows y elige Administración de discos (Disk Management).
Si no inicializaste la SSD local antes, la herramienta te pedirá que selecciones un esquema de partición para las particiones nuevas. Elige GPT y haz clic en Aceptar (OK).
Una vez que se inicialice la SSD local, haz clic con el botón derecho en el espacio del disco sin asignar y elige Nuevo volumen simple.
Sigue las instrucciones del Asistente para nuevo volumen simple (New Simple Volume Wizard) para configurar el volumen nuevo. Puedes usar cualquier formato de partición que quieras, pero para este ejemplo, elige NTFS. Además, debes marcar Dar formato rápido (Perform a quick format) para acelerar el proceso de formateo.
Una vez que seguiste los pasos del asistente y el volumen termina de formatearse, debes verificar la SSD local nuevo para asegurarte de que el estado sea Healthy.

Listo. Ahora puedes escribir archivos en la SSD local.

Da formato a varias particiones SSD locales en un solo volumen lógico y actívalas

A diferencia de las SSD persistentes, las SSD locales tienen una capacidad fija de 375 GB para cada dispositivo que conectes a la instancia. Si deseas combinar varias particiones SSD locales en un solo volumen lógico, debes definir la administración del volumen en estas particiones.

Instancias de Linux

Usa mdadm para crear un arreglo de RAID 0. En este ejemplo, se da formato al arreglo con un único sistema de archivos ext4, pero puedes aplicar cualquier sistema de archivos que prefieras.

Ve a la página Instancias de VM.
Ir a Instancias de VM
Haz clic en el botón SSH al lado de la instancia que tiene la SSD local nuevo conectado. El navegador abre una conexión de terminal a la instancia.
En la terminal, instala la herramienta mdadm. El proceso de instalación para mdadm incluye una solicitud de usuario que detiene las secuencias de comandos, por lo tanto, debes ejecutar este proceso de forma manual.

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
```
Usa el comando find para identificar todas las SSD locales que quieras activar juntos:

Para este ejemplo, la instancia tiene ocho particiones SSD locales 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. Está bien que los dispositivos aparezcan en un orden diferente, siempre que la cantidad de líneas del resultado coincida con la cantidad esperada de particiones SSD. Las SSD locales en modo SCSI tienen nombres estándar, como google-local-ssd. Las SSD locales en modo NVMe tienen nombres como google-local-nvme-ssd.

Usa mdadm para combinar varios dispositivos SSD locales en un solo arreglo llamado /dev/md0. En este ejemplo, se combinan ocho dispositivos SSD locales en modo NVMe. Para dispositivos SSD locales en modo SCSI, especifica los nombres que obtuviste del 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 del array con mdadm --detail. Agrega la marca --prefer=by-id para que se muestren los dispositivos que usan las rutas /dev/disk/by-id.

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

El resultado debería ser similar al siguiente para cada dispositivo del array.

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

Formatea el arreglo /dev/md0 completo con un sistema de archivos ext4.

Precaución: Con este comando se borran todos los datos existentes de las SSD locales.
```
$ sudo mkfs.ext4 -F /dev/md0
```
Crea un directorio en el que puedas activar /dev/md0. Para este ejemplo, crea el directorio /mnt/disks/ssd-array:
```
$ sudo mkdir -p /mnt/disks/[MNT_DIR]
```
Reemplaza [MNT_DIR] por el directorio en el que deseas activar tu arreglo de SSD local.
Activa el arreglo /dev/md0 en el directorio /mnt/disks/ssd-array.
```
$ sudo mount /dev/md0 /mnt/disks/[MNT_DIR]
```
Reemplaza [MNT_DIR] por el directorio en el que deseas activar tu arreglo de SSD local.
Configura el acceso de lectura y escritura al dispositivo. En este ejemplo, se debe otorgar acceso de escritura al dispositivo para todos los usuarios.
```
$ sudo chmod a+w /mnt/disks/[MNT_DIR]
```
Reemplaza [MNT_DIR] por el directorio en el que activaste tu arreglo de SSD local.

Cuando especifiques el archivo de entrada /etc/fstab, asegúrate de incluir la opción nofail para que la instancia pueda continuar arrancando, incluso si la SSD local no está presente. Por ejemplo, si tomas una instantánea del disco de arranque y creas una instancia nueva sin ningún SSD local conectado, la instancia puede continuar el proceso de inicio y no se detendrá de manera indefinida.

Crea la entrada /etc/fstab. Usa el comando blkid para buscar el UUID para el sistema de archivos en el dispositivo y edita el archivo /etc/fstab si quieres incluir ese UUID con las opciones de activación. Especifica la opción nofail para permitir que el sistema se inicie, 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
```
Reemplaza [MNT_DIR] por el directorio en el que activaste tu arreglo de SSD local.
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 en el inicio. Para hacerlo, sigue los dos pasos que se indican a continuación:
1. Asegúrate de que el array del disco se analice y se vuelva a ensamblar automáticamente en el inicio.
```
$ sudo mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf
```
2. Actualiza initramfs para que el array esté disponible durante el proceso de inicio anticipado.
```
$ sudo update-initramfs -u
```
Usa el comando cat para verificar que tus entradas /etc/fstab sean correctas:
```
$ cat /etc/fstab
```

Si creas una instantánea desde el disco de arranque de esta instancia y la usas para crear una instancia separada que no tenga SSD locales, edita el archivo /etc/fstab y quita la entrada para este array de SSD local. Incluso con la opción nofail establecida, debes mantener el archivo /etc/fstab en sincronización con las particiones conectadas a tu instancia y quitar estas entradas antes de crear la instantánea del disco de arranque.

Instancias de Windows

Usa las herramientas de administración de discos de Windows para formatear y activar un arreglo de SSD locales en una instancia de Windows.

Conéctate a la instancia a través de RDP. Para este ejemplo, ve a la página de instancias de VM y haz clic en el botón RDP al lado de la instancia que tiene las SSD locales conectados. Después de ingresar tu nombre de usuario y contraseña, se abre una ventana con la interfaz de escritorio de tu servidor.
Haz clic derecho en el botón Inicio de Windows y elige Administración de discos (Disk Management).
Si no inicializaste los SSD locales antes, la herramienta te pedirá que selecciones un esquema de partición para las particiones nuevas. Elige GPT y haz clic en Aceptar (OK).
Una vez que se inicialice la SSD local, haz clic con el botón derecho en el espacio del disco sin asignar y elige Nuevo volumen seccionado (New Striped Volume).
Elige las particiones SSD locales que deseas incluir en el arreglo seccionado. En este ejemplo, se seleccionan todas las particiones para combinarlas en un solo dispositivo SSD local.
Sigue las instrucciones del Asistente para nuevo volumen seccionado (New Striped Volume Wizard) para configurarlo. Puedes usar cualquier formato de partición que quieras, pero para este ejemplo, elige NTFS. Además, debes marcar Dar formato rápido (Perform a quick format) para acelerar el proceso de formateo.
Una vez que seguiste los pasos del asistente y el volumen termina de formatearse, debes verificar la SSD local nuevo para asegurarte de que el estado sea Healthy.

Ahora puedes escribir archivos en la SSD local.

¿Qué sigue?

Obtén más información sobre los nombres de dispositivos de tu VM.
Aprende a comparar el rendimiento de los discos SSD locales