Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Arresta o riavvia un'istanza Compute Engine

Linux Windows

Questo documento spiega come arrestare o riavviare manualmente un'istanza Compute Engine. In alternativa, per automatizzare l'arresto o il riavvio di un'istanza di computing, consulta quanto segue:

È possibile arrestare manualmente un'istanza di computing. Al termine di un'operazione di arresto e quando lo stato dell'istanza di computing passa a TERMINATED, puoi riavviare l'istanza di computing per riprendere il workload o eliminarla definitivamente se non ne hai più bisogno. L'arresto manuale di un'istanza di computing è utile quando vuoi:

Risparmia sui costi mantenendo le configurazioni: non vuoi più eseguire workload sull'istanza di computing. Tuttavia, vuoi conservare l'istanza di computing e i dischi, le impostazioni di configurazione, gli indirizzi IP, gli indirizzi MAC e i metadati collegati. Se devi anche conservare i dati in memoria e lo stato dell'applicazione, sospendi l'istanza di computing.
Aggiorna le proprietà: vuoi modificare una o più proprietà che richiedono l'arresto e il riavvio dell'istanza di computing prima che le modifiche possano avere effetto, ad esempio vuoi modificare il tipo di macchina o scollegare un disco. Per saperne di più, consulta Proprietà che puoi aggiornare.

Limitazioni

Quando arresti un'istanza di computing, si applicano le seguenti limitazioni:

Puoi arrestare o riavviare un'istanza di computing solo se lo stato dell'istanza di computing lo consente.
Puoi riavviare un'istanza di computing solo se sono presenti risorse sufficienti nella zona in cui si trova l'istanza di computing.
Non puoi riavviare le istanze di computing TPU. Dopo aver arrestato le istanze di computing TPU, puoi solo eliminarle.

Prima di iniziare

Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione verifica la tua identità per l'accesso ad API e servizi Google Cloud . Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi autenticarti su Compute Engine selezionando una delle seguenti opzioni:
Seleziona la scheda in base a come prevedi di utilizzare gli esempi in questa pagina:
Console

Quando utilizzi la console Google Cloud per accedere ai servizi e alle API Google Cloud , non devi configurare l'autenticazione.
gcloud
1. Installa Google Cloud CLI. Dopo l'installazione, inizializza Google Cloud CLI eseguendo il comando seguente:
  gcloud init
  Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
  
  Nota:se hai installato gcloud CLI in precedenza, assicurati di avere l'ultima versione eseguendo gcloud components update.
Imposta una regione e una zona predefinite.

Vai

Per utilizzare gli esempi di Go in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

Installa Google Cloud CLI.
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
Se utilizzi una shell locale, crea le credenziali di autenticazione locale per il tuo account utente:
```
gcloud auth application-default login
```
Non è necessario farlo se utilizzi Cloud Shell.

Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver eseguito l'accesso a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Java

Per utilizzare gli esempi di Java in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

Installa Google Cloud CLI.
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
Se utilizzi una shell locale, crea le credenziali di autenticazione locale per il tuo account utente:
```
gcloud auth application-default login
```
Non è necessario farlo se utilizzi Cloud Shell.

Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver eseguito l'accesso a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Node.js

Per utilizzare gli esempi di Node.js in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

Installa Google Cloud CLI.
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
Se utilizzi una shell locale, crea le credenziali di autenticazione locale per il tuo account utente:
```
gcloud auth application-default login
```
Non è necessario farlo se utilizzi Cloud Shell.

Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver eseguito l'accesso a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

PHP

Per utilizzare gli esempi PHP in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

Installa Google Cloud CLI.
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
Se utilizzi una shell locale, crea le credenziali di autenticazione locale per il tuo account utente:
```
gcloud auth application-default login
```
Non è necessario farlo se utilizzi Cloud Shell.

Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver eseguito l'accesso a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Python

Per utilizzare gli esempi di Python in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

Installa Google Cloud CLI.
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
Se utilizzi una shell locale, crea le credenziali di autenticazione locale per il tuo account utente:
```
gcloud auth application-default login
```
Non è necessario farlo se utilizzi Cloud Shell.

Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver eseguito l'accesso a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

REST

Per utilizzare gli esempi di API REST in questa pagina in un ambiente di sviluppo locale, utilizzi le credenziali che fornisci a gcloud CLI.

Installa Google Cloud CLI.

Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Autenticati per usare REST nella documentazione sull'autenticazione di Google Cloud .

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per arrestare o riavviare un'istanza di computing, chiedi all'amministratore di concederti il ruolo IAM Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per arrestare o riavviare un'istanza di computing. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per arrestare o riavviare un'istanza di computing sono necessarie le seguenti autorizzazioni:

Per arrestare un'istanza di computing: compute.instances.stop sull'istanza di computing
Per arrestare un'istanza di computing dal sistema operativo guest: compute.instances.setMetadata sull'istanza di computing se utilizza chiavi SSH pubbliche a livello di istanza.
Per riavviare un'istanza di computing: compute.instances.start sull'istanza di computing
Per riavviare un'istanza di computing che utilizza le chiavi di crittografia: compute.instances.startWithEncryptionKey sull'istanza di computing

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Arresta un'istanza di computing

Per arrestare l'istanza di computing, utilizza uno dei seguenti metodi. L'approccio migliore per il tuo caso d'uso dipende dalla presenza o meno di dischi SSD locali collegati all'istanza di computing e da come vuoi gestire eventuali script di arresto:

Arresta un'istanza di computing da Google Cloud. Puoi arrestare contemporaneamente una o più istanze di computing da Google Cloud. Se alle istanze di computing sono collegati dischi SSD locali, puoi scegliere se eliminare o conservare (anteprima) i dati dell'SSD locale. L'esecuzione di eventuali script di arresto nell'istanza di computing deve terminare prima che l'istanza di computing venga arrestata. Per istruzioni, consulta uno dei seguenti articoli:
- Arresta un'istanza di computing senza dischi SSD locali
- Arresta un'istanza di computing con dischi SSD locali
Arresta un'istanza di computing dal sistema operativo guest. Questo approccio garantisce che l'esecuzione degli script di arresto termini prima dell'arresto dell'istanza di computing. Se hai attivato l'arresto normale, puoi saltarlo o terminarlo. Tuttavia, l'arresto di un'istanza di computing dal sistema operativo guest comporta l'eliminazione dei dati su tutti i dischi SSD locali collegati, a meno che non esegua prima il backup dei dati in un'archiviazione durevole. Per le istruzioni, vedi Arresta un'istanza di computing dal sistema operativo guest.

Arresta un'istanza di computing senza dischi SSD locali

Per arrestare un'istanza di computing senza dischi SSD locali collegati, esamina le seguenti opzioni:

Se hai attivato l'arresto normale nell'istanza di computing, puoi risparmiare sui costi saltando o terminando un arresto normale in corso. Per farlo, utilizza la console Google Cloud , gcloud CLI o l'API REST.
Per arrestare più istanze di computing contemporaneamente, utilizza la consoleGoogle Cloud o, per le istanze di computing che si trovano nella stessa zona, gcloud CLI.

Per arrestare una o più istanze di computing, seleziona una delle seguenti opzioni:

Console

Nella console Google Cloud , vai alla pagina Istanze VM.

Vai a Istanze VM
Seleziona le istanze di computing in esecuzione da arrestare.
Fai clic su Arresta. Se non è presente l'opzione Arresta, fai clic su Altre azioni e seleziona Arresta.
Nella finestra di dialogo visualizzata, procedi nel seguente modo:
1. (Facoltativo) Per arrestare le istanze di computing senza ricorrere all'arresto normale o terminare un arresto normale in corso, seleziona la casella di controllo Salta arresto normale (se applicabile).
2. Per confermare, fai clic su Arresta.

gcloud

Per arrestare una o più istanze di computing che si trovano nella stessa zona, utilizza il comando gcloud compute instances stop:

gcloud compute instances stop INSTANCE_NAMES \
    --zone=ZONE

Sostituisci quanto segue:

INSTANCE_NAMES: un elenco di nomi di istanze di computing che vuoi arrestare, separati da spazi. Ad esempio, specifica instance-01 instance-02 instance-03.
ZONE: la zona in cui si trovano le istanze di computing.

Se vuoi saltare o terminare un arresto normale in corso, utilizza lo stesso comando con il flag --no-graceful-shutdown:

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

Vai

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

Per arrestare un'istanza di computing, effettua una richiesta POST al metodo instances.stop:

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

Sostituisci quanto segue:

INSTANCE_NAME: il nome dell'istanza di computing.
PROJECT_ID: l'ID del progetto in cui si trova l'istanza di computing.
ZONE: la zona in cui si trova l'istanza di computing.

Se vuoi saltare o terminare un arresto normale in corso, includi il parametro di query noGracefulShutdown=true nell'URL della richiesta:

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

Arresta un'istanza di computing con dischi SSD locali

Il metodo migliore per arrestare un'istanza di computing con dischi SSD locali collegati dipende dal caso d'uso. Utilizza una delle seguenti opzioni:

Se hai attivato l'arresto normale in un'istanza di computing, puoi risparmiare sui costi saltando o terminando un arresto normale in corso. Per farlo, utilizza la console Google Cloud , gcloud CLI o l'API REST.
Per conservare i dati dell'SSD locale (esclusi i tipi di macchine che utilizzano Titanium SSD), utilizza gcloud CLI o l'API REST.

Attenzione: se scegli di conservare i dati dell'SSD locale, Compute Engine li archivia in uno spazio di archiviazione durevole mentre l'istanza di computing è in fase di arresto. Prima di arrestare l'istanza di computing, verifica di avere una quota del disco sufficiente per archiviare i dati dell'SSD locale.
Per arrestare più istanze di computing contemporaneamente, utilizza la consoleGoogle Cloud o, per le istanze di computing che si trovano nella stessa zona, gcloud CLI.

Per arrestare una o più istanze di computing con dischi SSD locali collegati, seleziona una delle seguenti opzioni:

Console

Nella console Google Cloud , vai alla pagina Istanze VM.

Vai a Istanze VM
Seleziona le istanze di computing in esecuzione da arrestare.
Fai clic su Arresta. Se non è presente l'opzione Arresta, fai clic su Altre azioni e seleziona Arresta.
Nella finestra di dialogo visualizzata, procedi nel seguente modo:
1. (Facoltativo) Per arrestare le istanze di computing senza ricorrere all'arresto normale o terminare un arresto normale in corso, seleziona la casella di controllo Salta arresto normale (se applicabile).
2. Per confermare, fai clic su Arresta.

gcloud

Quando arresti una o più istanze di computing nella stessa zona con dischi SSD locali collegati, specifica se desideri eliminare o conservare i dati dell'SSD locale come segue:

Per eliminare i dati dell'SSD locale, utilizza il comando gcloud compute instances stop con il flag --discard-local-ssd=true:
```
gcloud compute instances stop INSTANCE_NAMES \
    --discard-local-ssd=true \
    --zone=ZONE
```
Per conservare i dati dell'SSD locale, utilizza il comando gcloud beta compute instances stop con il flag --discard-local-ssd=false:

Anteprima - Il flag --discard-local-ssd=false

Questa funzionalità è soggetta ai "Termini dell'offerta pre-GA" nella sezione dei Termini di servizio generali dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni della fase di lancio.
```
gcloud beta compute instances stop INSTANCE_NAMES \
    --discard-local-ssd=false \
    --zone=ZONE
```

Sostituisci quanto segue:

INSTANCE_NAMES: un elenco di nomi di istanze di computing che vuoi arrestare, separati da spazi. Ad esempio, specifica instance-01 instance-02 instance-03.
ZONE: la zona in cui si trovano le istanze di computing.

Se vuoi saltare o terminare un arresto normale in corso, includi il flag --no-graceful-shutdown nel comando:

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

Sostituisci DISCARD_LOCAL_SSD con true per eliminare i dati nei dischi SSD locali o con false per conservarli. Se specifichi false, devi utilizzare il comando gcloud beta compute instances stop.

REST

Quando arresti una o più istanze di computing nella stessa zona con dischi SSD locali collegati, specifica se desideri eliminare o conservare i dati dell'SSD locale come segue:

Per eliminare i dati dell'SSD locale, effettua una richiesta POST al metodo instances.stop. Nell'URL della richiesta, includi il parametro di query discardLocalSsd impostato su true:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/stop?discardLocalSsd=true
```
Per conservare i dati dell'SSD locale, invia una richiesta POST al metodo beta.instances.stop. Nell'URL della richiesta, includi il parametro di query discardLocalSsd impostato su false:

Anteprima - Il parametro di query discardLocalSsd=false

Questa funzionalità è soggetta ai "Termini dell'offerta pre-GA" nella sezione dei Termini di servizio generali dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni della fase di lancio.
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/stop?discardLocalSsd=false
```

Sostituisci quanto segue:

PROJECT_ID: l'ID del progetto in cui si trova l'istanza di computing.
ZONE: la zona in cui si trova l'istanza di computing.
INSTANCE_NAME: il nome dell'istanza di computing.

Se vuoi saltare o terminare un arresto normale in corso, includi il parametro di query noGracefulShutdown=true nell'URL della richiesta:

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

Sostituisci DISCARD_LOCAL_SSD con true per eliminare i dati nei dischi SSD locali o con false per conservarli. Se specifichi false, devi inviare una richiesta POST al metodo beta.instances.stop.

Arresta un'istanza di computing dal sistema operativo guest

Se a un'istanza di computing sono collegati dischi SSD locali, l'arresto del sistema operativo guest comporta l'eliminazione automatica dei dati dell'SSD locale. Per conservarli, copiali manualmente in una soluzione di archiviazione permanente prima di arrestare l'istanza di computing.

Per arrestare un'istanza di computing dal sistema operativo guest, seleziona una delle seguenti opzioni:

Linux

Se non l'hai ancora fatto, connettiti all'istanza di computing.
Per arrestare l'istanza di computing dal sistema operativo guest, seleziona uno dei seguenti metodi:
- Per arrestare correttamente il sistema operativo guest solo dopo che tutti gli script di arresto hanno terminato l'esecuzione, esegui il seguente comando:
```
sudo shutdown -h now
```
- Per forzare l'arresto del sistema operativo guest, esegui il seguente comando:
```
sudo poweroff
```

Windows

Se non l'hai già fatto, connettiti all'istanza di computing utilizzando uno dei seguenti metodi:
Per arrestare l'istanza di computing dal sistema operativo guest, seleziona uno dei seguenti metodi:
- Per arrestare correttamente il sistema operativo guest solo dopo che tutti gli script di arresto hanno terminato l'esecuzione, esegui il seguente comando:
```
shutdown /s
```
- Per forzare l'arresto del sistema operativo guest, esegui il seguente comando:
```
shutdown /f
```

Riavvia un'istanza di computing

Puoi riavviare un'istanza di computing che è stata completamente arrestata, vale a dire quando lo stato dell'istanza di computing è TERMINATED. Se hai scelto di conservare i dati dell'SSD locale quando hai arrestato l'istanza di computing, potresti dover rimontare i dischi SSD locali dopo aver riavviato l'istanza di computing. Per ulteriori informazioni, consulta Formatta e monta un dispositivo SSD locale.

Per riavviare un'istanza di computing, utilizza uno dei seguenti metodi. Il metodo migliore per il tuo caso d'uso dipende dal fatto che l'istanza di computing abbia dischi criptati con chiavi di crittografia fornite dal cliente (CSEK):

Riavviare un'istanza di computing che non dispone di dischi crittografati con CSEK
Riavvia un'istanza di computing con dischi criptati con CSEK

Riavvia un'istanza di computing senza dischi criptati con CSEK

Per riavviare più istanze di computing contemporaneamente in zone diverse, utilizza la console Google Cloud . Per le istanze di computing che si trovano nella stessa zona, puoi utilizzare gcloud CLI. Altrimenti, per altri scenari di riavvio, seleziona una delle seguenti opzioni:

Console

Nella console Google Cloud , vai alla pagina Istanze VM.

Vai a Istanze VM
Seleziona le istanze di computing che vuoi riavviare.
Fai clic su Avvia/Riprendi.

gcloud

Per riavviare una o più istanze di computing che si trovano nella stessa zona, utilizza il comando gcloud compute instances start:

gcloud compute instances start INSTANCE_NAMES \
    --zone=ZONE

Sostituisci quanto segue:

INSTANCE_NAMES: un elenco di nomi di istanze di computing che vuoi riavviare, separati da spazi. Ad esempio, specifica instance-01 instance-02 instance-03.
ZONE: la zona in cui si trovano le istanze di computing.

Vai

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

Per riavviare un'istanza di computing, effettua una richiesta POST al metodo instances.start:

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

Sostituisci quanto segue:

INSTANCE_NAME: il nome dell'istanza di computing.
PROJECT_ID: l'ID del progetto in cui si trova l'istanza di computing.
ZONE: la zona in cui si trova l'istanza di computing.

Riavvia un'istanza di computing con dischi criptati con CSEK

Quando riavvii un'istanza di computing arrestata collegata a dischi criptati tramite chiavi di crittografia fornite dal cliente, devi fornire le informazioni sulle chiavi di crittografia.

Console

Nella console Google Cloud , vai alla pagina Istanze VM.

Vai a Istanze VM
Seleziona le istanze di computing che vuoi riavviare.
Fai clic su Avvia/Riprendi.
Nella finestra di dialogo visualizzata, procedi nel seguente modo:
1. Specifica le chiavi di crittografia per ciascuno dei dischi criptati collegati alle istanze di computing.
2. Fai clic su Avvia.

gcloud

Per riavviare una o più istanze di computing che utilizzano dischi criptati esistenti nella stessa zona, utilizza il comando gcloud compute instances start con il flag --csek-key-file. Se invece utilizzi una chiave con wrapping RSA, utilizza il comando gcloud beta compute instances start con il flag --csek-key-file:

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

Sostituisci quanto segue:

INSTANCE_NAMES: un elenco di nomi di istanze di computing che vuoi riavviare, separati da spazi. Ad esempio, specifica instance-01 instance-02 instance-03.
ENCRYPTION_KEY_FILE: il percorso relativo al file JSON contenente la chiave di crittografia fornita dal cliente. Puoi riavviare più istanze di computing contemporaneamente solo se le istanze utilizzano la stessa chiave di crittografia fornita dal cliente. Il formato del file è descritto in Formato file chiave.
ZONE: la zona in cui si trovano le istanze di computing.

Vai

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

Per riavviare un'istanza di computing che utilizza dischi criptati, invia una richiesta POST al metodo 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"
      }
    }
  ]
}

Sostituisci quanto segue:

PROJECT_ID: l'ID del progetto in cui si trova l'istanza di computing.
ZONE: la zona in cui si trova l'istanza di computing.
INSTANCE_NAME: il nome dell'istanza di computing.
DISK_URL: l'URL della risorsa corrispondente al nome completo della risorsa del disco collegato, che è stato criptato con una chiave di crittografia fornita dal cliente.
ENCRYPTION_TYPE: il tipo di crittografia del disco che utilizzi, che può essere uno dei seguenti: rawKey, kmsKeyName o rsaEncryptedKey. Se utilizzi il tipo rsaEncryptedKey, invia una richiesta POST al metodo beta.instances.startWithEncryptionKey.
ENCRYPTION_KEY: la chiave di crittografia utilizzata per criptare i Persistent Disk collegati all'istanza di computing. Le chiavi rawKey o rsaEncryptedKey devono essere codificate in Base64. Inoltre, per preparare una chiave rsaEncryptedKey, consulta Wrapping delle chiavi RSA.

Arresta o riavvia un'istanza Compute Engine Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Limitazioni

Prima di iniziare

Console

gcloud

Vai

Java

Node.js

PHP

Python

REST

Ruoli obbligatori

Autorizzazioni obbligatorie

Arresta un'istanza di computing

Arresta un'istanza di computing senza dischi SSD locali

Console

gcloud

Vai

Java

Node.js

PHP

Python

REST

Arresta un'istanza di computing con dischi SSD locali

Console

gcloud

REST

Arresta un'istanza di computing dal sistema operativo guest

Linux

Windows

Riavvia un'istanza di computing

Riavvia un'istanza di computing senza dischi criptati con CSEK

Console

gcloud

Vai

Java

Node.js

PHP

Python

REST

Riavvia un'istanza di computing con dischi criptati con CSEK

Console

gcloud

Vai

Java

Node.js

PHP

Python

REST

Passaggi successivi

Arresta o riavvia un'istanza Compute Engine