スナップショットを使用してデータをバックアップする

このページでは、スナップショットを作成して、Vertex AI Workbench のユーザー管理ノートブックインスタンスに保存されたデータをバックアップする方法について説明します。

インスタンス上のデータはゾーンの永続ディスクに保存されます。このディスクのスナップショットを作成して使用することで、データのバックアップ、定期的なバックアップスケジュールの作成、新しいインスタンスへのデータの復元を行うことができます。

スナップショットを作成する

ディスクが実行中のインスタンスにアタッチされている場合でも、ディスクからスナップショットを作成できます。スナップショットはグローバルリソースであるため、スナップショットを使用して同じプロジェクト内の新しいディスクまたはインスタンスにデータを復元できます。また、プロジェクト間でスナップショットを共有することもできます。

このタスクに必要な権限

このタスクを行うには、次の権限が必要です。

プロジェクトに対する compute.snapshots.create
ディスクに対する compute.disks.createSnapshot

コンソール

Google Cloud コンソールで [VM インスタンス] ページに移動します。

VM インスタンスに移動
残りの手順は、Google Cloud コンソールに自動的に表示されます。
VM インスタンスが含まれているプロジェクトを選択します。
[名前] 列で、永続ディスクをバックアップする VM の名前をクリックします。
[ストレージ] で次の操作を行います。
- ブートディスクをバックアップするには、[ブートディスク] セクションでブートディスクの名前をクリックします。
- アタッチされた永続ディスクをバックアップするには、[追加ディスク] で、アタッチされた永続ディスクの名前をクリックします。
[スナップショットを作成] をクリックします。
[名前] に、スナップショットの目的をすぐに識別できる名前を入力します。次に例を示します。
- boot-disk-snapshot
- attached-persistent-disk-snapshot
種類では、定期的なスナップショットがデフォルトになります。これは、長期のバックアップや障害復旧に適しています。
データの保持にかかる費用対効果を高めるには、[アーカイブスナップショット] を選択します。
[ロケーション] セクションで、スナップショットの保存場所を選択します。スナップショット設定で定義されている事前定義またはカスタマイズされたデフォルトのロケーションが自動的に選択されます。必要に応じて、スナップショット設定をオーバーライドして、次の方法でカスタマイズされた保存場所にスナップショットを保存できます。
1. スナップショットを保存する保存場所の種類を選択します。
  - より高いコストで高い可用性を実現するには、[マルチリージョン] を選択します。
  - より低いコストでデータの物理的な位置をより細かく制御するには、[リージョンスナップショット] を選択します。
2. [ロケーションを選択] フィールドで、使用する特定のリージョンまたはマルチリージョンを選択します。ソースディスクに最も近いリージョンまたはマルチリージョンを使用するには、[ディスクの場所に基づく] を選択します。
手動スナップショットを作成するには、[作成] をクリックします。

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
スナップショット設定で定義された保存場所ポリシーまたは任意の別の保存場所を使用して、スナップショットを作成します。詳細については、スナップショットの保存場所を選択するをご覧ください。スナップショット名を指定する必要があります。名前は 1～63 文字で、RFC 1035 に準拠している必要があります。
- スナップショット設定で構成された事前定義またはカスタマイズされたデフォルトの場所に、Persistent Disk ボリュームのスナップショットを作成するには、gcloud compute snapshots create コマンドを使用します。
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk SOURCE_DISK \
    --snapshot-type SNAPSHOT_TYPE \
    --source-disk-zone SOURCE_DISK_ZONE
```
- また、スナップショット設定をオーバーライドしてスナップショットをカスタマイズされた保存場所に作成するには、--storage-location フラグを指定して、スナップショットの保存先を指定します。
```
gcloud compute snapshots create SNAPSHOT_NAME \
  --source-disk SOURCE_DISK \
  --source-disk-zone SOURCE_DISK_ZONE \
  --storage-location STORAGE_LOCATION \
  --snapshot-type SNAPSHOT_TYPE
```
  以下を置き換えます。
  - SNAPSHOT_NAME: スナップショットの名前。
  - SOURCE_DISK: スナップショットを作成するゾーン Persistent Disk ボリュームの名前。
  - SNAPSHOT_TYPE: スナップショットの種類（標準または アーカイブ）。スナップショットの種類が指定されない場合は、標準スナップショットが作成されます。データの保持にかかる費用対効果を高めるには、[アクティブ] を選択します。
  - SOURCE_DISK_ZONE: スナップショットを作成するゾーン Persistent Disk ボリュームのゾーン。
  - STORAGE_LOCATION: カスタマイズされた保存場所の場合、これは Cloud Storage マルチリージョンまたはスナップショットを保存する Cloud Storage リージョンです。保存場所は 1 つだけ指定できます。
  --storage-location フラグは、スナップショット設定で構成した事前定義またはカスタマイズされたデフォルトの保存場所をオーバーライドする場合にのみ使用します。
gcloud CLI は、このオペレーションに対して READY または FAILED のステータスが返されるか、最長タイムアウトに達してスナップショットの最新の既知情報が返されるまで待機します。
注: gcloud compute disks snapshot コマンドではなく、gcloud compute snapshots create コマンドを使用することをおすすめします。これは、ソースディスクプロジェクトとは異なるプロジェクトでスナップショットを作成するなど、より多くの機能をサポートしているためです。

Terraform

ゾーン永続ディスクのスナップショットを作成するには、google_compute_snapshot リソースを使用します。

resource "google_compute_snapshot" "snapdisk" {
  name        = "snapshot-name"
  source_disk = google_compute_disk.default.name
  zone        = "us-central1-a"
}

Terraform 構成を適用または削除する方法については、基本的な Terraform コマンドをご覧ください。

API

スナップショット設定で定義された保存場所ポリシー、または任意の別の保存場所を使用して、スナップショットを作成します。詳細については、スナップショットの保存場所を選択するをご覧ください。

スナップショット設定で構成された事前定義またはカスタマイズされたデフォルトの場所にスナップショットを作成するには、snapshots.insert メソッドに POST リクエストを発行します。
```
POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots

{
  "name": SNAPSHOT_NAME
  "sourceDisk": "projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks/SOURCE_DISK_NAME
  "snapshotType": SNAPSHOT_TYPE
}
```
以下を置き換えます。
- DESTINATION_PROJECT_ID: スナップショットを作成するプロジェクトの ID。
- SNAPSHOT_NAME: スナップショットの名前。
- SOURCE_PROJECT_ID: ソースディスクプロジェクトの ID。
- SOURCE_ZONE: ソースディスクのゾーン。
- SOURCE_DISK_NAME: スナップショットを作成する永続ディスクの名前。
- SNAPSHOT_TYPE: スナップショットのタイプ（STANDARD または ARCHIVE）。スナップショットの種類が指定されていない場合は、標準スナップショットが作成されます。
または、スナップショット設定をオーバーライドしてカスタマイズされた保存場所にスナップショットを作成するには、snapshots.insert メソッドに POST リクエストを送信し、リクエストに storageLocations プロパティを含めます。
```
POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots

{
  "name": SNAPSHOT_NAME
  "sourceDisk": "projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks/SOURCE_DISK_NAME
  "snapshotType": SNAPSHOT_TYPE
  "storageLocations": STORAGE_LOCATION
}
```
以下を置き換えます。
- DESTINATION_PROJECT_ID: スナップショットを作成するプロジェクトの ID。
- SNAPSHOT_NAME: スナップショットの名前。
- SOURCE_PROJECT_ID: ソースディスクプロジェクトの ID。
- SOURCE_ZONE: ソースディスクのゾーン。
- SOURCE_DISK_NAME: スナップショットを作成する永続ディスクの名前。
- SNAPSHOT_TYPE: スナップショットのタイプ（STANDARD または ARCHIVE）。スナップショットの種類が指定されていない場合は、標準スナップショットが作成されます。
- STORAGE_LOCATION: スナップショットを保存する Cloud Storage マルチリージョンまたは Cloud Storage リージョン。保存場所は 1 つだけ指定できます。
  
  storageLocations パラメータは、スナップショット設定で構成した事前定義またはカスタマイズされたデフォルトの保存場所をオーバーライドする場合にのみ使用します。

Go

このサンプルを試す前に、Compute Engine クイックスタート: クライアントライブラリの使用にある設定手順を完了してください。

Compute Engine に対して認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証を設定するをご覧ください。

import (
	"context"
	"fmt"
	"io"

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

// createSnapshot creates a snapshot of a disk.
func createSnapshot(
	w io.Writer,
	projectID, diskName, snapshotName, zone, region, location, diskProjectID string,
) error {
	// projectID := "your_project_id"
	// diskName := "your_disk_name"
	// snapshotName := "your_snapshot_name"
	// zone := "europe-central2-b"
	// region := "eupore-central2"
	// location = "eupore-central2"
	// diskProjectID = "YOUR_DISK_PROJECT_ID"

	ctx := context.Background()

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

	if zone == "" && region == "" {
		return fmt.Errorf("you need to specify `zone` or `region` for this function to work")
	}

	if zone != "" && region != "" {
		return fmt.Errorf("you can't set both `zone` and `region` parameters")
	}

	if diskProjectID == "" {
		diskProjectID = projectID
	}

	disk := &computepb.Disk{}
	locations := []string{}
	if location != "" {
		locations = append(locations, location)
	}

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

		getDiskReq := &computepb.GetDiskRequest{
			Project: projectID,
			Zone:    zone,
			Disk:    diskName,
		}

		disk, err = disksClient.Get(ctx, getDiskReq)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}
	} else {
		regionDisksClient, err := compute.NewRegionDisksRESTClient(ctx)
		if err != nil {
			return fmt.Errorf("NewRegionDisksRESTClient: %w", err)
		}
		defer regionDisksClient.Close()

		getDiskReq := &computepb.GetRegionDiskRequest{
			Project: projectID,
			Region:  region,
			Disk:    diskName,
		}

		disk, err = regionDisksClient.Get(ctx, getDiskReq)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}
	}

	req := &computepb.InsertSnapshotRequest{
		Project: projectID,
		SnapshotResource: &computepb.Snapshot{
			Name:             proto.String(snapshotName),
			SourceDisk:       proto.String(disk.GetSelfLink()),
			StorageLocations: locations,
		},
	}

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

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

	fmt.Fprintf(w, "Snapshot created\n")

	return nil
}

Java

このサンプルを試す前に、Compute Engine クイックスタート: クライアントライブラリの使用にある設定手順を完了してください。


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.RegionDisksClient;
import com.google.cloud.compute.v1.Snapshot;
import com.google.cloud.compute.v1.SnapshotsClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateSnapshot {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // You need to pass `zone` or `region` parameter relevant to the disk you want to
    // snapshot, but not both. Pass `zone` parameter for zonal disks and `region` for
    // regional disks.

    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the disk you want to create.
    String diskName = "YOUR_DISK_NAME";

    // Name of the snapshot that you want to create.
    String snapshotName = "YOUR_SNAPSHOT_NAME";

    // The zone of the source disk from which you create the snapshot (for zonal disks).
    String zone = "europe-central2-b";

    // The region of the source disk from which you create the snapshot (for regional disks).
    String region = "your-disk-region";

    // The Cloud Storage multi-region or the Cloud Storage region where you
    // want to store your snapshot.
    // You can specify only one storage location. Available locations:
    // https://cloud.google.com/storage/docs/locations#available-locations
    String location = "europe-central2";

    // Project ID or project number of the Cloud project that
    // hosts the disk you want to snapshot. If not provided, the value will be defaulted
    // to 'projectId' value.
    String diskProjectId = "YOUR_DISK_PROJECT_ID";

    createSnapshot(projectId, diskName, snapshotName, zone, region, location, diskProjectId);
  }

  // Creates a snapshot of a disk.
  public static void createSnapshot(String projectId, String diskName, String snapshotName,
      String zone, String region, String location, String diskProjectId)
      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 `snapshotsClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (SnapshotsClient snapshotsClient = SnapshotsClient.create()) {

      if (zone.isEmpty() && region.isEmpty()) {
        throw new Error("You need to specify 'zone' or 'region' for this function to work");
      }

      if (!zone.isEmpty() && !region.isEmpty()) {
        throw new Error("You can't set both 'zone' and 'region' parameters");
      }

      // If Disk's project id is not specified, then the projectId parameter will be used.
      if (diskProjectId.isEmpty()) {
        diskProjectId = projectId;
      }

      // If zone is not empty, use the DisksClient to create a disk.
      // Else, use the RegionDisksClient.
      Disk disk;
      if (!zone.isEmpty()) {
        DisksClient disksClient = DisksClient.create();
        disk = disksClient.get(projectId, zone, diskName);
      } else {
        RegionDisksClient regionDisksClient = RegionDisksClient.create();
        disk = regionDisksClient.get(diskProjectId, region, diskName);
      }

      // Set the snapshot properties.
      Snapshot snapshotResource;
      if (!location.isEmpty()) {
        snapshotResource = Snapshot.newBuilder()
            .setName(snapshotName)
            .setSourceDisk(disk.getSelfLink())
            .addStorageLocations(location)
            .build();
      } else {
        snapshotResource = Snapshot.newBuilder()
            .setName(snapshotName)
            .setSourceDisk(disk.getSelfLink())
            .build();
      }

      // Wait for the operation to complete.
      Operation operation = snapshotsClient.insertAsync(projectId, snapshotResource)
          .get(3, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Snapshot creation failed!" + operation);
        return;
      }

      // Retrieve the created snapshot.
      Snapshot snapshot = snapshotsClient.get(projectId, snapshotName);
      System.out.printf("Snapshot created: %s", snapshot.getName());

    }
  }
}

Node.js

このサンプルを試す前に、Compute Engine クイックスタート: クライアントライブラリの使用にある設定手順を完了してください。

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const diskName = 'YOUR_DISK_NAME';
// const snapshotName = 'YOUR_SNAPSHOT_NAME';
// const zone = 'europe-central2-b';
// const region = '';
// const location = 'europe-central2';
// let diskProjectId = 'YOUR_DISK_PROJECT_ID';

const compute = require('@google-cloud/compute');

async function createSnapshot() {
  const snapshotsClient = new compute.SnapshotsClient();

  let disk;

  if (!zone && !region) {
    throw new Error(
      'You need to specify `zone` or `region` for this function to work.'
    );
  }

  if (zone && region) {
    throw new Error("You can't set both `zone` and `region` parameters");
  }

  if (!diskProjectId) {
    diskProjectId = projectId;
  }

  if (zone) {
    const disksClient = new compute.DisksClient();
    [disk] = await disksClient.get({
      project: diskProjectId,
      zone,
      disk: diskName,
    });
  } else {
    const regionDisksClient = new compute.RegionDisksClient();
    [disk] = await regionDisksClient.get({
      project: diskProjectId,
      region,
      disk: diskName,
    });
  }

  const snapshotResource = {
    name: snapshotName,
    sourceDisk: disk.selfLink,
  };

  if (location) {
    snapshotResource.storageLocations = [location];
  }

  const [response] = await snapshotsClient.insert({
    project: projectId,
    snapshotResource,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.GlobalOperationsClient();

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

  console.log('Snapshot created.');
}

createSnapshot();

Python

このサンプルを試す前に、Compute Engine クイックスタート: クライアントライブラリの使用にある設定手順を完了してください。

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 create_snapshot(
    project_id: str,
    disk_name: str,
    snapshot_name: str,
    *,
    zone: str | None = None,
    region: str | None = None,
    location: str | None = None,
    disk_project_id: str | None = None,
) -> compute_v1.Snapshot:
    """
    Create a snapshot of a disk.

    You need to pass `zone` or `region` parameter relevant to the disk you want to
    snapshot, but not both. Pass `zone` parameter for zonal disks and `region` for
    regional disks.

    Args:
        project_id: project ID or project number of the Cloud project you want
            to use to store the snapshot.
        disk_name: name of the disk you want to snapshot.
        snapshot_name: name of the snapshot to be created.
        zone: name of the zone in which is the disk you want to snapshot (for zonal disks).
        region: name of the region in which is the disk you want to snapshot (for regional disks).
        location: The Cloud Storage multi-region or the Cloud Storage region where you
            want to store your snapshot.
            You can specify only one storage location. Available locations:
            https://cloud.google.com/storage/docs/locations#available-locations
        disk_project_id: project ID or project number of the Cloud project that
            hosts the disk you want to snapshot. If not provided, will look for
            the disk in the `project_id` project.

    Returns:
        The new snapshot instance.
    """
    if zone is None and region is None:
        raise RuntimeError(
            "You need to specify `zone` or `region` for this function to work."
        )
    if zone is not None and region is not None:
        raise RuntimeError("You can't set both `zone` and `region` parameters.")

    if disk_project_id is None:
        disk_project_id = project_id

    if zone is not None:
        disk_client = compute_v1.DisksClient()
        disk = disk_client.get(project=disk_project_id, zone=zone, disk=disk_name)
    else:
        regio_disk_client = compute_v1.RegionDisksClient()
        disk = regio_disk_client.get(
            project=disk_project_id, region=region, disk=disk_name
        )

    snapshot = compute_v1.Snapshot()
    snapshot.source_disk = disk.self_link
    snapshot.name = snapshot_name
    if location:
        snapshot.storage_locations = [location]

    snapshot_client = compute_v1.SnapshotsClient()
    operation = snapshot_client.insert(project=project_id, snapshot_resource=snapshot)

    wait_for_extended_operation(operation, "snapshot creation")

    return snapshot_client.get(project=project_id, snapshot=snapshot_name)

定期的なバックアップのスケジュールを設定する

スナップショットスケジュールを作成するときに、1 つ以上の永続ディスクに適用可能なリソースポリシーを作成します。スナップショットスケジュールは次の方法で作成できます。

スナップショットスケジュールには、次のプロパティがあります。

スケジュール名
スケジュールの説明
スナップショット頻度（時間、日、週単位）
スナップショット開始時刻
スナップショットスケジュールが利用可能なリージョン
ソースディスク削除ポリシー（ソースディスクが削除された場合、自動生成されたスナップショットを処理するためのポリシー）
保持ポリシーを使用すると、スナップショットスケジュールによって生成されたスナップショットの保持期間を定義できます。

制限事項

永続ディスクに一度に関連付けられるスナップショットスケジュールは 10 個までです。
スナップショットスケジュールを使用してアーカイブスナップショットを作成することはできません。
リージョンごとの使用中のスナップショットスケジュールを最大で 1,000 個作成できます。
スナップショットスケジュールは、それが作成されたプロジェクトにのみ適用されます。他のプロジェクトや組織では使用できません。
リージョンで追加のリソースが必要になった場合、コンソールからリソース割り当ての増量を申請する必要があります。
ディスクに関連付けられているスナップショットスケジュールを削除することはできません。このようなスケジュールを削除するためには、削除する前にすべてのディスクからそのスケジュールとの関連付けを解除する必要があります。
既存のスナップショットスケジュールを更新して、説明、スケジュール、ラベルを変更できます。スナップショットスケジュールの他の値を更新するには、スナップショットスケジュールを削除して新しいスケジュールを作成する必要があります。
顧客指定の暗号鍵（CSEK）を使用する永続ディスクの場合、スナップショットスケジュールを作成することはできません。
顧客管理の暗号鍵（CMEK）を使用する永続ディスクの場合、スナップショットスケジュールで作成されたすべてのスナップショットは同じ鍵で自動的に暗号化されます。

スケジュールを作成する

このタスクに必要な権限

このタスクを行うには、次の権限が必要です。

プロジェクトまたは組織に対する compute.resourcePolicies.create

Google Cloud コンソール、Google Cloud CLI、または Compute Engine API を使用して、永続ディスクのスナップショットスケジュールを作成します。スナップショットスケジュールは、永続ディスクが存在する同じリージョン内で作成する必要があります。たとえば、永続ディスクがゾーン us-west1-a に存在する場合、スナップショットスケジュールは us-west1 リージョン内に存在する必要があります。詳細については、保存場所を選択するをご覧ください。

コンソール

Google Cloud コンソールで [VM インスタンス] ページに移動します。

[VM インスタンス] に移動
残りの手順は、Google Cloud コンソールに自動的に表示されます。
VM インスタンスが含まれているプロジェクトを選択します。
[名前] 列で、永続ディスクを含む VM の名前をクリックして、スナップショットスケジュールを作成します。
[ストレージ] で、ブートディスクの名前をクリックするか、スナップショットスケジュールを作成する追加ディスクの名前をクリックします。
[編集] をクリックします。必要に応じて、 [その他の操作] メニューをクリックし、 [編集] をクリックします。
[スナップショットスケジュール] で [スケジュールを作成] を選択します。
[名前] で、スナップショットスケジュールに次のいずれかの名前を入力します。
- boot-disk-snapshot-schedule
- attached-persistent-disk-snapshot-schedule
[ロケーション] セクションで、スナップショットのストレージロケーションを選択します。スナップショット設定で定義されている事前定義またはカスタマイズされたデフォルトのロケーションが自動的に選択されます。必要に応じて、スナップショット設定をオーバーライドして、次の方法でカスタムストレージロケーションにスナップショットを保存できます。
1. スナップショットを保存するストレージロケーションの種類を選択します。
  - より高いコストで高い可用性を実現するには、[マルチリージョン] を選択します。
  - より低いコストでデータの物理的ロケーションをより細かく制御するには、[リージョンスナップショット] を選択します。
2. [ロケーションを選択] フィールドで、使用する特定のリージョンまたはマルチリージョンを選択します。ソースディスクに最も近いリージョンまたはマルチリージョンを使用するには、[ディスクの場所に基づく] を選択します。
スナップショットスケジュールの作成を終了するには、[作成] をクリックします。
このスナップショットスケジュールを永続ディスクに適用するには、[保存] をクリックします。

gcloud

永続ディスクのスナップショットスケジュールを作成するには、gcloud コマンドの compute resource-policies create snapshot-schedule を使用します。スケジュール頻度を時間、日、週単位から設定します。

  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] \
      --weekly-schedule-from-file [FILE_NAME] \
      --on-source-disk-delete [DELETION_OPTION]

ここで

[SCHEDULE_NAME] は、新しいスナップショットスケジュールの名前です。
"[SCHEDULE_DESCRIPTION]" は、スナップショットスケジュールの説明です。引用符で説明を囲みます。
[MAX_RETENTION_DAYS] は、スナップショットを保持する日数です。たとえば、3 を設定すると、スナップショットは 3 日間保持されてから削除されます。保持ポリシーの値は、少なくとも 1 日に設定する必要があります。
[START_TIME] は UTC 開始時刻です。開始時刻は正時でなければなりません。次に例を示します。
- 午後 2 時（PST）は 22:00 です。
- 開始時間を 22:13 に設定すると、エラーが発生します。
[SNAPSHOT_INTERVAL] は、スナップショットを生成する間隔を定義します。時間単位のスケジュールを設定するには、1～23 の整数を使用します。24 を割り切れる数値を時間として選択してください。たとえば、--hourly-schedule を 12 に設定すると、スナップショットは 12 時間ごとに生成されます。週単位スケジュールの場合は、スナップショットを生成する曜日を定義します。曜日を指定する必要があります。大文字と小文字は区別されません。スナップショット頻度のフラグ hourly-schedule、daily-schedule、weekly-schedule は相互に排他的です。スナップショットスケジュールに応じて、いずれかのフラグを選択する必要があります。
注: 曜日ごとに異なる開始時刻を設定した週単位スケジュールを指定するには、代わりに --weekly-schedule-from-file を使用してください。
[FILE_NAME] は、週単位スナップショットスケジュールが含まれるファイルの名前です（この形式でスケジュールを指定することを選択した場合）。ファイルを使用して、曜日ごとに異なる開始時刻を設定した週単位スケジュールを指定できます（コマンドラインで直接、複数の週単位スケジュールを指定することはできません）。たとえば、ファイルには、月曜日と水曜日のスナップショットスケジュールを [{"day": "MONDAY", "startTime": "04:00"}, {"day": "WEDNESDAY", "startTime": "02:00"}] のように指定できます。開始時刻をファイルに含める場合、--start-time フラグを設定する必要はありません。スケジュールでは UTC 時間基準が使用されます。
[DELETION_OPTION] は、ソースディスクが削除された場合のスナップショットの処理方法を決定します。このフラグを省略してデフォルトの keep-auto-snapshots を選択するか、apply-retention-policy を選択して保持ポリシーを適用します。

以下に、スナップショットスケジュールの設定の追加例を記載します。次の設定については、すべての例で共通しています。

ディスク削除ルールが含まれています。--on-source-disk-delete フラグをデフォルトの keep-auto-snapshots に設定して、自動生成されたすべてのスナップショットを永久に保持します。あるいは、このフラグを apply-retention-policy に設定してスナップショット保持ポリシーを使用することもできます。
ストレージロケーションは US に設定されています。したがって、生成されたすべてのスナップショットは米国のマルチリージョン内に保存されます。
生成されたすべてのスナップショットに、env=dev と media=images のラベルが適用されます。
保持ポリシーは 10 日に設定されています。

時間単位スケジュール: この例では、スナップショットスケジュールは 22 時（UTC）に開始し、4 時間ごとに生成されます。

  gcloud compute resource-policies create snapshot-schedule SCHEDULE_NAME \
      --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

日単位スケジュール: この例では、スナップショットスケジュールは 22 時（UTC）に開始し、毎日同じ時刻に生成されます。--daily-schedule フラグを指定する必要がありますが、ここでは値を設定していません。

gcloud compute resource-policies create snapshot-schedule SCHEDULE_NAME \
    --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

週単位スケジュール: この例では、スナップショットスケジュールは 22 時（UTC）に開始し、毎週火曜日と木曜日に生成されます。

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

API

API で、resourcePolicies.insert に対する POST リクエストを作成し、スナップショットスケジュールを作成します。リクエスト本文には少なくとも、スナップショットスケジュール名、リージョン内のスナップショットのストレージロケーション、スナップショット頻度を含める必要があります。

デフォルトの onSourceDiskDelete パラメータは keepAutoSnapshots に設定されています。つまり、ソースディスクが削除されても、自動生成されたそのディスクのスナップショットは無期限に保持されます。あるいは、このフラグを applyRetentionPolicy に設定して保持ポリシーを適用することもできます。

次の例では、毎日 12 時（UTC）に開始される日単位スナップショットスケジュールを設定しています。この例では、5 日の保持ポリシーも設定されています。したがって、スナップショットは生成されてから 5 日後に自動的に削除されます。

スナップショットが指定のロケーションに確実に保存されるよう、リクエスト本文にスナップショットロケーションオプションとスナップショットラベルを含めることもできます。

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": ["US"]
   }
 }
}

ここで

[PROJECT_ID] は、プロジェクト名です。
[REGION] は、スナップショットスケジュールリソースポリシーのロケーションです。
[SCHEDULE_DESCRIPTION] は、スナップショットスケジュールの説明です。
[SCHEDULE_NAME] は、スナップショットスケジュールの名前です。

週単位または月単位スケジュールも同じようにして作成できます。週単位または月単位スケジュールの設定に固有の詳細については、API リファレンスをご覧ください。

たとえば次のリクエストでは、月曜日の 9 時と木曜日の 2 時に実行される週単位スケジュールを作成しています。

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

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

スナップショットスケジュールをディスクに関連付ける

このタスクに必要な権限

このタスクを行うには、次の権限が必要です。

ディスクに対する compute.disks.addResourcePolicies
使用するリソースポリシーに対する compute.resourcePolicies.use

スケジュールを作成したら、それを既存のディスクに関連付けます。コンソール、gcloud コマンド、Compute Engine API メソッドのいずれかを使用できます。

Console

スナップショットスケジュールを既存のディスクに関連付けます。

Google Cloud コンソールで、[ディスク] ページに移動します。
[ディスク] ページに移動
スナップショットスケジュールを関連付けるディスクの名前を選択します。[ディスクの管理] ページが開きます。
[ディスクの管理] ページで、その他の操作メニューにカーソルを合わせてクリックし、編集アイコンを選択します。
[スナップショットスケジュール] プルダウンメニューを使用して、スケジュールをディスクに追加します。または、新しいスケジュールを作成します。
新しいスケジュールを作成した場合は、[作成] をクリックします。
[保存] をクリックしてタスクを完了します。

gcloud

スナップショットスケジュールをディスクにアタッチするには、gcloud コマンドの disks add-resource-policies を使用します。

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

ここで

[DISK_NAME] は、既存のディスクの名前です。
[SCHEDULE_NAME] は、スナップショットスケジュールの名前です。
[ZONE] は、ディスクのロケーションです。

API

API で、disks.addResourcePolicies に対する POST リクエストを作成し、スナップショットスケジュールを既存のディスクにアタッチします。

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

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

ここで

[PROJECT_ID] は、プロジェクト名です。
[ZONE] は、ディスクのロケーションです。
[REGION] は、スナップショットスケジュールのロケーションです。
[DISK_NAME] は、ディスクの名前です。
[SCHEDULE_NAME] は、このディスクに適用しているリージョン内のスナップショットスケジュールの名前です。

スナップショットからデータを復元する

スナップショットを使用してブートディスクや非ブートディスクをバックアップした場合は、スナップショットに基づいて新しいディスクを作成できます。

制限事項

新しいディスクは、少なくともスナップショットの元のソースディスクと同じサイズか、それ以上である必要があります。スナップショットの元のソースディスクよりも大きいディスクを作成する場合は、その永続ディスクでファイルシステムのサイズを変更して、追加のディスクスペースを含める必要があります。オペレーティングシステムおよびファイルシステムの種類によっては、異なるファイルシステムサイズ変更ツールの使用が必要になることがあります。詳細については、オペレーティングシステムのドキュメントをご覧ください。

スナップショットからディスクを作成して VM にアタッチする

このタスクに必要な権限

このタスクを行うには、次の権限が必要です。

新しいディスクを作成するプロジェクトに対する compute.disks.create
VM インスタンスに対する compute.instances.attachDisk 権限
接続するディスクに対する compute.disks.use 権限

コンソール

Google Cloud コンソールで、[スナップショット] ページに移動します。

[スナップショット] に移動
復元するスナップショットの名前を探します。
[ディスク] ページに移動します。

[ディスク] ページに移動
[新しいディスクの作成] をクリックします。
次の構成パラメータを指定します。
- ディスクの名前。
- ディスクの種類。
- 必要に応じて、デフォルトのリージョンとゾーンの選択をオーバーライドできます。ソーススナップショットのストレージロケーションに関係なく、任意のリージョンとゾーンを選択できます。
[ソースタイプ] で、[スナップショット] をクリックします。
復元するスナップショットの名前を選択します。
新しいディスクのサイズ（ギガバイト単位）を選択します。この数は、スナップショットの元のソースディスク以上である必要があります。
[作成] をクリックしてディスクを作成します。

新しいディスクを既存のインスタンスにアタッチできます。

[VM インスタンス] ページに移動します。
[VM インスタンス] ページに移動
ブートディスク以外のディスクを復元する先となるインスタンスの名前をクリックします。
インスタンス詳細ページの一番上で [編集] をクリックします。
[追加ディスク] で [既存のディスクを接続] をクリックします。
スナップショットから作成された新しいディスクの名前を選択します。
[完了] をクリックしてディスクをアタッチします。
インスタンスの詳細ページの一番下にある [保存] をクリックして、変更内容をインスタンスに適用します。

gcloud

gcloud compute snapshots list コマンドを使用して、復元するスナップショットの名前を確認します。
```
gcloud compute snapshots list
```
gcloud compute snapshots describe コマンドを使用して、復元するスナップショットのサイズを確認します。
```
gcloud compute snapshots describe SNAPSHOT_NAME
```
SNAPSHOT_NAME は、復元するスナップショットの名前に置き換えます。
gcloud compute disks create コマンドを使用して、スナップショットから新しいリージョンディスクまたはゾーンディスクを作成します。スループットや IOPS を上げるために SSD 永続ディスクが必要な場合は、--type フラグで pd-ssd を指定します。
```
gcloud compute disks create DISK_NAME \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --type=DISK_TYPE
```
次のように置き換えます。
- DISK_NAME: 新しいディスクの名前。
- DISK_SIZE: 新しいディスクのサイズ（ギガバイト単位）。この数は、スナップショットの元のソースディスク以上である必要があります。
- SNAPSHOT_NAME: 復元するスナップショットの名前。
- DISK_TYPE: ディスクのタイプの完全な URL または部分的な URL。例: https://www.googleapis.com/compute/v1/projects/PROJECT_ID /zones/ZONE/diskTypes/pd-ssd
gcloud compute instances attach-disk コマンドを使用して、新しいディスクを既存のインスタンスにアタッチします。
```
gcloud compute instances attach-disk INSTANCE_NAME \
    --disk DISK_NAME
```
次のように置き換えます。
- INSTANCE_NAME はインスタンス名です。
- DISK_NAME は、スナップショットから作成されたディスクの名前です。

API

snapshots.list への GET リクエストを作成して、プロジェクト内のスナップショットを一覧表示します。

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/snapshots

PROJECT_ID は、実際のプロジェクト ID に置き換えます。
POST リクエストを作成して、disks.insert メソッドでゾーンディスクを作成します。name、sizeGb、type プロパティを含めます。スナップショットを使用してディスクを復元するには、sourceSnapshot プロパティを含める必要があります。
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks

{
 "name": "DISK_NAME",
 "sizeGb": "DISK_SIZE",
 "type": "zones/ZONE/diskTypes/DISK_TYPE"
 "sourceSnapshot": "SNAPSHOT_NAME"
}
```
次のように置き換えます。
- PROJECT_ID: 実際のプロジェクト ID。
- ZONE: インスタンスと新しいディスクが配置されるゾーン。
- DISK_NAME: 新しいディスクの名前。
- DISK_SIZE: 新しいディスクのサイズ（ギガバイト単位）。この数は、スナップショットの元のソースディスク以上である必要があります。
- DISK_TYPE: ディスクのタイプの完全な URL または部分的な URL。例: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ ZONE/diskTypes/pd-ssd。
- SNAPSHOT_NAME は、復元するディスクのソーススナップショットです。
instances.attachDisk メソッドに対する POST リクエストを作成し、スナップショットから作成したディスクへの URL を含めることで、新しいディスクを既存のインスタンスにアタッチできます。
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/attachDisk

{
 "source": "/compute/v1/projects/PROJECT_ID/zones/ZONE/disks/DISK_NAME"
}
```
次のように置き換えます。
- PROJECT_ID はプロジェクト ID です。
- ZONE は、インスタンスと新しいディスクが配置されるゾーンです。
- INSTANCE_NAME は、新しいディスクを追加するインスタンスの名前です。
- DISK_NAME は、新しいディスクの名前です。

Go

このサンプルを試す前に、Vertex AI クイックスタート: クライアントライブラリの使用にある Go の設定手順を完了してください。詳細については、Vertex AI Go API のリファレンスドキュメントをご覧ください。

Vertex AI に対する認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証を設定するをご覧ください。

import (
	"context"
	"fmt"
	"io"

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

// createDiskFromSnapshot creates a new disk in a project in given zone.
func createDiskFromSnapshot(
	w io.Writer,
	projectID, zone, diskName, diskType, snapshotLink string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "zones/us-west3-b/diskTypes/pd-ssd"
	// snapshotLink := "projects/your_project_id/global/snapshots/snapshot_name"
	// diskSizeGb := 120

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

	req := &computepb.InsertDiskRequest{
		Project: projectID,
		Zone:    zone,
		DiskResource: &computepb.Disk{
			Name:           proto.String(diskName),
			Zone:           proto.String(zone),
			Type:           proto.String(diskType),
			SourceSnapshot: proto.String(snapshotLink),
			SizeGb:         proto.Int64(diskSizeGb),
		},
	}

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

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

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

	return nil
}

Java

このサンプルを試す前に、Vertex AI クイックスタート: クライアントライブラリの使用にある Java の設定手順を完了してください。詳細については、Vertex AI Java API のリファレンスドキュメントをご覧ください。


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

public class CreateDiskFromSnapshot {

  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 = "europe-central2-b";

    // Name of the disk you want to create.
    String diskName = "YOUR_DISK_NAME";

    // The type of disk you want to create. This value uses the following format:
    // "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
    // For example: "zones/us-west3-b/diskTypes/pd-ssd"
    String diskType = String.format("zones/%s/diskTypes/pd-ssd", zone);

    // Size of the new disk in gigabytes.
    long diskSizeGb = 10;

    // The full path and name of the snapshot that you want to use as the source for the new disk.
    // This value uses the following format:
    // "projects/{projectName}/global/snapshots/{snapshotName}"
    String snapshotLink = String.format("projects/%s/global/snapshots/%s", projectId,
        "SNAPSHOT_NAME");

    createDiskFromSnapshot(projectId, zone, diskName, diskType, diskSizeGb, snapshotLink);
  }

  // Creates a new disk in a project in given zone, using a snapshot.
  public static void createDiskFromSnapshot(String projectId, String zone, String diskName,
      String diskType, long diskSizeGb, String snapshotLink)
      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 `disksClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (DisksClient disksClient = DisksClient.create()) {

      // Set the disk properties and the source snapshot.
      Disk disk = Disk.newBuilder()
          .setName(diskName)
          .setZone(zone)
          .setSizeGb(diskSizeGb)
          .setType(diskType)
          .setSourceSnapshot(snapshotLink)
          .build();

      // Create the insert disk request.
      InsertDiskRequest insertDiskRequest = InsertDiskRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setDiskResource(disk)
          .build();

      // Wait for the create disk operation to complete.
      Operation response = disksClient.insertAsync(insertDiskRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Disk creation failed!" + response);
        return;
      }
      System.out.println("Disk created. Operation Status: " + response.getStatus());
    }
  }
}

Node.js

このサンプルを試す前に、Vertex AI クイックスタート: クライアントライブラリの使用にある Node.js の設定手順を完了してください。詳細については、Vertex AI Node.js API のリファレンスドキュメントをご覧ください。

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const diskName = 'YOUR_DISK_NAME';
// const diskType = 'zones/us-west3-b/diskTypes/pd-ssd';
// const diskSizeGb = 10;
// const snapshotLink = 'projects/project_name/global/snapshots/snapshot_name';

const compute = require('@google-cloud/compute');

async function createDiskFromSnapshot() {
  const disksClient = new compute.DisksClient();

  const [response] = await disksClient.insert({
    project: projectId,
    zone,
    diskResource: {
      sizeGb: diskSizeGb,
      name: diskName,
      zone,
      type: diskType,
      sourceSnapshot: snapshotLink,
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

  console.log('Disk created.');
}

createDiskFromSnapshot();

Python

Python をインストールまたは更新する方法については、Vertex AI SDK for Python をインストールするをご覧ください。詳細については、Python API リファレンスドキュメントをご覧ください。

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 create_disk_from_snapshot(
    project_id: str,
    zone: str,
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    snapshot_link: str,
) -> compute_v1.Disk:
    """
    Creates a new disk in a project in given zone.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone in which you want to create the disk.
        disk_name: name of the disk you want to create.
        disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        snapshot_link: a link to the snapshot you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/global/snapshots/{snapshot_name}"

    Returns:
        An unattached Disk instance.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.zone = zone
    disk.size_gb = disk_size_gb
    disk.source_snapshot = snapshot_link
    disk.type_ = disk_type
    disk.name = disk_name
    operation = disk_client.insert(project=project_id, zone=zone, disk_resource=disk)

    wait_for_extended_operation(operation, "disk creation")

    return disk_client.get(project=project_id, zone=zone, disk=disk_name)

ディスクをマウントする

ターミナルで、lsblk コマンドを使用してインスタンスに接続されているディスクを一覧表示し、マウントするディスクを探します。
```
$ sudo lsblk

NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda      8:0    0   10G  0 disk
└─sda1   8:1    0   10G  0 part /
sdb      8:16   0  250G  0 disk
```
この例では、sdb が新しい空の永続ディスクのデバイス名です。
mount ツールを使用してインスタンスにディスクをマウントし、discard オプションを有効にします。
```
$ sudo mount -o discard,defaults /dev/DEVICE_NAME /home/jupyter
```
次のように置き換えます。
- DEVICE_NAME: マウントするディスクのデバイス名。
ディスクに読み取り権限と書き込み権限を構成します。この例では、ディスクへの書き込みアクセス権をすべてのユーザーに付与します。
```
$ sudo chmod a+w /home/jupyter
```

スナップショットを使用してデータをバックアップする

スナップショットを作成する

このタスクに必要な権限

コンソール

gcloud

Terraform

API

Go

Go

Java

Java

Node.js

Node.js

Python

Python

定期的なバックアップのスケジュールを設定する

制限事項

スケジュールを作成する

このタスクに必要な権限

コンソール

gcloud

API

スナップショット スケジュールをディスクに関連付ける

このタスクに必要な権限

Console

gcloud

API

スナップショットからデータを復元する

制限事項

スナップショットからディスクを作成して VM にアタッチする

このタスクに必要な権限

コンソール

gcloud

API

Go

Go

Java

Java

Node.js

Node.js

Python

Python

ディスクをマウントする

次のステップ

スナップショットスケジュールをディスクに関連付ける