此页面由 Cloud Translation API 翻译。

创建和管理备份时间表

本页介绍了 Spanner 备份时间表操作，并说明了如何为数据库设置备份时间表。

准备工作

如需获得创建和管理备份时间表所需的权限，请让管理员向您授予实例的以下 IAM 角色：
- 创建、查看、更新和删除备份时间表：Cloud Spanner Backup Admin (roles/spanner.backupAdmin)
- 创建和查看备份时间表：Cloud Spanner Backup Writer (roles/spanner.backupWriter)
注意： IAM 基本角色可能还包含创建和管理备份时间表的权限。您不应在生产环境中授予基本角色，但可以在开发或测试环境中授予这些角色。

创建备份时间表

控制台

在 Google Cloud 控制台中，前往 Spanner 实例页面。

前往“Spanner 实例”页面
点击包含数据库的实例。
点击相应数据库。
在导航菜单中，点击备份/恢复。
点击创建备份时间表。
填写表单，然后点击创建。

gcloud

在使用下面的命令数据之前，请先进行以下替换：

SCHEDULE_ID：备份时间表 ID。
PROJECT_ID：项目 ID。
INSTANCE_ID：您要创建备份时间表的实例的 ID。
DATABASE_ID：您要创建备份时间表的数据库的 ID。
RETENTION_DURATION：由时间表创建的备份的保留时长。例如，如果您希望保留时长为一天，可以使用 86400s。
CRONTAB_EXPRESSION：备份时间表频率的 Crontab 表达式。例如，如果您希望备份时间安排频率为每 12 小时一次，则可以使用 0 12 * * *。
BACKUP_TYPE：是完整备份时间表还是增量备份时间表。可能的值为 full-backup 或 incremental-backup。
ENCRYPTION_TYPE：由备份时间表创建的备份的加密类型。有效值为 USE_DATABASE_ENCRYPTION、GOOGLE_DEFAULT_ENCRYPTION 或 CUSTOMER_MANAGED_ENCRYPTION。如果您使用 CUSTOMER_MANAGED_ENCRYPTION，则必须指定 kmsKeyName。如果您的备份类型为 incremental-backup，则加密类型必须为 GOOGLE_DEFAULT_ENCRYPTION。

执行以下命令：

Linux、macOS 或 Cloud Shell

gcloud spanner backup-schedules create SCHEDULE_ID \
  --project=PROJECT_ID \
  --instance=INSTANCE_ID \
  --database=DATABASE_ID \
  --retention-duration=RETENTION_DURATION \
  --cron="CRONTAB_EXPRESSION" \
  --backup-type=BACKUP_TYPE \
  --encryption-type=ENCRYPTION_TYPE

Windows (PowerShell)

gcloud spanner backup-schedules create SCHEDULE_ID `
  --project=PROJECT_ID `
  --instance=INSTANCE_ID `
  --database=DATABASE_ID `
  --retention-duration=RETENTION_DURATION `
  --cron="CRONTAB_EXPRESSION" `
  --backup-type=BACKUP_TYPE `
  --encryption-type=ENCRYPTION_TYPE

Windows (cmd.exe)

gcloud spanner backup-schedules create SCHEDULE_ID ^
  --project=PROJECT_ID ^
  --instance=INSTANCE_ID ^
  --database=DATABASE_ID ^
  --retention-duration=RETENTION_DURATION ^
  --cron="CRONTAB_EXPRESSION" ^
  --backup-type=BACKUP_TYPE ^
  --encryption-type=ENCRYPTION_TYPE

REST v1

在使用任何请求数据之前，请先进行以下替换：

PROJECT_ID：项目 ID。
INSTANCE_ID：您要创建备份时间表的实例的 ID。
DATABASE_ID：您要创建备份时间表的数据库的 ID。
SCHEDULE_ID：备份时间表 ID。
BACKUP_TYPE：是完整备份时间表还是增量备份时间表。可能的值为 fullBackupSpec 或 incrementalBackupSpec。
ENCRYPTION_TYPE：由备份时间表创建的备份的加密类型。可能的值为 USE_DATABASE_ENCRYPTION、GOOGLE_DEFAULT_ENCRYPTION 或 CUSTOMER_MANAGED_ENCRYPTION。如果您使用 CUSTOMER_MANAGED_ENCRYPTION，则必须指定 kmsKeyName。如果您的备份类型为 incremental-backup，则加密类型必须为 GOOGLE_DEFAULT_ENCRYPTION。
RETENTION_DURATION：按时间表创建的备份的保留时长。

HTTP 方法和网址：

POST https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules?backup_schedule_id=SCHEDULE_ID

请求 JSON 正文：

{
  "retentionDuration": "RETENTION_DURATION",
  "spec": {
    "cronSpec": {
      "text": "0 2 * * *"
    }
  },
  "encryptionConfig": {
    "encryptionType": "ENCRYPTION_TYPE"
  },
  "BACKUP_TYPE": {}
}

如需发送您的请求，请展开以下选项之一：

curl（Linux、macOS 或 Cloud Shell）

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI，或者使用了 Cloud Shell，这会使您自动登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules?backup_schedule_id=SCHEDULE_ID"

PowerShell (Windows)

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules?backup_schedule_id=SCHEDULE_ID" | Select-Object -Expand Content

您应该收到类似以下内容的 JSON 响应：

{
  "name": "projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID",
  "retentionDuration": "86400s",
  "encryptionConfig": {
    "encryptionType": "USE_DATABASE_ENCRYPTION"
  },
  "spec": {
    "cronSpec": {
      "text": "0 2 * * *",
      "timeZone": "UTC",
      "creationWindow": "14400s"
    }
  },
  "BACKUP_TYPE": {},
  "updateTime": "2024-05-22T11:13:51.835590Z"
}

客户端库

C#

如需创建完整备份时间表，请参阅以下示例代码：

using Google.Cloud.Spanner.Admin.Database.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.Protobuf.WellKnownTypes;
using System;

public class CreateFullBackupScheduleSample
{
    public BackupSchedule CreateFullBackupSchedule(string projectId, string instanceId, string databaseId, string scheduleId)
    {
        DatabaseAdminClient client = DatabaseAdminClient.Create();

        BackupSchedule response = client.CreateBackupSchedule(
            new CreateBackupScheduleRequest
            {
                ParentAsDatabaseName = DatabaseName.FromProjectInstanceDatabase(projectId, instanceId, databaseId),
                BackupScheduleId = scheduleId,
                BackupSchedule = new BackupSchedule
                {
                    Spec = new BackupScheduleSpec
                    {
                        CronSpec = new CrontabSpec
                        {
                            Text = "30 12 * * *",
                        }
                    },
                    RetentionDuration = new Duration
                    {
                        Seconds = 86400,
                    },
                    EncryptionConfig = new CreateBackupEncryptionConfig
                    {
                        EncryptionType = CreateBackupEncryptionConfig.Types.EncryptionType.UseDatabaseEncryption,
                    },
                    FullBackupSpec = new FullBackupSpec { },
                }
            });

        Console.WriteLine($"Created full backup schedule: {response}");
        return response;
    }
}

如需创建增量备份时间表，请参阅以下示例代码：

using Google.Cloud.Spanner.Admin.Database.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.Protobuf.WellKnownTypes;
using System;

public class CreateIncrementalBackupScheduleSample
{
    public BackupSchedule CreateIncrementalBackupSchedule(string projectId, string instanceId, string databaseId, string scheduleId)
    {
        DatabaseAdminClient client = DatabaseAdminClient.Create();

        BackupSchedule response = client.CreateBackupSchedule(
            new CreateBackupScheduleRequest
            {
                ParentAsDatabaseName = DatabaseName.FromProjectInstanceDatabase(projectId, instanceId, databaseId),
                BackupScheduleId = scheduleId,
                BackupSchedule = new BackupSchedule
                {
                    Spec = new BackupScheduleSpec
                    {
                        CronSpec = new CrontabSpec
                        {
                            Text = "30 12 * * *",
                        }
                    },
                    RetentionDuration = new Duration
                    {
                        Seconds = 86400,
                    },
                    EncryptionConfig = new CreateBackupEncryptionConfig
                    {
                        EncryptionType = CreateBackupEncryptionConfig.Types.EncryptionType.GoogleDefaultEncryption,
                    },
                    IncrementalBackupSpec = new IncrementalBackupSpec { },
                }
            });

        Console.WriteLine($"Created incremental backup schedule: {response}");
        return response;
    }
}

C++

如需创建完整备份时间表，请参阅以下示例代码：

void CreateFullBackupSchedule(
    google::cloud::spanner_admin::DatabaseAdminClient client,
    std::string const& project_id, std::string const& instance_id,
    std::string const& database_id, std::string const& backup_schedule_id) {
  google::spanner::admin::database::v1::BackupSchedule backup_schedule;
  *backup_schedule.mutable_full_backup_spec() = {};
  backup_schedule.mutable_spec()->mutable_cron_spec()->set_text("30 12 * * *");
  backup_schedule.mutable_retention_duration()->set_seconds(3600 * 24);

  google::spanner::admin::database::v1::CreateBackupEncryptionConfig
      encryption_config;
  encryption_config.set_encryption_type(
      google::spanner::admin::database::v1::CreateBackupEncryptionConfig::
          USE_DATABASE_ENCRYPTION);
  *backup_schedule.mutable_encryption_config() = std::move(encryption_config);

  google::cloud::spanner::Database db(project_id, instance_id, database_id);
  google::spanner::admin::database::v1::CreateBackupScheduleRequest request;
  request.set_parent(db.FullName());
  request.set_backup_schedule_id(backup_schedule_id);
  *request.mutable_backup_schedule() = std::move(backup_schedule);

  auto created_backup_schedule = client.CreateBackupSchedule(request);
  if (!created_backup_schedule) {
    throw std::move(created_backup_schedule).status();
  }
  std::cout << "Backup schedule " << created_backup_schedule->name()
            << " created at "
            << *google::cloud::spanner::MakeTimestamp(
                   created_backup_schedule->update_time());
}

如需创建增量备份时间表，请参阅以下示例代码：

void CreateIncrementalBackupSchedule(
    google::cloud::spanner_admin::DatabaseAdminClient client,
    std::string const& project_id, std::string const& instance_id,
    std::string const& database_id, std::string const& backup_schedule_id) {
  google::spanner::admin::database::v1::BackupSchedule backup_schedule;
  *backup_schedule.mutable_incremental_backup_spec() = {};
  backup_schedule.mutable_spec()->mutable_cron_spec()->set_text("30 12 * * *");
  backup_schedule.mutable_retention_duration()->set_seconds(3600 * 24);

  google::spanner::admin::database::v1::CreateBackupEncryptionConfig
      encryption_config;
  encryption_config.set_encryption_type(
      google::spanner::admin::database::v1::CreateBackupEncryptionConfig::
          GOOGLE_DEFAULT_ENCRYPTION);
  *backup_schedule.mutable_encryption_config() = std::move(encryption_config);

  google::cloud::spanner::Database db(project_id, instance_id, database_id);
  google::spanner::admin::database::v1::CreateBackupScheduleRequest request;
  request.set_parent(db.FullName());
  request.set_backup_schedule_id(backup_schedule_id);
  *request.mutable_backup_schedule() = std::move(backup_schedule);

  auto created_backup_schedule = client.CreateBackupSchedule(request);
  if (!created_backup_schedule) {
    throw std::move(created_backup_schedule).status();
  }
  std::cout << "Incremental backup schedule " << created_backup_schedule->name()
            << " created at "
            << *google::cloud::spanner::MakeTimestamp(
                   created_backup_schedule->update_time());
}

Go

如需创建完整备份时间表，请参阅以下示例代码：


import (
	"context"
	"fmt"
	"io"
	"time"

	database "cloud.google.com/go/spanner/admin/database/apiv1"
	"cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
	"google.golang.org/protobuf/types/known/durationpb"
)

func createFullBackupSchedule(w io.Writer, dbName string, scheduleId string) error {
	ctx := context.Background()

	client, err := database.NewDatabaseAdminClient(ctx)
	if err != nil {
		return err
	}
	defer client.Close()

	// Create a schedule to create full backups daily at 12:30 AM, using the
	// database's encryption config, and retained for 24 hours.
	req := databasepb.CreateBackupScheduleRequest{
		Parent:           dbName,
		BackupScheduleId: scheduleId,
		BackupSchedule: &databasepb.BackupSchedule{
			Spec: &databasepb.BackupScheduleSpec{
				ScheduleSpec: &databasepb.BackupScheduleSpec_CronSpec{
					CronSpec: &databasepb.CrontabSpec{
						Text: "30 12 * * *",
					},
				},
			},
			RetentionDuration: durationpb.New(24 * time.Hour),
			EncryptionConfig: &databasepb.CreateBackupEncryptionConfig{
				EncryptionType: databasepb.CreateBackupEncryptionConfig_USE_DATABASE_ENCRYPTION,
			},
			BackupTypeSpec: &databasepb.BackupSchedule_FullBackupSpec{},
		},
	}

	res, err := client.CreateBackupSchedule(ctx, &req)
	if err != nil {
		return err
	}

	fmt.Fprintf(w, "Created full backup schedule: %s", res)
	return nil
}

如需创建增量备份时间表，请参阅以下示例代码：


import (
	"context"
	"fmt"
	"io"
	"time"

	database "cloud.google.com/go/spanner/admin/database/apiv1"
	"cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
	"google.golang.org/protobuf/types/known/durationpb"
)

func createIncrementalBackupSchedule(w io.Writer, dbName string, scheduleId string) error {
	ctx := context.Background()

	client, err := database.NewDatabaseAdminClient(ctx)
	if err != nil {
		return err
	}
	defer client.Close()

	// Create a schedule to create incremental backups daily at 12:30 AM, using
	// Google-managed encryption, and retained for 24 hours.
	req := databasepb.CreateBackupScheduleRequest{
		Parent:           dbName,
		BackupScheduleId: scheduleId,
		BackupSchedule: &databasepb.BackupSchedule{
			Spec: &databasepb.BackupScheduleSpec{
				ScheduleSpec: &databasepb.BackupScheduleSpec_CronSpec{
					CronSpec: &databasepb.CrontabSpec{
						Text: "30 12 * * *",
					},
				},
			},
			RetentionDuration: durationpb.New(24 * time.Hour),
			EncryptionConfig: &databasepb.CreateBackupEncryptionConfig{
				EncryptionType: databasepb.CreateBackupEncryptionConfig_GOOGLE_DEFAULT_ENCRYPTION,
			},
			BackupTypeSpec: &databasepb.BackupSchedule_IncrementalBackupSpec{},
		},
	}

	res, err := client.CreateBackupSchedule(ctx, &req)
	if err != nil {
		return err
	}

	fmt.Fprintf(w, "Created incremental backup schedule: %s", res)
	return nil
}

Java

如需创建完整备份时间表，请参阅以下示例代码：


import com.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;
import com.google.protobuf.Duration;
import com.google.spanner.admin.database.v1.BackupSchedule;
import com.google.spanner.admin.database.v1.BackupScheduleSpec;
import com.google.spanner.admin.database.v1.CreateBackupEncryptionConfig;
import com.google.spanner.admin.database.v1.CreateBackupScheduleRequest;
import com.google.spanner.admin.database.v1.CrontabSpec;
import com.google.spanner.admin.database.v1.DatabaseName;
import com.google.spanner.admin.database.v1.FullBackupSpec;
import java.io.IOException;

class CreateFullBackupScheduleSample {

  static void createFullBackupSchedule() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    String backupScheduleId = "my-backup-schedule";
    createFullBackupSchedule(projectId, instanceId, databaseId, backupScheduleId);
  }

  static void createFullBackupSchedule(
      String projectId, String instanceId, String databaseId, String backupScheduleId)
      throws IOException {
    final CreateBackupEncryptionConfig encryptionConfig =
        CreateBackupEncryptionConfig.newBuilder()
            .setEncryptionType(CreateBackupEncryptionConfig.EncryptionType.USE_DATABASE_ENCRYPTION)
            .build();
    final BackupSchedule backupSchedule =
        BackupSchedule.newBuilder()
            .setFullBackupSpec(FullBackupSpec.newBuilder().build())
            .setRetentionDuration(Duration.newBuilder().setSeconds(3600 * 24).build())
            .setSpec(
                BackupScheduleSpec.newBuilder()
                    .setCronSpec(CrontabSpec.newBuilder().setText("30 12 * * *").build())
                    .build())
            .setEncryptionConfig(encryptionConfig)
            .build();

    try (DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.create()) {
      DatabaseName databaseName = DatabaseName.of(projectId, instanceId, databaseId);
      final BackupSchedule createdBackupSchedule =
          databaseAdminClient.createBackupSchedule(
              CreateBackupScheduleRequest.newBuilder()
                  .setParent(databaseName.toString())
                  .setBackupScheduleId(backupScheduleId)
                  .setBackupSchedule(backupSchedule)
                  .build());
      System.out.println(
          String.format(
              "Created backup schedule: %s\n%s",
              createdBackupSchedule.getName(), createdBackupSchedule.toString()));
    }
  }
}

如需创建增量备份时间表，请参阅以下示例代码：


import com.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;
import com.google.protobuf.Duration;
import com.google.spanner.admin.database.v1.BackupSchedule;
import com.google.spanner.admin.database.v1.BackupScheduleSpec;
import com.google.spanner.admin.database.v1.CreateBackupEncryptionConfig;
import com.google.spanner.admin.database.v1.CreateBackupScheduleRequest;
import com.google.spanner.admin.database.v1.CrontabSpec;
import com.google.spanner.admin.database.v1.DatabaseName;
import com.google.spanner.admin.database.v1.IncrementalBackupSpec;
import java.io.IOException;

class CreateIncrementalBackupScheduleSample {

  static void createIncrementalBackupSchedule() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    String backupScheduleId = "my-backup-schedule";
    createIncrementalBackupSchedule(projectId, instanceId, databaseId, backupScheduleId);
  }

  static void createIncrementalBackupSchedule(
      String projectId, String instanceId, String databaseId, String backupScheduleId)
      throws IOException {
    final CreateBackupEncryptionConfig encryptionConfig =
        CreateBackupEncryptionConfig.newBuilder()
            .setEncryptionType(
                CreateBackupEncryptionConfig.EncryptionType.GOOGLE_DEFAULT_ENCRYPTION)
            .build();
    final BackupSchedule backupSchedule =
        BackupSchedule.newBuilder()
            .setIncrementalBackupSpec(IncrementalBackupSpec.newBuilder().build())
            .setRetentionDuration(Duration.newBuilder().setSeconds(3600 * 24).build())
            .setSpec(
                BackupScheduleSpec.newBuilder()
                    .setCronSpec(CrontabSpec.newBuilder().setText("30 12 * * *").build())
                    .build())
            .setEncryptionConfig(encryptionConfig)
            .build();

    try (DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.create()) {
      DatabaseName databaseName = DatabaseName.of(projectId, instanceId, databaseId);
      final BackupSchedule createdBackupSchedule =
          databaseAdminClient.createBackupSchedule(
              CreateBackupScheduleRequest.newBuilder()
                  .setParent(databaseName.toString())
                  .setBackupScheduleId(backupScheduleId)
                  .setBackupSchedule(backupSchedule)
                  .build());
      System.out.println(
          String.format(
              "Created incremental backup schedule: %s\n%s",
              createdBackupSchedule.getName(), createdBackupSchedule.toString()));
    }
  }
}

Node.js

如需创建完整备份时间表，请参阅以下示例代码：

// Import the Google Cloud client library for Spanner.
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance-id';
// const databaseId = 'my-database-id';
// const scheduleId = 'my-schedule-id';

// Create a Spanner database admin client.
const spanner = new Spanner({projectId});
const client = spanner.getDatabaseAdminClient();

try {
  // Create a schedule to create full backups daily at 12:30 AM, using the
  // database's encryption config, and retained for 24 hours.
  const [response] = await client.createBackupSchedule({
    parent: client.databasePath(projectId, instanceId, databaseId),
    backupScheduleId: scheduleId,
    backupSchedule: {
      spec: {
        cronSpec: {
          text: '30 12 * * *',
        },
      },
      retentionDuration: {
        seconds: 86400,
      },
      encryptionConfig: {
        encryptionType: 'USE_DATABASE_ENCRYPTION',
      },
      fullBackupSpec: {},
    },
  });
  console.log('Created full backup schedule:', response);
} catch (err) {
  console.error('ERROR:', err);
}

如需创建增量备份时间表，请参阅以下示例代码：

// Import the Google Cloud client library for Spanner.
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance-id';
// const databaseId = 'my-database-id';
// const scheduleId = 'my-schedule-id';

// Create a Spanner database admin client.
const spanner = new Spanner({projectId});
const client = spanner.getDatabaseAdminClient();

try {
  // Create a schedule to create incremental backups daily at 12:30 AM,
  // using Google-managed encryption, and retained for 24 hours.
  const [response] = await client.createBackupSchedule({
    parent: client.databasePath(projectId, instanceId, databaseId),
    backupScheduleId: scheduleId,
    backupSchedule: {
      spec: {
        cronSpec: {
          text: '30 12 * * *',
        },
      },
      retentionDuration: {
        seconds: 86400,
      },
      encryptionConfig: {
        encryptionType: 'GOOGLE_DEFAULT_ENCRYPTION',
      },
      incrementalBackupSpec: {},
    },
  });
  console.log('Created incremental backup schedule:', response);
} catch (err) {
  console.error('ERROR:', err);
}

PHP

如需创建完整备份时间表，请参阅以下示例代码：

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;
use Google\Cloud\Spanner\Admin\Database\V1\CreateBackupScheduleRequest;
use Google\Cloud\Spanner\Admin\Database\V1\CreateBackupEncryptionConfig;
use Google\Cloud\Spanner\Admin\Database\V1\CreateBackupEncryptionConfig\EncryptionType;
use Google\Cloud\Spanner\Admin\Database\V1\BackupSchedule;
use Google\Cloud\Spanner\Admin\Database\V1\FullBackupSpec;
use Google\Cloud\Spanner\Admin\Database\V1\BackupScheduleSpec;
use Google\Cloud\Spanner\Admin\Database\V1\CrontabSpec;
use Google\Protobuf\Duration;

/**
 * Create a backup schedule.
 * Example:
 * ```
 * create_backup_schedule($projectId, $instanceId, $databaseId, $backupScheduleId);
 * ```
 *
 * @param string $projectId The Google Cloud project ID.
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 * @param string $backupScheduleId The ID of the backup schedule to be created.
 * at https://cloud.google.com/spanner/docs/reference/rest/v1/projects.instances.databases.backupSchedules#BackupSchedule.FIELDS
 */
function create_backup_schedule(
    string $projectId,
    string $instanceId,
    string $databaseId,
    string $backupScheduleId,
): void {
    $databaseAdminClient = new DatabaseAdminClient();
    $databaseFullName = DatabaseAdminClient::databaseName($projectId, $instanceId, $databaseId);
    printf('%s', $databaseFullName);

    $encryptionConfig = (new CreateBackupEncryptionConfig())
        ->setEncryptionType(EncryptionType::USE_DATABASE_ENCRYPTION);
    $backupSchedule = new BackupSchedule([
        'full_backup_spec' => new FullBackupSpec(),
        'retention_duration' => (new Duration())
            ->setSeconds(24 * 60 * 60),
        'spec' => new BackupScheduleSpec([
            'cron_spec' => new CrontabSpec([
                'text' => '30 12 * * *'
            ]),
        ]),
        'encryption_config' => $encryptionConfig,
    ]);
    $request = new CreateBackupScheduleRequest([
        'parent' => $databaseFullName,
        'backup_schedule_id' => $backupScheduleId,
        'backup_schedule' => $backupSchedule,
    ]);

    $created_backup_schedule = $databaseAdminClient->createBackupSchedule($request);

    printf('Created backup scehedule %s' . PHP_EOL, $created_backup_schedule->getName());
}

Python

如需创建完整备份时间表，请参阅以下示例代码：

def create_full_backup_schedule(
        instance_id: str,
        database_id: str,
        schedule_id: str,
) -> None:
    from datetime import timedelta
    from google.cloud import spanner
    from google.cloud.spanner_admin_database_v1.types import \
        backup_schedule as backup_schedule_pb
    from google.cloud.spanner_admin_database_v1.types import \
        CreateBackupEncryptionConfig, FullBackupSpec

    client = spanner.Client()
    database_admin_api = client.database_admin_api

    request = backup_schedule_pb.CreateBackupScheduleRequest(
        parent=database_admin_api.database_path(
            client.project,
            instance_id,
            database_id
        ),
        backup_schedule_id=schedule_id,
        backup_schedule=backup_schedule_pb.BackupSchedule(
            spec=backup_schedule_pb.BackupScheduleSpec(
                cron_spec=backup_schedule_pb.CrontabSpec(
                    text="30 12 * * *",
                ),
            ),
            retention_duration=timedelta(hours=24),
            encryption_config=CreateBackupEncryptionConfig(
                encryption_type=CreateBackupEncryptionConfig.EncryptionType.USE_DATABASE_ENCRYPTION,
            ),
            full_backup_spec=FullBackupSpec(),
        ),
    )

    response = database_admin_api.create_backup_schedule(request)
    print(f"Created full backup schedule: {response}")

如需创建增量备份时间表，请参阅以下示例代码：

def create_incremental_backup_schedule(
        instance_id: str,
        database_id: str,
        schedule_id: str,
) -> None:
    from datetime import timedelta
    from google.cloud import spanner
    from google.cloud.spanner_admin_database_v1.types import \
        backup_schedule as backup_schedule_pb
    from google.cloud.spanner_admin_database_v1.types import \
        CreateBackupEncryptionConfig, IncrementalBackupSpec

    client = spanner.Client()
    database_admin_api = client.database_admin_api

    request = backup_schedule_pb.CreateBackupScheduleRequest(
        parent=database_admin_api.database_path(
            client.project,
            instance_id,
            database_id
        ),
        backup_schedule_id=schedule_id,
        backup_schedule=backup_schedule_pb.BackupSchedule(
            spec=backup_schedule_pb.BackupScheduleSpec(
                cron_spec=backup_schedule_pb.CrontabSpec(
                    text="30 12 * * *",
                ),
            ),
            retention_duration=timedelta(hours=24),
            encryption_config=CreateBackupEncryptionConfig(
                encryption_type=CreateBackupEncryptionConfig.EncryptionType.GOOGLE_DEFAULT_ENCRYPTION,
            ),
            incremental_backup_spec=IncrementalBackupSpec(),
        ),
    )

    response = database_admin_api.create_backup_schedule(request)
    print(f"Created incremental backup schedule: {response}")

获取备份时间表

控制台

在 Google Cloud 控制台中，前往 Spanner 实例页面。

前往“Spanner 实例”页面
点击包含数据库的实例。
点击相应数据库。
在导航菜单中，点击备份/恢复。
点击时间表标签页可查看所有备份时间表及其信息。

gcloud

在使用下面的命令数据之前，请先进行以下替换：

PROJECT_ID：项目 ID。
INSTANCE_ID：实例 ID。
DATABASE_ID：数据库 ID。
SCHEDULE_ID：备份时间表 ID。

执行以下命令：

Linux、macOS 或 Cloud Shell

gcloud spanner backup-schedules describe SCHEDULE_ID \
  --project=PROJECT_ID \
  --instance=INSTANCE_ID \
  --database=DATABASE_ID

Windows (PowerShell)

gcloud spanner backup-schedules describe SCHEDULE_ID `
  --project=PROJECT_ID `
  --instance=INSTANCE_ID `
  --database=DATABASE_ID

Windows (cmd.exe)

gcloud spanner backup-schedules describe SCHEDULE_ID ^
  --project=PROJECT_ID ^
  --instance=INSTANCE_ID ^
  --database=DATABASE_ID

您应该会收到类似如下所示的响应：

{
  encryptionConfig:
    encryptionType: USE_DATABASE_ENCRYPTION
  incrementalBackupSpec: {}
  name: projects/my-project/instances/my-instance/databases/my-database/backupSchedules/my-schedule
  retentionDuration: 2592000s
  spec:
    cronSpec:
      creationWindow: 14400s
      text: 0 */4 * * *
      timeZone: UTC
  updateTime: '2024-09-13T10:24:18.754839Z'
}

REST v1

在使用任何请求数据之前，请先进行以下替换：

PROJECT_ID：项目 ID。
INSTANCE_ID：实例 ID。
DATABASE_ID：数据库 ID。
SCHEDULE_ID：备份时间表 ID。

HTTP 方法和网址：

GET https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID

如需发送您的请求，请展开以下选项之一：

curl（Linux、macOS 或 Cloud Shell）

执行以下命令：

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID"

PowerShell (Windows)

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

执行以下命令：

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID" | Select-Object -Expand Content

您应该收到类似以下内容的 JSON 响应：

{
  "name": "projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID",
  "retentionDuration": "100000s",
  "encryptionConfig": {
    "encryptionType": "USE_DATABASE_ENCRYPTION"
  },
  "spec": {
    "cronSpec": {
      "text": "0 2 * * *",
      "timeZone": "UTC",
      "creationWindow": "14400s"
    }
  },
  "fullBackupSpec": {},
  "updateTime": "2024-05-22T11:13:51.835590Z"
}

客户端库

C#

using Google.Cloud.Spanner.Admin.Database.V1;
using System;

public class GetBackupScheduleSample
{
    public BackupSchedule GetBackupSchedule(string projectId, string instanceId, string databaseId, string scheduleId)
    {
        DatabaseAdminClient client = DatabaseAdminClient.Create();

        BackupSchedule response = client.GetBackupSchedule(BackupScheduleName.FromProjectInstanceDatabaseSchedule(projectId, instanceId, databaseId, scheduleId));

        Console.WriteLine($"Backup schedule: {response}");
        return response;
    }
}

C++

void GetBackupSchedule(google::cloud::spanner_admin::DatabaseAdminClient client,
                       std::string const& project_id,
                       std::string const& instance_id,
                       std::string const& database_id,
                       std::string const& backup_schedule_id) {
  google::cloud::spanner::Database db(project_id, instance_id, database_id);
  std::string backup_schedule_name =
      db.FullName() + "/backupSchedules/" + backup_schedule_id;

  google::spanner::admin::database::v1::GetBackupScheduleRequest request;
  request.set_name(backup_schedule_name);

  auto backup_schedule = client.GetBackupSchedule(request);
  if (!backup_schedule) throw std::move(backup_schedule).status();
  std::cout << "Retrieved backup schedule:\n" << backup_schedule->DebugString();
}

Go


import (
	"context"
	"fmt"
	"io"

	database "cloud.google.com/go/spanner/admin/database/apiv1"
	"cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
)

func getBackupSchedule(w io.Writer, dbName string, scheduleId string) error {
	ctx := context.Background()

	client, err := database.NewDatabaseAdminClient(ctx)
	if err != nil {
		return err
	}
	defer client.Close()

	req := databasepb.GetBackupScheduleRequest{
		Name: fmt.Sprintf("%s/backupSchedules/%s", dbName, scheduleId),
	}

	res, err := client.GetBackupSchedule(ctx, &req)
	if err != nil {
		return err
	}

	fmt.Fprintf(w, "Backup schedule: %s", res)
	return nil
}

Java


import com.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;
import com.google.spanner.admin.database.v1.BackupSchedule;
import com.google.spanner.admin.database.v1.BackupScheduleName;
import com.google.spanner.admin.database.v1.GetBackupScheduleRequest;
import java.io.IOException;

class GetBackupScheduleSample {

  static void getBackupSchedule() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    String backupScheduleId = "my-backup-schedule";
    getBackupSchedule(projectId, instanceId, databaseId, backupScheduleId);
  }

  static void getBackupSchedule(
      String projectId, String instanceId, String databaseId, String backupScheduleId)
      throws IOException {
    try (DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.create()) {
      BackupScheduleName backupScheduleName =
          BackupScheduleName.of(projectId, instanceId, databaseId, backupScheduleId);
      final BackupSchedule backupSchedule =
          databaseAdminClient.getBackupSchedule(
              GetBackupScheduleRequest.newBuilder().setName(backupScheduleName.toString()).build());
      System.out.println(
          String.format(
              "Backup schedule: %s\n%s", backupSchedule.getName(), backupSchedule.toString()));
    }
  }
}

Node.js

// Import the Google Cloud client library for Spanner.
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance-id';
// const databaseId = 'my-database-id';
// const scheduleId = 'my-schedule-id';

// Create a Spanner database admin client.
const spanner = new Spanner({projectId});
const client = spanner.getDatabaseAdminClient();

try {
  // Get the backup schedule.
  const [response] = await client.getBackupSchedule({
    name: client.backupSchedulePath(
      projectId,
      instanceId,
      databaseId,
      scheduleId
    ),
  });
  console.log('Backup schedule:', response);
} catch (err) {
  console.error('ERROR:', err);
}

PHP

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;
use Google\Cloud\Spanner\Admin\Database\V1\GetBackupScheduleRequest;

/**
 * Get a backup schedule.
 * Example:
 * ```
 * get_backup_schedule($projectId, $instanceId, $databaseId, $backupScheduleId);
 * ```
 *
 * @param string $projectId The Google Cloud project ID.
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 * @param string $backupScheduleId The ID of the backup schedule to be created.
 * at https://cloud.google.com/spanner/docs/reference/rest/v1/projects.instances.databases.backupSchedules#BackupSchedule.FIELDS
 */
function get_backup_schedule(
    string $projectId,
    string $instanceId,
    string $databaseId,
    string $backupScheduleId,
): void {
    $databaseAdminClient = new DatabaseAdminClient();

    $backupScheduleName = sprintf(
        'projects/%s/instances/%s/databases/%s/backupSchedules/%s',
        $projectId,
        $instanceId,
        $databaseId,
        $backupScheduleId
    );
    $request = new GetBackupScheduleRequest([
        'name' => $backupScheduleName,
    ]);

    $backup_schedule = $databaseAdminClient->getBackupSchedule($request);

    printf('Fetched backup scehedule %s' . PHP_EOL, $backup_schedule->getName());
}

Python

def get_backup_schedule(
        instance_id: str,
        database_id: str,
        schedule_id: str,
) -> None:
    from google.cloud import spanner
    from google.cloud.spanner_admin_database_v1.types import \
        backup_schedule as backup_schedule_pb

    client = spanner.Client()
    database_admin_api = client.database_admin_api

    request = backup_schedule_pb.GetBackupScheduleRequest(
        name=database_admin_api.backup_schedule_path(
            client.project,
            instance_id,
            database_id,
            schedule_id,
        ),
    )

    response = database_admin_api.get_backup_schedule(request)
    print(f"Backup schedule: {response}")

列出备份时间表

控制台

在 Google Cloud 控制台中，前往 Spanner 实例页面。

前往“Spanner 实例”页面
点击包含数据库的实例。
点击相应数据库。
在导航菜单中，点击备份/恢复。
点击时间表标签页可查看所有备份时间表及其信息。

gcloud

在使用下面的命令数据之前，请先进行以下替换：

PROJECT_ID：项目 ID。
INSTANCE_ID：实例 ID。
DATABASE_ID：数据库 ID。

执行以下命令：

Linux、macOS 或 Cloud Shell

gcloud spanner backup-schedules list \
  --project=PROJECT_ID \
  --instance=INSTANCE_ID \
  --database=DATABASE_ID

Windows (PowerShell)

gcloud spanner backup-schedules list `
  --project=PROJECT_ID `
  --instance=INSTANCE_ID `
  --database=DATABASE_ID

Windows (cmd.exe)

gcloud spanner backup-schedules list ^
  --project=PROJECT_ID ^
  --instance=INSTANCE_ID ^
  --database=DATABASE_ID

您应该会收到类似如下所示的响应：


  
    Name
    Backup type
    Cron
    Retention duration
    Encryption type
  

    my-full-schedule
    FULL
    30 12 * * *
    2592000s
    USE_DATABASE_ENCRYPTION
  
  
    my-incr-schedule
    INCREMENTAL
    0 */4 * * *
    2592000s
    USE_DATABASE_ENCRYPTION

Name	Backup type	Cron	Retention duration	Encryption type
my-full-schedule	FULL	30 12 * * *	2592000s	USE_DATABASE_ENCRYPTION
my-incr-schedule	INCREMENTAL	0 /4 * *	2592000s	USE_DATABASE_ENCRYPTION

REST v1

在使用任何请求数据之前，请先进行以下替换：

PROJECT_ID：项目 ID。
INSTANCE_ID：实例 ID。
DATABASE_ID：数据库 ID。

HTTP 方法和网址：

GET https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules

如需发送您的请求，请展开以下选项之一：

curl（Linux、macOS 或 Cloud Shell）

执行以下命令：

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules"

PowerShell (Windows)

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

执行以下命令：

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules" | Select-Object -Expand Content

您应该收到类似以下内容的 JSON 响应：

{
  "backupSchedules": [
    {
      "name": "projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID",
      "retentionDuration": "172800s",
      "encryptionConfig": {
        "encryptionType": "USE_DATABASE_ENCRYPTION"
      },
      "spec": {
        "cronSpec": {
          "text": "0 */12 * * *",
          "timeZone": "UTC",
          "creationWindow": "14400s"
        }
      },
      "fullBackupSpec": {},
      "updateTime": "2024-09-09T07:21:43.946180Z"
    },
    {
      "name": "projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID",
      "retentionDuration": "2592000s",
      "encryptionConfig": {
        "encryptionType": "CUSTOMER_MANAGED_ENCRYPTION",
        "kmsKeyName": "projects/PROJECT_ID/locations/us-central1/keyRings/cmek-demo/cryptoKeys/test-key"
      },
      "spec": {
        "cronSpec": {
          "text": "30 12 * * *",
          "timeZone": "UTC",
          "creationWindow": "14400s"
        }
      },
      "fullBackupSpec": {},
      "updateTime": "2024-09-17T18:27:53.868741Z"
    }
  ]
}

客户端库

C#

using Google.Cloud.Spanner.Admin.Database.V1;
using Google.Cloud.Spanner.Common.V1;
using System;
using System.Collections.Generic;

public class ListBackupSchedulesSample
{
    public IEnumerable<BackupSchedule> ListBackupSchedules(string projectId, string instanceId, string databaseId)
    {
        DatabaseAdminClient client = DatabaseAdminClient.Create();

        var backupSchedules = client.ListBackupSchedules(
            new ListBackupSchedulesRequest
            {
                ParentAsDatabaseName = DatabaseName.FromProjectInstanceDatabase(projectId, instanceId, databaseId),
            });

        foreach (BackupSchedule backupSchedule in backupSchedules)
        {
            Console.WriteLine($"Backup schedule: {backupSchedule}");
        }
        return backupSchedules;
    }
}

C++

void ListBackupSchedules(
    google::cloud::spanner_admin::DatabaseAdminClient client,
    std::string const& project_id, std::string const& instance_id,
    std::string const& database_id) {
  google::cloud::spanner::Database db(project_id, instance_id, database_id);
  google::spanner::admin::database::v1::ListBackupSchedulesRequest request;
  request.set_parent(db.FullName());

  int count = 0;
  for (auto& backup_schedule : client.ListBackupSchedules(request)) {
    if (!backup_schedule) throw std::move(backup_schedule).status();

    std::cout << "Backup Schedule [" << ++count << "]:\n"
              << backup_schedule->DebugString();
  }
  if (count == 0) {
    std::cout << "No backup schedules found for database " << db.FullName();
  }
}

Go


import (
	"context"
	"fmt"
	"io"

	database "cloud.google.com/go/spanner/admin/database/apiv1"
	"cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
	"google.golang.org/api/iterator"
)

func listBackupSchedules(w io.Writer, dbName string) error {
	ctx := context.Background()

	client, err := database.NewDatabaseAdminClient(ctx)
	if err != nil {
		return err
	}
	defer client.Close()

	req := databasepb.ListBackupSchedulesRequest{
		Parent: dbName,
	}
	iter := client.ListBackupSchedules(ctx, &req)

	for {
		backupSchedule, err := iter.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "Backup schedule: %s\n", backupSchedule)
	}

	return nil
}

Java


import com.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;
import com.google.spanner.admin.database.v1.BackupSchedule;
import com.google.spanner.admin.database.v1.DatabaseName;
import java.io.IOException;

class ListBackupSchedulesSample {

  static void listBackupSchedules() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    listBackupSchedules(projectId, instanceId, databaseId);
  }

  static void listBackupSchedules(String projectId, String instanceId, String databaseId)
      throws IOException {
    try (DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.create()) {
      DatabaseName databaseName = DatabaseName.of(projectId, instanceId, databaseId);

      System.out.println(
          String.format("Backup schedules for database '%s'", databaseName.toString()));
      for (BackupSchedule backupSchedule :
          databaseAdminClient.listBackupSchedules(databaseName).iterateAll()) {
        System.out.println(
            String.format(
                "Backup schedule: %s\n%s", backupSchedule.getName(), backupSchedule.toString()));
      }
    }
  }
}

Node.js

// Import the Google Cloud client library for Spanner.
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance-id';
// const databaseId = 'my-database-id';

// Create a Spanner database admin client.
const spanner = new Spanner({projectId});
const client = spanner.getDatabaseAdminClient();

try {
  // List backup schedules of a database.
  const [schedules] = await client.listBackupSchedules({
    parent: client.databasePath(projectId, instanceId, databaseId),
  });
  schedules.forEach(schedule => {
    console.log('Backup schedule:', schedule);
  });
} catch (err) {
  console.error('ERROR:', err);
}

PHP

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;
use Google\Cloud\Spanner\Admin\Database\V1\ListBackupSchedulesRequest;

/**
 * Get list of all backup schedules for a given database.
 * Example:
 * ```
 * list_backup_schedules($projectId, $instanceId, $databaseId, $backupScheduleId);
 * ```
 *
 * @param string $projectId The Google Cloud project ID.
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 * at https://cloud.google.com/spanner/docs/reference/rest/v1/projects.instances.databases.backupSchedules#BackupSchedule.FIELDS
 */
function list_backup_schedules(
    string $projectId,
    string $instanceId,
    string $databaseId,
): void {
    $databaseAdminClient = new DatabaseAdminClient();
    $databaseFullName = DatabaseAdminClient::databaseName($projectId, $instanceId, $databaseId);

    $request = new ListBackupSchedulesRequest([
        'parent' => $databaseFullName,
    ]);
    $backup_schedules = $databaseAdminClient->listBackupSchedules($request);

    printf('Backup schedules for database %s' . PHP_EOL, $databaseFullName);
    foreach ($backup_schedules as $schedule) {
        printf('Backup schedule: %s' . PHP_EOL, $schedule->getName());
    }
}

Python

def list_backup_schedules(instance_id: str, database_id: str) -> None:
    from google.cloud import spanner
    from google.cloud.spanner_admin_database_v1.types import \
        backup_schedule as backup_schedule_pb

    client = spanner.Client()
    database_admin_api = client.database_admin_api

    request = backup_schedule_pb.ListBackupSchedulesRequest(
        parent=database_admin_api.database_path(
            client.project,
            instance_id,
            database_id,
        ),
    )

    for backup_schedule in database_admin_api.list_backup_schedules(request):
        print(f"Backup schedule: {backup_schedule}")

更新备份时间表

控制台

在 Google Cloud 控制台中，前往 Spanner 实例页面。

前往“Spanner 实例”页面
点击包含数据库的实例。
点击相应数据库。
在导航菜单中，点击备份/恢复。
点击时间安排标签页。
选择备份时间表对应的更多操作，然后点击更新。
您可以更新备份时间表的频率和保留时间。如果是完整备份时间表，您还可以更新加密类型。
点击保存。

gcloud

在使用下面的命令数据之前，请先进行以下替换：

SCHEDULE_ID：备份时间表 ID。
PROJECT_ID：项目 ID。
INSTANCE_ID：您要修改备份时间表的实例的 ID。
DATABASE_ID：您要修改备份时间表的数据库的 ID。
RETENTION_DURATION：按时间表创建的备份的保留时长。
CRONTAB_EXPRESSION：备份时间表频率的 Crontab 表达式。例如，如果您希望备份时间安排频率为每 12 小时一次，则可以使用 0 12 * * *。
ENCRYPTION_TYPE：由备份时间表创建的备份的加密类型。有效值为 USE_DATABASE_ENCRYPTION、GOOGLE_DEFAULT_ENCRYPTION 或 CUSTOMER_MANAGED_ENCRYPTION。如果您使用 CUSTOMER_MANAGED_ENCRYPTION，则必须指定 kmsKeyName。如果您的备份类型为 incremental-backup，则加密类型必须为 GOOGLE_DEFAULT_ENCRYPTION。

执行以下命令：

Linux、macOS 或 Cloud Shell

gcloud spanner backup-schedules update SCHEDULE_ID \
  --project=PROJECT_ID \
  --instance=INSTANCE_ID \
  --database=DATABASE_ID \
  --retention-duration=RETENTION_DURATION \
  --cron="CRONTAB_EXPRESSION" \
  --encryption-type=ENCRYPTION_TYPE

Windows (PowerShell)

gcloud spanner backup-schedules update SCHEDULE_ID `
  --project=PROJECT_ID `
  --instance=INSTANCE_ID `
  --database=DATABASE_ID `
  --retention-duration=RETENTION_DURATION `
  --cron="CRONTAB_EXPRESSION" `
  --encryption-type=ENCRYPTION_TYPE

Windows (cmd.exe)

gcloud spanner backup-schedules update SCHEDULE_ID ^
  --project=PROJECT_ID ^
  --instance=INSTANCE_ID ^
  --database=DATABASE_ID ^
  --retention-duration=RETENTION_DURATION ^
  --cron="CRONTAB_EXPRESSION" ^
  --encryption-type=ENCRYPTION_TYPE

REST v1

在使用任何请求数据之前，请先进行以下替换：

PROJECT_ID：项目 ID。
INSTANCE_ID：您要修改备份时间表的实例的 ID。
DATABASE_ID：您要修改备份时间表的数据库的 ID。
SCHEDULE_ID：备份时间表 ID。
RETENTION_DURATION：由时间表创建的备份的保留时长。例如，如果您希望保留时长为 1 天，请指定 86400s。
ENCRYPTION_TYPE：由备份时间表创建的备份的加密类型。可能的值为 USE_DATABASE_ENCRYPTION、GOOGLE_DEFAULT_ENCRYPTION 或 CUSTOMER_MANAGED_ENCRYPTION。如果您使用 CUSTOMER_MANAGED_ENCRYPTION，则必须指定 kmsKeyName。如果您的备份类型为 incremental-backup，则加密类型必须为 GOOGLE_DEFAULT_ENCRYPTION。

HTTP 方法和网址：

PATCH https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID?updateMask=retention_duration,encryption_config,spec.cron_spec.text

请求 JSON 正文：

{
  "retentionDuration": "RETENTION_DURATION",
  "spec": {
    "cronSpec": {
      "text": "0 2 * * *"
    }
    "encryptionConfig": {
      "encryptionType": "ENCRYPTION_TYPE"
    },
  },
}

如需发送您的请求，请展开以下选项之一：

curl（Linux、macOS 或 Cloud Shell）

将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID?updateMask=retention_duration,encryption_config,spec.cron_spec.text"

PowerShell (Windows)

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method PATCH `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID?updateMask=retention_duration,encryption_config,spec.cron_spec.text" | Select-Object -Expand Content

您应该收到类似以下内容的 JSON 响应：

  {
    "name": "projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID",
    "retentionDuration": "86400s",
    "encryptionConfig": {
      "encryptionType": "USE_DATABASE_ENCRYPTION"
    },
    "spec": {
      "cronSpec": {
        "text": "0 2 * * *",
        "timeZone": "UTC",
        "creationWindow": "14400s"
      }
    },
    "fullBackupSpec": {},
    "updateTime": "2024-05-22T11:13:51.835590Z"
  }

客户端库

C#

using Google.Cloud.Spanner.Admin.Database.V1;
using Google.Protobuf.WellKnownTypes;
using System;

public class UpdateBackupScheduleSample
{
    public BackupSchedule UpdateBackupSchedule(string projectId, string instanceId, string databaseId, string scheduleId)
    {
        DatabaseAdminClient client = DatabaseAdminClient.Create();

        BackupSchedule response = client.UpdateBackupSchedule(
            new UpdateBackupScheduleRequest
            {
                BackupSchedule = new BackupSchedule
                {
                    BackupScheduleName = BackupScheduleName.FromProjectInstanceDatabaseSchedule(projectId, instanceId, databaseId, scheduleId),
                    Spec = new BackupScheduleSpec
                    {
                        CronSpec = new CrontabSpec
                        {
                            Text = "45 15 * * *",
                        },
                    },
                    RetentionDuration = new Duration
                    {
                        Seconds = 172800,
                    },
                    EncryptionConfig = new CreateBackupEncryptionConfig
                    {
                        EncryptionType = CreateBackupEncryptionConfig.Types.EncryptionType.UseDatabaseEncryption,
                    },
                },
                UpdateMask = new FieldMask
                {
                    Paths = { "spec.cron_spec.text", "retention_duration", "encryption_config" },
                },
            });

        Console.WriteLine($"Updated backup schedule: {response}");
        return response;
    }
}

C++

void UpdateBackupSchedule(
    google::cloud::spanner_admin::DatabaseAdminClient client,
    std::string const& project_id, std::string const& instance_id,
    std::string const& database_id, std::string const& backup_schedule_id) {
  google::cloud::spanner::Database db(project_id, instance_id, database_id);
  std::string backup_schedule_name =
      db.FullName() + "/backupSchedules/" + backup_schedule_id;

  google::spanner::admin::database::v1::BackupSchedule backup_schedule;
  backup_schedule.set_name(backup_schedule_name);
  backup_schedule.mutable_spec()->mutable_cron_spec()->set_text("45 15 * * *");
  backup_schedule.mutable_retention_duration()->set_seconds(3600 * 48);

  google::spanner::admin::database::v1::CreateBackupEncryptionConfig
      encryption_config;
  encryption_config.set_encryption_type(
      google::spanner::admin::database::v1::CreateBackupEncryptionConfig::
          USE_DATABASE_ENCRYPTION);
  *backup_schedule.mutable_encryption_config() = std::move(encryption_config);

  google::protobuf::FieldMask update_mask;
  update_mask.add_paths("spec.cron_spec.text");
  update_mask.add_paths("retention_duration");
  update_mask.add_paths("encryption_config");

  google::spanner::admin::database::v1::UpdateBackupScheduleRequest request;
  *request.mutable_backup_schedule() = std::move(backup_schedule);
  *request.mutable_update_mask() = std::move(update_mask);

  auto updated_backup_schedule = client.UpdateBackupSchedule(request);
  if (!updated_backup_schedule) {
    throw std::move(updated_backup_schedule).status();
  }
  std::cout << "Backup schedule " << updated_backup_schedule->name()
            << " updated at "
            << *google::cloud::spanner::MakeTimestamp(
                   updated_backup_schedule->update_time());
}

Go


import (
	"context"
	"fmt"
	"io"
	"time"

	database "cloud.google.com/go/spanner/admin/database/apiv1"
	"cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
	"google.golang.org/protobuf/types/known/durationpb"
	"google.golang.org/protobuf/types/known/fieldmaskpb"
)

func updateBackupSchedule(w io.Writer, dbName string, scheduleId string) error {
	ctx := context.Background()

	client, err := database.NewDatabaseAdminClient(ctx)
	if err != nil {
		return err
	}
	defer client.Close()

	// Update a schedule to create backups daily at 3:45 PM, using the database's
	// encryption config, and retained for 48 hours.
	req := databasepb.UpdateBackupScheduleRequest{
		BackupSchedule: &databasepb.BackupSchedule{
			Name: fmt.Sprintf("%s/backupSchedules/%s", dbName, scheduleId),
			Spec: &databasepb.BackupScheduleSpec{
				ScheduleSpec: &databasepb.BackupScheduleSpec_CronSpec{
					CronSpec: &databasepb.CrontabSpec{
						Text: "45 15 * * *",
					},
				},
			},
			RetentionDuration: durationpb.New(48 * time.Hour),
			EncryptionConfig: &databasepb.CreateBackupEncryptionConfig{
				EncryptionType: databasepb.CreateBackupEncryptionConfig_USE_DATABASE_ENCRYPTION,
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{
			Paths: []string{
				"spec.cron_spec.text",
				"retention_duration",
				"encryption_config",
			},
		},
	}

	res, err := client.UpdateBackupSchedule(ctx, &req)
	if err != nil {
		return err
	}

	fmt.Fprintf(w, "Updated backup schedule: %s", res)
	return nil
}

Java


import com.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;
import com.google.protobuf.Duration;
import com.google.protobuf.FieldMask;
import com.google.spanner.admin.database.v1.BackupSchedule;
import com.google.spanner.admin.database.v1.BackupScheduleName;
import com.google.spanner.admin.database.v1.BackupScheduleSpec;
import com.google.spanner.admin.database.v1.CreateBackupEncryptionConfig;
import com.google.spanner.admin.database.v1.CrontabSpec;
import com.google.spanner.admin.database.v1.UpdateBackupScheduleRequest;
import java.io.IOException;

class UpdateBackupScheduleSample {

  static void updateBackupSchedule() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    String backupScheduleId = "my-backup-schedule";
    updateBackupSchedule(projectId, instanceId, databaseId, backupScheduleId);
  }

  static void updateBackupSchedule(
      String projectId, String instanceId, String databaseId, String backupScheduleId)
      throws IOException {
    BackupScheduleName backupScheduleName =
        BackupScheduleName.of(projectId, instanceId, databaseId, backupScheduleId);
    final CreateBackupEncryptionConfig encryptionConfig =
        CreateBackupEncryptionConfig.newBuilder()
            .setEncryptionType(CreateBackupEncryptionConfig.EncryptionType.USE_DATABASE_ENCRYPTION)
            .build();
    final BackupSchedule backupSchedule =
        BackupSchedule.newBuilder()
            .setName(backupScheduleName.toString())
            .setRetentionDuration(Duration.newBuilder().setSeconds(3600 * 48))
            .setSpec(
                BackupScheduleSpec.newBuilder()
                    .setCronSpec(CrontabSpec.newBuilder().setText("45 15 * * *").build())
                    .build())
            .setEncryptionConfig(encryptionConfig)
            .build();

    try (DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.create()) {
      final FieldMask fieldMask =
          FieldMask.newBuilder()
              .addPaths("retention_duration")
              .addPaths("spec.cron_spec.text")
              .addPaths("encryption_config")
              .build();
      final BackupSchedule updatedBackupSchedule =
          databaseAdminClient.updateBackupSchedule(
              UpdateBackupScheduleRequest.newBuilder()
                  .setBackupSchedule(backupSchedule)
                  .setUpdateMask(fieldMask)
                  .build());
      System.out.println(
          String.format(
              "Updated backup schedule: %s\n%s",
              updatedBackupSchedule.getName(), updatedBackupSchedule.toString()));
    }
  }
}

Node.js

// Import the Google Cloud client library for Spanner.
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance-id';
// const databaseId = 'my-database-id';
// const scheduleId = 'my-schedule-id';

// Create a Spanner database admin client.
const spanner = new Spanner({projectId});
const client = spanner.getDatabaseAdminClient();

try {
  // Update the schedule to create backups daily at 3:45 PM, using the
  // database's encryption config, and retained for 48 hours.
  const [response] = await client.updateBackupSchedule({
    backupSchedule: {
      name: client.backupSchedulePath(
        projectId,
        instanceId,
        databaseId,
        scheduleId
      ),
      spec: {
        cronSpec: {
          text: '45 15 * * *',
        },
      },
      retentionDuration: {
        seconds: 172800,
      },
      encryptionConfig: {
        encryptionType: 'USE_DATABASE_ENCRYPTION',
      },
    },
    updateMask: {
      paths: [
        'spec.cron_spec.text',
        'retention_duration',
        'encryption_config',
      ],
    },
  });
  console.log('Updated backup schedule:', response);
} catch (err) {
  console.error('ERROR:', err);
}

PHP

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;
use Google\Cloud\Spanner\Admin\Database\V1\UpdateBackupScheduleRequest;
use Google\Cloud\Spanner\Admin\Database\V1\CreateBackupEncryptionConfig;
use Google\Cloud\Spanner\Admin\Database\V1\CreateBackupEncryptionConfig\EncryptionType;
use Google\Cloud\Spanner\Admin\Database\V1\BackupSchedule;
use Google\Cloud\Spanner\Admin\Database\V1\FullBackupSpec;
use Google\Cloud\Spanner\Admin\Database\V1\BackupScheduleSpec;
use Google\Cloud\Spanner\Admin\Database\V1\CrontabSpec;
use Google\Protobuf\Duration;
use Google\Protobuf\FieldMask;

/**
 * Update an existing backup schedule.
 * Example:
 * ```
 * update_backup_schedule($projectId, $instanceId, $databaseId, $backupScheduleId);
 * ```
 *
 * @param string $projectId The Google Cloud project ID.
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 * @param string $backupScheduleId The ID of the backup schedule to be created.
 * at https://cloud.google.com/spanner/docs/reference/rest/v1/projects.instances.databases.backupSchedules#BackupSchedule.FIELDS
 */
function update_backup_schedule(
    string $projectId,
    string $instanceId,
    string $databaseId,
    string $backupScheduleId,
): void {
    $databaseAdminClient = new DatabaseAdminClient();

    $encryptionConfig = new CreateBackupEncryptionConfig([
        'encryption_type' => EncryptionType::USE_DATABASE_ENCRYPTION,
    ]);
    $backupScheduleName = sprintf(
        'projects/%s/instances/%s/databases/%s/backupSchedules/%s',
        $projectId,
        $instanceId,
        $databaseId,
        $backupScheduleId
    );
    $backupSchedule = new BackupSchedule([
        'name' => $backupScheduleName,
        'full_backup_spec' => new FullBackupSpec(),
        'retention_duration' => (new Duration())
            ->setSeconds(48 * 60 * 60),
        'spec' => new BackupScheduleSpec([
            'cron_spec' => new CrontabSpec([
                'text' => '45 15 * * *'
            ]),
        ]),
        'encryption_config' => $encryptionConfig,
    ]);
    $fieldMask = (new FieldMask())
        ->setPaths([
            'retention_duration',
            'spec.cron_spec.text',
            'encryption_config',
        ]);

    $request = new UpdateBackupScheduleRequest([
        'backup_schedule' => $backupSchedule,
        'update_mask' => $fieldMask,
    ]);

    $updated_backup_schedule = $databaseAdminClient->updateBackupSchedule($request);

    printf('Updated backup scehedule %s' . PHP_EOL, $updated_backup_schedule->getName());
}

Python

def update_backup_schedule(
        instance_id: str,
        database_id: str,
        schedule_id: str,
) -> None:
    from datetime import timedelta
    from google.cloud import spanner
    from google.cloud.spanner_admin_database_v1.types import \
        backup_schedule as backup_schedule_pb
    from google.cloud.spanner_admin_database_v1.types import \
        CreateBackupEncryptionConfig
    from google.protobuf.field_mask_pb2 import FieldMask

    client = spanner.Client()
    database_admin_api = client.database_admin_api

    request = backup_schedule_pb.UpdateBackupScheduleRequest(
        backup_schedule=backup_schedule_pb.BackupSchedule(
            name=database_admin_api.backup_schedule_path(
                client.project,
                instance_id,
                database_id,
                schedule_id,
            ),
            spec=backup_schedule_pb.BackupScheduleSpec(
                cron_spec=backup_schedule_pb.CrontabSpec(
                    text="45 15 * * *",
                ),
            ),
            retention_duration=timedelta(hours=48),
            encryption_config=CreateBackupEncryptionConfig(
                encryption_type=CreateBackupEncryptionConfig.EncryptionType.USE_DATABASE_ENCRYPTION,
            ),
        ),
        update_mask=FieldMask(
            paths=[
                "spec.cron_spec.text",
                "retention_duration",
                "encryption_config",
            ],
        ),
    )

    response = database_admin_api.update_backup_schedule(request)
    print(f"Updated backup schedule: {response}")

删除备份时间表

控制台

在 Google Cloud 控制台中，前往 Spanner 实例页面。

前往“Spanner 实例”页面
点击包含数据库的实例。
点击相应数据库。
在导航菜单中，点击备份/恢复。
针对备份时间表选择更多操作，然后点击删除。
输入备份时间表名称。
点击确认。

gcloud

在使用下面的命令数据之前，请先进行以下替换：

SCHEDULE_ID：备份时间表 ID。
PROJECT_ID：项目 ID。
INSTANCE_ID：您要删除备份时间表的实例的 ID。
DATABASE_ID：您要删除备份时间表所在的数据库的 ID。

执行以下命令：

Linux、macOS 或 Cloud Shell

gcloud spanner backup-schedules delete SCHEDULE_ID \
  --project=PROJECT_ID \
  --instance=INSTANCE_ID \
  --database=DATABASE_ID

Windows (PowerShell)

gcloud spanner backup-schedules delete SCHEDULE_ID `
  --project=PROJECT_ID `
  --instance=INSTANCE_ID `
  --database=DATABASE_ID

Windows (cmd.exe)

gcloud spanner backup-schedules delete SCHEDULE_ID ^
  --project=PROJECT_ID ^
  --instance=INSTANCE_ID ^
  --database=DATABASE_ID

REST v1

在使用任何请求数据之前，请先进行以下替换：

PROJECT_ID：项目 ID。
INSTANCE_ID：您要删除备份时间表的实例的 ID。
DATABASE_ID：您要删除备份时间表所在的数据库的 ID。
SCHEDULE_ID：备份时间表 ID。

HTTP 方法和网址：

DELETE https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID

如需发送您的请求，请展开以下选项之一：

curl（Linux、macOS 或 Cloud Shell）

执行以下命令：

curl -X DELETE \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID"

PowerShell (Windows)

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

执行以下命令：

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method DELETE `
    -Headers $headers `
    -Uri "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID" | Select-Object -Expand Content

您应该会收到一个成功的状态代码 (2xx) 和一个空响应。

客户端库

C#

using Google.Cloud.Spanner.Admin.Database.V1;
using System;

public class DeleteBackupScheduleSample
{
    public void DeleteBackupSchedule(string projectId, string instanceId, string databaseId, string scheduleId)
    {
        DatabaseAdminClient client = DatabaseAdminClient.Create();

        client.DeleteBackupSchedule(BackupScheduleName.FromProjectInstanceDatabaseSchedule(projectId, instanceId, databaseId, scheduleId));

        Console.WriteLine("Deleted backup schedule");
    }
}

C++

void DeleteBackupSchedule(
    google::cloud::spanner_admin::DatabaseAdminClient client,
    std::string const& project_id, std::string const& instance_id,
    std::string const& database_id, std::string const& backup_schedule_id) {
  google::cloud::spanner::Database db(project_id, instance_id, database_id);
  std::string backup_schedule_name =
      db.FullName() + "/backupSchedules/" + backup_schedule_id;

  google::spanner::admin::database::v1::DeleteBackupScheduleRequest request;
  request.set_name(backup_schedule_name);

  auto status = client.DeleteBackupSchedule(request);
  if (!status.ok()) throw std::move(status);
  std::cout << "Backup schedule " << backup_schedule_name << " deleted";
}

Go


import (
	"context"
	"fmt"
	"io"

	database "cloud.google.com/go/spanner/admin/database/apiv1"
	"cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
)

func deleteBackupSchedule(w io.Writer, dbName string, scheduleId string) error {
	ctx := context.Background()

	client, err := database.NewDatabaseAdminClient(ctx)
	if err != nil {
		return err
	}
	defer client.Close()

	req := databasepb.DeleteBackupScheduleRequest{
		Name: fmt.Sprintf("%s/backupSchedules/%s", dbName, scheduleId),
	}

	err = client.DeleteBackupSchedule(ctx, &req)
	if err != nil {
		return err
	}

	fmt.Fprintf(w, "Deleted backup schedule")
	return nil
}

Java


import com.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;
import com.google.spanner.admin.database.v1.BackupScheduleName;
import com.google.spanner.admin.database.v1.DeleteBackupScheduleRequest;
import java.io.IOException;

class DeleteBackupScheduleSample {

  static void deleteBackupSchedule() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    String backupScheduleId = "my-backup-schedule";
    deleteBackupSchedule(projectId, instanceId, databaseId, backupScheduleId);
  }

  static void deleteBackupSchedule(
      String projectId, String instanceId, String databaseId, String backupScheduleId)
      throws IOException {
    try (DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.create()) {
      BackupScheduleName backupScheduleName =
          BackupScheduleName.of(projectId, instanceId, databaseId, backupScheduleId);
      databaseAdminClient.deleteBackupSchedule(
          DeleteBackupScheduleRequest.newBuilder().setName(backupScheduleName.toString()).build());
      System.out.println(
          String.format("Deleted backup schedule: %s", backupScheduleName.toString()));
    }
  }
}

Node.js

// Import the Google Cloud client library for Spanner.
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance-id';
// const databaseId = 'my-database-id';
// const scheduleId = 'my-schedule-id';

// Create a Spanner database admin client.
const spanner = new Spanner({projectId});
const client = spanner.getDatabaseAdminClient();

try {
  // Delete the backup schedule.
  await client.deleteBackupSchedule({
    name: client.backupSchedulePath(
      projectId,
      instanceId,
      databaseId,
      scheduleId
    ),
  });
  console.log('Deleted backup schedule');
} catch (err) {
  console.error('ERROR:', err);
}

PHP

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;
use Google\Cloud\Spanner\Admin\Database\V1\DeleteBackupScheduleRequest;

/**
 * Delete a backup schedule.
 * Example:
 * ```
 * delete_backup_schedule($projectId, $instanceId, $databaseId, $backupScheduleId);
 * ```
 *
 * @param string $projectId The Google Cloud project ID.
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 * @param string $backupScheduleId The ID of the backup schedule to be created.
 * at https://cloud.google.com/spanner/docs/reference/rest/v1/projects.instances.databases.backupSchedules#BackupSchedule.FIELDS
 */
function delete_backup_schedule(
    string $projectId,
    string $instanceId,
    string $databaseId,
    string $backupScheduleId,
): void {
    $databaseAdminClient = new DatabaseAdminClient();

    $backupScheduleName = sprintf(
        'projects/%s/instances/%s/databases/%s/backupSchedules/%s',
        $projectId,
        $instanceId,
        $databaseId,
        $backupScheduleId
    );
    $request = new DeleteBackupScheduleRequest([
        'name' => strval($backupScheduleName),
    ]);

    $databaseAdminClient->deleteBackupSchedule($request);
    printf('Deleted backup scehedule %s' . PHP_EOL, $backupScheduleName);
}

Python

def delete_backup_schedule(
        instance_id: str,
        database_id: str,
        schedule_id: str,
) -> None:
    from google.cloud import spanner
    from google.cloud.spanner_admin_database_v1.types import \
        backup_schedule as backup_schedule_pb

    client = spanner.Client()
    database_admin_api = client.database_admin_api

    request = backup_schedule_pb.DeleteBackupScheduleRequest(
        name=database_admin_api.backup_schedule_path(
            client.project,
            instance_id,
            database_id,
            schedule_id,
        ),
    )

    database_admin_api.delete_backup_schedule(request)
    print("Deleted backup schedule")

设置 IAM 访问权限控制政策

您可以设置 IAM 访问权限政策，以指定哪些用户有权访问备份时间表。

gcloud

在使用下面的命令数据之前，请先进行以下替换：

SCHEDULE_ID：备份时间表 ID。
PROJECT_ID：项目 ID。
INSTANCE_ID：实例 ID。
DATABASE_ID：数据库 ID。

执行以下命令：

Linux、macOS 或 Cloud Shell

gcloud spanner backup-schedules set-iam-policy SCHEDULE_ID \
  --project=PROJECT_ID \
  --instance=INSTANCE_ID \
  --database=DATABASE_ID \
  policy.json

Windows (PowerShell)

gcloud spanner backup-schedules set-iam-policy SCHEDULE_ID `
  --project=PROJECT_ID `
  --instance=INSTANCE_ID `
  --database=DATABASE_ID `
  policy.json

Windows (cmd.exe)

gcloud spanner backup-schedules set-iam-policy SCHEDULE_ID ^
  --project=PROJECT_ID ^
  --instance=INSTANCE_ID ^
  --database=DATABASE_ID ^
  policy.json

您应该会收到类似如下所示的响应：

Updated IAM policy for backupSchedule [SCHEDULE_ID].
bindings:
- members:
  - user:test@google.com
  role: roles/editor
etag: BwYi82k-fho=
version: 1

以下是您可以与以下 gcloud CLI 命令搭配使用的示例 policy.json 文件：

{
"version": 1,
"etag": "BwYi8ypICC0=",
"bindings": [
  {
    "role": "roles/editor",
    "members": [
      "user:test@gmail.com"
    ]
  }
]
}

REST v1

在使用任何请求数据之前，请先进行以下替换：

PROJECT_ID：项目 ID。
INSTANCE_ID：实例 ID。
DATABASE_ID：数据库 ID。
SCHEDULE_ID：备份时间表 ID。

HTTP 方法和网址：

POST https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID:setIamPolicy?alt=json

请求 JSON 正文：

{
  "policy": {
    "version": 1,
    "etag": "BwYi8ypICC0=",
    "bindings": [
      {
        "role": "roles/editor",
        "members": [
          "user:test@gmail.com"
        ]
      }
    ]
  }
}

如需发送您的请求，请展开以下选项之一：

curl（Linux、macOS 或 Cloud Shell）

将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID:setIamPolicy?alt=json"

PowerShell (Windows)

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID:setIamPolicy?alt=json" | Select-Object -Expand Content

您应该收到类似以下内容的 JSON 响应：

{
  {
    "version": 1,
    "etag": "etag",
    "bindings": [
      {
        "role": "roles/non-primitive",
        "members": [
          "user:test@gmail.com"
        ]
      }
    ]
  }
}

获取 IAM 访问权限控制政策

gcloud

在使用下面的命令数据之前，请先进行以下替换：

SCHEDULE_ID：备份时间表 ID。
PROJECT_ID：项目 ID。
INSTANCE_ID：实例 ID。
DATABASE_ID：数据库 ID。

执行以下命令：

Linux、macOS 或 Cloud Shell

gcloud spanner backup-schedules get-iam-policy SCHEDULE_ID \
  --project=PROJECT_ID \
  --instance=INSTANCE_ID \
  --database=DATABASE_ID

Windows (PowerShell)

gcloud spanner backup-schedules get-iam-policy SCHEDULE_ID `
  --project=PROJECT_ID `
  --instance=INSTANCE_ID `
  --database=DATABASE_ID

Windows (cmd.exe)

gcloud spanner backup-schedules get-iam-policy SCHEDULE_ID ^
  --project=PROJECT_ID ^
  --instance=INSTANCE_ID ^
  --database=DATABASE_ID

您应该会收到类似如下所示的响应：

bindings:
- members:
  - user:test@gmail.com
  role: roles/editor
etag: BwYi82k-fho=
version: 1

REST v1

在使用任何请求数据之前，请先进行以下替换：

INSTANCE_ID：实例 ID。
DATABASE_ID：数据库 ID。
SCHEDULE_ID：备份时间表 ID。
PROJECT_ID：项目 ID。

HTTP 方法和网址：

POST https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID:getIamPolicy?alt=json

如需发送您的请求，请展开以下选项之一：

curl（Linux、macOS 或 Cloud Shell）

执行以下命令：

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d "" \
     "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID:getIamPolicy?alt=json"

PowerShell (Windows)

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

执行以下命令：

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -Uri "https://spanner.googleapis.com/v1/projects/PROJECT_ID/instances/INSTANCE_ID/databases/DATABASE_ID/backupSchedules/SCHEDULE_ID:getIamPolicy?alt=json" | Select-Object -Expand Content

您应该收到类似以下内容的 JSON 响应：

{
  {
    "version": 1,
    "etag": "BwYbyZ9pc4o=",
    "bindings": [
      {
        "role": "roles/editor",
        "members": [
          "user:test@gmail.com"
        ]
      }
    ]
  }
}

后续步骤

备份概览