Esta página foi traduzida pela API Cloud Translation.

Crie imagens personalizadas

Linux

Pode criar imagens personalizadas a partir de discos de origem, imagens, instantâneos ou imagens armazenadas no Cloud Storage e usar estas imagens para criar instâncias de máquinas virtuais (VM). As imagens personalizadas são ideais para situações em que criou e modificou um disco de arranque persistente ou uma imagem específica para um determinado estado e precisa de guardar esse estado para criar VMs.

Em alternativa, pode usar a ferramenta de importação de discos virtuais para importar imagens de discos de arranque para o Compute Engine a partir dos seus sistemas existentes e adicioná-las à lista de imagens personalizadas.

Antes de começar

Leia o documento Imagens.
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.
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.
Node.js

Para usar os Node.js 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 imagem personalizada

Esta secção descreve como criar uma imagem personalizada numa VM do Linux. Para obter informações sobre como criar uma imagem do Windows, consulte o artigo Criar uma imagem do Windows.

Selecione uma localização de armazenamento de imagens

Quando cria uma imagem personalizada, pode especificar a localização do Cloud Storage da imagem, excluindo localizações de região dupla. Ao especificar a localização do armazenamento de imagens, pode cumprir os requisitos regulamentares e de conformidade para a localidade dos dados, bem como as suas necessidades de elevada disponibilidade, fornecendo redundância em várias regiões. Para criar, modificar e eliminar imagens armazenadas no Cloud Storage, tem de ter roles/compute.storageAdmin.

A funcionalidade de localização de armazenamento é opcional. Se não selecionar uma localização, o Compute Engine armazena a imagem na multirregião mais próxima da origem da imagem. Por exemplo, quando cria uma imagem a partir de um disco de origem localizado em us-central1 e não especifica uma localização para a imagem personalizada, o Compute Engine armazena a imagem na multirregião us.

Se a imagem não estiver disponível numa região onde está a criar uma VM, o Compute Engine armazena a imagem em cache nessa região na primeira vez que cria uma VM.

Para ver a localização onde uma imagem está armazenada, use o comando images describe de gcloud compute:

gcloud compute images describe IMAGE_NAME \
    --project=PROJECT_ID

Substitua o seguinte:

IMAGE_NAME: o nome da imagem.
PROJECT_ID: o ID do projeto ao qual a imagem pertence.

Todas as suas imagens existentes antes do lançamento desta funcionalidade permanecem onde estão. A única alteração é que pode ver a localização da imagem de todas as suas imagens. Se tiver uma imagem existente que queira mover, tem de a recriar na nova localização.

Prepare a VM para uma imagem

Pode criar uma imagem a partir de um disco, mesmo quando este está anexado a uma VM em execução. No entanto, a imagem é mais fiável se colocar a VM num estado que seja mais fácil de capturar para a imagem. Esta secção descreve como preparar o disco de arranque para a imagem.

Minimize a gravação de dados no disco persistente

Use um dos seguintes processos para reduzir as gravações no disco:

Pare a VM para que possa ser encerrada e parar de escrever dados no disco persistente.
Se não conseguir parar a VM antes de criar a imagem, minimize a quantidade de gravações no disco e sincronize o sistema de ficheiros. Para minimizar a escrita no disco persistente, siga estes passos:
1. Pause as apps ou os processos do sistema operativo que escrevem dados nesse disco persistente.
2. Execute uma descarga da app para o disco, se necessário. Por exemplo, o MySQL tem uma declaração FLUSH. Outras apps podem ter processos semelhantes.
3. Impeça as suas apps de escreverem no disco persistente.
4. Corrida sudo sync.

Desative a opção de eliminação automática para o disco

Por predefinição, a opção de eliminação automática está ativada nos discos de arranque. Antes de criar uma imagem a partir de um disco, desative a eliminação automática para evitar que o disco seja eliminado automaticamente quando eliminar a VM.

Para desativar a eliminação automática para o disco, use um dos seguintes métodos:

Consola

Na Google Cloud consola, aceda à página Instâncias de VM.

Aceda à página de instâncias de VM
Clique no nome da VM que está a usar como origem para criar uma imagem.

É apresentada a página Detalhes da instância de VM.
Clique em Edit.
Na secção Disco de arranque, para a Regra de eliminação, verifique se a opção Manter disco está selecionada.
Clique em Guardar.

gcloud

Na CLI gcloud, use o comando gcloud compute instances set-disk-auto-delete para desativar a opção de eliminação automática do disco.

gcloud compute instances set-disk-auto-delete VM_NAME \
    --no-auto-delete \
    --disk=SOURCE_DISK

Substitua o seguinte:

VM_NAME: o nome da sua instância de VM.
SOURCE_DISK: o nome do disco a partir do qual quer criar a imagem.

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

// setDiskAutodelete sets the autodelete flag of a disk to given value.
func setDiskAutoDelete(
	w io.Writer,
	projectID, zone, instanceName, diskName string, autoDelete bool,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b"
	// instanceName := "your_instance_name"
	// diskName := "your_disk_name"
	// autoDelete := true

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	getInstanceReq := &computepb.GetInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	instance, err := instancesClient.Get(ctx, getInstanceReq)
	if err != nil {
		return fmt.Errorf("unable to get instance: %w", err)
	}

	diskExists := false

	for _, disk := range instance.GetDisks() {
		if disk.GetDeviceName() == diskName {
			diskExists = true
			break
		}
	}

	if !diskExists {
		return fmt.Errorf(
			"instance %s doesn't have a disk named %s attached",
			instanceName,
			diskName,
		)
	}

	req := &computepb.SetDiskAutoDeleteInstanceRequest{
		Project:    projectID,
		Zone:       zone,
		Instance:   instanceName,
		DeviceName: diskName,
		AutoDelete: autoDelete,
	}

	op, err := instancesClient.SetDiskAutoDelete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to set disk autodelete field: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "disk autoDelete field updated.\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.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.SetDiskAutoDeleteInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class SetDiskAutodelete {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.

    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // The zone of the disk that you want to modify.
    String zone = "europe-central2-b";

    // Name of the instance the disk is attached to.
    String instanceName = "YOUR_INSTANCE_NAME";

    // The name of the disk for which you want to modify the autodelete flag.
    String diskName = "YOUR_DISK_NAME";

    // The new value of the autodelete flag.
    boolean autoDelete = true;

    setDiskAutodelete(projectId, zone, instanceName, diskName, autoDelete);
  }

  // Sets the autodelete flag of a disk to given value.
  public static void setDiskAutodelete(String projectId, String zone, String instanceName,
      String diskName, boolean autoDelete)
      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()) {

      // Retrieve the instance given by the instanceName.
      Instance instance = instancesClient.get(projectId, zone, instanceName);

      // Check if the instance contains a disk that matches the given diskName.
      boolean diskNameMatch = instance.getDisksList()
          .stream()
          .anyMatch(disk -> disk.getDeviceName().equals(diskName));

      if (!diskNameMatch) {
        throw new Error(
            String.format("Instance %s doesn't have a disk named %s attached", instanceName,
                diskName));
      }

      // Create the request object.
      SetDiskAutoDeleteInstanceRequest request = SetDiskAutoDeleteInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstance(instanceName)
          .setDeviceName(diskName)
          // Update the autodelete property.
          .setAutoDelete(autoDelete)
          .build();

      // Wait for the update instance operation to complete.
      Operation response = instancesClient.setDiskAutoDeleteAsync(request)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Failed to update Disk autodelete field!" + response);
        return;
      }
      System.out.println(
          "Disk autodelete field updated. Operation Status: " + response.getStatus());
    }
  }
}

Node.js

Antes de experimentar este exemplo, siga as Node.jsinstruçõ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 Node.js 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.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';
// const diskName = 'YOUR_DISK_NAME';
// const autoDelete = true;

const compute = require('@google-cloud/compute');

async function setDiskAutodelete() {
  const instancesClient = new compute.InstancesClient();

  const [instance] = await instancesClient.get({
    project: projectId,
    zone,
    instance: instanceName,
  });

  if (!instance.disks.some(disk => disk.deviceName === diskName)) {
    throw new Error(
      `Instance ${instanceName} doesn't have a disk named ${diskName} attached.`
    );
  }

  const [response] = await instancesClient.setDiskAutoDelete({
    project: projectId,
    zone,
    instance: instanceName,
    deviceName: diskName,
    autoDelete,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

  // Wait for the update instance operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log('Disk autoDelete field updated.');
}

setDiskAutodelete();

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 sys
from typing import Any

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


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 set_disk_autodelete(
    project_id: str, zone: str, instance_name: str, disk_name: str, autodelete: bool
) -> None:
    """
    Set the autodelete flag of a disk to given value.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone in which is the disk you want to modify.
        instance_name: name of the instance the disk is attached to.
        disk_name: the name of the disk which flag you want to modify.
        autodelete: the new value of the autodelete flag.
    """
    instance_client = compute_v1.InstancesClient()
    instance = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )

    for disk in instance.disks:
        if disk.device_name == disk_name:
            break
    else:
        raise RuntimeError(
            f"Instance {instance_name} doesn't have a disk named {disk_name} attached."
        )

    disk.auto_delete = autodelete

    operation = instance_client.update(
        project=project_id,
        zone=zone,
        instance=instance_name,
        instance_resource=instance,
    )

    wait_for_extended_operation(operation, "disk update")

REST

Para definir a opção de eliminação automática de um disco, faça um pedido POST ao método.instances.setDiskAutoDelete

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/setDiskAutoDelete?autoDelete=false&deviceName=SOURCE_DISK

Substitua o seguinte:

PROJECT_ID: o ID do projeto ao qual a VM de origem pertence.
ZONE: a zona onde a VM de origem está localizada.
VM_NAME: o nome da VM de origem.
SOURCE_DISK: o nome do dispositivo do disco a partir do qual quer criar a imagem.

Depois de preparar a VM, crie a imagem.

Crie a imagem

Pode criar imagens de disco a partir das seguintes origens:

Um disco persistente, mesmo quando esse disco está anexado a uma VM
Um instantâneo de um disco persistente
Outra imagem no seu projeto
Uma imagem partilhada a partir de outro projeto
Uma imagem RAW comprimida no Cloud Storage

Pode criar uma imagem de disco uma vez a cada 10 minutos. Se quiser emitir uma série de pedidos para criar uma imagem de disco, pode emitir, no máximo, 6 pedidos em 60 minutos. Para mais informações, consulte o artigo Limites de frequência de instantâneos.

Consola

Na Google Cloud consola, aceda à página Criar uma imagem.

Aceda a Crie uma imagem
Especifique o Nome da imagem.
Especifique a origem a partir da qual quer criar uma imagem. Pode ser um disco persistente, um instantâneo, outra imagem ou um ficheiro disk.raw no Cloud Storage.
Se estiver a criar uma imagem a partir de um disco associado a uma VM em execução, selecione Manter instância em execução para confirmar que quer criar a imagem enquanto a VM está em execução. Pode preparar a VM antes de criar a imagem.
Na lista pendente Com base na localização do disco de origem (predefinição), especifique a localização para armazenar a imagem. Por exemplo, especifique us para armazenar a imagem na região us ou us-central1 para a armazenar na região us-central1. Se não fizer uma seleção, o Compute Engine armazena a imagem na multirregião mais próxima da localização de origem da imagem.
Opcional: especifique as propriedades da imagem.
- Família: a família de imagens a que esta nova imagem pertence.
- Descrição: uma descrição da imagem personalizada.
- Etiqueta: uma etiqueta para agrupar recursos.
Especifique a chave de encriptação. Pode escolher entre uma chave do Google-owned and Google-managed encryption keyCloud Key Management Service (Cloud KMS) ou uma chave de encriptação fornecida pelo cliente (CSEK). Se não for especificada nenhuma chave de encriptação, as imagens são encriptadas com uma Google-owned and Google-managed encryption key.
Clique em Criar para criar a imagem.

gcloud

Na CLI Google Cloud, use o comando gcloud compute images create para criar uma imagem personalizada.

Crie uma imagem a partir de um disco de origem:

A flag --force é uma flag opcional que lhe permite criar a imagem a partir de uma instância em execução. Por predefinição, não pode criar imagens a partir de instâncias em execução. Especifique esta flag apenas se tiver a certeza de que quer criar a imagem enquanto a instância está em execução.

gcloud compute images create IMAGE_NAME \
    --source-disk=SOURCE_DISK \
    --source-disk-zone=ZONE \
    [--family=IMAGE_FAMILY] \
    [--storage-location=LOCATION] \
    [--force]

Substitua o seguinte:

IMAGE_NAME: um nome para a nova imagem
SOURCE_DISK: o disco a partir do qual quer criar a imagem
ZONE: a zona onde o disco está localizado
IMAGE_FAMILY: opcional: um indicador que especifica a que família de imagens esta imagem pertence
LOCATION: Opcional: um indicador que lhe permite designar a região ou a região múltipla onde a sua imagem está armazenada. Por exemplo, especifique us para armazenar a imagem na us região multirregional ou us-central1 para a armazenar na região us-central1. Se não fizer uma seleção, o Compute Engine armazena a imagem na multirregião mais próxima da localização de origem da imagem.

Crie uma imagem a partir de uma imagem de origem:

gcloud compute images create IMAGE_NAME \
  --source-image=SOURCE_IMAGE \
  [--source-image-project=IMAGE_PROJECT] \
  [--family=IMAGE_FAMILY] \
  [--storage-location=LOCATION]

Substitua o seguinte:

IMAGE_NAME: um nome para a nova imagem.
SOURCE_IMAGE: a imagem a partir da qual quer criar a nova imagem.
IMAGE_PROJECT: Opcional: o projeto no qual a imagem de origem está localizada. Use este parâmetro se quiser copiar uma imagem de outro projeto.
IMAGE_FAMILY: opcional: a família de imagens à qual esta nova imagem pertence.
LOCATION: opcional: permite-lhe designar a região ou as várias regiões onde a sua imagem está armazenada. Por exemplo, especifique us para armazenar a imagem na região us ou us-central1 para a armazenar na região us-central1. Se não fizer uma seleção, o Compute Engine armazena a imagem na multirregião mais próxima da localização de origem da imagem.

Crie uma imagem a partir de um instantâneo:

gcloud compute images create IMAGE_NAME \
    --source-snapshot=SOURCE_SNAPSHOT \
    [--storage-location=LOCATION]

Substitua o seguinte:

IMAGE_NAME: um nome para a nova imagem
SOURCE_SNAPSHOT: o instantâneo a partir do qual quer criar a imagem
LOCATION: Opcional: um indicador que lhe permite designar a região ou a região múltipla onde a sua imagem está armazenada. Por exemplo, especifique us para armazenar a imagem na us região multirregional ou us-central1 para a armazenar na região us-central1. Se não fizer uma seleção, o Compute Engine armazena a imagem na multirregião mais próxima da localização de origem da imagem.

Veja a localização de uma imagem:

Use o comando gcloud compute images describe para ver a localização de uma imagem.

gcloud compute images describe IMAGE_NAME

Substitua IMAGE_NAME pelo nome da imagem que quer rever.

Go

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

// Creates a disk image from an existing disk
func createImageFromDisk(
	w io.Writer,
	projectID, zone, sourceDiskName, imageName string,
	storageLocations []string,
	forceCreate bool,
) error {
	// projectID := "your_project_id"
	// zone := "us-central1-a"
	// sourceDiskName := "your_disk_name"
	// imageName := "my_image"
	// // If storageLocations empty, automatically selects the closest one to the source
	// storageLocations = []string{}
	// // If forceCreate is set to `true`, proceeds even if the disk is attached to
	// // a running instance. This may compromise integrity of the image!
	// forceCreate = false

	ctx := context.Background()
	disksClient, err := compute.NewDisksRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewDisksRESTClient: %w", err)
	}
	defer disksClient.Close()
	imagesClient, err := compute.NewImagesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewImagesRESTClient: %w", err)
	}
	defer imagesClient.Close()

	// Get the source disk
	source_req := &computepb.GetDiskRequest{
		Disk:    sourceDiskName,
		Project: projectID,
		Zone:    zone,
	}

	disk, err := disksClient.Get(ctx, source_req)
	if err != nil {
		return fmt.Errorf("unable to get source disk: %w", err)
	}

	// Create the image
	req := computepb.InsertImageRequest{
		ForceCreate: &forceCreate,
		ImageResource: &computepb.Image{
			Name:             &imageName,
			SourceDisk:       disk.SelfLink,
			StorageLocations: storageLocations,
		},
		Project: projectID,
	}

	op, err := imagesClient.Insert(ctx, &req)

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Disk image %s created\n", imageName)

	return nil
}

Java

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.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.Image;
import com.google.cloud.compute.v1.ImagesClient;
import com.google.cloud.compute.v1.InsertImageRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateImage {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.

    // Project ID or project number of the Cloud project you use.
    String project = "your-project-id";
    // Zone of the disk you copy from.
    String zone = "europe-central2-b";
    // Name of the source disk you copy from.
    String sourceDiskName = "source-disk-name";
    // Name of the image you want to create.
    String imageName = "your-image-name";
    // Storage location for the image. If the value is undefined,
    // function will store the image in the multi-region closest to your image's source location.
    String storageLocation = "eu";
    // Create the image even if the source disk is attached to a running instance.
    boolean forceCreate = false;

    createImage(project, zone, sourceDiskName, imageName, storageLocation, forceCreate);
  }

  // Creates a new disk image from the specified source disk.
  public static void createImage(String project, String zone, String sourceDiskName,
      String imageName, String storageLocation, boolean forceCreate)
      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 `client.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ImagesClient imagesClient = ImagesClient.create();
        InstancesClient instancesClient = InstancesClient.create();
        DisksClient disksClient = DisksClient.create()) {

      Disk disk = disksClient.get(project, zone, sourceDiskName);

      // Getting instances where source disk is attached.
      for (String fullInstanceName : disk.getUsersList()) {
        Map<String, String> instanceInfo = parseInstanceName(fullInstanceName);
        Instance instance = instancesClient.get(instanceInfo.get("instanceProjectId"),
            instanceInfo.get("instanceZone"), instanceInfo.get("instanceName"));

        // Сheck whether the instances are stopped.
        if (!Arrays.asList("TERMINATED", "STOPPED").contains(instance.getStatus())
            && !forceCreate) {
          throw new IllegalStateException(
              String.format(
                  "Instance %s should be stopped. For Windows instances please stop the instance "
                      + "using GCESysprep command. For Linux instances just shut it down normally."
                      + " You can suppress this error and create an image of the disk by setting "
                      + "'forceCreate' parameter to true (not recommended). "
                      + "More information here: "
                      + "* https://cloud.google.com/compute/docs/instances/windows/creating-windows-os-image#api"
                      + "* https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#prepare_instance_for_image",
                  instanceInfo.get("instanceName")));
        }
      }

      if (forceCreate) {
        System.out.println(
            "Warning: forceCreate option compromise the integrity of your image. "
                + "Stop the instance before you create the image if possible.");
      }

      // Create Image.
      IImageimage = IImagenewBuilder()
          .setName(imageName)
          .setSourceDisk(String.format("/zones/%s/disks/%s", zone, sourceDiskName))
          .addStorageLocations(storageLocation.isEmpty() ? "" : storageLocation)
          .build();

      IInsertImageRequestinsertImageRequest = IInsertImageRequestnewBuilder()
          .setProject(project)
          .ssetForceCreateforceCreate)
          .setImageResource(image)
          .build();

      OOperationresponse = imagesClient.insertAsync(insertImageRequest).get(5, TimeUnit.MINUTES);

      if (rresponse.hasError() {
        System.out.println("Image creation failed ! ! " + response);
        return;
      }

      System.out.println("Image created.");
    }
  }


  public static Map<String, String> parseInstanceName(String name) {
    String[] parsedName = name.split("/");
    int splitLength = parsedName.length;

    if (splitLength < 5) {
      throw new IllegalArgumentException(
          "Provide correct instance name in the following format: "
              + "https://www.googleapis.com/compute/v1/projects/PROJECT/zones/ZONE/instances/INSTANCE_NAME");
    }

    return new HashMap<>() {
      {
        put("instanceName", parsedName[splitLength - 1]);
        put("instanceZone", parsedName[splitLength - 3]);
        put("instanceProjectId", parsedName[splitLength - 5]);
      }
    };
  }

}

Python

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 sys
from typing import Any
import warnings

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


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


STOPPED_MACHINE_STATUS = (
    compute_v1.Instance.Status.TERMINATED.name,
    compute_v1.Instance.Status.STOPPED.name,
)


def create_image_from_disk(
    project_id: str,
    zone: str,
    source_disk_name: str,
    image_name: str,
    storage_location: str | None = None,
    force_create: bool = False,
) -> compute_v1.Image:
    """
    Creates a new disk image.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        zone: zone of the disk you copy from.
        source_disk_name: name of the source disk you copy from.
        image_name: name of the image you want to create.
        storage_location: storage location for the image. If the value is undefined,
            function will store the image in the multi-region closest to your image's
            source location.
        force_create: create the image even if the source disk is attached to a
            running instance.

    Returns:
        An Image object.
    """
    image_client = compute_v1.ImagesClient()
    disk_client = compute_v1.DisksClient()
    instance_client = compute_v1.InstancesClient()

    # Get source disk
    disk = disk_client.get(project=project_id, zone=zone, disk=source_disk_name)

    for disk_user in disk.users:
        instance_name = disk_user.split("/")[-1]
        instance = instance_client.get(
            project=project_id, zone=zone, instance=instance_name
        )
        if instance.status in STOPPED_MACHINE_STATUS:
            continue
        if not force_create:
            raise RuntimeError(
                f"Instance {disk_user} should be stopped. For Windows instances please "
                f"stop the instance using `GCESysprep` command. For Linux instances just "
                f"shut it down normally. You can supress this error and create an image of"
                f"the disk by setting `force_create` parameter to true (not recommended). \n"
                f"More information here: \n"
                f" * https://cloud.google.com/compute/docs/instances/windows/creating-windows-os-image#api \n"
                f" * https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#prepare_instance_for_image"
            )
        else:
            warnings.warn(
                f"Warning: The `force_create` option may compromise the integrity of your image. "
                f"Stop the {disk_user} instance before you create the image if possible."
            )

    # Create image
    image = compute_v1.Image()
    image.source_disk = disk.self_link
    image.name = image_name
    if storage_location:
        image.storage_locations = [storage_location]

    operation = image_client.insert(project=project_id, image_resource=image)

    wait_for_extended_operation(operation, "image creation from disk")

    return image_client.get(project=project_id, image=image_name)

REST

Faça um pedido POST ao método images().insert, um URL no corpo do pedido que aponte para o objeto de origem a partir do qual quer criar a imagem. Especifique os URLs para os seus recursos através do seu próprio ID do projeto e nomes de recursos.

Crie uma imagem a partir de um disco persistente:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/images

{
  "name": "IMAGE_NAME",
  "sourceDisk": "/zones/ZONE/disks/SOURCE_DISK",
  ("storageLocations": "LOCATION",)
  ("forceCreate": "TRUE")
}

Substitua o seguinte:

PROJECT_ID: o ID do projeto ao qual a imagem pertence.
IMAGE_NAME: um nome para a nova imagem que quer criar.
ZONE: a zona onde o disco de origem está localizado.
SOURCE_DISK: o disco a partir do qual quer criar a imagem.
LOCATION: opcional: a localização de armazenamento da sua imagem. Por exemplo, especifique us para armazenar a imagem na us região multirregional ou us-central1 para a armazenar na região us-central1. Se não fizer uma seleção, o Compute Engine armazena a imagem na multirregião mais próxima da localização de origem da imagem.

O parâmetro forceCreate opcional permite-lhe criar a imagem a partir de uma VM em execução. Especifique TRUE apenas se tiver a certeza de que quer criar a imagem a partir de uma VM em execução. A forceCreatedefinição predefinida é FALSE.

Crie uma imagem a partir de outra imagem:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/images

{
  "name": "IMAGE_NAME",
  "sourceImage": "/global/images/SOURCE_IMAGE",
  ("storageLocations": "LOCATION")
}

Substitua o seguinte:

PROJECT_ID: o projeto ao qual a imagem pertence.
IMAGE_NAME: um nome para a nova imagem que quer criar.
SOURCE_IMAGE: a imagem a partir da qual quer criar a imagem.
LOCATION: opcional: a localização de armazenamento da sua imagem. Por exemplo, especifique us para armazenar a imagem na us região multirregional ou us-central1 para a armazenar na região us-central1. Se não fizer uma seleção, o Compute Engine armazena a imagem na multirregião mais próxima da localização de origem da imagem.

Crie uma imagem a partir de um instantâneo:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/images
{
  "name": "IMAGE_NAME",
  "sourceSnapshot": "(/SOURCE_PROJECT_ID)/global/snapshots/SOURCE_SNAPSHOT",
  ("storageLocations": "LOCATION")
}

Substitua o seguinte:

PROJECT_ID: o projeto ao qual a imagem pertence.
IMAGE_NAME: um nome para a nova imagem que quer criar.
SOURCE_PROJECT_ID: opcional: o projeto no qual o snapshot está localizado. Tem de ter autorização para aceder ao recurso de instantâneo nesse projeto.
SOURCE_SNAPSHOT: o instantâneo a partir do qual quer criar a imagem.
LOCATION: opcional: a localização de armazenamento da sua imagem. Por exemplo, especifique us para armazenar a imagem na us região multirregional ou us-central1 para a armazenar na região us-central1. Se não fizer uma seleção, o Compute Engine armazena a imagem na multirregião mais próxima da localização de origem da imagem.

Para mais informações sobre como adicionar imagens, consulte a referência de imagens.

Partilhe a imagem

Depois de criar uma imagem personalizada, pode partilhá-la em vários projetos. Se permitir que os utilizadores de outro projeto usem as suas imagens personalizadas, estes podem aceder a estas imagens especificando o projeto de imagem no respetivo pedido.

Ative as funcionalidades do sistema operativo convidado

Use funcionalidades do sistema operativo (SO) convidado para configurar as seguintes opções de rede, segurança, armazenamento e SO em imagens personalizadas. As imagens personalizadas com estas funcionalidades configuradas são usadas como discos de arranque.

gcloud

Use o comando gcloud compute images create com a flag --guest-os-features para criar uma nova imagem personalizada a partir de uma imagem personalizada existente.

gcloud compute images create IMAGE_NAME \
    --source-image=SOURCE_IMAGE \
    [--source-image-project=IMAGE_PROJECT] \
    --guest-os-features="FEATURES,..." \
    [--storage-location=LOCATION]

Substitua o seguinte:

IMAGE_NAME: o nome da nova imagem
SOURCE_IMAGE: uma imagem na qual basear a nova imagem
IMAGE_PROJECT: opcional: o projeto que contém a imagem de origem

Use este parâmetro para copiar uma imagem de outro projeto.
FEATURES: etiquetas do SO convidado para ativar funcionalidades para VMs que cria a partir de imagens

Para adicionar vários valores, use vírgulas para separar os valores. Definido para um ou mais dos seguintes valores:
- VIRTIO_SCSI_MULTIQUEUE. Use em dispositivos SSD locais como alternativa ao NVMe. Para mais informações sobre imagens que suportam SCSI, consulte o artigo Escolher uma interface.
  
  Para imagens Linux, pode ativar o SCSI de várias filas em dispositivos SSD locais em imagens com versões do kernel 3.17 ou posteriores. Para imagens do Windows, pode ativar o SCSI de várias filas em dispositivos SSD locais em imagens com o controlador do Windows do Compute Engine versão 1.2.
- WINDOWS. Etiquete as imagens de arranque personalizadas do Windows Server como imagens do Windows.
- MULTI_IP_SUBNET. Configurar interfaces com uma máscara de rede diferente de /32. Para mais informações sobre várias interfaces de rede e como funcionam, consulte o artigo Vista geral e exemplos de várias interfaces de rede.
- UEFI_COMPATIBLE. Arranque com o firmware UEFI e as seguintes funcionalidades da VM protegida:
  - Arranque seguro: desativado por predefinição
  - Trusted Platform Module virtual (vTPM): ativado por predefinição
  - Monitorização da integridade: ativada por predefinição
- GVNIC. Suportar larguras de banda de rede mais elevadas de até 50 Gbps a 100 Gbps. Para mais informações, consulte Usar a NIC virtual da Google.
- IDPF. Suporte interfaces de rede da função de caminho de dados de infraestrutura Intel (IDPF).
- SEV_CAPABLE ou SEV_SNP_CAPABLE. Use estas etiquetas se quiser usar a sua imagem numa instância de VM confidencial com a virtualização encriptada segura (SEV) da AMD ou a virtualização encriptada segura da AMD com suporte de paginação aninhada segura (SEV-SNP). Para verificar se o seu kernel suporta AMD SEV ou AMD SEV-SNP, consulte os detalhes do kernel do Linux.
- SEV_LIVE_MIGRATABLE_V2. Use esta etiqueta se quiser usar a sua imagem numa instância de VM confidencial que suporte a migração em direto no AMD SEV. Para verificar se o seu kernel suporta a migração em direto, consulte os detalhes do kernel do Linux.
- TDX_CAPABLE. Use esta etiqueta se quiser usar a sua imagem numa instância de máquina virtual confidencial com suporte para as extensões de domínio fidedigno (TDX) da Intel. Para verificar se o seu kernel suporta o Intel TDX, consulte os detalhes do kernel do Linux.
LOCATION: Opcional: região ou multirregião na qual armazenar a imagem

Por exemplo, especifique us para armazenar a imagem na multirregião us ou us-central1 para a armazenar na região us-central1. Se não fizer uma seleção, o Compute Engine armazena a imagem na multirregião mais próxima da localização de origem da imagem.

REST

Use o método images().insert com a flag guestOsFeatures para criar uma nova imagem personalizada a partir de uma imagem personalizada existente.


POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/images

{
 "name": "IMAGE_NAME",
 "sourceImage": "(projects/IMAGE_PROJECT)/global/images/SOURCE_IMAGE",
 ("storageLocations": "LOCATION",)
 "guestOsFeatures": [
  {
   "type": "FEATURES"
  }
 ]
}

Substitua o seguinte:

PROJECT_ID: o ID do projeto no qual criar a nova imagem
IMAGE_NAME: um nome para a nova imagem
IMAGE_PROJECT: opcional: o projeto que contém a imagem de origem

Use este parâmetro para copiar uma imagem de outro projeto.
SOURCE_IMAGE: a imagem na qual basear a nova imagem
LOCATION: Opcional: uma região ou várias regiões nas quais armazenar a imagem

Por exemplo, especifique us para armazenar a imagem na região us ou us-central1 para a armazenar na região us-central1. Se não fizer uma seleção, o Compute Engine armazena a imagem na multirregião mais próxima da localização de origem da imagem.
FEATURES: etiquetas do SO convidado para ativar funcionalidades para VMs que cria a partir de imagens

Para adicionar vários valores, use vírgulas para separar os valores. Definido para um ou mais dos seguintes valores:
- VIRTIO_SCSI_MULTIQUEUE. Use em dispositivos SSD locais como alternativa ao NVMe. Para mais informações sobre imagens que suportam SCSI, consulte o artigo Escolher uma interface.
  
  Para imagens Linux, pode ativar o SCSI de várias filas em dispositivos SSD locais em imagens com versões do kernel 3.17 ou posteriores. Para imagens do Windows, pode ativar o SCSI de várias filas em dispositivos SSD locais em imagens com o controlador do Windows do Compute Engine versão 1.2.
- WINDOWS. Etiquete as imagens de arranque personalizadas do Windows Server como imagens do Windows.
- MULTI_IP_SUBNET. Configurar interfaces com uma máscara de rede diferente de /32. Para mais informações sobre várias interfaces de rede e como funcionam, consulte o artigo Vista geral e exemplos de várias interfaces de rede.
- UEFI_COMPATIBLE. Arranque com o firmware UEFI e as seguintes funcionalidades da VM protegida:
  - Arranque seguro: desativado por predefinição
  - Trusted Platform Module virtual (vTPM): ativado por predefinição
  - Monitorização da integridade: ativada por predefinição
- GVNIC. Suportar larguras de banda de rede mais elevadas de até 50 Gbps a 100 Gbps. Para mais informações, consulte Usar a NIC virtual da Google.
- IDPF. Suporte interfaces de rede da função de caminho de dados de infraestrutura Intel (IDPF).
- SEV_CAPABLE ou SEV_SNP_CAPABLE. Use estas etiquetas se quiser usar a sua imagem numa instância de VM confidencial com a virtualização encriptada segura (SEV) da AMD ou a virtualização encriptada segura da AMD com suporte de paginação aninhada segura (SEV-SNP). Para verificar se o seu kernel suporta AMD SEV ou AMD SEV-SNP, consulte os detalhes do kernel do Linux.
- SEV_LIVE_MIGRATABLE_V2. Use esta etiqueta se quiser usar a sua imagem numa instância de VM confidencial que suporte a migração em direto no AMD SEV. Para verificar se o seu kernel suporta a migração em direto, consulte os detalhes do kernel do Linux.
- TDX_CAPABLE. Use esta etiqueta se quiser usar a sua imagem numa instância de máquina virtual confidencial com suporte para as extensões de domínio fidedigno (TDX) da Intel. Para verificar se o seu kernel suporta o Intel TDX, consulte os detalhes do kernel do Linux.

Evite informações confidenciais nas variáveis UEFI

As variáveis da Interface de firmware extensível unificada (UEFI) são variáveis de pares de chave-valor usadas pelo firmware de UEFI durante o tempo de arranque para arrancar o sistema operativo de uma VM. Ao contrário das máquinas físicas, em que as variáveis são armazenadas num chip de hardware, o Compute Engine virtualiza o armazenamento destas variáveis. Como tal, em muitos sistemas operativos, todas as aplicações e utilizadores podem aceder a estas variáveis e a estas informações.

Por este motivo, a Google recomenda vivamente que não escreva nem armazene informações confidenciais ou de identificação pessoal, como palavras-passe ou chaves privadas, nas variáveis UEFI.

Considerações para imagens Arm

A Google oferece as séries de máquinas A4X, C4A e Tau T2A, que são executadas em plataformas de CPU Arm. Pode iniciar uma VM com uma destas séries de máquinas e, em seguida, usar essa VM de origem para criar uma imagem Arm. O processo de criação de uma imagem Arm personalizada é idêntico ao de criação de uma imagem x86.

Para ajudar os utilizadores a distinguir entre imagens Arm e x86, as imagens Arm têm um campo architecture definido como ARM64. Os valores possíveis para este campo são:

ARCHITECTURE_UNSPECIFIED
X86_64
ARM64

Os utilizadores de imagens podem, em seguida, filtrar este campo para encontrar imagens baseadas em x86 ou Arm.

O que se segue?

Partilhe a sua imagem privada com outros projetos.
Saiba como importar discos, imagens e instâncias de VM.
Saiba como exportar uma imagem para o Cloud Storage.
Saiba como iniciar uma VM a partir de uma imagem personalizada.
Saiba como definir a versão da imagem numa família de imagens.
Saiba como descontinuar uma imagem personalizada.
Saiba como eliminar uma imagem personalizada.

Crie imagens personalizadas 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

Go

Java

Node.js

Python

REST

Crie uma imagem personalizada

Selecione uma localização de armazenamento de imagens

Prepare a VM para uma imagem

Minimize a gravação de dados no disco persistente

Desative a opção de eliminação automática para o disco

Consola

gcloud

Go

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Crie a imagem

Consola

gcloud

Go

Go

Java

Java

Python

Python

REST

Partilhe a imagem

Ative as funcionalidades do sistema operativo convidado

gcloud

REST

Evite informações confidenciais nas variáveis UEFI

Considerações para imagens Arm

O que se segue?

Crie imagens personalizadas