Esta página foi traduzida pela API Cloud Translation.

Adicione um SSD local à sua VM

Os SSDs locais foram concebidos para exemplos de utilização de armazenamento temporário, como caches ou espaço de processamento temporário. Uma vez que os SSDs locais estão localizados na máquina física onde a VM está a ser executada, só podem ser criados durante o processo de criação da VM. Não é possível usar SSDs locais como dispositivos de arranque.

Para a série de máquinas de terceira geração e posteriores, é adicionada uma quantidade definida de discos SSD locais à VM quando a cria. A única forma de adicionar armazenamento SSD local a estas VMs é:

Para C4, C4D, C3 e C3D, o armazenamento SSD local só está disponível com determinados tipos de máquinas, como c3-standard-88-lssd.
Para as séries de máquinas Z3, A4, A4X, A3 e A2 Ultra, todos os tipos de máquinas incluem armazenamento SSD local.

Para os tipos de máquinas M3 e de primeira e segunda geração, tem de especificar discos SSD locais quando cria a VM.

Depois de criar um disco SSD local, tem de formatar e montar o dispositivo antes de o poder usar.

Para obter informações sobre a quantidade de armazenamento SSD local disponível com vários tipos de máquinas e o número de discos SSD locais que pode associar a uma VM, consulte o artigo Escolher um número válido de SSDs locais.

Antes de começar

Reveja as limitações do SSD local antes de usar SSDs locais.
Reveja os cenários de persistência de dados para discos SSD locais.
Se estiver a adicionar SSDs locais a instâncias de máquinas virtuais (VM) com GPUs associadas, consulte o artigo Disponibilidade de SSDs locais por regiões e zonas de GPU.
Se ainda não o tiver feito, configure a autenticação. A autenticação valida a sua identidade para aceder a Google Cloud serviços e APIs. Para executar código ou exemplos a partir de um ambiente de desenvolvimento local, pode autenticar-se no Compute Engine selecionando uma das seguintes opções:
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. Instale a CLI Google Cloud. Após a instalação, inicialize a CLI gcloud executando o seguinte comando:
  gcloud init
  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.
  
  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.
2. Set a default region and zone.
Terraform

Para usar os exemplos do Terraform nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as credenciais predefinidas da aplicação com as suas credenciais de utilizador.
Para mais informações, consulte Set up authentication for a local development environment.
Go

Para usar os Go exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.
Para mais informações, consulte Set up authentication for a local development environment.
Java

Para usar os Java exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.
Para mais informações, consulte Set up authentication for a local development environment.
Python

Para usar os Python exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.
Para mais informações, consulte Set up authentication for a local development environment.
REST

Para usar os exemplos da API REST nesta página num ambiente de desenvolvimento local, usa as credenciais que fornece à CLI gcloud.
Para mais informações, consulte o artigo Autenticar para usar REST na Google Cloud documentação de autenticação.

Crie uma VM com um SSD local

Pode criar uma VM com armazenamento em disco SSD local através da Google Cloud console, da CLI gcloud ou da API Compute Engine.

Consola

Aceda à página Criar uma instância.

Aceda a Criar uma instância
Especifique o nome, a região e a zona da sua VM. Opcionalmente, adicione etiquetas ou rótulos.
Na secção Configuração da máquina, escolha a família de máquinas que contém o tipo de máquina de destino.
Selecione uma série na lista Série e, em seguida, escolha o tipo de máquina.
- Para C4, C4D, C3 e C3D, escolha um tipo de máquina que termine em -lssd.
- Para o Z3, o A4, o A4X, o A3 e o A2 Ultra, todos os tipos de máquinas incluem armazenamento SSD local.
- Para a série de máquinas M3 ou de primeira e segunda geração, depois de selecionar o tipo de máquina, faça o seguinte:
  1. Expanda a secção Opções avançadas.
  2. Expanda Discos, clique em Adicionar SSD local e faça o seguinte:
    1. Na página Configurar SSD local, escolha o tipo de interface de disco.
    2. Selecione o número de discos pretendido na lista Capacidade do disco.
    3. Clique em Guardar.
Continue com o processo de criação da VM.
Depois de criar a VM com discos SSD locais, tem de formatar e montar cada dispositivo antes de poder usar os discos.

gcloud

Para as séries de máquinas Z3, A4, A4X, A3 e A2 Ultra, para criar uma VM com discos SSD locais anexados, crie uma VM que use qualquer um dos tipos de máquinas disponíveis para essa série seguindo as instruções para criar uma instância.
Para as séries de máquinas C4, C4D, C3 e C3D, para criar uma VM com discos SSD locais anexados, siga as instruções para criar uma instância, mas especifique um tipo de instância que inclua discos SSD locais (-lssd).

Por exemplo, pode criar uma VM C3 com duas partições de SSD local que usam a interface de disco NVMe da seguinte forma:
```
gcloud compute instances create example-c3-instance \
   --zone ZONE \
   --machine-type c3-standard-8-lssd \
   --image-project IMAGE_PROJECT \
   --image-family IMAGE_FAMILY
```
Para as séries de máquinas M3 e de primeira e segunda geração, para criar uma VM com discos SSD local anexados, siga as instruções para criar uma instância, mas use a flag --local-ssd para criar e anexar um disco SSD local. Para criar vários discos SSD locais, adicione mais flags --local-ssd. Opcionalmente, também pode definir valores para a interface e o nome do dispositivo para cada indicador --local-ssd.

Por exemplo, pode criar uma VM M3 com quatro discos SSD locais e especificar o tipo de interface de disco da seguinte forma:
```
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
```

Substitua o seguinte:

VM_NAME: o nome da nova VM
ZONE: a zona na qual criar a VM. Esta flag é opcional se tiver configurado a propriedade compute/zone da CLI gcloud ou a variável de ambiente CLOUDSDK_COMPUTE_ZONE.
INTERFACE_TYPE: o tipo de interface de disco que quer usar para o dispositivo SSD local. Especifique nvme se estiver a criar uma VM M3 ou se a imagem do disco de arranque tiver controladores NVMe otimizados. Especifique scsi para outras imagens.
DEVICE-NAME: Opcional: um nome que indica o nome do disco a usar no link simbólico (symlink) do sistema operativo convidado.
IMAGE_FAMILY: uma das famílias de imagens disponíveis que quer instalada no disco de arranque
IMAGE_PROJECT: o projeto de imagem ao qual a família de imagens pertence

Se necessário, pode anexar SSDs locais a uma VM de primeira ou segunda geração através de uma combinação de nvme e scsi para diferentes partições. O desempenho do dispositivo nvme depende da imagem do disco de arranque da sua instância. As VMs de terceira geração só suportam a interface de disco NVMe.

Depois de criar uma VM com um SSD local, tem de formatar e montar cada dispositivo antes de o poder usar.

Terraform

Para criar uma VM com discos SSD locais anexados, pode usar o 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 como aplicar ou remover uma configuração do Terraform, consulte os comandos básicos do Terraform.

Para gerar o código do Terraform, pode usar o componente Código equivalente na Google Cloud consola.

Na Google Cloud consola, aceda à página Instâncias de VM.
Aceder a Instâncias de VM
Clique em Criar instância.
Especifique os parâmetros pretendidos.
Na parte superior ou inferior da página, clique em Código equivalente e, de seguida, clique no separador Terraform para ver o código Terraform.

Go

Antes de experimentar este exemplo, siga as Goinstruções de configuração no guia de início rápido do Compute Engine com bibliotecas cliente. Para mais informações, consulte a documentação de referência da API Go Compute Engine.

Para se autenticar no Compute Engine, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento 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 experimentar este exemplo, siga as Javainstruções de configuração no guia de início rápido do Compute Engine com bibliotecas cliente. Para mais informações, consulte a documentação de referência da API Java Compute Engine.

Para se autenticar no Compute Engine, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento 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

Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no guia de início rápido do Compute Engine com bibliotecas cliente. Para mais informações, consulte a documentação de referência da API Python Compute Engine.

Para se autenticar no Compute Engine, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento 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

Use o comando instances.insert method para criar uma VM a partir de uma família de imagens ou de uma versão específica de uma imagem do sistema operativo.

Para as séries de máquinas Z3, A4, A4X, A3 e A2 Ultra, para criar uma VM com discos SSD locais anexados, crie uma VM que use qualquer um dos tipos de máquinas disponíveis para essa série.

Para as séries de máquinas C4, C4D, C3 e C3D, para criar uma VM com discos SSD locais anexados, especifique um tipo de instância que inclua discos SSD locais (-lssd).

Segue-se um exemplo de payload de pedido que cria uma VM C3 com um disco de arranque do Ubuntu e dois discos SSD locais:

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

Para as séries de máquinas M3 e de primeira e segunda geração, para criar uma VM com discos SSD locais anexados, pode adicionar dispositivos SSD locais durante a criação da VM através da propriedade initializeParams. Também tem de fornecer as seguintes propriedades:

diskType: definido como SSD local
autoDelete: definido como verdadeiro
type: definido como SCRATCH

Não é possível usar as seguintes propriedades com dispositivos SSD local:

diskName
sourceImage propriedade
diskSizeGb

Segue-se um exemplo de uma carga útil de pedido que cria uma VM M3 com um disco de arranque e quatro discos SSD locais:

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

Depois de criar um disco SSD local, tem de formatar e montar cada dispositivo antes de o poder usar.

Para mais informações sobre como criar uma instância através da REST, consulte a API Compute Engine.

Formatar e montar um dispositivo SSD local

Pode formatar e montar cada disco SSD local individualmente ou combinar vários discos SSD locais num único volume lógico.

Formate e monte partições SSD locais individuais

A forma mais fácil de ligar SSDs locais à sua instância é formatar e montar cada dispositivo com uma única partição. Em alternativa, pode combinar várias partições num único volume lógico.

Instâncias do Linux

Formate e monte o novo SSD local na sua instância do Linux. Pode usar qualquer formato de partição e configuração de que necessitar. Para este exemplo, crie uma única partição ext4.

Aceda à página de instâncias de VM.
Aceder às instâncias de VM
Clique no botão SSH junto à instância que tem o novo SSD local anexado. O navegador abre uma ligação de terminal à instância.
No terminal, use o comando find para identificar o SSD local que quer montar.
```
$ find /dev/ | grep google-local-nvme-ssd
```
Os SSDs locais no modo SCSI têm nomes padrão, como google-local-ssd-0. Os SSDs locais no modo NVMe têm nomes como google-local-nvme-ssd-0, conforme mostrado no seguinte resultado:
```
 $ find /dev/ | grep google-local-nvme-ssd

 /dev/disk/by-id/google-local-nvme-ssd-0
```
Formate o SSD local com um sistema de ficheiros ext4. Este comando elimina todos os dados existentes do SSD local.
```
$ sudo mkfs.ext4 -F /dev/disk/by-id/[SSD_NAME]
```
Substitua [SSD_NAME] pelo ID do SSD local que quer formatar. Por exemplo, especifique google-local-nvme-ssd-0 para formatar o primeiro NVMe Local SSD na instância.
Use o comando mkdir para criar um diretório onde pode montar o dispositivo.
```
$ sudo mkdir -p /mnt/disks/[MNT_DIR]
```
Substitua [MNT_DIR] pelo caminho do diretório onde quer montar o disco SSD local.
Monte o SSD local na VM.
```
$ sudo mount /dev/disk/by-id/[SSD_NAME] /mnt/disks/[MNT_DIR]
```
Substitua o seguinte:
- [SSD_NAME]: o ID do SSD local que quer montar.
- [MNT_DIR]: o diretório onde quer montar o SSD local.
Configurar o acesso de leitura e escrita ao dispositivo. Para este exemplo, conceda acesso de escrita ao dispositivo a todos os utilizadores.
```
$ sudo chmod a+w /mnt/disks/[MNT_DIR]
```
Substitua [MNT_DIR] pelo diretório onde montou o SSD local.

Opcionalmente, pode adicionar o SSD local ao ficheiro /etc/fstab para que o dispositivo seja montado automaticamente novamente quando a instância for reiniciada. Esta entrada não preserva os dados no SSD local se a instância for interrompida. Consulte o artigo Persistência de dados do SSD local para ver os detalhes completos.

Quando especificar o ficheiro /etc/fstab, certifique-se de que inclui a opção nofail para que a instância possa continuar a ser iniciada mesmo que o SSD local não esteja presente. Por exemplo, se tirar uma captura instantânea do disco de arranque e criar uma nova instância sem discos SSD locais anexados, a instância pode continuar o processo de arranque e não pausar indefinidamente.

Crie a entrada /etc/fstab. Use o comando blkid para encontrar o UUID do sistema de ficheiros no dispositivo e edite o ficheiro /etc/fstab para incluir esse UUID com as opções de montagem. Pode concluir este passo com um único comando.

Por exemplo, para um SSD local no modo NVMe, use o seguinte 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 um SSD local num modo não NVMe, como SCSI, use o seguinte 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
```
Substitua [MNT_DIR] pelo diretório onde montou o SSD local.
Use o comando cat para verificar se as entradas /etc/fstab estão corretas:
```
$ cat /etc/fstab
```

Se criar um instantâneo a partir do disco de arranque desta instância e o usar para criar uma instância separada que não tenha SSDs locais, edite o ficheiro /etc/fstab e remova a entrada para este SSD local. Mesmo com a opção nofail ativada, mantenha o ficheiro /etc/fstab sincronizado com as partições anexadas à sua instância e remova estas entradas antes de criar a imagem instantânea do disco de arranque.

Instâncias do Windows

Use a ferramenta de gestão de discos do Windows para formatar e montar um SSD local numa instância do Windows.

Ligue-se à instância através do RDP. Para este exemplo, aceda à página de instâncias de VMs e clique no botão RDP junto à instância que tem os SSDs locais anexados. Depois de introduzir o nome de utilizador e a palavra-passe, é aberta uma janela com a interface de computador para o seu servidor.
Clique com o botão direito do rato no botão Iniciar do Windows e selecione Gestão de discos.
Se não tiver inicializado o SSD local anteriormente, a ferramenta pede-lhe que selecione um esquema de partição para as novas partições. Selecione GPT e clique em OK.
Após a inicialização do SSD local, clique com o botão direito do rato no espaço não atribuído do disco e selecione New Simple Volume.
Siga as instruções no New Simple Volume Wizard para configurar o novo volume. Pode usar qualquer formato de partição que quiser, mas, para este exemplo, selecione NTFS. Além disso, selecione Perform a quick format para acelerar o processo de formatação.
Depois de concluir o assistente e a formatação do volume, verifique o novo SSD local para garantir que tem o estado Healthy.

E é tudo! Agora, pode escrever ficheiros no SSD local.

Formate e monte várias partições de SSD local num único volume lógico

Ao contrário dos SSDs persistentes, os SSDs locais têm uma capacidade fixa de 375 GB para cada dispositivo que associa à instância. Se quiser combinar várias partições de SSD local num único volume lógico, tem de definir a gestão de volumes nestas partições.

Instâncias do Linux

Use mdadm para criar uma matriz RAID 0. Este exemplo formata a matriz com um único sistema de ficheiros ext4, mas pode aplicar qualquer sistema de ficheiros que preferir.

Aceda à página de instâncias de VM.
Aceder às instâncias de VM
Clique no botão SSH junto à instância que tem o novo SSD local anexado. O navegador abre uma ligação de terminal à instância.
No terminal, instale a ferramenta mdadm. O processo de instalação do mdadm inclui um pedido ao utilizador que interrompe os scripts, pelo que deve executar este processo manualmente.

Debian e Ubuntu:
```
$ sudo apt update && sudo apt install mdadm --no-install-recommends
```
CentOS e RHEL:
```
$ sudo yum install mdadm -y
```
SLES e openSUSE:
```
$ sudo zypper install -y mdadm
```
Use o comando find para identificar todos os SSDs locais que quer montar em conjunto.

Para este exemplo, a instância tem oito partições de SSD local no 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 não garante uma encomenda. Não há problema se os dispositivos forem apresentados por ordem diferente, desde que o número de linhas de saída corresponda ao número esperado de partições SSD. Os SSDs locais no modo SCSI têm nomes padrão, como google-local-ssd. Os SSDs locais no modo NVMe têm nomes como google-local-nvme-ssd.

Use mdadm para combinar vários dispositivos SSD locais num único conjunto denominado /dev/md0. Este exemplo une oito dispositivos SSD locais no modo NVMe. Para dispositivos SSD locais no modo SCSI, especifique os nomes que obteve através do 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.

Pode confirmar os detalhes da matriz com mdadm --detail. A adição da flag --prefer=by-id apresenta uma lista dos dispositivos que usam os caminhos /dev/disk/by-id.

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

O resultado deve ser semelhante ao seguinte para cada dispositivo na matriz.

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

Formate a matriz /dev/md0 completa com um sistema de ficheiros ext4.

Aviso: este comando elimina todos os dados existentes dos SSDs locais.
```
$ sudo mkfs.ext4 -F /dev/md0
```
Crie um diretório onde possa montar /dev/md0. Para este exemplo, crie o diretório /mnt/disks/ssd-array:
```
$ sudo mkdir -p /mnt/disks/[MNT_DIR]
```
Substitua [MNT_DIR] pelo diretório onde quer montar a sua matriz de SSD local.
Monte a matriz /dev/md0 no diretório /mnt/disks/ssd-array:
```
$ sudo mount /dev/md0 /mnt/disks/[MNT_DIR]
```
Substitua [MNT_DIR] pelo diretório onde quer montar a sua matriz de SSD local.
Configurar o acesso de leitura e escrita ao dispositivo. Para este exemplo, conceda acesso de escrita ao dispositivo a todos os utilizadores.
```
$ sudo chmod a+w /mnt/disks/[MNT_DIR]
```
Substitua [MNT_DIR] pelo diretório onde montou a matriz de SSD local.

Quando especificar o ficheiro /etc/fstab, certifique-se de que inclui a opção nofail para que a instância possa continuar a ser iniciada mesmo que o SSD local não esteja presente. Por exemplo, se tirar uma captura instantânea do disco de arranque e criar uma nova instância sem SSDs locais anexados, a instância pode continuar o processo de arranque e não pausar indefinidamente.

Crie a entrada /etc/fstab. Use o comando blkid para encontrar o UUID do sistema de ficheiros no dispositivo e edite o ficheiro /etc/fstab para incluir esse UUID com as opções de montagem. Especifique a opção nofail para permitir que o sistema seja iniciado mesmo que o SSD local esteja indisponível.Pode concluir este passo com um único comando. Por exemplo:
```
$ 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
```
Substitua [MNT_DIR] pelo diretório onde montou a matriz de SSD local.
Se usar um nome de dispositivo como /dev/md0 no ficheiro /etc/fstab, em vez do UUID, tem de editar o ficheiro /etc/mdadm/mdadm.conf para se certificar de que a matriz é remontada automaticamente no arranque. Para o fazer, conclua os dois passos seguintes:
1. Certifique-se de que a matriz de discos é analisada e remontada automaticamente no arranque.
```
$ sudo mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf
```
2. Atualize initramfs para que a matriz esteja disponível durante o processo de arranque inicial.
```
$ sudo update-initramfs -u
```
Use o comando cat para verificar se as entradas /etc/fstab estão corretas:
```
$ cat /etc/fstab
```

Se criar um instantâneo a partir do disco de arranque desta instância e o usar para criar uma instância separada que não tenha SSDs locais, edite o ficheiro /etc/fstab e remova a entrada para esta matriz de SSDs locais. Mesmo com a opção nofail ativada, mantenha o ficheiro /etc/fstab sincronizado com as partições anexadas à sua instância e remova estas entradas antes de criar a imagem instantânea do disco de arranque.

Instâncias do Windows

Use a ferramenta de gestão de discos do Windows para formatar e montar uma matriz de SSDs locais numa instância do Windows.

Ligue-se à instância através do RDP. Para este exemplo, aceda à página de instâncias de VMs e clique no botão RDP junto à instância que tem os SSDs locais anexados. Depois de introduzir o nome de utilizador e a palavra-passe, é aberta uma janela com a interface de computador para o seu servidor.
Clique com o botão direito do rato no botão Iniciar do Windows e selecione Gestão de discos.
Se não tiver inicializado os SSDs locais anteriormente, a ferramenta pede-lhe que selecione um esquema de partição para as novas partições. Selecione GPT e clique em OK.
Após a inicialização do SSD local, clique com o botão direito do rato no espaço não atribuído do disco e selecione New Striped Volume.
Selecione as partições de SSD local que quer incluir na matriz em faixas. Para este exemplo, selecione todas as partições para as combinar num único dispositivo SSD local.
Siga as instruções no Novo assistente de volume listrado para configurar o novo volume. Pode usar qualquer formato de partição que quiser, mas, para este exemplo, selecione NTFS. Além disso, selecione Perform a quick format para acelerar o processo de formatação.
Depois de concluir o assistente e a formatação do volume, verifique o novo SSD local para garantir que tem o estado Healthy.

Agora, pode escrever ficheiros no SSD local.

O que se segue?

Saiba mais sobre os nomes dos dispositivos da sua MV.
Saiba como comparar o desempenho dos discos SSD locais

Adicione um SSD local à sua VM Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Console

gcloud

Terraform

Go

Java

Python

REST

Crie uma VM com um SSD local

Consola

gcloud

Terraform

Go

Go

Java

Java

Python

Python

REST

Formatar e montar um dispositivo SSD local

Formate e monte partições SSD locais individuais

Instâncias do Linux

Instâncias do Windows

Formate e monte várias partições de SSD local num único volume lógico

Instâncias do Linux

Instâncias do Windows

O que se segue?

Adicione um SSD local à sua VM