Esta página se ha traducido con Cloud Translation API.

Crear imágenes personalizadas de Windows Server

Windows

Puedes crear imágenes de Windows Server personalizadas a partir de imágenes de Windows Server de Compute Engine. Usa estas imágenes personalizadas para crear instancias con discos de arranque iguales a los de tus instancias.

Estas imágenes personalizadas son útiles para guardar la configuración del sistema operativo de tus instancias y reutilizar la misma configuración para crear otras instancias.

En esta sección no se tratan las siguientes tareas:

Crea una VM a partir de una imagen pública o personalizada. En su lugar, consulta Crear una instancia de Windows.
Programar una copia de seguridad de tus discos persistentes; consulta Capturas de discos persistentes.
Importar sistemas Windows Server o SQL Server. En su lugar, usa el servicio de migración de VMs.

Antes de empezar

Si aún no lo has hecho, configura la autenticación. La autenticación verifica tu identidad para acceder a Google Cloud servicios y APIs. Para ejecutar código o ejemplos desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:
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. Instala Google Cloud CLI. Después de la instalación, inicializa la CLI de Google Cloud ejecutando el siguiente comando:
  gcloud init
  Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.
  
  Nota: Si ya has instalado la CLI de gcloud, asegúrate de que tienes la versión más reciente ejecutando gcloud components update.
2. Set a default region and zone.
Go

Para usar las Go muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.
Para obtener más información, consulta Set up authentication for a local development environment.
Java

Para usar las Java muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.
Para obtener más información, consulta Set up authentication for a local development environment.
Node.js

Para usar las Node.js muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.
Para obtener más información, consulta Set up authentication for a local development environment.
Python

Para usar las Python muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.
Para obtener más información, consulta Set up authentication for a local development environment.
REST

Para usar las muestras de la API REST de esta página en un entorno de desarrollo local, debes usar las credenciales que proporciones a la CLI de gcloud.
Para obtener más información, consulta el artículo Autenticarse para usar REST de la documentación sobre autenticación de Google Cloud .

Preparar la creación de una imagen de Windows Server

Antes de crear la imagen, ejecuta GCESysprep en la instancia para prepararla para el proceso de creación de la imagen.

GCESysprep prepara una instancia para que se convierta en una imagen de Compute Engine siguiendo estos pasos:

Inhabilita la tarea programada GCEStartup.
Elimina todos los archivos de la ubicación de la carpeta temporal.
Borra todos los registros de eventos de Windows.
Ejecuta sysprep.exe /generalize /oobe /quit /unattend
Configura instance_setup.ps1 para que se ejecute en el primer arranque de la instancia de VM.
Elimina el certificado RDP.
Elimina la lista almacenada de discos persistentes.
Habilita las reglas de cortafuegos de RDP y WinRM.
Inhabilita el servicio de configuración del SO de Google.
Cierra la instancia.

Las operaciones de GCESysprep se registran en el registro de eventos de Windows y en el puerto serie 1. Sysprep escribe en varios archivos de registro.

Para crear una imagen de Compute Engine con GCESysprep, sigue estos pasos:

Ejecuta GCESysprep con derechos de administrador.
```
GCESysprep
```
Crea la imagen.

Especificar la ubicación de una imagen

Cuando creas una imagen personalizada, puedes especificar la ubicación de Cloud Storage de la imagen, excepto las ubicaciones birregionales. Al especificar la ubicación de almacenamiento de las imágenes, puedes cumplir los requisitos de cumplimiento y normativas de localidad de los datos, así como tus necesidades de alta disponibilidad, ya que se garantiza la redundancia en todas las regiones.

La función de ubicación de almacenamiento es opcional. Si no seleccionas ninguna ubicación, Compute Engine almacenará la imagen en la multirregión más cercana a la fuente de la imagen. Puedes crear imágenes personalizadas a partir de discos, imágenes o snapshots de origen, o bien a partir de imágenes almacenadas en Cloud Storage. Puedes usar estas imágenes para crear nuevas instancias de VM.

Todas las imágenes que ya tenías antes de que se lanzara esta función seguirán en el mismo sitio. El único cambio es que puedes ver la ubicación de todas tus imágenes. Si tienes una imagen que quieres mover, debes volver a crearla en la ubicación seleccionada.

Crear una imagen de Windows

Puedes crear imágenes de disco a partir de las siguientes fuentes:

Un disco persistente, incluso cuando está conectado a una instancia
Una captura de un disco persistente
Otra imagen de tu proyecto
Una imagen compartida desde otro proyecto
Una imagen importada almacenada en Cloud Storage

Consola

En la Google Cloud consola, ve a la página Crear una imagen.
Crear una imagen
Especifica el Nombre de la imagen.
Elige un disco de origen con un sistema operativo Windows del que quieras crear una imagen.
Especifica la ubicación en la que quieres guardar la imagen. Elige una ubicación de la imagen en el menú desplegable Basado en la ubicación del disco de origen (opción predeterminada). Por ejemplo, especifica us para almacenar la imagen en la multirregión us o us-central1 para almacenarla en la región us-central1. Si no haces ninguna selección, Compute Engine almacenará la imagen en la multirregión más cercana a la ubicación de origen de la imagen.
Especifica las propiedades de la imagen. Por ejemplo, puedes especificar un nombre de familia de imágenes para organizar la imagen como parte de una familia de imágenes.
Haz clic en Crear.

gcloud

Usa gcloud compute con images create y proporciona el disco persistente de origen a partir del que quieras crear una imagen. Si quieres, incluye la marca --force para crear la imagen aunque esté conectada a una instancia activa.

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

Haz los cambios siguientes:

DISK_NAME: nombre del disco de origen a partir del que se creará la imagen.
ZONE: la zona del disco.
LOCATION: una marca opcional que te permite designar la región o multirregión en la que se va a almacenar tu imagen. Por ejemplo, especifica us para almacenar la imagen en la multirregión us o us-central1 para almacenarla en la región us-central1. Si no seleccionas ninguna, Compute Engine almacenará la imagen en la multirregión más cercana a la ubicación de origen de la imagen.
--force: una marca opcional que crea la imagen aunque el disco esté conectado a una instancia en ejecución. Esta opción puede poner en riesgo la integridad de la imagen. Si es posible, detén la instancia antes de crear la imagen.

Cuando ejecutas este comando, gcloud compute crea una imagen basada en el disco persistente que has proporcionado y la añade a tu colección. Para confirmar que la imagen se ha creado correctamente, ejecuta el siguiente comando:

gcloud compute images list

Go

Antes de probar este ejemplo, sigue las Go instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

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 probar este ejemplo, sigue las Java instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de Compute Engine.


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

Antes de probar este ejemplo, sigue las Node.js instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de Compute Engine.

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

Antes de probar este ejemplo, sigue las Python instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de Compute Engine.

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

Envía una solicitud POST al método images().insert con una URL sourceDisk en el cuerpo de la solicitud.

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",
}

Haz los cambios siguientes:

PROJECT_ID: el ID de proyecto de esta solicitud.
FORCE_OPTION: una marca opcional para crear la imagen aunque el disco de origen esté conectado a una instancia en ejecución. Especifica forceCreate=true al final de la línea POST para definir esta opción. Esta opción puede poner en riesgo la integridad de la imagen. Si es posible, detén la instancia antes de crear la imagen.
IMAGE_NAME: el nombre que se le asignará a la imagen.
ZONE: la zona del disco de origen a partir de la que se creará la imagen.
DISK_NAME: el nombre del disco de origen.
LOCATION: parámetro opcional que te permite seleccionar la ubicación de almacenamiento de tu imagen (una multirregión o una región). Por ejemplo, especifica us para almacenar la imagen en la multirregión us o us-central1 para almacenarla en la región us-central1. Si no seleccionas ninguna, Compute Engine almacenará la imagen en la multirregión más cercana a la ubicación de origen de la imagen.

Para obtener más información sobre cómo añadir imágenes, consulta la referencia de imágenes.

Actualizar agentes y secuencias de comandos de Windows

De vez en cuando, Compute Engine publica nuevas imágenes de Windows con los agentes y las secuencias de comandos más recientes. Estos elementos ayudan a las instancias de Windows con los procesos de inicio y apagado, la gestión de cuentas y la gestión de direcciones.

Desde la versión v20160112 de la imagen de Windows, el agente de Windows se actualiza automáticamente con las versiones de la fuente. Para inhabilitar estas actualizaciones del agente, asigna el valor true a la clave de metadatos de instancia disable-agent-updates. Si tienes instancias basadas en versiones anteriores de imágenes, puedes actualizar manualmente el agente de Windows de esas instancias.

Crear imágenes personalizadas de Windows Server Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Antes de empezar

Console

gcloud

Go

Java

Node.js

Python

REST

Preparar la creación de una imagen de Windows Server

Especificar la ubicación de una imagen

Crear una imagen de Windows

Consola

gcloud

Go

Java

Node.js

Node.js

Python

Python

REST

Actualizar agentes y secuencias de comandos de Windows

Siguientes pasos

Crear imágenes personalizadas de Windows Server