Criar imagens personalizadas

É possível criar imagens personalizadas com base em discos, imagens, snapshots ou imagens de origem armazenados no Cloud Storage e usá-las para criar instâncias de máquina virtual (VM, na sigla em inglês). As imagens personalizadas são ideais para situações em que você criou e modificou um disco de inicialização permanente para determinado estado e precisa salvar esse estado para criar VMs.

Também é possível usar a ferramenta de importação de disco virtual para importar imagens do disco de inicialização dos sistemas atuais para o Compute Engine e adicioná-las à lista de imagens personalizadas.

Antes de começar

Papéis e permissões necessárias

Para receber as permissões necessárias para criar uma imagem personalizada, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto:

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esses papéis predefinidos contêm as permissões necessárias para criar uma imagem personalizada. Para acessar as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para criar uma imagem personalizada:

  • compute.images.create
  • Para criar uma imagem personalizada de um disco:
    • compute.disks.useReadOnly no disco
    • iam.serviceAccounts.actAs na conta de serviço da instância, se o disco for o disco de inicialização de uma instância com uma conta de serviço anexada
  • Para criar uma imagem personalizada com base em uma imagem existente: compute.images.useReadOnly na imagem de origem
  • Para criar uma imagem personalizada com base em um snapshot padrão ou snapshot de arquivamento: compute.snapshots.useReadOnly no snapshot de origem
  • Para adicionar um rótulo à nova imagem: compute.images.setLabels no rótulo

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Criar uma imagem personalizada

Nesta seção, descrevemos como criar uma imagem personalizada em uma VM do Linux. Para informações sobre como criar uma imagem do Windows, consulte Como criar uma imagem do Windows.

Selecione um local de armazenamento de imagens

Ao criar uma imagem personalizada, especifique o local dela no Cloud Storage, excluindo os locais birregionais. Ao especificar o local de armazenamento de imagens, você tem como atender aos seus requisitos normativos e de conformidade referentes à localidade de dados, bem como suas necessidades de alta disponibilidade, garantindo redundância entre as regiões. Para criar, modificar e excluir imagens armazenadas no Cloud Storage, você precisa ter roles/compute.storageAdmin.

O recurso de local de armazenamento é opcional. Se um local não for selecionado, o Compute Engine armazenará a imagem na multirregião mais próxima da origem dela. Por exemplo, ao criar uma imagem de um disco de origem localizado em us-central1 e se você não especifica um local para a imagem personalizada, o Compute Engine armazena a imagem na us multirregional.

Se a imagem não estiver disponível em uma região em que você está criando uma VM, o Compute Engine armazenará a imagem nessa região na primeira vez que você criar uma VM.

Para ver o local em que uma imagem está armazenada, use o comando images describe de gcloud compute:

gcloud compute images describe IMAGE_NAME \
    --project=PROJECT_ID

Substitua:

  • IMAGE_NAME: o nome da imagem;

  • PROJECT_ID: o ID do projeto que contém a imagem.

Todas as imagens atuais antes do lançamento desse recurso permanecem onde estão, a única mudança é que é possível ver o local das imagens de todas as imagens. Se você tiver uma imagem atual que queira mover, recrie-a no novo local.

Prepare a VM para uma imagem

Crie uma imagem de um disco mesmo com ele anexado a uma instância de VM em execução. No entanto, a imagem torna-se mais confiável se você a coloca em um estado mais fácil para a captura da imagem. Veja nesta seção como preparar o disco de inicialização da imagem.

Minimizar a gravação de dados no disco permanente

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

  • Pare a VM para que ela possa ser encerrada e parar de gravar dados no disco permanente.

  • Se não for possível parar a VM antes de criar a imagem, minimize a quantidade de gravações no disco e sincronize o sistema de arquivos. Para minimizar a gravação no disco permanente, siga estas etapas:

    1. Pause os apps ou processos do sistema operacional que gravam dados nesse disco permanente.
    2. Execute uma limpeza de app no disco, se necessário. Por exemplo, o MySQL tem uma instrução FLUSH. Outros aplicativos talvez usem processos semelhantes.
    3. Pare os aplicativos para que não gravem mais dados no disco permanente.
    4. Execute sudo sync.

Desativar a opção de exclusão automática do disco

Por padrão, a opção de exclusão automática está ativada nos discos de inicialização. Antes de criar uma imagem de um disco, desative a exclusão automática para evitar que ele seja excluído automaticamente quando você excluir a VM.

Para desativar a exclusão automática do disco, use um dos seguintes métodos:

Console

  1. No console do Google Cloud , acesse a página Instâncias de VM.

    Acessar a página "Instâncias de VM"

  2. Clique no nome da VM que está sendo usada como origem para criar uma imagem.

    A página Detalhes da instância de VM será exibida.

  3. Clique em Editar.

  4. Na seção Disco de inicialização, em Regra de exclusão, verifique se a opção Manter disco está selecionada.

  5. Clique em Salvar.

gcloud

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

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

Substitua:

  • VM_NAME: o nome da instância de VM.
  • SOURCE_DISK: o nome do disco do qual você quer criar a imagem.

Go

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Go do Compute Engine.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

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

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java do Compute Engine.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 


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

Node.js

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js do Compute Engine.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

/**
 * 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

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Python do Compute Engine.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

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 exclusão automática de um disco, faça uma solicitação POST para o 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:

  • PROJECT_ID: o ID do projeto que contém a VM de origem.
  • ZONE: é a zona em que a VM de origem está localizada
  • VM_NAME: o nome da VM de origem.
  • SOURCE_DISK: o nome de dispositivo do disco que você quer usar como base para criar a imagem.

Depois de preparar a VM, crie a imagem.

Criar a imagem

Crie imagens de disco com base nas seguintes origens:

  • Um disco permanente, mesmo que esteja anexado a uma VM
  • Um snapshot de um disco permanente
  • Outra imagem no projeto
  • Uma imagem compartilhada de outro projeto
  • Uma imagem RAW compactada no Cloud Storage

É possível criar uma imagem do disco uma vez a cada 10 minutos. Se você quiser emitir um burst de solicitações para criar uma imagem do disco, será possível emitir no máximo 6 solicitações em 60 minutos. Para mais informações, consulte Limites de frequência de snapshots.

Console

  1. No console do Google Cloud , acesse a página Criar uma imagem.

    Acessar "Criar uma imagem"

  2. Especifique o Nome da imagem.

  3. Especifique a Origem de onde você quer criar uma imagem. Pode ser um disco permanente, um snapshot, outra imagem ou um arquivo disk.raw no Google Cloud Storage.

  4. Se você está criando uma imagem de um disco anexado a uma VM em execução, selecione Manter a instância em execução para confirmar que quer criar a imagem durante a execução da VM. É possível preparar sua VM antes de criar a imagem.

  5. Na lista suspensa Com base na localização do disco de origem (padrão), especifique o local para armazenar a imagem. Por exemplo, especifique us para armazenar a imagem na multirregião us ou us-central1 para armazená-la na região us-central1. Se você não especificar, o Compute Engine armazenará a imagem na multirregião mais próxima do local de origem dela.

  6. Opcional: especifique as propriedades da imagem.

    • Família: a família de imagens à qual esta nova imagem pertence.
    • Descrição: uma descrição para a imagem personalizada.
    • Rótulo: um rótulo para agrupar recursos.

  7. Especifique a chave de criptografia. É possível escolher entre uma Google-owned and Google-managed encryption key, uma chave do Cloud Key Management Service (Cloud KMS) ou uma chave de criptografia fornecida pelo cliente (CSEK). Se nenhuma chave de criptografia for especificada, as imagens serão criptografadas usando um Google-owned and Google-managed encryption key.

  8. Clique em Criar para criar a imagem.

gcloud

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

Criar uma imagem de um disco de origem:

A sinalização --force é uma sinalização opcional que permite criar a imagem a partir de uma instância em execução. Por padrão, não é possível criar imagens de instâncias em execução. Especifique essa sinalização apenas se tiver certeza de que quer criar a imagem enquanto a instância está sendo executada.

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

Substitua:

  • IMAGE_NAME: um nome para a nova imagem.
  • SOURCE_DISK: o disco pelo qual você quer criar a imagem
  • ZONE: a zona em que o disco está localizado.
  • IMAGE_FAMILY: (opcional): uma sinalização que especifica a qual família de imagens essa imagem pertence
  • LOCATION (opcional): uma sinalização que permite designar a região ou a multirregião em que a imagem está armazenada. Por exemplo, especifique us para armazenar a imagem na multirregião us ou us-central1 para armazená-la na região us-central1. Se você não especificar, o Compute Engine armazenará a imagem na multirregião mais próxima do local de origem dela.

Criar uma imagem com base em imagens de origem:

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

Substitua:

  • IMAGE_NAME: um nome para a nova imagem.
  • SOURCE_IMAGE: a imagem que você quer usar como base para criar a nova imagem.
  • IMAGE_PROJECT (opcional): o projeto em que a imagem de origem está localizada. Use esse 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 designar a região ou a multirregião em que a imagem está armazenada. Por exemplo, especifique us para armazenar a imagem na multirregião us ou us-central1 para armazená-la na região us-central1. Se você não especificar, o Compute Engine armazenará a imagem na multirregião mais próxima do local de origem dela.

Criar uma imagem de um snapshot:

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

Substitua:

  • IMAGE_NAME: um nome para a nova imagem.
  • SOURCE_SNAPSHOT: o snapshot que você quer usar como base para criar a imagem.
  • LOCATION (opcional): uma sinalização que permite designar a região ou a multirregião em que a imagem está armazenada. Por exemplo, especifique us para armazenar a imagem na multirregião us ou us-central1 para armazená-la na região us-central1. Se você não especificar, o Compute Engine armazenará a imagem na multirregião mais próxima do local de origem dela.

Ver o local de uma imagem:

Use o comando gcloud compute images describe para ver o local de uma imagem. 

gcloud compute images describe IMAGE_NAME

Substitua IMAGE_NAME pelo nome da imagem que você quer analisar.

Go

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Go do Compute Engine.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

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

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java do Compute Engine.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 


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

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Python do Compute Engine.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

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 uma solicitação POST para o método images().insert, um URL no corpo da solicitação que aponta para o objeto de origem com que você quer criar a imagem. Especifique URLs para seus recursos usando o próprio ID do projeto e nomes de recursos.

Criar uma imagem de um disco permanente:

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:

  • PROJECT_ID: o ID do projeto que contém a imagem.
  • IMAGE_NAME: um nome para a nova imagem que você quer criar.
  • ZONE: a zona em que o disco de origem está localizado.
  • SOURCE_DISK: o disco que você quer usar como base para criar a imagem.
  • LOCATION (opcional): o local de armazenamento da imagem. Por exemplo, especifique us para armazenar a imagem na multirregião us ou us-central1 para armazená-la na região us-central1. Se você não especificar, o Compute Engine armazenará a imagem na multirregião mais próxima do local de origem dela.

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

Criar uma imagem 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:

  • PROJECT_ID: o projeto que contém a imagem.
  • IMAGE_NAME: um nome para a nova imagem que você quer criar.
  • SOURCE_IMAGE: a imagem que você quer usar como base para criar a imagem.
  • LOCATION (opcional): o local de armazenamento da imagem. Por exemplo, especifique us para armazenar a imagem na multirregião us ou us-central1 para armazená-la na região us-central1. Se você não especificar, o Compute Engine armazenará a imagem na multirregião mais próxima do local de origem dela.

Criar uma imagem de um snapshot:

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:

  • PROJECT_ID: o projeto que contém a imagem.
  • IMAGE_NAME: um nome para a nova imagem que você quer criar.
  • SOURCE_PROJECT_ID (opcional): o projeto em que o snapshot está localizado. É necessário ter permissão para acessar o recurso de snapshot nesse projeto.
  • SOURCE_SNAPSHOT: o snapshot que você quer usar como base para criar a imagem.
  • LOCATION (opcional): o local de armazenamento da imagem. Por exemplo, especifique us para armazenar a imagem na multirregião us ou us-central1 para armazená-la na região us-central1. Se você não especificar, o Compute Engine armazenará a imagem na multirregião mais próxima do local de origem dela.

Para saber mais sobre como adicionar imagens, consulte a referência de imagens.

Compartilhar a imagem

Depois de criar uma imagem personalizada, é possível compartilhá-la entre projetos. Se você permitir que usuários de outro projeto usem suas imagens personalizadas, elas poderão acessar essas imagens especificando o projeto de imagem na solicitação.

Ativar recursos do sistema operacional convidado

Use os recursos do sistema operacional (SO) convidado para configurar a rede, a segurança, o armazenamento e as opções de SO a seguir em imagens personalizadas. Imagens personalizadas com esses recursos configurados são usadas como discos de inicialização.

gcloud

Use o comando gcloud compute images create com a sinalização --guest-os-features para criar uma nova imagem personalizada a partir de uma imagem personalizada atual.

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

Substitua:

  • IMAGE_NAME: o nome da nova imagem
  • SOURCE_IMAGE: imagem que servirá como base para a nova

  • IMAGE_PROJECT (opcional): projeto que contém a imagem de origem

    Use esse parâmetro para copiar uma imagem de outro projeto.

  • FEATURES: tags do SO convidado para ativar os recursos das VMs criadas a partir de imagens

    Para adicionar vários valores, use vírgulas para separar os valores. Defina um ou mais dos seguintes valores:

    • VIRTIO_SCSI_MULTIQUEUE. Use em dispositivos SSD locais como alternativa ao NVMe. Para mais informações sobre imagens compatíveis com SCSI, consulte Como escolher uma interface.

      Para imagens do Linux, é possível ativar o SCSI multifilas em dispositivos SSD locais em imagens com versões de kernel 3.17 ou posteriores. Para imagens do Windows, é possível ativar o SCSI de várias filas em dispositivos SSD locais em imagens com o driver do Windows do Compute Engine versão 1.2.

    • WINDOWS. Inclua tags nas imagens de inicialização personalizadas do Windows Server como imagens do Windows.
    • MULTI_IP_SUBNET. Configure interfaces com uma máscara de rede diferente de /32. Para mais informações sobre várias interfaces de rede e como elas funcionam, consulte Visão geral e exemplos de várias interfaces de rede.
    • UEFI_COMPATIBLE. Inicialização com firmware UEFI e os seguintes recursos de VM protegida:
    • GVNIC. Compatível com larguras de banda de rede maiores de até 50 Gbps a velocidades de 100 Gbps. Para mais informações, consulte Como usar a NIC virtual do Google.
    • IDPF. Suporte a interfaces de rede da função de caminho de dados de infraestrutura (IDPF) da Intel.
    • SEV_CAPABLE ou SEV_SNP_CAPABLE. Use essas tags se quiser usar sua imagem em uma instância de VM confidencial com suporte para virtualização criptografada segura (SEV) da AMD ou virtualização criptografada segura com paginação aninhada segura (SEV-SNP) da AMD. Para verificar se o kernel é compatível com AMD SEV ou AMD SEV-SNP, consulte Detalhes do kernel do Linux.
    • SEV_LIVE_MIGRATABLE_V2. Use essa tag se quiser usar sua imagem em uma instância de VM confidencial que ofereça suporte à migração em tempo real no AMD SEV. Para verificar se o kernel é compatível com a migração em tempo real, consulte Detalhes do kernel do Linux.
    • TDX_CAPABLE. Use essa tag se quiser usar sua imagem em uma instância de VM confidencial com suporte para Intel Trust Domain Extensions (TDX). Para verificar se o kernel é compatível com o Intel TDX, consulte Detalhes do kernel do Linux.

  • LOCATION (opcional): região ou multirregião em que a imagem será armazenada

    Por exemplo, especifique us para armazenar a imagem na multirregião us ou us-central1 para armazená-la na região us-central1. Se você não especificar, o Compute Engine armazenará a imagem na multirregião mais próxima do local de origem dela.

REST

Use o método images().insert com a sinalização guestOsFeatures para criar uma nova imagem personalizada a partir de uma imagem personalizada atual.


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:

  • PROJECT_ID: ID do projeto em que a nova imagem será criada
  • IMAGE_NAME: um nome para a nova imagem.

  • IMAGE_PROJECT (opcional): projeto que contém a imagem de origem

    Use esse parâmetro para copiar uma imagem de outro projeto.

  • SOURCE_IMAGE: imagem que servirá como base para a nova

  • LOCATION (opcional): uma região ou multirregião em que a imagem será armazenada

    Por exemplo, especifique us para armazenar a imagem na multirregião us ou us-central1 para armazená-la na região us-central1. Se você não especificar, o Compute Engine armazenará a imagem na multirregião mais próxima do local de origem dela.

  • FEATURES: tags do SO convidado para ativar os recursos das VMs criadas a partir de imagens

    Para adicionar vários valores, use vírgulas para separar os valores. Defina um ou mais dos seguintes valores:

    • VIRTIO_SCSI_MULTIQUEUE. Use em dispositivos SSD locais como alternativa ao NVMe. Para mais informações sobre imagens compatíveis com SCSI, consulte Como escolher uma interface.

      Para imagens do Linux, é possível ativar o SCSI multifilas em dispositivos SSD locais em imagens com versões de kernel 3.17 ou posteriores. Para imagens do Windows, é possível ativar o SCSI de várias filas em dispositivos SSD locais em imagens com o driver do Windows do Compute Engine versão 1.2.

    • WINDOWS. Inclua tags nas imagens de inicialização personalizadas do Windows Server como imagens do Windows.
    • MULTI_IP_SUBNET. Configure interfaces com uma máscara de rede diferente de /32. Para mais informações sobre várias interfaces de rede e como elas funcionam, consulte Visão geral e exemplos de várias interfaces de rede.
    • UEFI_COMPATIBLE. Inicialização com firmware UEFI e os seguintes recursos de VM protegida:
    • GVNIC. Compatível com larguras de banda de rede maiores de até 50 Gbps a velocidades de 100 Gbps. Para mais informações, consulte Como usar a NIC virtual do Google.
    • IDPF. Suporte a interfaces de rede da função de caminho de dados de infraestrutura (IDPF) da Intel.
    • SEV_CAPABLE ou SEV_SNP_CAPABLE. Use essas tags se quiser usar sua imagem em uma instância de VM confidencial com suporte para virtualização criptografada segura (SEV) da AMD ou virtualização criptografada segura com paginação aninhada segura (SEV-SNP) da AMD. Para verificar se o kernel é compatível com AMD SEV ou AMD SEV-SNP, consulte Detalhes do kernel do Linux.
    • SEV_LIVE_MIGRATABLE_V2. Use essa tag se quiser usar sua imagem em uma instância de VM confidencial que ofereça suporte à migração em tempo real no AMD SEV. Para verificar se o kernel é compatível com a migração em tempo real, consulte Detalhes do kernel do Linux.
    • TDX_CAPABLE. Use essa tag se quiser usar sua imagem em uma instância de VM confidencial com suporte para Intel Trust Domain Extensions (TDX). Para verificar se o kernel é compatível com o Intel TDX, consulte Detalhes do kernel do Linux.

Evite informações sensíveis em variáveis UEFI

As variáveis da Unified Extensible Firmware Interface (UEFI) são variáveis de par de chave-valor usadas pelo firmware da UEFI durante a inicialização para iniciar o sistema operacional de uma VM. Ao contrário das máquinas físicas, em que as variáveis são armazenadas em um chip de hardware, o Compute Engine virtualiza o armazenamento dessas variáveis. Assim, em muitos sistemas operacionais, todos os aplicativos e usuários podem acessar essas variáveis e informações.

Por isso, o Google recomenda que você não grave nem armazene informações sensíveis ou de identificação pessoal, como senhas ou chaves privadas, em variáveis UEFI.

Considerações sobre imagens de Arm

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

Para ajudar os usuários a diferenciar entre imagens de Arm e x86, as imagens de Arm terão um campo architecture definido como ARM64. Os valores possíveis para esse campo são:

  • ARCHITECTURE_UNSPECIFIED
  • X86_64
  • ARM64

Os usuários podem filtrar esse campo para encontrar imagens com base em x86 ou em Arm.

A seguir