Reiniciar ou redefinir uma instância do Compute Engine

Neste documento, explicamos como reiniciar ou redefinir uma instância do Compute Engine. Para saber mais sobre os efeitos da redefinição de uma instância, bem como as diferenças entre suspender, interromper ou redefinir uma instância, consulte Suspender, interromper ou redefinir instâncias do Compute Engine.

A reinicialização ou a redefinição de uma instância pode ajudar a garantir o desempenho e a estabilidade ideais ou resolver problemas como um sistema operacional convidado (SO) congelado, lento ou com falhas. Com base no estado do SO convidado da instância, faça uma das seguintes ações:

  • Reinicie a instância. Se o SO convidado estiver lento ou travado, a reinicialização dá tempo suficiente para que ele termine as tarefas em execução antes de ser desligado.

  • Redefina a instância. Redefina uma instância somente se o SO convidado tiver falhado ou não estiver respondendo, e você não tiver outras opções. A redefinição de uma instância não permite que o SO convidado seja desligado corretamente. Essa ação pode descartar dados não salvos e corromper os sistemas de arquivos de qualquer disco.

Antes de começar

Funções exigidas

Para receber as permissões necessárias para redefinir 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 do Compute (v1) (roles/compute.instanceAdmin.v1) na instância. 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 redefinir 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 seguintes permissões são necessárias para redefinir ou reiniciar uma instância de computação:

  • Para redefinir uma instância: compute.instances.reset
  • Para reiniciar uma instância no SO convidado: compute.instances.setMetadata

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

Limitações

Não é possível redefinir instâncias G4 com menos de uma GPU (GPUs fracionárias) (prévia). Para mais informações sobre tipos de máquinas G4 com GPUs fracionadas (vGPUs), consulte a visão geral da série de máquinas G4.

Reiniciar uma instância

A reinicialização de uma instância de computação permite que o SO convidado na instância conclua as tarefas em execução antes que o Compute Engine envie o sinal de desligamento da ACPI. Isso ajuda a garantir um encerramento limpo do SO convidado.

A reinicialização de uma instância apaga a memória usada por ela. Se você estiver usando discos RAM com suas instâncias e precisar preservar esses dados, faça backup deles antes de reiniciar a instância.

Para reiniciar uma instância, selecione uma das seguintes opções:

Linux

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

  2. Para reiniciar a instância, execute o seguinte comando:

    sudo reboot

Windows

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

  2. Para reiniciar a instância, execute o seguinte comando:

    shutdown /r /t 0

  3. Opcional: para monitorar o processo de encerramento e reinicialização da instância, ative o menu do Gerenciador de inicialização do Windows.

Redefinir uma instância

A redefinição de uma instância apaga todos os dados na memória dela, incluindo arquivos temporários armazenados em discos RAM. Esses dados são perdidos permanentemente, e o Compute Engine não cria backups antes de redefinir a instância.

É possível redefinir várias instâncias simultaneamente ou instâncias individuais. Para várias instâncias, use o console do Google Cloud ou, para instâncias localizadas na mesma zona, a Google Cloud CLI. Para instâncias individuais, 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 que você quer redefinir.

  3. Clique em Redefinir e depois em Redefinir para confirmar.

gcloud

Para redefinir uma ou mais instâncias em execução em uma única zona, use o comando gcloud compute instances reset:

gcloud compute instances reset INSTANCE_NAMES \
    --zone=ZONE

Substitua:

  • INSTANCE_NAMES: uma lista separada por espaços em branco de nomes de instâncias, 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"
)

// resetInstance resets a running Google Compute Engine instance (with unencrypted disks).
func resetInstance(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.ResetInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Reset(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to reset 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 reset\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.ResetInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ResetInstance {

  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 reset.
     */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    resetInstance(project, zone, instanceName);
  }

  // Resets a running Google Compute Engine instance (with unencrypted disks).
  public static void resetInstance(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()) {

      ResetInstanceRequest resetInstanceRequest = ResetInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName)
          .build();

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

      if (response.getStatus() == Status.DONE) {
        System.out.println("Instance reset 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 resetInstance() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.reset({
    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 reset.');
}

resetInstance();

PHP 

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

/**
 * Reset a running 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 reset.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function reset_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Stop the Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new ResetInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->reset($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s reset successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to reset 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 reset_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Resets 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 reset.
    """
    instance_client = compute_v1.InstancesClient()

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

    wait_for_extended_operation(operation, "instance reset")

REST

Para redefinir uma instância em execução, faça uma solicitação POST para o método instances.reset:

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

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á.

A seguir