Criar imagens personalizadas do Windows Server

É possível criar imagens personalizadas do Windows Server a partir de imagens existentes do Windows Server no Compute Engine. Use essas imagens personalizadas para criar instâncias com discos de inicialização que sejam iguais às suas instâncias atuais.

Essas imagens são úteis para salvar a configuração do sistema operacional de suas instâncias existentes e reutilizar a mesma configuração para criar outras instâncias.

As seguintes tarefas não são abordadas nesta seção:

Antes de começar

Para receber as permissões necessárias para criar uma imagem personalizada do Windows Server, 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 do Windows Server. 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 do Windows Server:

  • compute.images.create
  • Para criar uma imagem personalizada do disco de inicialização de uma instância com uma conta de serviço anexada:
    • iam.serviceAccounts.actAs na conta de serviço da instância
    • compute.disks.useReadOnly no disco
  • Para criar uma imagem personalizada de todos os outros discos: compute.disks.useReadOnly no disco
  • Para criar uma imagem personalizada com base em uma imagem atual: 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.

Preparar-se para criar uma imagem do Windows Server

Antes de criar a imagem, execute GCESysprep na instância a fim de prepará-la para o processo de criação de imagem.

GCESysprep prepara uma instância para se tornar uma imagem do Compute Engine por meio das seguintes etapas:

  1. Desativa a tarefa programada para GCEStartup.
  2. Exclui todos os arquivos do local da pasta temporária.
  3. Limpa todos os logs de eventos do Windows.
  4. Executa sysprep.exe /generalize /oobe /quit /unattend
  5. Configura instance_setup.ps1 para ser executado na primeira inicialização da instância de VM.
  6. Exclui o certificado RDP.
  7. Remove a lista armazenada de discos permanentes.
  8. Ativa as regras de firewall RDP e WinRM.
  9. Desativa o serviço de configuração do sistema operacional do Google.
  10. Encerra a instância.

As operações GCESysprep são registradas no log de eventos do Windows e na porta serial 1. O Sysprep grava em vários arquivos de registro.

Como criar uma imagem do Compute Engine usando GCESysprep:

  1. Execute GCESysprep com direitos administrativos.

    GCESysprep

  2. Criar a imagem

Especificar o local de uma imagem

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 a localidade de dados, bem como suas necessidades de alta disponibilidade, garantindo redundância entre regiões.

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. É possível criar imagens personalizadas a partir de discos, imagens, snapshots ou imagens de origem armazenados no Cloud Storage. Essas imagens podem ser usadas para criar novas instâncias de VM.

Todas as imagens atuais anteriores ao lançamento desse recurso permanecem onde estão. A única alteração é que o local de todas as imagens pode ser visualizado. Se você tiver uma imagem atual que queira mover, recrie-a no local selecionado.

Crie uma imagem do Windows.

Crie imagens de disco com base nas seguintes origens:

  • Um disco permanente, mesmo que esteja anexado a uma instância
  • Um snapshot de um disco permanente
  • Outra imagem no projeto
  • Uma imagem compartilhada de outro projeto

  • Uma imagem importada armazenada no Cloud Storage

Console

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

    Criar uma nova imagem

  2. Especifique o Nome da imagem.
  3. Escolha um disco de Origem com o sistema operacional Windows que você usará para criar uma imagem.
  4. Especifique o Local para armazenar a imagem. Escolha um local para a imagem no menu suspenso Com base na localização do disco de origem (padrão). 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 fizer uma seleção, o Compute Engine armazenará a imagem na multirregião mais próxima do local de origem da sua imagem.
  5. Especifique as propriedades da imagem. Por exemplo, especifique um nome de família para incluir a imagem como parte de uma família de imagens.
  6. Clique em Criar.

CLI do Google Cloud

Use gcloud compute com images create e especifique o disco permanente de origem a partir do qual você quer criar uma imagem. Se quiser, inclua a sinalização --force para criar a imagem, mesmo que ela esteja conectada a uma instância em execução.

gcloud compute images create example-image --source-disk DISK_NAME \
    --source-disk-zone ZONE \
    --storage-location LOCATION \
   [--force]

Substitua:

  • DISK_NAME: o nome do disco de origem para criar a imagem.
  • ZONE: a zona do disco.
  • LOCATION: uma flag opcional que permite designar a região ou a 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.
  • --force: uma flag opcional que cria a imagem mesmo que o disco esteja conectado a uma instância em execução. Essa opção pode comprometer a integridade da imagem. Interrompa a instância antes de criar a imagem, se possível.

Quando você executa esse comando, gcloud compute cria uma nova imagem com base no disco permanente especificado e a adiciona à sua coleção. Verifique se a imagem foi criada com sucesso executando:

gcloud compute images list

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

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// createWindowsOSImage creates a new Windows image from the specified source disk.
func createWindowsOSImage(
	w io.Writer,
	projectID, zone, sourceDiskName, imageName, storageLocation string,
	forceCreate bool,
) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// sourceDiskName := "your_source_disk_name"
	// imageName := "your_image_name"
	// storageLocation := "eu"
	// forceCreate := false

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

	// Getting instances where source disk is attached
	diskRequest := &computepb.GetDiskRequest{
		Project: projectID,
		Zone:    zone,
		Disk:    sourceDiskName,
	}

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

	// Сhecking whether the instances is stopped
	for _, fullInstanceName := range sourceDisk.GetUsers() {
		parsedName := strings.Split(fullInstanceName, "/")
		l := len(parsedName)
		if l < 5 {
			return fmt.Errorf(
				"API returned instance name with unexpected format",
			)
		}
		instanceReq := &computepb.GetInstanceRequest{
			Project:  parsedName[l-5],
			Zone:     parsedName[l-3],
			Instance: parsedName[l-1],
		}
		instance, err := instancesClient.Get(ctx, instanceReq)
		if err != nil {
			return fmt.Errorf("unable to get instance: %w", err)
		}

		if instance.GetStatus() != "TERMINATED" && instance.GetStatus() != "STOPPED" {
			if !forceCreate {
				return fmt.Errorf("instance %s should be stopped. "+
					"Please stop the instance using "+
					"GCESysprep command or set forceCreate parameter to true "+
					"(not recommended). More information here: "+
					"https://cloud.google.com/compute/docs/instances/windows/creating-windows-os-image#api",
					parsedName[l-1],
				)
			}
		}
	}

	if forceCreate {
		fmt.Fprintf(w, "Warning: ForceCreate option compromise the integrity of your image. "+
			"Stop the instance before you create the image if possible.",
		)
	}

	req := &computepb.InsertImageRequest{
		Project:     projectID,
		ForceCreate: &forceCreate,
		ImageResource: &computepb.Image{
			Name:             proto.String(imageName),
			SourceDisk:       proto.String(fmt.Sprintf("zones/%s/disks/%s", zone, sourceDiskName)),
			StorageLocations: []string{storageLocation},
		},
	}

	op, err := imagesClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create image: %w", err)
	}

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

	fmt.Fprintf(w, "Image created\n")

	return nil
}

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]);
      }
    };
  }

}

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 sourceDiskName = 'YOUR_SOURCE_DISK_NAME';
// const imageName = 'YOUR_IMAGE_NAME';
// const storageLocation = 'eu';
// const forceCreate = false;

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

function parseInstanceName(name) {
  const parsedName = name.split('/');
  const l = parsedName.length;

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

  return [parsedName[l - 1], parsedName[l - 3], parsedName[l - 5]];
}

async function createWindowsOSImage() {
  const imagesClient = new compute.ImagesClient();
  const instancesClient = new compute.InstancesClient();
  const disksClient = new compute.DisksClient();

  // Getting instances where source disk is attached
  const [sourceDisk] = await disksClient.get({
    project: projectId,
    zone,
    disk: sourceDiskName,
  });

  // Сhecking whether the instances is stopped
  for (const fullInstanceName of sourceDisk.users) {
    const [instanceName, instanceZone, instanceProjectId] =
      parseInstanceName(fullInstanceName);
    const [instance] = await instancesClient.get({
      project: instanceProjectId,
      zone: instanceZone,
      instance: instanceName,
    });

    if (
      !['TERMINATED', 'STOPPED'].includes(instance.status) &&
      !forceCreate
    ) {
      throw new Error(
        `Instance ${instanceName} should be stopped. Please stop the instance using GCESysprep command or set forceCreate parameter to true (not recommended). More information here: https://cloud.google.com/compute/docs/instances/windows/creating-windows-os-image#api.`
      );
    }
  }

  if (forceCreate) {
    console.warn(
      'Warning: forceCreate option compromise the integrity of your image. Stop the instance before you create the image if possible.'
    );
  }

  const [response] = await imagesClient.insert({
    project: projectId,
    forceCreate,
    imageResource: {
      name: imageName,
      sourceDisk: `/zones/${zone}/disks/${sourceDiskName}`,
      storageLocations: storageLocation ? [storageLocation] : [],
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new ccompute.GlobalOperationsClient);

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

  console.log('Image created.');
}

createWindowsOSImage();

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 um solicitação POST para o método images().insert, com um URL sourceDisk no corpo da solicitação.

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

{
  "name": "IMAGE_NAME",
  "sourceDisk": "zones/ZONE/disks/DISK_NAME",
  "storageLocations": "LOCATION",
}

Substitua:

  • PROJECT_ID: o ID do projeto desta solicitação.
  • FORCE_OPTION: uma flag opcional para criar a imagem mesmo que o disco de origem esteja conectado a uma instância em execução. Especifique forceCreate=true no final da linha POST para definir essa opção. Essa opção pode comprometer a integridade da imagem. Interrompa a instância antes de criar a imagem, se possível.
  • IMAGE_NAME: o nome que você quer dar a essa imagem.
  • ZONE: a zona do disco de origem para criar uma imagem.
  • DISK_NAME: o nome do disco de origem.
  • LOCATION: um parâmetro opcional que permite selecionar o local de armazenamento da multirregião ou de uma região 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.

Atualizar agentes e scripts do Windows

No Compute Engine, às vezes são liberadas novas imagens do Windows com os agentes e scripts mais recentes. Esses itens ajudam as instâncias do Windows com processos de inicialização e encerramento, gerenciamento de contas e gerenciamento de endereços.

Desde a versão de imagem v20160112, o agente do Windows é atualizado automaticamente com as versões upstream. Desative essas atualizações definindo a chave de metadados de instância disable-agent-updates como true. Para instâncias baseadas em versões de imagem anteriores, atualize o agente do Windows manualmente.

A seguir