Reinicializar ou redefinir uma instância do Compute Engine

Este documento explica como reinicializar 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 .

Reiniciar ou redefinir uma instância pode ajudar a garantir desempenho e estabilidade ideais ou ajudar a resolver problemas como sistema operacional (SO) convidado congelado, lento ou com falha. Com base no estado do sistema operacional convidado da sua instância, siga um destes procedimentos:

  • Reinicie a instância . Se o seu sistema operacional convidado estiver lento ou travado, a reinicialização dará tempo suficiente para concluir a execução das tarefas antes de desligar.

  • Redefina a instância . Redefina uma instância somente se o sistema operacional convidado travar ou não responder e você não tiver outras opções. A redefinição de uma instância não permite que o sistema operacional convidado seja encerrado corretamente. Esta ação pode descartar dados não salvos e corromper os sistemas de arquivos de qualquer disco.

Antes de começar

Funções obrigatórias

Para obter as permissões necessárias para redefinir ou reinicializar uma instância de computação, peça ao administrador para conceder a você a função do IAM Compute Instance Admin (v1) ( roles/compute.instanceAdmin.v1 ) na instância. Para obter mais informações sobre a concessão de funções, consulte Gerenciar acesso a projetos, pastas e organizações .

Esta função predefinida contém as permissões necessárias para redefinir ou reinicializar uma instância de computação. Para ver 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 reinicializar uma instância de computação:

  • Para redefinir uma instância: compute.instances.reset
  • Para reinicializar uma instância de seu sistema operacional convidado: compute.instances.setMetadata

Você também poderá obter essas permissões com funções personalizadas ou outras funções predefinidas .

Reinicializar uma instância

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

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

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

Linux

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

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

    sudo reboot

Windows

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

  2. Para reinicializar 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 Gerenciador de inicialização do Windows .

Redefinir uma instância

A redefinição de uma instância apaga todos os dados da memória da instância, incluindo quaisquer 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.

Você pode 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 CLI do Google Cloud. Para instâncias individuais, selecione qualquer uma das seguintes opções:

Console

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

    Acesse as instâncias de VM

  2. Selecione as instâncias a serem redefinidas.

  3. Clique em Redefinir e 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 o seguinte:

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

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

Ir 

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

Pitão 

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

DESCANSAR

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 o seguinte:

  • INSTANCE_NAME : o nome da instância.

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

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

O que vem a seguir