Zeitpläne für Laufwerk-Snapshots erstellen

Sie erstellen einen Snapshot-Zeitplan, um zonale und regionale Persistent Disk- und Google Cloud Hyperdisk-Volumes regelmäßig und automatisch zu sichern. Snapshot-Zeitpläne sind eine bewährte Methode zum Sichern von Compute Engine-Arbeitslasten.

Wenn Sie einen Snapshot-Zeitplan erstellen möchten, der den Status der Anwendungsdaten zum Zeitpunkt der Sicherung erfasst (auch als Anwendungskonsistenz , Gastbereinigung oder VSS-Snapshot bezeichnet), siehe Snapshots von konsistenten Laufwerken für Linux-Anwendungen erstellen oderSnapshot eines konsistenten Laufwerks für Windows-Anwendungen erstellen “

Weitere Informationen zu den Attributen des Snapshot-Zeitplans finden Sie unter Attribute des Snapshot-Zeitplans.

Hinweise

  • Sehen Sie sich die Einschränkungen für Snapshot-Zeitpläne an.
  • Richten Sie die Authentifizierung ein, falls Sie dies noch nicht getan haben. Bei der Authentifizierung wird Ihre Identität für den Zugriff auf Google Cloud -Dienste und APIs überprüft. Zum Ausführen von Code oder Beispielen aus einer lokalen Entwicklungsumgebung können Sie sich so bei der Compute Engine authentifizieren:

    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. Installieren Sie die Google Cloud CLI. Initialisieren Sie die Google Cloud CLI nach der Installation mit dem folgenden Befehl: 

      gcloud init

      Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

    2. Set a default region and zone.

    Go

    Wenn Sie die Go -Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten Sie dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

      Installieren Sie die Google Cloud CLI.

      Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

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

      gcloud auth application-default login

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

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

    Weitere Informationen finden Sie unter Set up authentication for a local development environment.

    Java

    Wenn Sie die Java -Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten Sie dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

      Installieren Sie die Google Cloud CLI.

      Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

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

      gcloud auth application-default login

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

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

    Weitere Informationen finden Sie unter Set up authentication for a local development environment.

    Node.js

    Wenn Sie die Node.js -Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten Sie dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

      Installieren Sie die Google Cloud CLI.

      Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

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

      gcloud auth application-default login

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

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

    Weitere Informationen finden Sie unter Set up authentication for a local development environment.

    Python

    Wenn Sie die Python -Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten Sie dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

      Installieren Sie die Google Cloud CLI.

      Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

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

      gcloud auth application-default login

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

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

    Weitere Informationen finden Sie unter Set up authentication for a local development environment.

    REST

    Wenn Sie die REST API-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, verwenden Sie die Anmeldedaten, die Sie der gcloud CLI bereitstellen.

      Installieren Sie die Google Cloud CLI.

      Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

    Weitere Informationen finden Sie in der Dokumentation zur Google Cloud -Authentifizierung unter Für die Verwendung von REST authentifizieren.

Erforderliche Rollen und Berechtigungen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen eines Snapshot-Zeitplans benötigen:

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierten Rollen enthalten die Berechtigungen, die zum Erstellen eines Snapshot-Zeitplans erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um einen Snapshot-Zeitplan zu erstellen:

  • Zum Erstellen eines Snapshot-Zeitplans: compute.resourcePolicies.create für das Projekt oder die Organisation
  • Snapshot-Zeitplan mit Laufwerk verknüpfen:
    • compute.disks.addResourcePolicies für das Laufwerk
    • compute.resourcePolicies.use für die Ressourcenrichtlinie
  • Laufwerk mit Snapshot-Zeitplan erstellen:
    • compute.disks.create für das Projekt
    • compute.resourcePolicies.create für das Projekt
    • compute.disks.addResourcePolicies für das Laufwerk

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Snapshot-Zeitpläne erstellen – Übersicht

Wenn Sie einen Snapshot-Zeitplan erstellen, erstellen Sie eine Ressourcenrichtlinie, die Sie auf einen oder mehrere Persistent Disk- oder Hyperdisk-Volumes anwenden können.

So erstellen Sie einen Snapshot-Zeitplan:

Verschlüsselung mit Snapshot-Zeitplänen verwenden

Wenn ein Laufwerk einen vom Kunden verwalteten Verschlüsselungsschlüssel (Customer-Managed Encryption Key, CMEK) verwendet und Sie einen Snapshot-Zeitplan zum Erstellen von Snapshots dieses Laufwerks verwenden, werden alle erstellten Snapshots automatisch mit demselben Schlüssel verschlüsselt.

Sie können keine Snapshot-Zeitpläne für Laufwerke verwenden, die einen vom Kunden bereitgestellten Verschlüsselungsschlüssel (CSEK) verwenden.

Snapshot-Zeitplan erstellen

Sie können einen Snapshot-Zeitplan für Ihre Laufwerke mit der Google Cloud Console, der Google Cloud CLI oder REST erstellen. Sie müssen den Snapshot-Zeitplan in derselben Region erstellen, in der sich das Laufwerk befindet. Wenn sich Ihr Laufwerk beispielsweise in der Zone us-west1-a befindet, müssen Sie den Snapshot-Zeitplan in der Region us-west1 erstellen. Sie können die vom Snapshot-Zeitplan generierten Snapshots jedoch an einem anderen Speicherort speichern.

Console

  1. Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf:

    Zu „VM-Instanzen“
    Die verbleibenden Schritte werden automatisch in der Google Cloud Console angezeigt.

  2. Wählen Sie das Projekt aus, das Ihre VM-Instanzen enthält.
  3. Klicken Sie in der Spalte Name auf den Namen der VM mit dem nichtflüchtigen Speicher, für den Sie einen Snapshot-Zeitplan erstellen möchten.
  4. Unter Speicher klicken Sie auf den Namen des Bootlaufwerks oder des zusätzlichen Laufwerks, um dafür einen Snapshot-Zeitplan zu erstellen.
  5. Klicken Sie auf  Bearbeiten. Möglicherweise müssen Sie auf das Menü  Weitere Aktionen und dann auf  Bearbeiten klicken.
  6. Wählen Sie unter Snapshot-Zeitplan die Option Zeitplan erstellen aus.
  7. Geben Sie unter Name einen der folgenden Namen für den Snapshot-Zeitplan ein:
    • boot-disk-snapshot-schedule
    • attached-persistent-disk-snapshot-schedule

  8. Wählen Sie im Bereich Standort den Snapshot-Speicherort aus. Der vordefinierte oder benutzerdefinierte Standardspeicherort, der in Ihren Snapshot-Einstellungen definiert ist, wird automatisch ausgewählt. Optional können Sie die Snapshot-Einstellungen überschreiben und die Snapshots an einem benutzerdefinierten Standort speichern. Gehen Sie dazu so vor:

    1. Wählen Sie die Art des gewünschten Speicherorts für den Snapshot aus.

      • Wählen Sie Multiregional aus, um eine höhere Verfügbarkeit zu höheren Kosten zu erreichen.
      • Wählen Sie Regionale Snapshots aus, um den physischen Standort Ihrer Daten zu geringeren Kosten besser steuern zu können.

    2. Wählen Sie im Feld Standort auswählen die Region oder Multiregion aus, die Sie verwenden möchten. Wählen Sie Je nach Standort des Laufwerks aus, um die Region bzw. Multiregion mit der geringsten Entfernung zu Ihrem Quelllaufwerk zu verwenden.

  9. Klicken Sie auf Erstellen, um die Erstellung des Snapshot-Zeitplans abzuschließen.
  10. Klicken Sie auf Speichern, um diesen Snapshot-Zeitplan an den nichtflüchtigen Speicher anzuhängen.

gcloud

  • Verwenden Sie den Befehl gcloud compute resource-policies create snapshot-schedule, um global angelegte Snapshots für ein Laufwerk zu planen. Legen Sie die Häufigkeit des Zeitplans auf stündlich, täglich oder wöchentlich fest.

    gcloud compute resource-policies create snapshot-schedule SCHEDULE_NAME \
    --description "SCHEDULE_DESCRIPTION" \
    --max-retention-days MAX_RETENTION_DAYS \
    --start-time START_TIME \
    --hourly-schedule SNAPSHOT_INTERVAL \
    --daily-schedule \
    --weekly-schedule SNAPSHOT_INTERVAL or --weekly-schedule-from-file FILE_NAME \
    --on-source-disk-delete DELETION_OPTION \
    --storage-location=STORAGE_LOCATION

  • Vorabversion: Wenn Sie regional begrenzte Snapshots für eine Festplatte planen möchten, verwenden Sie den gcloud compute resource-policies create snapshot-schedule-Befehl und geben Sie die Snapshot-Region an.

    gcloud beta compute resource-policies create snapshot-schedule SCHEDULE_NAME \
    --description "SCHEDULE_DESCRIPTION" \
    --max-retention-days MAX_RETENTION_DAYS \
    --start-time START_TIME \
    --hourly-schedule SNAPSHOT_INTERVAL \
    --daily-schedule \
    --weekly-schedule SNAPSHOT_INTERVAL or --weekly-schedule-from-file FILE_NAME \
    --on-source-disk-delete DELETION_OPTION \
    --storage-location=STORAGE_LOCATION \
    --region REGION \
    --snapshot-region SNAPSHOT_REGION

Ersetzen Sie Folgendes:

  • SCHEDULE_NAME ist der Name des Snapshot-Zeitplans
  • SCHEDULE_DESCRIPTION: eine Beschreibung des Snapshot-Zeitplans. Setzen Sie die Beschreibung in Anführungszeichen.
  • REGION: der Speicherort der Ressourcenrichtlinie für den Snapshot-Zeitplan.
  • SNAPSHOT_REGION: die Region, auf die der geplante Snapshot beschränkt ist.

  • MAX_RETENTION_DAYS: die Anzahl der Tage, für die der Snapshot aufbewahrt werden soll.

    Der Wert 3 bedeutet beispielsweise, dass die Snapshots 3 Tage lang aufbewahrt werden, bevor sie gelöscht werden. Sie müssen einen Wert von 1 oder höher verwenden.

  • START_TIME: der Beginn in der Zeitzone UTC. Sie müssen die Uhrzeit als volle Stunde angeben.

    Beispiel:

    • 14:00 Uhr PST muss als 22:00 angegeben werden.
    • Wenn Sie als Beginn 22:13 festlegen, erhalten Sie eine Fehlermeldung.

    Wenn Sie das Flag --weekly-schedule-from-file verwenden und in der Datei eine Startzeit angeben, müssen Sie dieses Flag nicht einfügen.

  • SNAPSHOT_INTERVAL: das Intervall zwischen dem Erstellen aufeinanderfolgender Snapshots. Die Flags der Snapshot-Häufigkeit hourly-schedule, daily-schedule, weekly-schedule und weekly-schedule-from-file schließen sich gegenseitig aus. Sie können nur eins für den Snapshot-Zeitplan verwenden.

    • Wenn Sie ein tägliches Programm festlegen möchten, fügen Sie das Flag --daily-schedule ohne Wert ein.
    • Legen Sie einen stündlichen Zeitplan fest, wobei das Flag --hourly-schedule auf einen ganzzahligen Wert zwischen 1 und 23 gesetzt ist. Wählen Sie eine Stundenzahl aus, die ein Teiler von 24 ist, um jeden Tag zur selben Zeit Snapshots zu generieren. Wenn Sie --hourly-schedule beispielsweise auf 12 setzen, wird alle 12 Stunden ein Snapshot erstellt.
    • Legen Sie einen wöchentlichen Zeitplan fest, wobei das Flag --weekly-schedule auf den Wochentag festgelegt ist, an dem der Snapshot erstellt werden soll. Wochentag muss ausgeschrieben werden; die Groß-/Kleinschreibung wird nicht berücksichtigt. Wenn Sie Ihr Laufwerk beispielsweise jeden Freitag sichern möchten, muss Ihr Befehl --weekly-schedule=friday enthalten.

    • Legen Sie einen erweiterten Wochenplan fest, indem Sie mit dem Flag --weekly-schedule-from-file verschiedene Wochentage und unterschiedliche Startzeiten angeben. Ersetzen Sie FILE_NAME durch den Namen der Datei, die den wöchentlichen Snapshot-Zeitplan enthält. Sie können zwar verschiedene Wochentage und unterschiedliche Startzeiten mithilfe einer Datei angeben, aber nicht mehrere wöchentliche Zeitpläne direkt in der Befehlszeile. Beispiel: In Ihrer Datei sind möglicherweise zwei wöchentliche Zeitpläne für Montag und Mittwoch angegeben. Sie können diese Einstellung jedoch nicht in der Befehlszeile duplizieren:

      [
  {"day": "MONDAY", "startTime": "04:00"},
  {"day": "WEDNESDAY", "startTime": "02:00"}
]

      Wenn Sie in der Datei eine Startzeit angeben, wird das Flag --start-time in der Befehlszeile nicht benötigt. Der Zeitplan verwendet die UTC-Zeitzone.

  • DELETION_OPTION: legt fest, was mit den Snapshots geschieht, wenn das Quelllaufwerk gelöscht wird. Wenn Sie alle generierten Snapshots beibehalten möchten, können Sie dieses Flag weglassen. Geben Sie andernfalls apply-retention-policy an, um die Einstellungen in einer Aufbewahrungsrichtlinie zu verwenden.

  • STORAGE_LOCATION: Optional: der Speicherort. Wenn Sie dieses Flag weglassen, wird der Standardspeicherort verwendet.

Beispiele

Für alle folgenden Beispiele gilt:

  • Die Regel für gelöschtes Laufwerk ist enthalten. Das Flag --on-source-disk-delete wird auf den Standardwert keep-auto-snapshots gesetzt, damit alle automatisch generierten Snapshots dauerhaft gespeichert werden. Alternativ können Sie dieses Flag auf apply-retention-policy festlegen, um Ihre Snapshot-Aufbewahrungsrichtlinie zu verwenden.
  • Der Speicherort ist manuell auf US gesetzt, sodass alle generierten Snapshots am multiregionalen Standort "US" gespeichert werden.
  • Die Labels env=dev und media=images werden auf alle generierten Snapshots angewendet.
  • Die Aufbewahrungsrichtlinie ist auf 10 Tage festgelegt.

Stündlicher Zeitplan: In diesem Beispiel beginnt der Snapshot-Zeitplan um 22:00 Uhr UTC (14:00 Uhr PST) und wird alle vier Stunden ausgeführt.

  gcloud compute resource-policies create snapshot-schedule hourly-schedule1 \
      --description "MY HOURLY SNAPSHOT SCHEDULE" \
      --max-retention-days 10 \
      --start-time 22:00 \
      --hourly-schedule 4 \
      --region us-west1 \
      --on-source-disk-delete keep-auto-snapshots \
      --snapshot-labels env=dev,media=images \
      --storage-location US

Täglicher Zeitplan: In diesem Beispiel beginnt der Snapshot-Zeitplan um 22:00 Uhr UTC (14:00 Uhr PST) und wird jeden Tag zur selben Zeit ausgeführt. Das Flag --daily-schedule muss vorhanden sein, darf aber keinen zugehörigen Wert haben.

gcloud compute resource-policies create snapshot-schedule daily-schedule2 \
    --description "MY DAILY SNAPSHOT SCHEDULE" \
    --max-retention-days 10 \
    --start-time 22:00 \
    --daily-schedule \
    --region us-west1 \
    --on-source-disk-delete keep-auto-snapshots \
    --snapshot-labels env=dev,media=images \
    --storage-location US

Wöchentlicher Zeitplan: In diesem Beispiel beginnt der Snapshot-Zeitplan um 22:00 Uhr UTC (14:00 Uhr PST) und wird jeden Dienstag ausgeführt.

gcloud compute resource-policies create snapshot-schedule weekly-schedule3 \
    --description "MY WEEKLY SNAPSHOT SCHEDULE" \
    --max-retention-days 10 \
    --start-time 22:00 \
    --weekly-schedule tuesday \
    --region us-west1 \
    --on-source-disk-delete keep-auto-snapshots \
    --snapshot-labels env=dev,media=images \
    --storage-location US

Go

import (
	"context"
	"fmt"
	"io"

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

// createSnapshotSchedule creates a snapshot schedule.
func createSnapshotSchedule(w io.Writer, projectID, scheduleName, region string) error {
	// projectID := "your_project_id"
	// snapshotName := "your_snapshot_name"
	// region := "eupore-central2"

	ctx := context.Background()

	snapshotsClient, err := compute.NewResourcePoliciesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewResourcePoliciesRESTClient: %w", err)
	}
	defer snapshotsClient.Close()

	req := &computepb.InsertResourcePolicyRequest{
		Project: projectID,
		Region:  region,
		ResourcePolicyResource: &computepb.ResourcePolicy{
			Name:        proto.String(scheduleName),
			Description: proto.String("MY DAILY SNAPSHOT SCHEDULE"),
			Region:      proto.String("europe-central2"),
			SnapshotSchedulePolicy: &computepb.ResourcePolicySnapshotSchedulePolicy{
				RetentionPolicy: &computepb.ResourcePolicySnapshotSchedulePolicyRetentionPolicy{
					MaxRetentionDays: proto.Int32(10),
					// Check the OnSourceDiskDelete enum for the list of possible values.
					OnSourceDiskDelete: proto.String("KEEP_AUTO_SNAPSHOTS"),
				},
				Schedule: &computepb.ResourcePolicySnapshotSchedulePolicySchedule{
					DailySchedule: &computepb.ResourcePolicyDailyCycle{
						DaysInCycle: proto.Int32(1),
						StartTime:   proto.String("22:00"),
					},
				},
				SnapshotProperties: &computepb.ResourcePolicySnapshotSchedulePolicySnapshotProperties{
					StorageLocations: []string{"eu"},
					Labels: map[string]string{
						"env":   "dev",
						"media": "images",
					},
				},
			},
		},
	}
	op, err := snapshotsClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create snapshot schedule: %w", err)
	}

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

	fmt.Fprint(w, "Snapshot schedule created\n")

	return nil
}

Java 

import com.google.cloud.compute.v1.InsertResourcePolicyRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.ResourcePoliciesClient;
import com.google.cloud.compute.v1.ResourcePolicy;
import com.google.cloud.compute.v1.ResourcePolicyHourlyCycle;
import com.google.cloud.compute.v1.ResourcePolicySnapshotSchedulePolicy;
import com.google.cloud.compute.v1.ResourcePolicySnapshotSchedulePolicyRetentionPolicy;
import com.google.cloud.compute.v1.ResourcePolicySnapshotSchedulePolicyRetentionPolicy.OnSourceDiskDelete;
import com.google.cloud.compute.v1.ResourcePolicySnapshotSchedulePolicySchedule;
import com.google.cloud.compute.v1.ResourcePolicySnapshotSchedulePolicySnapshotProperties;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateSnapshotSchedule {
  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the region in which you want to create the snapshot schedule.
    String region = "us-central1";
    // Name of the snapshot schedule you want to create.
    String snapshotScheduleName = "YOUR_SCHEDULE_NAME";
    // Description of the snapshot schedule.
    String scheduleDescription = "YOUR_SCHEDULE_DESCRIPTION";
    // Maximum number of days to retain snapshots.
    int maxRetentionDays = 10;
    // Storage location for the snapshots.
    // More about storage locations:
    // https://cloud.google.com/compute/docs/disks/snapshots?authuser=0#selecting_a_storage_location
    String storageLocation = "US";

    createSnapshotSchedule(projectId, region, snapshotScheduleName, scheduleDescription,
            maxRetentionDays, storageLocation);
  }

  // Creates a snapshot schedule policy.
  public static Status createSnapshotSchedule(String projectId, String region,
            String snapshotScheduleName, String scheduleDescription, int maxRetentionDays,
            String storageLocation)
          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.
    try (ResourcePoliciesClient resourcePoliciesClient = ResourcePoliciesClient.create()) {
      int snapshotInterval = 10; // Create a snapshot every 10 hours
      String startTime = "08:00"; // Define the hourly schedule

      ResourcePolicyHourlyCycle hourlyCycle = ResourcePolicyHourlyCycle.newBuilder()
              .setHoursInCycle(snapshotInterval)
              .setStartTime(startTime)
              .build();

      ResourcePolicySnapshotSchedulePolicyRetentionPolicy retentionPolicy =
              ResourcePolicySnapshotSchedulePolicyRetentionPolicy.newBuilder()
                      .setMaxRetentionDays(maxRetentionDays)
                      .setOnSourceDiskDelete(OnSourceDiskDelete.KEEP_AUTO_SNAPSHOTS.toString())
              .build();

      ResourcePolicySnapshotSchedulePolicySnapshotProperties snapshotProperties =
              ResourcePolicySnapshotSchedulePolicySnapshotProperties.newBuilder()
                      .addStorageLocations(storageLocation)
                      .build();

      ResourcePolicySnapshotSchedulePolicy snapshotSchedulePolicy =
              ResourcePolicySnapshotSchedulePolicy.newBuilder()
                      .setRetentionPolicy(retentionPolicy)
                      .setSchedule(ResourcePolicySnapshotSchedulePolicySchedule.newBuilder()
                               .setHourlySchedule(hourlyCycle)
                               .build())
                      .setSnapshotProperties(snapshotProperties)
                      .build();

      ResourcePolicy resourcePolicy = ResourcePolicy.newBuilder()
              .setName(snapshotScheduleName)
              .setDescription(scheduleDescription)
              .setSnapshotSchedulePolicy(snapshotSchedulePolicy)
              .build();
      InsertResourcePolicyRequest request = InsertResourcePolicyRequest.newBuilder()
              .setProject(projectId)
              .setRegion(region)
              .setResourcePolicyResource(resourcePolicy)
              .build();

      Operation response = resourcePoliciesClient.insertAsync(request)
              .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Snapshot schedule creation failed! " + response.getError());
      }
      return response.getStatus();
    }
  }
}

Node.js 

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

// Instantiate a resourcePoliciesClient
const resourcePoliciesClient = new computeLib.ResourcePoliciesClient();
// Instantiate a regionOperationsClient
const regionOperationsClient = new computeLib.RegionOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project name.
const projectId = await resourcePoliciesClient.getProjectId();

// The location of the snapshot schedule resource policy.
// region = 'us-central1';

// The name of the snapshot schedule.
// snapshotScheduleName = 'snapshot-schedule-name';

// The description of the snapshot schedule.
const snapshotScheduleDescription = 'snapshot schedule description...';

async function callCreateSnapshotSchedule() {
  const [response] = await resourcePoliciesClient.insert({
    project: projectId,
    region,
    resourcePolicyResource: new compute.ResourcePolicy({
      name: snapshotScheduleName,
      description: snapshotScheduleDescription,
      snapshotSchedulePolicy:
        new compute.ResourcePolicyInstanceSchedulePolicySchedule({
          retentionPolicy:
            new compute.ResourcePolicySnapshotSchedulePolicyRetentionPolicy({
              maxRetentionDays: 5,
            }),
          schedule: new compute.ResourcePolicySnapshotSchedulePolicySchedule({
            // Similarly, you can create a weekly or monthly schedule.
            // Review the resourcePolicies.insert method for details specific to setting a weekly or monthly schedule.
            // To see more details, open: `https://cloud.google.com/compute/docs/disks/scheduled-snapshots?authuser=0#create_snapshot_schedule`
            dailySchedule: new compute.ResourcePolicyDailyCycle({
              startTime: '12:00',
              daysInCycle: 1,
            }),
          }),
          snapshotProperties:
            new compute.ResourcePolicySnapshotSchedulePolicySnapshotProperties(
              {
                guestFlush: false,
                labels: {
                  env: 'dev',
                  media: 'images',
                },
                // OPTIONAL: the storage location. If you omit this flag, the default storage location is used.
                // storageLocations: 'storage-location',
              }
            ),
        }),
    }),
  });

  let operation = response.latestResponse;

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

  console.log(`Snapshot schedule: ${snapshotScheduleName} created.`);
}

await callCreateSnapshotSchedule();

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 snapshot_schedule_create(
    project_id: str,
    region: str,
    schedule_name: str,
    schedule_description: str,
    labels: dict,
) -> compute_v1.ResourcePolicy:
    """
    Creates a snapshot schedule for disks for a specified project and region.
    Args:
        project_id (str): The ID of the Google Cloud project.
        region (str): The region where the snapshot schedule will be created.
        schedule_name (str): The name of the snapshot schedule group.
        schedule_description (str): The description of the snapshot schedule group.
        labels (dict): The labels to apply to the snapshots. Example: {"env": "dev", "media": "images"}
    Returns:
        compute_v1.ResourcePolicy: The created resource policy.
    """

    # # Every hour, starts at 12:00 AM
    # hourly_schedule = compute_v1.ResourcePolicyHourlyCycle(
    #     hours_in_cycle=1, start_time="00:00"
    # )
    #
    # # Every Monday, starts between 12:00 AM and 1:00 AM
    # day = compute_v1.ResourcePolicyWeeklyCycleDayOfWeek(
    #     day="MONDAY", start_time="00:00"
    # )
    # weekly_schedule = compute_v1.ResourcePolicyWeeklyCycle(day_of_weeks=[day])

    # In this example we use daily_schedule - every day, starts between 12:00 AM and 1:00 AM
    daily_schedule = compute_v1.ResourcePolicyDailyCycle(
        days_in_cycle=1, start_time="00:00"
    )

    schedule = compute_v1.ResourcePolicySnapshotSchedulePolicySchedule()
    # You can change the schedule type to daily_schedule, weekly_schedule, or hourly_schedule
    schedule.daily_schedule = daily_schedule

    # Autodelete snapshots after 5 days
    retention_policy = compute_v1.ResourcePolicySnapshotSchedulePolicyRetentionPolicy(
        max_retention_days=5
    )
    snapshot_properties = (
        compute_v1.ResourcePolicySnapshotSchedulePolicySnapshotProperties(
            guest_flush=False, labels=labels
        )
    )

    snapshot_policy = compute_v1.ResourcePolicySnapshotSchedulePolicy()
    snapshot_policy.schedule = schedule
    snapshot_policy.retention_policy = retention_policy
    snapshot_policy.snapshot_properties = snapshot_properties

    resource_policy_resource = compute_v1.ResourcePolicy(
        name=schedule_name,
        description=schedule_description,
        snapshot_schedule_policy=snapshot_policy,
    )

    client = compute_v1.ResourcePoliciesClient()
    operation = client.insert(
        project=project_id,
        region=region,
        resource_policy_resource=resource_policy_resource,
    )
    wait_for_extended_operation(operation, "Resource Policy creation")

    return client.get(project=project_id, region=region, resource_policy=schedule_name)

REST

  • Erstellen Sie eine POST-Anfrage an resourcePolicies.insert, um einen Snapshot-Zeitplan für global verfügbare Snapshots zu erstellen. Sie müssen den Namen des Snapshot-Zeitplans und die Snapshot-Häufigkeit angeben.

    Sie können auch den Snapshot-Speicherort manuell angeben und der Anfrage Ressourcenlabels hinzufügen.

    Standardmäßig ist der Parameter onSourceDiskDelete auf keepAutoSnapshots eingestellt. Diese Einstellung gibt an, dass die automatisch generierten Snapshots für dieses Laufwerk auf unbestimmte Zeit beibehalten werden, wenn das Quelllaufwerk gelöscht wird. Alternativ können Sie das Flag auf applyRetentionPolicy setzen, um die Aufbewahrungsrichtlinie anzuwenden.

    Im folgenden Beispiel wird ein täglicher Snapshot-Zeitplan festgelegt, der um 12:00 UTC (04:00 PST) beginnt und täglich wiederholt wird. In diesem Beispiel wird außerdem eine Aufbewahrungsrichtlinie von 5 Tagen festgelegt. Nach 5 Tagen werden die Snapshots automatisch entfernt.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies

    {
    "name": "SCHEDULE_NAME",
    "description": "SCHEDULE_DESCRIPTION",
    "snapshotSchedulePolicy": {
      "schedule": {
        "dailySchedule": {
          "startTime": "12:00",
          "daysInCycle": "1"
        }
      },
      "retentionPolicy": {
        "maxRetentionDays": "5"
      },
      "snapshotProperties": {
        "guestFlush": "False",
        "labels": {
          "env": "dev",
          "media": "images"
        },
        "storageLocations": "STORAGE_LOCATION"
      }
    }
    }

  • Vorabversion: Wenn Sie einen Snapshot-Zeitplan für regional begrenzte Snapshots erstellen möchten, stellen Sie eine POST-Anfrage an resourcePolicies.insert und geben Sie die Snapshot-Region an.

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/regions/REGION/resourcePolicies

    {
    "name": "SCHEDULE_NAME",
    "description": "SCHEDULE_DESCRIPTION",
    "snapshotSchedulePolicy": {
      "schedule": {
        "dailySchedule": {
          "startTime": "12:00",
          "daysInCycle": "1"
        }
      },
      "retentionPolicy": {
        "maxRetentionDays": "5"
      },
      "snapshotProperties": {
        "guestFlush": "False",
        "region": "SNAPSHOT_REGION"
      }
    }
    }

Ersetzen Sie Folgendes:

  • PROJECT_ID: der Projektname
  • REGION: der Speicherort der Ressourcenrichtlinie für den Snapshot-Zeitplan
  • SNAPSHOT_REGION: die Region, auf die der geplante Snapshot beschränkt ist
  • SCHEDULE_DESCRIPTION: die Beschreibung des Snapshot-Zeitplans
  • SCHEDULE_NAME: der Name des Snapshot-Zeitplans
  • STORAGE_LOCATION: Optional: der Speicherort. Wenn Sie dieses Flag weglassen, wird der Standardspeicherort verwendet.

Auf ähnliche Weise können Sie einen wöchentlichen oder monatlichen Zeitplan erstellen. In der resourcePolicies.insert-Methode finden Sie Informationen zum Festlegen von wöchentlichen und monatlichen Zeitplänen.

Die folgende Anfrage erstellt beispielsweise einen wöchentlichen Zeitplan, der dienstags um 9:00 Uhr UTC ausgeführt wird.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies

{
   "name": "SCHEDULE_NAME",
   "description": "SCHEDULE_DESCRIPTION",
   "snapshotSchedulePolicy": {
      "schedule": {
        "weeklySchedule": {
          "dayOfWeeks": [
          {
            "day": "Tuesday",
            "startTime": "9:00"
          }
          ]
        }
      },
      "retentionPolicy": {
          "maxRetentionDays": "5"
      },
      "snapshotProperties": {
          "guestFlush": "False",
          "labels": {
               "production": "webserver"
          },
          "storageLocations": "US"
      }
  }
}

Snapshot-Zeitplan mit Laufwerk verknüpfen

Nachdem Sie einen Zeitplan erstellt haben, können Sie ihn mit einem vorhandenen Laufwerk verknüpfen. Verwenden Sie die Console, die gcloud CLI oder die Compute Engine API.

Console

So verknüpfen Sie einen Snapshot-Zeitplan mit einem vorhandenen Laufwerk:

  1. Rufen Sie in der Google Cloud Console die Seite Laufwerke auf.

    Zur Seite „Laufwerke“

  2. Klicken Sie auf den Namen des Laufwerks, an das Sie einen Snapshot-Zeitplan anhängen möchten. Dadurch wird die Seite Laufwerk verwalten geöffnet.

  3. Klicken Sie auf der Seite Laufwerk verwalten auf Bearbeiten. Möglicherweise müssen Sie zuerst auf das Menü Weitere Aktionen klicken.

  4. Verwenden Sie das Drop-down-Menü Snapshot-Zeitplan, um den Zeitplan zum Laufwerk hinzuzufügen. Alternativ erstellen Sie einen neuen Zeitplan.

  5. Wenn Sie einen neuen Zeitplan erstellt haben, klicken Sie auf Erstellen.

  6. Klicken Sie auf Speichern, um die Aufgabe abzuschließen.

gcloud

Verwenden Sie den Befehl gcloud disks add-resource-policies, um einen Snapshot-Zeitplan an ein Laufwerk anzuhängen.

gcloud compute disks add-resource-policies DISK_NAME \
    --resource-policies SCHEDULE_NAME \
    --zone ZONE

Ersetzen Sie Folgendes:

  • DISK_NAME: der Name des vorhandenen Laufwerks
  • SCHEDULE_NAME: der Name des Snapshot-Zeitplans
  • ZONE: der Standort des Laufwerks

Go

import (
	"context"
	"fmt"
	"io"

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

// attachSnapshotSchedule attaches a snapshot schedule to disk.
func attachSnapshotSchedule(w io.Writer, projectID, scheduleName, diskName, region string) error {
	// projectID := "your_project_id"
	// snapshotName := "your_snapshot_name"
	// diskName := "your_disk_name"
	// region := "europe-central2"

	ctx := context.Background()

	disksClient, err := compute.NewRegionDisksRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewDisksRESTClient: %w", err)
	}
	defer disksClient.Close()

	req := &computepb.AddResourcePoliciesRegionDiskRequest{
		Project: projectID,
		Region:  region,
		Disk:    diskName,
		RegionDisksAddResourcePoliciesRequestResource: &computepb.RegionDisksAddResourcePoliciesRequest{
			ResourcePolicies: []string{
				fmt.Sprintf("projects/%s/regions/%s/resourcePolicies/%s", projectID, region, scheduleName),
			},
		},
	}
	op, err := disksClient.AddResourcePolicies(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to attach schedule: %w", err)
	}

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

	fmt.Fprint(w, "Snapshot schedule attached\n")

	return nil
}

Java 

import com.google.cloud.compute.v1.AddResourcePoliciesDiskRequest;
import com.google.cloud.compute.v1.DisksAddResourcePoliciesRequest;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class AttachSnapshotScheduleToDisk {
  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone where your disk is located.
    String zone = "us-central1-a";
    // Name of the disk you want to attach the snapshot schedule to.
    String diskName = "YOUR_DISK_NAME";
    // Name of the snapshot schedule you want to attach.
    String snapshotScheduleName = "YOUR_SNAPSHOT_SCHEDULE_NAME";
    // Name of the region where your snapshot schedule is located.
    String region = "us-central1";

    attachSnapshotScheduleToDisk(projectId, zone, diskName, snapshotScheduleName, region);
  }

  // Attaches a snapshot schedule to a disk.
  public static Status attachSnapshotScheduleToDisk(
        String projectId, String zone, String diskName, String snapshotScheduleName, String region)
        throws IOException, ExecutionException, InterruptedException, TimeoutException {

    String resourcePolicyLink = String.format(
            "projects/%s/regions/%s/resourcePolicies/%s", projectId, region, snapshotScheduleName);
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (DisksClient disksClient = DisksClient.create()) {

      AddResourcePoliciesDiskRequest request = AddResourcePoliciesDiskRequest.newBuilder()
              .setProject(projectId)
              .setZone(zone)
              .setDisk(diskName)
              .setDisksAddResourcePoliciesRequestResource(
                      DisksAddResourcePoliciesRequest.newBuilder()
                              .addResourcePolicies(resourcePolicyLink)
                              .build())
              .build();

      Operation response = disksClient.addResourcePoliciesAsync(request).get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Error attaching snapshot schedule to disk: " + response.getError());
      }
      return response.getStatus();
    }
  }
}

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 snapshot_schedule_attach(
    project_id: str, zone: str, region: str, disk_name: str, schedule_name: str
) -> None:
    """
    Attaches a snapshot schedule to a specified disk.
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone where the disk is located.
        region (str): The region where the snapshot schedule was created
        disk_name (str): The name of the disk to which the snapshot schedule will be attached.
        schedule_name (str): The name of the snapshot schedule that you are applying to this disk
    Returns:
        None
    """
    disks_add_request = compute_v1.DisksAddResourcePoliciesRequest(
        resource_policies=[f"regions/{region}/resourcePolicies/{schedule_name}"]
    )

    client = compute_v1.DisksClient()
    operation = client.add_resource_policies(
        project=project_id,
        zone=zone,
        disk=disk_name,
        disks_add_resource_policies_request_resource=disks_add_request,
    )
    wait_for_extended_operation(operation, "Attaching snapshot schedule to disk")

REST

Erstellen Sie eine POST-Anfrage an disks.addResourcePolicies, um einen Snapshot-Zeitplan an ein vorhandenes Laufwerk anzuhängen.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks/DISK_NAME/addResourcePolicies

{
  "resourcePolicies": [
    "regions/REGION/resourcePolicies/SCHEDULE_NAME"
  ]
}

Ersetzen Sie Folgendes:

  • PROJECT_ID: der Projektname
  • ZONE ist die Zone, in der sich das Laufwerk befindet
  • REGION: die Region, in der der Snapshot-Zeitplan erstellt wurde
  • DISK_NAME: Name des Laufwerks
  • SCHEDULE_NAME: der Name des Snapshot-Zeitplans, den Sie auf dieses Laufwerk anwenden

Laufwerk mit Snapshot-Zeitplan erstellen

Sie können die Google Cloud Console oder die gcloud CLI verwenden, um gleichzeitig ein Laufwerk und einen Snapshot-Zeitplan zu erstellen.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Laufwerke auf.

    Zur Seite „Laufwerke“

  2. Klicken Sie auf Laufwerk erstellen.

  3. Füllen Sie die erforderlichen Felder aus, um ein zonales oder regionales Laufwerk zu erstellen.

  4. Erstellen Sie das Laufwerk in derselben Region, in der der Snapshot-Zeitplan gespeichert ist.

  5. Füllen Sie die Felder für den Snapshot-Zeitplan aus.

  6. Verwenden Sie das Drop-down-Menü und füllen Sie die Felder aus, um den Zeitplan zu erstellen.

  7. Klicken Sie auf Erstellen, um den Zeitplan zu erstellen.

  8. Klicken Sie auf Erstellen, um das Laufwerk anzulegen.

gcloud

Erstellen Sie mit dem -Befehl gcloud disks create eine zonale oder regionale Persistent Disk oder Hyperdisk und hängen Sie daran einen Snapshot-Zeitplan an.

gcloud compute disks create DISK_NAME \
     --resource-policies SCHEDULE_NAME \
     --zone ZONE

Ersetzen Sie Folgendes:

  • DISK_NAME: Name des neuen Laufwerks
  • SCHEDULE_NAME: der Name des Snapshot-Zeitplans
  • ZONE: der Ort, an dem Sie das Laufwerk erstellen. Das Laufwerk muss sich in einer Zone befinden, die sich in derselben Region wie der Snapshot-Zeitplan befindet.

Go

import (
	"context"
	"fmt"
	"io"

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

// createDiskWithSnapshotSchedule creates a new empty regional disk with snapshot schedule
func createDiskWithSnapshotSchedule(
	w io.Writer,
	projectID, region, diskName, diskType, scheduleName string,
	replicaZones []string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// region := "us-west3" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "regions/us-west3/diskTypes/pd-ssd"
	// scheduleName := "your_schedule_name"
	// replicaZones := []string{"us-west3-a", "us-west3-b"}
	// diskSizeGb := 120

	// Exactly two replica zones must be specified
	replicaZoneURLs := []string{
		fmt.Sprintf("projects/%s/zones/%s", projectID, replicaZones[0]),
		fmt.Sprintf("projects/%s/zones/%s", projectID, replicaZones[1]),
	}

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

	req := &computepb.InsertRegionDiskRequest{
		Project: projectID,
		Region:  region,
		DiskResource: &computepb.Disk{
			Name:         proto.String(diskName),
			Region:       proto.String(region),
			Type:         proto.String(diskType),
			SizeGb:       proto.Int64(diskSizeGb),
			ReplicaZones: replicaZoneURLs,
			ResourcePolicies: []string{
				fmt.Sprintf("projects/%s/regions/%s/resourcePolicies/%s", projectID, region, scheduleName),
			},
		},
	}

	op, err := disksClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create disk with schedule: %w", err)
	}

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

	fmt.Fprintf(w, "Disk with schedule created\n")

	return nil
}

Java 

import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateDiskWithSnapshotSchedule {
  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone in which you want to create the disk.
    String zone = "us-central1-a";
    // Name of the disk you want to create.
    String diskName = "YOUR_DISK_NAME";
    // Name of the schedule you want to link to the disk.
    String snapshotScheduleName = "YOUR_SCHEDULE_NAME";

    createDiskWithSnapshotSchedule(projectId, zone, diskName, snapshotScheduleName);
  }

  // Creates disk with linked snapshot schedule.
  public static Status createDiskWithSnapshotSchedule(
      String projectId, String zone, String diskName, String snapshotScheduleName)
      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.
    try (DisksClient disksClient = DisksClient.create()) {
      String region = zone.substring(0, zone.lastIndexOf('-'));
      // Get the resource policy to link to the disk
      String resourcePolicyLink = String.format("projects/%s/regions/%s/resourcePolicies/%s",
              projectId, region, snapshotScheduleName);

      Disk disk = Disk.newBuilder()
              .setName(diskName)
              .setZone(zone)
              .addAllResourcePolicies(List.of(resourcePolicyLink))
              .build();

      Operation response = disksClient.insertAsync(projectId, zone, disk).get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Disk creation failed! " + response.getError());
      }
      return response.getStatus();
    }
  }
}

Nächste Schritte