디스크의 스냅샷 일정 관리


이 문서에서는 영역과 리전별 Persistent DiskGoogle Cloud Hyperdisk의 스냅샷 일정을 관리하는 방법을 설명합니다.

다음과 같이 스냅샷 일정을 관리할 수 있습니다.

  • 스냅샷 일정 보기
  • 스냅샷 일정 변경
  • 스냅샷 일정 삭제

또한 예약된 스냅샷에 대한 알림을 구성할 수 있습니다.

시작하기 전에

  • 아직 인증을 설정하지 않았다면 설정합니다. 인증은 Google Cloud 서비스 및 API에 액세스하기 위해 ID를 확인하는 프로세스입니다. 로컬 개발 환경에서 코드 또는 샘플을 실행하려면 다음 옵션 중 하나를 선택하여 Compute Engine에 인증하면 됩니다.

    Select the tab for how you plan to use the samples on this page:

    Console

    When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

    gcloud

    1. Install the Google Cloud CLI, then initialize it by running the following command:

      gcloud init
    2. Set a default region and zone.
    3. Go

      로컬 개발 환경에서 이 페이지의 Go 샘플을 사용하려면 gcloud CLI를 설치 및 초기화한 다음 사용자 인증 정보로 애플리케이션 기본 사용자 인증 정보를 설정하세요.

      1. Install the Google Cloud CLI.
      2. To initialize the gcloud CLI, run the following command:

        gcloud init
      3. 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.

      자세한 내용은 다음을 참조하세요: Set up authentication for a local development environment.

      Java

      로컬 개발 환경에서 이 페이지의 Java 샘플을 사용하려면 gcloud CLI를 설치 및 초기화한 다음 사용자 인증 정보로 애플리케이션 기본 사용자 인증 정보를 설정하세요.

      1. Install the Google Cloud CLI.
      2. To initialize the gcloud CLI, run the following command:

        gcloud init
      3. 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.

      자세한 내용은 다음을 참조하세요: Set up authentication for a local development environment.

      Node.js

      로컬 개발 환경에서 이 페이지의 Node.js 샘플을 사용하려면 gcloud CLI를 설치 및 초기화한 다음 사용자 인증 정보로 애플리케이션 기본 사용자 인증 정보를 설정하세요.

      1. Install the Google Cloud CLI.
      2. To initialize the gcloud CLI, run the following command:

        gcloud init
      3. 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.

      자세한 내용은 다음을 참조하세요: Set up authentication for a local development environment.

      Python

      로컬 개발 환경에서 이 페이지의 Python 샘플을 사용하려면 gcloud CLI를 설치 및 초기화한 다음 사용자 인증 정보로 애플리케이션 기본 사용자 인증 정보를 설정하세요.

      1. Install the Google Cloud CLI.
      2. To initialize the gcloud CLI, run the following command:

        gcloud init
      3. 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.

      자세한 내용은 다음을 참조하세요: Set up authentication for a local development environment.

      REST

      로컬 개발 환경에서 이 페이지의 REST API 샘플을 사용하려면 gcloud CLI에 제공한 사용자 인증 정보를 사용합니다.

        Install the Google Cloud CLI, then initialize it by running the following command:

        gcloud init

      자세한 내용은 Google Cloud 인증 문서의 REST 사용을 위한 인증을 참고하세요.

필수 역할 및 권한

스냅샷 일정을 만드는 데 필요한 권한을 얻으려면 관리자에게 프로젝트에 대한 다음 IAM 역할을 부여해 달라고 요청하세요.

역할 부여에 대한 자세한 내용은 프로젝트, 폴더, 조직에 대한 액세스 관리를 참조하세요.

이러한 사전 정의된 역할에는 스냅샷 일정을 만드는 데 필요한 권한이 포함되어 있습니다. 필요한 정확한 권한을 보려면 필수 권한 섹션을 펼치세요.

필수 권한

스냅샷 일정을 만들려면 다음 권한이 필요합니다.

  • 스냅샷 일정 보기: 프로젝트 또는 조직에 대한 compute.resourcePolicies.list 권한
  • 스냅샷 일정 업데이트하기:
    • 리소스 정책에 대한 compute.resourcePolicies.update 권한
    • 리소스 정책에 대한 compute.resourcePolicies.get 권한
  • 스냅샷 일정 교체하기:
    • 리소스 정책에 대한 compute.resourcePolicies.use 권한
    • 디스크에 대한 compute.disks.addResourcePolicies 권한
    • 디스크에 대한 compute.disks.removeResourcePolicies 권한
  • 스냅샷 일정 삭제하기:
    • 리소스 정책에 대한 compute.resourcePolicies.delete 권한
    • 디스크에 대한 compute.disks.removeResourcePolicies 권한

커스텀 역할이나 다른 사전 정의된 역할을 사용하여 이 권한을 부여받을 수도 있습니다.

스냅샷 일정 보기

스냅샷 일정 목록을 가져오려면 콘솔, gcloud 명령어 또는 Compute Engine API 메서드를 사용합니다. 이 요청을 수행하면 프로젝트 내의 모든 스냅샷 일정의 이름, 설명, 리전이 표시됩니다.

콘솔

  1. Google Cloud 콘솔에서 스냅샷 페이지로 이동합니다.

    스냅샷 페이지로 이동

  2. 스냅샷 일정 탭을 선택합니다.
  3. 스냅샷 일정의 목록 범위를 좁히려면 필터 필드를 사용합니다.
  4. 스냅샷 일정의 이름을 클릭하여 세부정보를 봅니다.

gcloud

스냅샷 일정 목록을 보려면 resource-policies list 명령어를 사용합니다.

 gcloud compute resource-policies list

특정 스냅샷 일정에 대한 설명을 보려면 resource-policies describe 명령어를 사용합니다.

gcloud compute resource-policies describe SCHEDULE_NAME

SCHEDULE_NAME을 스냅샷 일정의 이름으로 바꿉니다.

Go

스냅샷 일정 나열

import (
	"context"
	"fmt"
	"io"

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

// listSnapshotSchedule retrieves a list of snapshot schedules.
func listSnapshotSchedule(w io.Writer, projectID, region, filter string) error {
	// projectID := "your_project_id"
	// snapshotName := "your_snapshot_name"
	// region := "eupore-central2"

	// Formatting for filters:
	// https://cloud.google.com/python/docs/reference/compute/latest/google.cloud.compute_v1.types.ListResourcePoliciesRequest

	ctx := context.Background()

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

	req := &computepb.ListResourcePoliciesRequest{
		Project: projectID,
		Region:  region,
		Filter:  proto.String(filter),
	}
	it := snapshotsClient.List(ctx, req)

	for {
		policy, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "- %s", policy.GetName())
	}
	return nil
}

스냅샷 일정 설명

import (
	"context"
	"fmt"
	"io"

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

// getSnapshotSchedule gets a snapshot schedule.
func getSnapshotSchedule(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.GetResourcePolicyRequest{
		Project:        projectID,
		Region:         region,
		ResourcePolicy: scheduleName,
	}
	schedule, err := snapshotsClient.Get(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to get snapshot schedule: %w", err)
	}

	fmt.Fprintf(w, "Found snapshot schedule: %s\n", schedule.GetName())

	return nil
}

자바

스냅샷 일정 나열

import com.google.cloud.compute.v1.ListResourcePoliciesRequest;
import com.google.cloud.compute.v1.ResourcePoliciesClient;
import com.google.cloud.compute.v1.ResourcePoliciesClient.ListPagedResponse;
import com.google.cloud.compute.v1.ResourcePolicy;
import java.io.IOException;

public class ListSnapshotSchedules {

  public static void main(String[] args) throws IOException {
    // 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 you want to list snapshot schedules from.
    String region = "us-central1";
    // Name of the snapshot schedule you want to list.
    String snapshotScheduleName = "YOUR_SCHEDULE_NAME";

    listSnapshotSchedules(projectId, region, snapshotScheduleName);
  }

  // Lists snapshot schedules in a specified region, optionally filtered.
  public static ListPagedResponse listSnapshotSchedules(
          String projectId, String region, String snapshotScheduleName) throws IOException {
    String filter = String.format("name = %s", 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 (ResourcePoliciesClient resourcePoliciesClient = ResourcePoliciesClient.create()) {

      ListResourcePoliciesRequest request = ListResourcePoliciesRequest.newBuilder()
              .setProject(projectId)
              .setRegion(region)
              .setFilter(filter)
              .build();
      ListPagedResponse response = resourcePoliciesClient.list(request);
      for (ResourcePolicy resourcePolicy : response.iterateAll()) {
        System.out.println(resourcePolicy);
      }
      return response;
    }
  }
}

스냅샷 일정 설명

import com.google.cloud.compute.v1.GetResourcePolicyRequest;
import com.google.cloud.compute.v1.ResourcePoliciesClient;
import com.google.cloud.compute.v1.ResourcePolicy;
import java.io.IOException;

public class GetSnapshotSchedule {

  public static void main(String[] args) throws IOException {
    // 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 your snapshot schedule is located.
    String region = "us-central1";
    // Name of your snapshot schedule.
    String snapshotScheduleName = "YOUR_SCHEDULE_NAME";

    getSnapshotSchedule(projectId, region, snapshotScheduleName);
  }

  // Retrieves the details of a snapshot schedule.
  public static ResourcePolicy getSnapshotSchedule(
        String projectId, String region, String snapshotScheduleName) throws IOException {
    // 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()) {
      GetResourcePolicyRequest request = GetResourcePolicyRequest.newBuilder()
              .setProject(projectId)
              .setRegion(region)
              .setResourcePolicy(snapshotScheduleName)
              .build();
      ResourcePolicy resourcePolicy = resourcePoliciesClient.get(request);
      System.out.println(resourcePolicy);

      return resourcePolicy;
    }
  }
}

Node.js

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

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

/**
 * 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';

async function callGetSnapshotSchedule() {
  const [response] = await resourcePoliciesClient.get({
    project: projectId,
    region,
    resourcePolicy: snapshotScheduleName,
  });

  console.log(JSON.stringify(response));
}

await callGetSnapshotSchedule();

Python

스냅샷 일정 나열

from google.cloud import compute_v1
from google.cloud.compute_v1.services.resource_policies import pagers


def snapshot_schedule_list(project_id: str, region: str) -> pagers.ListPager:
    """
    Lists snapshot schedules for a specified project and region.
    Args:
        project_id (str): The ID of the Google Cloud project.
        region (str): The region where the snapshot schedules are located.
    Returns:
        ListPager: A pager for iterating through the list of snapshot schedules.
    """
    client = compute_v1.ResourcePoliciesClient()

    request = compute_v1.ListResourcePoliciesRequest(
        project=project_id,
        region=region,
        filter='status = "READY"',  # Optional filter
    )

    schedules = client.list(request=request)
    return schedules

스냅샷 일정 설명

from google.cloud import compute_v1


def snapshot_schedule_get(
    project_id: str, region: str, snapshot_schedule_name: str
) -> compute_v1.ResourcePolicy:
    """
    Retrieves a snapshot schedule 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 is located.
        snapshot_schedule_name (str): The name of the snapshot schedule.
    Returns:
        compute_v1.ResourcePolicy: The retrieved snapshot schedule.
    """
    client = compute_v1.ResourcePoliciesClient()
    schedule = client.get(
        project=project_id, region=region, resource_policy=snapshot_schedule_name
    )
    return schedule

REST

프로젝트의 스냅샷 일정 목록을 반환하려면 resourcePolicies.aggregatedList에 대한 GET 요청을 수행합니다.

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/aggregated/resourcePolicies

PROJECT_ID를 프로젝트 이름으로 바꿉니다.

리전별 스냅샷 일정 보기

특정 리전 내 프로젝트의 스냅샷 일정을 보려면 Google Cloud 콘솔, gcloud CLI 또는 REST를 사용합니다.

콘솔

  1. Google Cloud 콘솔에서 스냅샷 페이지로 이동합니다.

    스냅샷 페이지로 이동

  2. 스냅샷 일정 탭을 선택합니다.
  3. 필터 필드를 사용하여 특정 리전의 스냅샷 일정을 나열합니다.

gcloud

특정 리전 내 프로젝트의 스냅샷 일정을 보려면 resource-policies list 명령어를 사용합니다.

gcloud compute resource-policies list PROJECT_ID --filter REGION

다음을 바꿉니다.

  • PROJECT_ID: 프로젝트 이름
  • REGION: 리전(예: us-west1)

REST

리전에서 생성된 스냅샷 일정을 검색하려면 resourcePolicies.list 메서드에 대한 GET 요청을 수행합니다.

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

다음을 바꿉니다.

  • PROJECT_ID: 프로젝트 이름
  • REGION: 리전(예: us-west1)

스냅샷 일정 변경

스냅샷 일정을 만든 후 스냅샷 일정 업데이트 절차를 사용하여 다음 필드를 동적으로 수정할 수 있습니다.

  • 설명
  • 스냅샷 일정
  • 생성된 스냅샷에 적용되는 라벨
  • 소스 디스크가 삭제된 경우 자동 생성된 스냅샷 처리를 위한 소스 디스크 삭제 정책
  • 스냅샷 일정에 따라 생성된 스냅샷의 보관 기간을 정의하는 보관 정책

스냅샷 일정의 다른 값을 업데이트하려면 스냅샷 일정 바꾸기의 설명대로 스냅샷 일정을 삭제하고 새 일정을 만들어야 합니다.

스냅샷 일정 업데이트는 업데이트 후 첫 번째 스냅샷에 적용됩니다. 스냅샷 일정을 업데이트하는 동안 스냅샷이 실행 중이면 다음 스냅샷에서 변경사항이 적용됩니다.

스냅샷 일정 업데이트

스냅샷 일정 변경에 설명된 대로 Google Cloud CLI 또는 Compute Engine API를 사용하여 스냅샷 일정의 일부 속성을 변경할 수 있습니다.

스냅샷 일정의 다른 속성을 변경하려면 스냅샷 일정 교체에 설명된 방법을 사용합니다.

콘솔

  1. Google Cloud 콘솔에서 스냅샷 페이지로 이동합니다.

    스냅샷 페이지로 이동

  2. 스냅샷 일정을 선택하여 일정 목록을 표시합니다.
  3. 수정할 스냅샷 일정의 이름을 클릭합니다.
  4. 스냅샷 일정 세부정보 페이지에서 일정 수정 버튼을 클릭합니다.

gcloud

스냅샷 일정의 설명, 일정, 보관 정책 또는 라벨을 업데이트하려면 compute resource-policies update 명령어를 사용합니다.

gcloud compute resource-policies update snapshot-schedule SCHEDULE_NAME \
   --region=REGION \
   --description="DESCRIPTION" \
   --snapshot-labels="KEY=VALUE" \
   --max-retention-days=DAYS \
   --on-source-disk-delete=DELETE_OPTION \
   --start-time=START_TIME \
   SCHEDULE_FLAG

다음을 바꿉니다.

  • SCHEDULE_NAME: 스냅샷 일정의 이름
  • REGION: 스냅샷 일정이 있는 리전
  • DESCRIPTION: 스냅샷 일정에 대한 설명입니다. 설명을 따옴표를 사용하여 묶습니다.
  • KEYVALUE: 관련된 리소스 또는 연결된 리소스를 그룹화하는 데 사용할 수 있는 키-값 쌍입니다.
  • DAYS: 스냅샷이 삭제되기 전에 유지되는 최대 일 수입니다.
  • DELETE_OPTION: 원본 디스크가 삭제된 후의 자동 스냅샷 보관 동작입니다. 값은 다음 중 하나여야 합니다.
    • apply-retention-policy: 소스 디스크가 삭제되었으면 스냅샷 일정에 따라 생성된 모든 스냅샷에 대해 보관 기간을 계속 적용합니다.
    • keep-auto-snapshots: (기본값) 소스 디스크가 삭제된 경우 보관 기간에 관계없이 스냅샷 일정에 따라 생성된 모든 스냅샷을 유지합니다.
  • START_TIME: UTC 시작 시간입니다. 시작 시간은 정시에 시작해야 합니다. 예를 들면 다음과 같습니다.
    • 태평양 표준시(PST 기준) 오후 2시는 22:00입니다.
    • 시작 시간을 22:13으로 설정하면 오류가 발생합니다.
  • SCHEDULE_FLAG: 다음 플래그 중 하나입니다.

    • --hourly-schedule=HOURLY_INTERVAL: 모든 스냅샷 사이의 시간입니다. HOURLY_INTERVAL1에서 23 사이의 정수여야 합니다. 예를 들어 --hourly-schedule을 12로 설정하면 스냅샷이 12시간마다 생성됩니다.
    • --daily-schedule: 매일 START_TIME에 스냅샷을 수행합니다.
    • --weekly-schedule=WEEKLY_INTERVAL: 스냅샷을 만들 요일을 정의합니다. 요일을 정확히 입력해야 하며 값은 대소문자를 구분하지 않습니다.

    • --weekly-schedule-from-file=FILE_NAME: 주 단위 스냅샷 일정이 포함된 파일을 지정합니다. 파일을 사용하여 다른 요일과 다른 시간으로 주 단위 일정을 지정할 수 있습니다. 예를 들어 파일에 다음과 같이 월요일과 수요일에 스냅샷 일정을 지정할 수 있습니다(none [{"day": "MONDAY", "startTime": "04:00"}, {"day": "WEDNESDAY", "startTime": "02:00"}]). 파일에 시작 시간을 포함하면 --start-time 플래그를 설정하지 않아도 됩니다. 일정은 UTC 시간대를 사용합니다. 시작 시간은 정시에 시작해야 합니다. 예를 들면 다음과 같습니다.

      • 태평양 표준시(PST 기준) 오후 2시는 22:00입니다.
      • 시작 시간을 22:13으로 설정하면 오류가 발생합니다.

    스냅샷 빈도 플래그 hourly-schedule, daily-schedule, weekly-schedule, weekly-schedule-from-file을 함께 사용할 수 없습니다. 스냅샷 일정에 하나만 사용할 수 있습니다.

예:

스냅샷 일정을 일 단위 일정으로 변경하려면 다음 단계를 따르세요.

gcloud compute resource-policies update snapshot-schedule SCHEDULE_NAME \
    --region=REGION --daily-schedule --start-time=START_TIME

스냅샷을 시간 단위 일정으로 변경하고 설명 및 스냅샷 라벨도 업데이트하려면 다음 안내를 따르세요.

gcloud compute resource-policies update snapshot-schedule SCHEDULE_NAME \
    --region=REGION --description="DESCRIPTION" \
    --hourly-schedule=HOURLY_INTERVAL --start-time=START_TIME \
    --snapshot-labels="KEY=VALUE"

스냅샷 일정의 스냅샷 보관 및 소스 디스크 삭제 정책을 변경하려면 다음 안내를 따르세요.

gcloud compute resource-policies update snapshot-schedule SCHEDULE_NAME \
    --region=REGION --max-retention-days=DAYS \
    --on-source-disk-delete=DELETE_OPTION

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

// editSnapshotSchedule edits a snapshot schedule.
func editSnapshotSchedule(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.PatchResourcePolicyRequest{
		Project:        projectID,
		Region:         region,
		ResourcePolicy: scheduleName,
		ResourcePolicyResource: &computepb.ResourcePolicy{
			Name:        proto.String(scheduleName),
			Description: proto.String("MY HOURLY SNAPSHOT SCHEDULE"),
			SnapshotSchedulePolicy: &computepb.ResourcePolicySnapshotSchedulePolicy{
				Schedule: &computepb.ResourcePolicySnapshotSchedulePolicySchedule{
					HourlySchedule: &computepb.ResourcePolicyHourlyCycle{
						HoursInCycle: proto.Int32(12),
						StartTime:    proto.String("22:00"),
					},
				},
			},
		},
	}
	op, err := snapshotsClient.Patch(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 changed\n")

	return nil
}

자바

import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.PatchResourcePolicyRequest;
import com.google.cloud.compute.v1.ResourcePoliciesClient;
import com.google.cloud.compute.v1.ResourcePolicy;
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 com.google.cloud.compute.v1.ResourcePolicyWeeklyCycle;
import com.google.cloud.compute.v1.ResourcePolicyWeeklyCycleDayOfWeek;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class EditSnapshotSchedule {

  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 region where your snapshot schedule is located.
    String region = "us-central1";
    // Name of the snapshot schedule you want to update.
    String snapshotScheduleName = "YOUR_SCHEDULE_NAME";

    editSnapshotSchedule(projectId, region, snapshotScheduleName);
  }

  // Edits a snapshot schedule.
  public static Status editSnapshotSchedule(
          String projectId, String region, String snapshotScheduleName)
          throws IOException, InterruptedException, ExecutionException, 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()) {
      Map<String, String> snapshotLabels = new HashMap<>();
      snapshotLabels.put("key", "value");

      ResourcePolicySnapshotSchedulePolicySnapshotProperties.Builder snapshotProperties =
              ResourcePolicySnapshotSchedulePolicySnapshotProperties.newBuilder();
      snapshotProperties.putAllLabels(snapshotLabels);

      ResourcePolicyWeeklyCycleDayOfWeek dayOfWeek = ResourcePolicyWeeklyCycleDayOfWeek.newBuilder()
              .setDay("Tuesday")
              .setStartTime("09:00")
              .build();
      ResourcePolicyWeeklyCycle weeklySchedule = ResourcePolicyWeeklyCycle.newBuilder()
              .addDayOfWeeks(dayOfWeek)
              .build();

      int maxRetentionDays = 3;

      ResourcePolicySnapshotSchedulePolicyRetentionPolicy.Builder retentionPolicy =
              ResourcePolicySnapshotSchedulePolicyRetentionPolicy.newBuilder();
      retentionPolicy.setOnSourceDiskDelete(OnSourceDiskDelete.APPLY_RETENTION_POLICY.toString());
      retentionPolicy.setMaxRetentionDays(maxRetentionDays);

      String description = "Updated description";

      ResourcePolicy updatedSchedule = ResourcePolicy.newBuilder()
              .setName(snapshotScheduleName)
              .setDescription(description)
              .setSnapshotSchedulePolicy(
                      ResourcePolicySnapshotSchedulePolicy.newBuilder()
                              .setSchedule(ResourcePolicySnapshotSchedulePolicySchedule.newBuilder()
                                      .setWeeklySchedule(weeklySchedule))
                              .setSnapshotProperties(snapshotProperties)
                              .setRetentionPolicy(retentionPolicy.build())
                              .build())
              .build();

      PatchResourcePolicyRequest request = PatchResourcePolicyRequest.newBuilder()
              .setProject(projectId)
              .setRegion(region)
              .setResourcePolicy(snapshotScheduleName)
              .setResourcePolicyResource(updatedSchedule)
              .build();

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

      if (response.hasError()) {
        throw new Error("Failed to update snapshot schedule! " + 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';

async function callEditSnapshotSchedule() {
  const [response] = await resourcePoliciesClient.patch({
    project: projectId,
    region,
    resourcePolicy: snapshotScheduleName,
    resourcePolicyResource: compute.ResourcePolicy({
      snapshotSchedulePolicy:
        compute.ResourcePolicyInstanceSchedulePolicySchedule({
          schedule: compute.ResourcePolicySnapshotSchedulePolicySchedule({
            weeklySchedule: compute.ResourcePolicyWeeklyCycle({
              dayOfWeeks: [
                compute.ResourcePolicyWeeklyCycleDayOfWeek({
                  day: 'Tuesday',
                  startTime: '9:00',
                }),
              ],
            }),
          }),
        }),
    }),
  });

  let operation = response.latestResponse;

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

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

await callEditSnapshotSchedule();

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_update(
    project_id: str,
    region: str,
    schedule_name: str,
    schedule_description: str,
    labels: dict,
) -> compute_v1.ResourcePolicy:
    """
    Updates a snapshot schedule 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 is located.
        schedule_name (str): The name of the snapshot schedule to update.
        schedule_description (str): The new description for the snapshot schedule.
        labels (dict): A dictionary of new labels to apply to the snapshot schedule.
    Returns:
        compute_v1.ResourcePolicy: The updated snapshot schedule.
    """

    # 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])

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

    # Autodelete snapshots after 10 days
    retention_policy = compute_v1.ResourcePolicySnapshotSchedulePolicyRetentionPolicy(
        max_retention_days=10
    )
    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.patch(
        project=project_id,
        region=region,
        resource_policy=schedule_name,
        resource_policy_resource=resource_policy_resource,
    )
    wait_for_extended_operation(operation, "Resource Policy updating")

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

REST

스냅샷 일정의 설명, 일정, 보관 정책, 소스 디스크 삭제 정책 또는 라벨을 업데이트하려면 resourcePolicies 메서드에 대한 PATCH 요청을 수행합니다. 요청 본문에서 name 및 업데이트할 필드만 지정하면 됩니다.

  • 설명 및 라벨을 변경합니다.

    PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies/SCHEDULE_NAME
    {
        "name": "SCHEDULE_NAME",
        "description": "DESCRIPTION",
        "snapshotProperties": {
            "labels": {"KEY": "VALUE"}
        }
    }
    
  • 스냅샷 일정을 시간 단위로 변경합니다.

    PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies/SCHEDULE_NAME
    {
        "name": "SCHEDULE_NAME",
        "snapshotSchedulePolicy": {
            "schedule": {
              "hourlySchedule": {
                  "hoursInCycle": HOURLY_INTERVAL,
                  "startTime": START_TIME
               }
            }
        }
    }
    
  • 스냅샷 일정을 일 단위로 변경합니다.

    PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies/SCHEDULE_NAME
    {
        "name": "SCHEDULE_NAME",
        "snapshotSchedulePolicy": {
            "schedule": {
              "dailySchedule": {
                  "daysInCycle": DAILY_INTERVAL,
                  "startTime": START_TIME
               }
            }
        }
    }
    
  • 스냅샷 일정을 주 단위로 변경합니다.

    PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies/SCHEDULE_NAME
    {
        "name": "SCHEDULE_NAME",
        "snapshotSchedulePolicy": {
            "schedule": {
               "weeklySchedule": {
                  "dayOfWeeks": [
                     {
                        "day": WEEKLY_INTERVAL,
                        "startTime": START_TIME
                     }
                  ]
               }
            }
        }
    }
    
  • 스냅샷 보관 정책을 변경합니다.

    PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies/SCHEDULE_NAME
    {
        "name": "SCHEDULE_NAME",
        "snapshotSchedulePolicy": {
            "retentionPolicy": {
                "maxRetentionDays": DAYS,
                "onSourceDiskDelete":"DELETE_OPTION"
            }
       }
    }
    

다음을 바꿉니다.

  • PROJECT_ID: 프로젝트 이름
  • REGION: 스냅샷 일정이 있는 리전
  • SCHEDULE_NAME: 스냅샷 일정의 이름
  • DESCRIPTION: 스냅샷 일정에 대한 설명입니다. 설명을 따옴표를 사용하여 묶습니다.
  • KEYVALUE: 관련된 리소스 또는 연결된 리소스를 그룹화하는 데 사용할 수 있는 키-값 쌍입니다.
  • HOURLY_INTERVAL은 스냅샷 실행 간격을 정의합니다. 1에서 23 사이의 정수를 사용하여 시간 단위 일정을 설정합니다. 매일 같은 시간에 스냅샷을 만들려면 24(1, 2, 3, 4, 6, 8, 12)를 균등하게 나누는 숫자를 선택합니다. 예를 들어 --hourly-schedule을 12로 설정하면 스냅샷이 12시간마다 생성됩니다.
  • DAILY_INTERVAL: 각 스냅샷 사이의 일수를 정의합니다. 매일 스냅샷을 만들려면 1 값을 사용합니다.
  • WEEKLY_INTERVAL: 특정 요일에 실행되는 일정을 정의합니다. 1일 이상 지정합니다. MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY 옵션을 사용할 수 있습니다. 요일을 정확히 입력해야 하며 대소문자를 구분하지 않습니다. dayOfWeeks에서 요일당 하나씩 최대 7개 까지 간격을 정의할 수 있습니다.
  • START_TIME: UTC 시작 시간입니다. 시작 시간은 정시에 시작해야 합니다. 예를 들면 다음과 같습니다.
    • 태평양 표준시(PST 기준) 오후 2시는 22:00(UTC)입니다.
    • 시작 시간을 22:13으로 설정하면 오류가 발생합니다.
  • DAYS: 스냅샷이 삭제되기 전에 유지되는 최대 일 수입니다.
  • DELETE_OPTION: 원본 디스크가 삭제된 후의 자동 스냅샷 보관 동작입니다. 값은 다음 중 하나여야 합니다.
    • APPLY_RETENTION_POLICY: 소스 디스크가 삭제되었으면 스냅샷 일정에 따라 생성된 모든 스냅샷에 대해 보관 기간을 계속 적용합니다.
    • KEEP_AUTO_SNAPSHOTS: (기본값) 소스 디스크가 삭제된 경우 보관 기간에 관계없이 스냅샷 일정에 따라 생성된 모든 스냅샷을 유지합니다.

스냅샷 일정 교체

스냅샷 일정을 삭제하고 새 일정을 만들려면 다음 단계를 따르세요. 이 방법을 사용하면 스냅샷 일정 업데이트 절차에 따라 변경할 수 없는 스냅샷 일정 속성을 수정할 수 있습니다.

이미 디스크에 연결된 스냅샷 일정을 교체하는 경우 먼저 디스크에서 일정을 분리한 후 삭제해야 합니다. 그런 다음 새 일정을 만들어 디스크에 연결할 수 있습니다.

분리된 스냅샷 일정에서 생성된 스냅샷은 신규 정책에서 관리되지 않습니다. 이러한 스냅샷은 삭제될 때까지 무기한 보관됩니다.

Google Cloud 콘솔, gcloud CLI 또는 REST를 사용하여 스냅샷 일정을 삭제하고 교체합니다.

콘솔

  1. Google Cloud 콘솔에서 디스크 페이지로 이동합니다.

    디스크 페이지로 이동

  2. 연결 해제하려는 일정이 있는 디스크를 선택합니다.
  3. 디스크 관리 페이지에서 수정을 클릭합니다. 먼저 작업 더보기 메뉴를 클릭해야 할 수 있습니다.
  4. 스냅샷 일정 드롭다운 메뉴를 엽니다.
  5. 일정 없음을 클릭하여 디스크에서 일정을 연결 해제합니다.
  6. 새 일정을 만들거나 디스크 옵션을 수정하는 동안 일정을 바꿀 수 있습니다.
  7. 저장을 클릭하여 작업을 완료합니다.

gcloud

  1. gcloud disks remove-resource-policies 명령어를 사용하여 변경하려는 일정이 있는 디스크에서 스냅샷 일정을 연결 해제합니다.

    gcloud compute disks remove-resource-policies DISK_NAME \
        --resource-policies SCHEDULE_NAME \
        --region REGION \
        --zone ZONE
    

    다음을 바꿉니다.

    • DISK_NAME: 스냅샷 일정이 연결된 디스크의 이름
    • SCHEDULE_NAME: 디스크에서 연결 해제하려는 스냅샷 일정의 이름
    • REGION: 스냅샷 일정이 있는 리전
    • ZONE: 영역 디스크가 있는 영역
  2. gcloud disks add-resource-policies 명령어를 사용하여 디스크에 새 스냅샷 일정을 추가합니다.

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

    다음을 바꿉니다.

    • DISK_NAME: 스냅샷 일정 리소스 정책이 있는 디스크의 이름
    • SCHEDULE_NAME: 디스크에 추가하려는 스냅샷 일정의 이름
    • ZONE: 디스크가 있는 영역

REST

  1. disks.removeResourcePolicies에 대한 POST 요청을 작성하여 디스크에서 현재 스냅샷 일정을 분리합니다.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks/DISK_NAME/removeResourcePolicies
    
    {
      "resourcePolicies": [
         "regions/REGION/resourcePolicies/SCHEDULE_NAME"
      ]
    }
    

    다음을 바꿉니다.

    • PROJECT_ID: 프로젝트 이름
    • ZONE: 디스크가 있는 영역
    • DISK_NAME: 연결된 스냅샷 일정이 있는 디스크의 이름
    • REGION: 스냅샷 일정의 위치
    • SCHEDULE_NAME: 디스크에서 삭제하려는 스냅샷 일정의 이름
  2. 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: 디스크의 위치
    • DISK_NAME: 디스크의 이름
    • REGION: 스냅샷 일정의 위치
    • SCHEDULE_NAME: 디스크에 적용할 스냅샷 일정의 이름

스냅샷 일정 삭제

스냅샷 일정을 삭제하면 스냅샷 일정과 관련된 모든 자동 생성 스냅샷이 무기한 유지됩니다. 그러나 일정을 삭제하면 더 이상 스냅샷을 생성할 수 없습니다.

보관 정책은 스냅샷 일정의 일부입니다. 일정이 삭제되면 보관 정책이 더 이상 적용되지 않습니다. 이미 생성된 스냅샷은 수동으로 삭제할 때까지 무기한 유지됩니다.

기존 스냅샷 일정을 삭제하려면 Google Cloud 콘솔, Google Cloud CLI, Compute Engine API 메서드를 사용합니다. 일정이 이미 디스크에 연결되어 있는 경우 먼저 디스크에서 일정을 연결 해제한 다음 일정을 삭제하세요. 디스크에 연결된 스냅샷 일정은 삭제할 수 없습니다.

콘솔

  1. Google Cloud 콘솔에서 스냅샷 페이지로 이동합니다.

    스냅샷 페이지로 이동

  2. 스냅샷 일정을 선택하여 일정 목록을 표시합니다.
  3. 디스크에 연결되지 않은 일정을 선택합니다.
  4. 삭제를 클릭합니다.

gcloud

스냅샷 일정을 삭제하려면 resource-policies delete 명령어를 사용합니다.

gcloud compute resource-policies delete SCHEDULE_NAME \
    --region REGION

다음을 바꿉니다.

  • SCHEDULE_NAME: 스냅샷 일정의 이름
  • REGION: 스냅샷 일정의 위치

Go

import (
	"context"
	"fmt"
	"io"

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

// deleteSnapshotSchedule deletes a snapshot schedule.
func deleteSnapshotSchedule(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.DeleteResourcePolicyRequest{
		Project:        projectID,
		Region:         region,
		ResourcePolicy: scheduleName,
	}
	op, err := snapshotsClient.Delete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to delete 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 deleted\n")

	return nil
}

자바

import com.google.cloud.compute.v1.DeleteResourcePolicyRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.ResourcePoliciesClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class DeleteSnapshotSchedule {
  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 where your snapshot schedule is located.
    String region = "us-central1";
    // Name of the snapshot schedule you want to delete.
    String snapshotScheduleName = "YOUR_SCHEDULE_NAME";

    deleteSnapshotSchedule(projectId, region, snapshotScheduleName);
  }

  // Deletes a snapshot schedule policy.
  public static Status deleteSnapshotSchedule(
          String projectId, String region, 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 (ResourcePoliciesClient resourcePoliciesClient = ResourcePoliciesClient.create()) {
      DeleteResourcePolicyRequest request = DeleteResourcePolicyRequest.newBuilder()
              .setProject(projectId)
              .setRegion(region)
              .setResourcePolicy(snapshotScheduleName)
              .build();
      Operation response = resourcePoliciesClient.deleteAsync(request).get(3, TimeUnit.MINUTES);

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

Node.js

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

// 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'

async function callDeleteSnapshotSchedule() {
  // If the snapshot schedule is already attached to a disk, you will receive an error.
  const [response] = await resourcePoliciesClient.delete({
    project: projectId,
    region,
    resourcePolicy: snapshotScheduleName,
  });

  let operation = response.latestResponse;

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

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

await callDeleteSnapshotSchedule();

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_delete(
    project_id: str, region: str, snapshot_schedule_name: str
) -> None:
    """
    Deletes a snapshot schedule 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 is located.
        snapshot_schedule_name (str): The name of the snapshot schedule to delete.
    Returns:
        None
    """
    client = compute_v1.ResourcePoliciesClient()
    operation = client.delete(
        project=project_id, region=region, resource_policy=snapshot_schedule_name
    )
    wait_for_extended_operation(operation, "Resource Policy deletion")

REST

스냅샷 일정을 삭제하려면 resourcePolicies.delete 메서드에 대해 DELETE 요청을 수행합니다. 스냅샷 일정이 이미 디스크에 연결되어 있으면 오류가 발생합니다.

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

다음을 바꿉니다.

  • PROJECT_ID: 프로젝트 이름
  • REGION: 스냅샷 일정의 위치
  • SCHEDULE_NAME: 스냅샷 일정의 이름

로그 기록 및 모니터링

디스크에 연결된 모든 스냅샷 일정은 시스템 이벤트를 계속해서 생성하며 시스템 이벤트는 항상 모니터링 및 로깅됩니다. 시스템 이벤트 감사 로그는 항상 사용 설정되어 있습니다.

이러한 로그는 연결된 디스크 각각에 대한 예약된 스냅샷의 행동 정보를 제공합니다. Google Cloud 콘솔의 Logging 메뉴에서 로그를 볼 수 있습니다.

로그 탐색기 사용에 대한 자세한 내용은 로그 탐색기를 사용하여 로그 보기를 참조하세요.

콘솔

  1. Google Cloud Console에서 로그 탐색기 페이지로 이동합니다.

    로그 탐색기 페이지로 이동

  2. All resource(모든 리소스) 드롭다운 목록에서 디스크를 가리키고 All disk_id(모든 disk_id)를 선택합니다.

  3. All logs(모든 로그) 드롭다운 목록에서 cloudaudit.googleapis.com/system_event를 선택하고 확인을 클릭합니다.

  4. 모든 로그 수준 드롭다운 목록에서 로그 유형을 선택합니다.

다음 단계