Esta página foi traduzida pela API Cloud Translation.

Redefinir ou reiniciar uma instância do Compute Engine

Linux Windows

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

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

Reinicie a instância. Se o SO convidado estiver lento ou congelado, a reinicialização vai dar tempo suficiente para que ele conclua as tarefas em execução antes de ser encerrado.
Redefina a instância. Redefina uma instância somente se o SO convidado tiver falhado e você não tiver outras opções. A redefinição de uma instância não permite uma desativação limpa e, portanto, pode corromper sistemas de arquivos de inicialização ou não inicialização.

Antes de começar

Configure a autenticação, caso ainda não tenha feito isso. A autenticação é o processo de verificação da sua identidade para acesso a serviços e APIs do Google Cloud. Para executar códigos ou amostras de um ambiente de desenvolvimento local, autentique-se no Compute Engine selecionando uma das seguintes opções:

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. Install the Google Cloud CLI, then initialize it by running the following command:
  gcloud init
  Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
2. Set a default region and zone.

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 da computação (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 conferir 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.

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 desligamento simples 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

Conecte-se à instância, caso ainda não tenha feito isso.
Para reiniciar a instância, execute o seguinte comando:
```
sudo reboot
```

Windows

Se ainda não fez isso, conecte-se à instância usando um dos seguintes métodos:
Para reiniciar a instância, execute o seguinte comando:
```
shutdown /r /t 0
```
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 de computação em execução apaga a memória usada por ela. Se você estiver usando discos RAM e precisar preservar esses dados, faça backup deles antes de redefinir a instância.

É possível redefinir várias instâncias simultaneamente ou individualmente. 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

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

Acessar instâncias de VM
Selecione as instâncias a serem redefinidas.
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:

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

Redefinir ou reiniciar uma instância do Compute Engine

Antes de começar

Console

gcloud

Go

Java

Node.js

PHP

Python

REST

Funções exigidas

Permissões necessárias

Reiniciar uma instância

Linux

Windows

Redefinir uma instância

Console

gcloud

Go

Java

Node.js

PHP

Python

REST

A seguir