Interromper ou reiniciar uma instância do Compute Engine

Linux Windows

Neste documento, explicamos como interromper ou reiniciar uma instância do Compute Engine. Para saber mais sobre como suspender, interromper ou redefinir uma instância, consulte Suspender, interromper ou redefinir instâncias do Compute Engine.

Interromper uma instância é útil quando ela não é mais usada ou para modificar as propriedades dela, por exemplo, para mudar o tipo de máquina ou remover discos anexados e montados. Depois de interromper a instância, faça o seguinte:

• Reinicie-o para retomar sua carga de trabalho.

• Exclua se não precisar mais dele.

Para automatizar a interrupção ou reinicialização de uma instância, consulte o seguinte:

• Como programar uma instância de VM para iniciar e parar

• Limitar o ambiente de execução de uma VM

Antes de começar

• Configure a autenticação, caso ainda não tenha feito isso. Com isso, você confirma sua identidade para acesso a serviços e APIs do Google Cloud . Para executar código ou exemplos em um ambiente de desenvolvimento local, faça a autenticação no Compute Engine com um destes métodos:

  Select the tab for how you plan to use the samples on this page:

  Console

  When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

  gcloud

  1. Instale a CLI do Google Cloud. Após a instalação, inicialize a CLI do Google Cloud executando o seguinte comando:

     gcloud init

     Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI com sua identidade federada.

     Observação: se você já instalou a gcloud CLI, execute o comando gcloud components update para verificar se você tem a versão mais recente.
  2. Set a default region and zone.

  Go

  Para usar os exemplos do Go desta página em um ambiente de desenvolvimento local, instale e inicialize a gcloud CLI e configure o Application Default Credentials com suas credenciais de usuário.

  Instale a CLI do Google Cloud.

  Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI com sua identidade federada.

  Observação: se você já instalou a gcloud CLI, execute o comando gcloud components update para verificar se você tem a versão mais recente.

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Saiba mais em Set up authentication for a local development environment.

  Java

  Para usar os exemplos do Java desta página em um ambiente de desenvolvimento local, instale e inicialize a gcloud CLI e configure o Application Default Credentials com suas credenciais de usuário.

  Instale a CLI do Google Cloud.

  Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI com sua identidade federada.

  Observação: se você já instalou a gcloud CLI, execute o comando gcloud components update para verificar se você tem a versão mais recente.

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Saiba mais em Set up authentication for a local development environment.

  Node.js

  Para usar os exemplos do Node.js desta página em um ambiente de desenvolvimento local, instale e inicialize a gcloud CLI e configure o Application Default Credentials com suas credenciais de usuário.

  Instale a CLI do Google Cloud.

  Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI com sua identidade federada.

  Observação: se você já instalou a gcloud CLI, execute o comando gcloud components update para verificar se você tem a versão mais recente.

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Saiba mais em Set up authentication for a local development environment.

  PHP

  Para usar os exemplos do PHP desta página em um ambiente de desenvolvimento local, instale e inicialize a gcloud CLI e configure o Application Default Credentials com suas credenciais de usuário.

  Instale a CLI do Google Cloud.

  Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI com sua identidade federada.

  Observação: se você já instalou a gcloud CLI, execute o comando gcloud components update para verificar se você tem a versão mais recente.

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Saiba mais em Set up authentication for a local development environment.

  Python

  Para usar os exemplos do Python desta página em um ambiente de desenvolvimento local, instale e inicialize a gcloud CLI e configure o Application Default Credentials com suas credenciais de usuário.

  Instale a CLI do Google Cloud.

  Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI com sua identidade federada.

  Observação: se você já instalou a gcloud CLI, execute o comando gcloud components update para verificar se você tem a versão mais recente.

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Saiba mais em Set up authentication for a local development environment.

  REST

  Para usar as amostras da API REST desta página em um ambiente de desenvolvimento local, use as credenciais fornecidas para gcloud CLI.

  Instale a CLI do Google Cloud.

  Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI com sua identidade federada.

  Observação: se você já instalou a gcloud CLI, execute o comando gcloud components update para verificar se você tem a versão mais recente.

  Saiba mais em Autenticar para usar REST na documentação de autenticação do Google Cloud .

Funções exigidas

Para receber as permissões necessárias para interromper ou reiniciar uma instância de computação, peça ao administrador para conceder a você o papel do IAM de Administrador da instância da computação (v1) (roles/compute.instanceAdmin.v1) no projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para interromper ou reiniciar uma instância de computação. Para acessar as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As permissões a seguir são necessárias para interromper ou reiniciar uma instância de computação:

• Para interromper uma instância: compute.instances.stop na instância
• Para interromper uma instância no SO convidado: compute.instances.setMetadata na instância se ela usar chaves SSH públicas no nível da instância.
• Para reiniciar uma instância: compute.instances.start na instância
• Para reiniciar uma instância que usa chaves de criptografia: compute.instances.startWithEncryptionKey na instância

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

Interromper uma instância

Quando você interrompe uma instância de computação ou o Compute Engine faz isso por uma ação programada, a instância mantém os recursos anexados, as configurações de configuração, os endereços IP internos, os endereços MAC e os metadados. No entanto, a instância perde os dados na memória e o estado do aplicativo. Se você precisar manter esses estados, suspenda a instância.

Importante :você continua recebendo cobranças por todos os recursos anexados a uma instância interrompida. Para evitar custos desnecessários, desvincule e exclua os recursos que não são mais necessários.

É possível interromper uma instância usando os seguintes métodos, dependendo se a instância tem discos SSD locais anexados e de como você quer processar os scripts de desligamento:

• Parar uma instância sem discos SSD locais

  É possível interromper uma ou mais instâncias simultaneamente que não tenham discos SSD locais anexados. Todos os scripts de desligamento em uma instância precisam terminar a execução dentro do período de desligamento padrão.

• Parar uma instância com discos SSD locais

  Ao interromper uma ou mais instâncias simultaneamente que têm discos SSD locais anexados, você pode descartar ou preservar (prévia) os dados nesses discos. Todos os scripts de desligamento na instância precisam terminar a execução dentro do período de desligamento padrão.

• Interromper uma instância no SO convidado

  Essa abordagem permite interromper uma única instância somente depois que os scripts de encerramento terminarem de ser executados ou, se você tiver ativado o encerramento normal, interromper a instância sem encerrá-la normalmente ou encerrar um encerramento normal em andamento. A menos que você faça backup manual dos dados de qualquer disco SSD local anexado em um volume de armazenamento durável, interromper uma instância no disco do SO convidado descarta todos os dados nesses discos.

Parar uma instância sem discos SSD locais

Dependendo do que você quer fazer ao interromper uma instância, use as seguintes opções:

• Se você tiver ativado o desligamento normal na instância, poderá interromper a instância sem desligá-la normalmente ou encerrar um desligamento normal em andamento usando o console Google Cloud , a CLI gcloud ou a API REST.

• Para interromper várias instâncias simultaneamente, use o console Google Cloud ou, no caso de instâncias localizadas na mesma zona, a CLI gcloud.

Para interromper uma ou mais instâncias, selecione uma das seguintes opções:

Console

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

   Acessar instâncias de VM

2. Selecione as instâncias em execução que você quer interromper.

3. Clique em Interromper. Se não houver a opção Parar, clique em Mais ações > Parar.

4. Na caixa de diálogo, faça o seguinte:

   1. Opcional: para interromper as instâncias sem encerrá-las normalmente ou encerrar um encerramento normal em andamento, marque a caixa de seleção Ignorar encerramento normal (se aplicável).

   2. Para confirmar, clique em Interromper.

gcloud

Para interromper uma ou mais instâncias na mesma zona, use o comando gcloud compute instances stop:

gcloud compute instances stop INSTANCE_NAMES \
    --zone=ZONE

Substitua:

• INSTANCE_NAMES: uma lista de nomes de instâncias separados por espaços. Por exemplo, instance-01 instance-02 instance-03.

• ZONE: a zona em que as instâncias estão localizadas.

Opcionalmente, se você tiver ativado o encerramento normal em uma ou mais instâncias, poderá interrompê-las sem fazer isso ou encerrar manualmente um encerramento normal em andamento. Para fazer isso, use o comando gcloud beta compute instances stop com a flag --no-graceful-shutdown:

Prévia — The --no-graceful-shutdown flag

Este recurso está sujeitos aos "Termos das Soluções Pré-GA" na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os recursos pré-GA estão disponíveis no estado em que se encontram e podem ter suporte limitado. Para mais informações, consulte as descrições das fases de lançamento.

gcloud beta compute instances stop INSTANCE_NAMES \
    --no-graceful-shutdown \
    --zone=ZONE

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// stopInstance stops a started Google Compute Engine instance
func stopInstance(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"

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

	req := &computepb.StopInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Stop(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to stop instance: %w", err)
	}

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

	fmt.Fprintf(w, "Instance stopped\n")

	return nil
}

Java

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StopInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StopInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    /* project: project ID or project number of the Cloud project your instance belongs to.
       zone: name of the zone your instance belongs to.
       instanceName: name of the instance your want to stop.
     */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    stopInstance(project, zone, instanceName);
  }

  // Stops a started Google Compute Engine instance.
  public static void stopInstance(String project, String zone, String instanceName)
      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()) {

      StopInstanceRequest stopInstanceRequest = StopInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.stopAsync(
          stopInstanceRequest);
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.getStatus() == Status.DONE) {
        System.out.println("Instance stopped successfully ! ");
      }
    }
  }
}

Node.js

/**
 * 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 compute = require('@google-cloud/compute');

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

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

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

  console.log('Instance stopped.');
}

stopInstance();

PHP

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\StopInstanceRequest;

/**
 * Stops a running Google Compute Engine instance.
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to stop.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function stop_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Stop the Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new StopInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->stop($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s stopped successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to stop instance: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

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 stop_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Stops a running Google Compute Engine instance.
    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to stop.
    """
    instance_client = compute_v1.InstancesClient()

    operation = instance_client.stop(
        project=project_id, zone=zone, instance=instance_name
    )
    wait_for_extended_operation(operation, "instance stopping")

REST

Para interromper uma instância, faça uma solicitação POST para o método instances.stop:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/stop

Substitua:

• INSTANCE_NAME: o nome da instância.

• PROJECT_ID: o ID do projeto em que a instância está localizada.

• ZONE: a zona em que a instância está localizada.

Se você tiver ativado o encerramento normal em uma instância, poderá interromper a instância sem encerrá-la normalmente ou encerrar manualmente um encerramento normal em andamento. Para fazer isso, envie uma solicitação POST ao método instances.stop. No URL da solicitação, inclua o parâmetro de consulta noGracefulShutdown=true:

Prévia — The noGracefulShutdown query parameter

Este recurso está sujeitos aos "Termos das Soluções Pré-GA" na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os recursos pré-GA estão disponíveis no estado em que se encontram e podem ter suporte limitado. Para mais informações, consulte as descrições das fases de lançamento.

POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/stop?noGracefulShutdown=true

Interromper uma instância com discos SSD locais

Dependendo do que você quer fazer ao interromper uma instância de computação, use as seguintes opções:

• Se você tiver ativado o desligamento normal na instância, poderá interromper a instância sem desligá-la normalmente ou encerrar um desligamento normal em andamento usando o console Google Cloud , a CLI gcloud ou a API REST.

• Para preservar os dados dos discos SSD locais anexados a uma instância (exceto tipos de máquina que usam SSD Titanium), interrompa a instância usando a CLI gcloud ou a API REST.

  Atenção: se você optar por preservar os dados do SSD local, o Compute Engine vai armazenar esses dados em um armazenamento durável enquanto a instância estiver interrompida. Portanto, antes de interromper a instância, verifique se você tem cota de disco suficiente para armazenar os dados do SSD local.

• Para interromper várias instâncias simultaneamente, use o console Google Cloud ou, no caso de instâncias localizadas na mesma zona, a CLI gcloud.

Para interromper uma ou mais instâncias com discos SSD locais anexados, selecione uma das seguintes opções:

Console

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

   Acessar instâncias de VM

2. Selecione as instâncias em execução que você quer interromper.

3. Clique em Interromper. Se não houver a opção Parar, clique em Mais ações > Parar.

4. Na caixa de diálogo, faça o seguinte:

   1. Opcional: para interromper as instâncias sem encerrá-las normalmente ou encerrar um encerramento normal em andamento, marque a caixa de seleção Ignorar encerramento normal (se aplicável).

   2. Para confirmar, clique em Interromper.

gcloud

Ao interromper uma ou mais instâncias na mesma zona que têm discos SSD locais anexados, especifique se os dados do SSD local serão descartados ou preservados da seguinte maneira:

• Para descartar dados da SSD local, use o comando gcloud compute instances stop com a flag --discard-local-ssd=true:

  gcloud compute instances stop INSTANCE_NAMES \
      --discard-local-ssd=true \
      --zone=ZONE
  

• Para preservar os dados da SSD local, use o comando gcloud beta compute instances stop com a flag --discard-local-ssd=false:

  Prévia — The --discard-local-ssd=false flag

  Este recurso está sujeitos aos "Termos das Soluções Pré-GA" na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os recursos pré-GA estão disponíveis no estado em que se encontram e podem ter suporte limitado. Para mais informações, consulte as descrições das fases de lançamento.

  gcloud beta compute instances stop INSTANCE_NAMES \
      --discard-local-ssd=false \
      --zone=ZONE
  

Substitua:

• INSTANCE_NAMES: uma lista de nomes de instâncias separados por espaços. Por exemplo, instance-01 instance-02 instance-03.

• ZONE: a zona em que as instâncias estão localizadas.

Opcionalmente, se você tiver ativado o desligamento normal em uma ou mais instâncias, é possível interromper as instâncias sem desligá-las normalmente ou encerrar um desligamento normal em andamento. Para fazer isso, use o comando gcloud beta compute instances stop com a flag --no-graceful-shutdown:

Prévia — The --no-graceful-shutdown flag

Este recurso está sujeitos aos "Termos das Soluções Pré-GA" na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os recursos pré-GA estão disponíveis no estado em que se encontram e podem ter suporte limitado. Para mais informações, consulte as descrições das fases de lançamento.

gcloud beta compute instances stop INSTANCE_NAMES \
    --discard-local-ssd=DISCARD_LOCAL_SSD \
    --no-graceful-shutdown \
    --zone=ZONE

Substitua DISCARD_LOCAL_SSD por true para descartar os dados nos discos SSD locais ou false para preservar os dados.

REST

Ao interromper uma instância com discos SSD locais anexados, especifique se os dados do SSD local serão descartados ou preservados da seguinte maneira:

• Para descartar dados da SSD local, faça uma solicitação POST ao método instances.stop. No URL da solicitação, inclua o parâmetro de consulta discardLocalSsd definido como true:

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/stop?discardLocalSsd=true
  

• Para preservar os dados do SSD local, faça uma solicitação POST para o método beta.instances.stop. No URL da solicitação, inclua o parâmetro de consulta discardLocalSsd definido como false:

  Prévia — The discardLocalSsd=false query parameter

  Este recurso está sujeitos aos "Termos das Soluções Pré-GA" na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os recursos pré-GA estão disponíveis no estado em que se encontram e podem ter suporte limitado. Para mais informações, consulte as descrições das fases de lançamento.

  POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/stop?discardLocalSsd=false
  

Substitua:

• PROJECT_ID: o ID do projeto em que a instância está localizada.

• ZONE: a zona em que a instância está localizada.

• INSTANCE_NAME: o nome da instância.

Opcionalmente, se você tiver ativado o encerramento normal em uma instância, poderá parar a instância sem encerrá-la normalmente ou encerrar manualmente um encerramento normal em andamento. Para fazer isso, envie uma solicitação POST ao método instances.stop. No URL da solicitação, inclua o parâmetro de consulta noGracefulShutdown=true:

Prévia — The noGracefulShutdown query parameter

Este recurso está sujeitos aos "Termos das Soluções Pré-GA" na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os recursos pré-GA estão disponíveis no estado em que se encontram e podem ter suporte limitado. Para mais informações, consulte as descrições das fases de lançamento.

POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/stop?discardLocalSsd=DISCARD_LOCAL_SSD&noGracefulShutdown=true

Substitua DISCARD_LOCAL_SSD por true para descartar os dados nos discos SSD locais ou false para preservar os dados.

Interromper uma instância no SO convidado

Se uma instância de computação tiver discos SSD locais anexados, o encerramento do SO convidado vai descartar automaticamente os dados do SSD local. Para preservar esses dados, copie-os manualmente para uma opção de armazenamento permanente antes de interromper a instância.

Para interromper uma instância no SO convidado, selecione uma das seguintes opções:

Linux

1. Se você ainda não fez isso, conecte-se à instância.

2. Para interromper a instância, selecione um dos seguintes métodos:

   • Para um encerramento limpo que permita que a instância execute scripts de encerramento antes de encerrar o SO convidado, execute o seguinte comando:

     sudo shutdown -h now
     

   • Caso contrário, para forçar um encerramento, execute o seguinte comando:

     sudo poweroff
     

Windows

1. Se ainda não fez isso, conecte-se à instância usando um dos métodos a seguir:

   • PowerShell

   • Protocolo de área de trabalho remota (RDP)

   • Secure Shell (SSH)

   • Console de administração especial (SAC)

2. Para interromper a instância, selecione um dos seguintes métodos:

   • Para interromper a instância corretamente e permitir que ela execute scripts de encerramento antes de desligar o SO convidado, execute o seguinte comando:

     shutdown /s
     

   • Para forçar um encerramento, execute o seguinte comando:

     shutdown /f
     

Reiniciar uma instância

É possível reiniciar uma instância de computação que foi totalmente interrompida, ou seja, quando o estado da instância é TERMINATED.

Se você optou por preservar os dados dos discos SSD locais ao interromper a instância, talvez seja necessário remontar os discos SSD locais após reiniciar a instância. Para mais informações sobre como ativar discos SSD locais, consulte Formatar e ativar um dispositivo SSD local.

Para reiniciar uma instância, use um dos seguintes métodos, dependendo se ela tem discos criptografados anexados:

• Se a instância não tiver discos criptografados anexados, consulte Reiniciar uma instância sem discos criptografados.

• Caso contrário, consulte Reiniciar uma instância com discos criptografados.

Reiniciar uma instância sem discos criptografados

Para reiniciar várias instâncias simultaneamente em diferentes zonas, use o console doGoogle Cloud . Para instâncias localizadas na mesma zona, use a CLI gcloud. Caso contrário, para outros cenários de reinicialização, selecione uma das seguintes opções:

Console

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

   Acessar instâncias de VM

2. Selecione uma ou mais instâncias.

3. Clique em Iniciar / continuar .

gcloud

Para reiniciar uma ou mais instâncias na mesma zona, use o comando gcloud compute instances start:

gcloud compute instances start INSTANCE_NAMES \
    --zone=ZONE

Substitua:

• INSTANCE_NAMES: uma lista de nomes de instâncias separados por espaços. Por exemplo, instance-01 instance-02 instance-03.

• ZONE: a zona em que as instâncias estão localizadas.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// startInstance starts a stopped Google Compute Engine instance (with unencrypted disks).
func startInstance(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"

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

	req := &computepb.StartInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Start(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to start instance: %w", err)
	}

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

	fmt.Fprintf(w, "Instance started\n")

	return nil
}

Java

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StartInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StartInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    /* project: project ID or project number of the Cloud project your instance belongs to.
       zone: name of the zone your instance belongs to.
       instanceName: name of the instance your want to start. */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    startInstance(project, zone, instanceName);
  }

  // Starts a stopped Google Compute Engine instance (with unencrypted disks).
  public static void startInstance(String project, String zone, String instanceName)
      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()) {

      // Create the request.
      StartInstanceRequest startInstanceRequest = StartInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.startAsync(
          startInstanceRequest);

      // Wait for the operation to complete.
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.getStatus() == Status.DONE) {
        System.out.println("Instance started successfully ! ");
      }
    }
  }
}

Node.js

/**
 * 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 compute = require('@google-cloud/compute');

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

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

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

  console.log('Instance started.');
}

startInstance();

PHP

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\StartInstanceRequest;

/**
 * Starts a stopped Google Compute Engine instance (with unencrypted disks).
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to stop.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function start_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Start the Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new StartInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->start($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s started successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to start instance: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

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 start_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Starts a stopped Google Compute Engine instance (with unencrypted disks).
    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to start.
    """
    instance_client = compute_v1.InstancesClient()

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

    wait_for_extended_operation(operation, "instance start")

REST

Para reiniciar uma instância, faça uma solicitação POST para o método instances.start:

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/start

Substitua:

• INSTANCE_NAME: o nome da instância a ser reiniciada.

• PROJECT_ID: o ID do projeto em que a instância está localizada.

• ZONE: a zona em que a instância está localizada.

Reiniciar uma instância com discos criptografados

Ao reiniciar uma instância de computação interrompida com discos anexados criptografados usando chaves de criptografia fornecidas pelo cliente, é necessário fornecer as informações da chave de criptografia.

Para reiniciar várias instâncias simultaneamente em diferentes zonas, use o console doGoogle Cloud . Para instâncias localizadas na mesma zona, use a CLI gcloud. Caso contrário, para outros cenários de reinicialização, selecione uma das seguintes opções:

Console

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

   Acessar instâncias de VM

2. Selecione as instâncias a serem reiniciadas.

3. Clique em Iniciar / continuar .

4. Especifique as chaves de criptografia para cada um dos discos criptografados anexados às instâncias e clique em Iniciar.

gcloud

Para reiniciar uma ou mais instâncias que usam discos criptografados na mesma zona, use o comando gcloud compute instances start com a flag --csek-key-file. Se você estiver usando uma chave incorporada por RSA, use o comando gcloud beta compute instances start com a flag --csek-key-file:

gcloud compute instances start INSTANCE_NAMES \
    --csek-key-file=ENCRYPTION_KEY_FILE \
    --zone=ZONE

Substitua:

• INSTANCE_NAMES: uma lista de nomes de instâncias separados por espaços. Por exemplo, instance-01 instance-02 instance-03.

• ENCRYPTION_KEY_FILE: o caminho relativo para o arquivo JSON que contém a chave de criptografia fornecida pelo cliente. Só é possível reiniciar várias instâncias simultaneamente se elas usarem a mesma chave de criptografia fornecida pelo cliente.

• ZONE: a zona em que as instâncias estão localizadas.

Go

import (
	"context"
	"fmt"
	"io"

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

// startInstanceWithEncKey starts a stopped Google Compute Engine instance (with encrypted disks).
func startInstanceWithEncKey(w io.Writer, projectID, zone, instanceName, key string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// key := "your_encryption_key"

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

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

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

	req := &computepb.StartWithEncryptionKeyInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
		InstancesStartWithEncryptionKeyRequestResource: &computepb.InstancesStartWithEncryptionKeyRequest{
			Disks: []*computepb.CustomerEncryptionKeyProtectedDisk{
				{
					Source: proto.String(instance.GetDisks()[0].GetSource()),
					DiskEncryptionKey: &computepb.CustomerEncryptionKey{
						RawKey: proto.String(key),
					},
				},
			},
		},
	}

	op, err := instancesClient.StartWithEncryptionKey(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to start instance with encryption key: %w", err)
	}

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

	fmt.Fprintf(w, "Instance with encryption key started\n")

	return nil
}

Java

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.CustomerEncryptionKey;
import com.google.cloud.compute.v1.CustomerEncryptionKeyProtectedDisk;
import com.google.cloud.compute.v1.GetInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.InstancesStartWithEncryptionKeyRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StartWithEncryptionKeyInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StartEncryptedInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    /* project: project ID or project number of the Cloud project your instance belongs to.
       zone: name of the zone your instance belongs to.
       instanceName: name of the instance your want to start.
       key: bytes object representing a raw base64 encoded key to your machines boot disk.
            For more information about disk encryption see:
            https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
     */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";
    String key = "raw-key";

    startEncryptedInstance(project, zone, instanceName, key);
  }

  // Starts a stopped Google Compute Engine instance (with encrypted disks).
  public static void startEncryptedInstance(String project, String zone, String instanceName,
      String key)
      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()) {

      GetInstanceRequest getInstanceRequest = GetInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName).build();

      Instance instance = instancesClient.get(getInstanceRequest);

      // Prepare the information about disk encryption.
      CustomerEncryptionKeyProtectedDisk protectedDisk = CustomerEncryptionKeyProtectedDisk
          .newBuilder()
          /* Use raw_key to send over the key to unlock the disk
             To use a key stored in KMS, you need to provide:
             `kms_key_name` and `kms_key_service_account`
           */
          .setDiskEncryptionKey(CustomerEncryptionKey.newBuilder()
              .setRawKey(key).build())
          .setSource(instance.getDisks(0).getSource())
          .build();

      InstancesStartWithEncryptionKeyRequest startWithEncryptionKeyRequest =
          InstancesStartWithEncryptionKeyRequest.newBuilder()
              .addDisks(protectedDisk).build();

      StartWithEncryptionKeyInstanceRequest encryptionKeyInstanceRequest =
          StartWithEncryptionKeyInstanceRequest.newBuilder()
              .setProject(project)
              .setZone(zone)
              .setInstance(instanceName)
              .setInstancesStartWithEncryptionKeyRequestResource(startWithEncryptionKeyRequest)
              .build();

      OperationFuture<Operation, Operation> operation = instancesClient.startWithEncryptionKeyAsync(
          encryptionKeyInstanceRequest);
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.getStatus() == Status.DONE) {
        System.out.println("Encrypted instance started successfully ! ");
      }
    }
  }

}

Node.js

/**
 * 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 key = 'YOUR_KEY_STRING'

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

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

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

  const [response] = await instancesClient.startWithEncryptionKey({
    project: projectId,
    zone,
    instance: instanceName,
    instancesStartWithEncryptionKeyRequestResource: {
      disks: [
        {
          source: instance.disks[0].source,
          diskEncryptionKey: {
            rawKey: key,
          },
        },
      ],
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

  console.log('Instance with encryption key started.');
}

startInstanceWithEncryptionKey();

PHP

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\CustomerEncryptionKey;
use Google\Cloud\Compute\V1\CustomerEncryptionKeyProtectedDisk;
use Google\Cloud\Compute\V1\GetInstanceRequest;
use Google\Cloud\Compute\V1\InstancesStartWithEncryptionKeyRequest;
use Google\Cloud\Compute\V1\StartWithEncryptionKeyInstanceRequest;

/**
 * Starts a stopped Google Compute Engine instance (with encrypted disks).
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to stop.
 * @param string $key Bytes object representing a raw base64 encoded key to your instance's boot disk.
 *                    For more information about disk encryption see:
 *                    https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function start_instance_with_encryption_key(
    string $projectId,
    string $zone,
    string $instanceName,
    string $key
) {
    // Initiate the InstancesClient.
    $instancesClient = new InstancesClient();

    // Get data about the instance.
    $request = (new GetInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $instanceData = $instancesClient->get($request);

    // Use `setRawKey` to send over the key to unlock the disk
    // To use a key stored in KMS, you need to use `setKmsKeyName` and `setKmsKeyServiceAccount`
    $customerEncryptionKey = (new CustomerEncryptionKey())
        ->setRawKey($key);

    /** @var \Google\Cloud\Compute\V1\AttachedDisk */
    $disk = $instanceData->getDisks()[0];

    // Prepare the information about disk encryption.
    $diskData = (new CustomerEncryptionKeyProtectedDisk())
        ->setSource($disk->getSource())
        ->setDiskEncryptionKey($customerEncryptionKey);

    // Set request with one disk.
    $instancesStartWithEncryptionKeyRequest = (new InstancesStartWithEncryptionKeyRequest())
        ->setDisks(array($diskData));

    // Start the instance with encrypted disk.
    $request2 = (new StartWithEncryptionKeyInstanceRequest())
        ->setInstance($instanceName)
        ->setInstancesStartWithEncryptionKeyRequestResource($instancesStartWithEncryptionKeyRequest)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->startWithEncryptionKey($request2);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s started successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Starting instance failed: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

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 start_instance_with_encryption_key(
    project_id: str, zone: str, instance_name: str, key: bytes
) -> None:
    """
    Starts a stopped Google Compute Engine instance (with encrypted disks).
    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to start.
        key: bytes object representing a raw base64 encoded key to your machines boot disk.
            For more information about disk encryption see:
            https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
    """
    instance_client = compute_v1.InstancesClient()

    instance_data = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )

    # Prepare the information about disk encryption
    disk_data = compute_v1.CustomerEncryptionKeyProtectedDisk()
    disk_data.source = instance_data.disks[0].source
    disk_data.disk_encryption_key = compute_v1.CustomerEncryptionKey()
    # Use raw_key to send over the key to unlock the disk
    # To use a key stored in KMS, you need to provide `kms_key_name` and `kms_key_service_account`
    disk_data.disk_encryption_key.raw_key = key
    enc_data = compute_v1.InstancesStartWithEncryptionKeyRequest()
    enc_data.disks = [disk_data]

    operation = instance_client.start_with_encryption_key(
        project=project_id,
        zone=zone,
        instance=instance_name,
        instances_start_with_encryption_key_request_resource=enc_data,
    )

    wait_for_extended_operation(operation, "instance start (with encrypted disk)")

REST

Para reiniciar uma instância que usa discos criptografados, faça uma solicitação POST para o método instances.startWithEncryptionKey:

POST  https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/startWithEncryptionKey

{
  "disks": [
    {
      "source": "DISK_URL",
      "diskEncryptionKey": {
        "ENCRYPTION_TYPE": "ENCRYPTION_KEY"
      }
    }
  ]
}

Substitua:

• PROJECT_ID: o ID do projeto em que a instância está localizada.

• ZONE: a zona em que a instância está localizada.

• INSTANCE_NAME: o nome da instância.

• DISK_URL: o URL do recurso correspondente ao nome completo do recurso do disco anexado, criptografado com uma chave de criptografia fornecida pelo cliente

• ENCRYPTION_TYPE: o tipo de criptografia de disco que você está usando, que pode ser uma das seguintes opções: rawKey, kmsKeyName ou rsaEncryptedKey. Se você usar o tipo rsaEncryptedKey, faça uma solicitação POST ao método beta.instances.startWithEncryptionKey.

• ENCRYPTION_KEY: a chave de criptografia usada para criptografar os discos permanentes anexados à instância. As chaves rawKey ou rsaEncryptedKey precisam ser codificadas em base64. Além disso, para preparar uma chave rsaEncryptedKey, consulte Encapsulamento de chaves por RSA.

A seguir

• Como solucionar problemas de desligamentos e reinicializações da VM

• Como solucionar problemas usando o console serial

• Editar o tipo de máquina de uma instância de computação

• Excluir uma instância do Compute Engine