Sicherungszeitpläne erstellen und verwalten

Diese Seite beschreibt die Sicherungsplanungsfunktionen von Spanner und erklärt, wie Sie einen Sicherungsplan für Ihre Datenbank einrichten.

Hinweis

  • Um die Berechtigungen zu erhalten, die Sie zum Erstellen und Verwalten von Sicherungszeitplänen benötigen, bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für die Instanz zuzuweisen:

Sicherungszeitplan erstellen

Console

  1. Rufen Sie in der Google Cloud Console die Seite Instanzen für Spanner auf.

Zur Seite „Spanner-Instanzen“

  1. Klicken Sie auf die Instanz, die die Datenbank enthält.

  2. Klicken Sie auf die Datenbank.

  3. Klicken Sie im Navigationsmenü auf Backup/Restore.

  4. Klicken Sie auf Sicherungsplan erstellen.

  5. Füllen Sie das Formular aus und klicken Sie dann auf Erstellen.

gcloud

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • SCHEDULE_ID: die ID des Sicherungszeitplans.
  • PROJECT_ID: Projekt-ID.
  • INSTANCE_ID: die ID der Instanz, für die Sie den Sicherungszeitplan erstellen möchten.
  • DATABASE_ID: die ID der Datenbank, für die Sie den Sicherungsplan erstellen möchten.
  • RETENTION_DURATION: die Aufbewahrungsdauer der gemäß dem Zeitplan erstellten Backups. Wenn Sie beispielsweise eine Aufbewahrungsdauer von einem Tag wünschen, können Sie 86400s verwenden.
  • CRONTAB_EXPRESSION: der Crontab-Ausdruck für die Häufigkeit des Backup-Zeitplans. Wenn Sie beispielsweise möchten, dass die Datensicherung alle 12 Stunden erfolgt, können Sie 0 12 * * * verwenden.
  • BACKUP_TYPE: ob es sich um einen vollständigen oder einen inkrementellen Sicherungsplan handelt. Mögliche Werte sind full-backup oder incremental-backup.
  • ENCRYPTION_TYPE: der Verschlüsselungstyp der durch den Sicherungsplan erstellten Backups. Gültige Werte sind USE_DATABASE_ENCRYPTION, GOOGLE_DEFAULT_ENCRYPTION oder CUSTOMER_MANAGED_ENCRYPTION. Wenn Sie CUSTOMER_MANAGED_ENCRYPTION verwenden, müssen Sie kmsKeyName oder kmsKeyNames angeben.

Führen Sie folgenden Befehl aus:

Linux, macOS oder 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 Version 1

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Projekt-ID.
  • INSTANCE_ID: die ID der Instanz, für die Sie den Sicherungszeitplan erstellen möchten.
  • DATABASE_ID: die ID der Datenbank, für die Sie den Sicherungsplan erstellen möchten.
  • SCHEDULE_ID: die ID des Sicherungszeitplans.
  • BACKUP_TYPE: Gibt an, ob es sich um einen Zeitplan für Vollsicherungen oder für inkrementelle Sicherungen handelt. Mögliche Werte sind fullBackupSpec oder incrementalBackupSpec.
  • ENCRYPTION_TYPE: Der Verschlüsselungstyp von Sicherungen, die vom Sicherungszeitplan erstellt werden. Mögliche Werte sind USE_DATABASE_ENCRYPTION, GOOGLE_DEFAULT_ENCRYPTION oder CUSTOMER_MANAGED_ENCRYPTION. Wenn Sie CUSTOMER_MANAGED_ENCRYPTION verwenden, müssen Sie kmsKeyName oder kmsKeyNames angeben.
  • RETENTION_DURATION: die Aufbewahrungsdauer der gemäß dem Zeitplan erstellten Backups.

HTTP-Methode und URL: 

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

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "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"
}

Clientbibliotheken

C#

Sehen Sie sich den folgenden Beispielcode an, um einen Zeitplan für die vollständige Sicherung zu erstellen: 

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;
    }
}
Um einen inkrementellen Sicherungsplan zu erstellen, beachten Sie bitte den folgenden Beispielcode: 
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++

Um einen vollständigen Sicherungsplan zu erstellen, beachten Sie bitte den folgenden Beispielcode: 

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());
}
Sehen Sie sich den folgenden Beispielcode an, um einen Zeitplan für inkrementelle Sicherungen zu erstellen: 
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

Um einen vollständigen Sicherungsplan zu erstellen, beachten Sie bitte den folgenden Beispielcode: 


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
}
Um einen inkrementellen Sicherungsplan zu erstellen, beachten Sie bitte den folgenden Beispielcode: 

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

Um einen vollständigen Sicherungsplan zu erstellen, beachten Sie bitte den folgenden Beispielcode: 


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()));
    }
  }
}
Sehen Sie sich den folgenden Beispielcode an, um einen Zeitplan für inkrementelle Sicherungen zu erstellen: 

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

Sehen Sie sich den folgenden Beispielcode an, um einen Zeitplan für die vollständige Sicherung zu erstellen: 

// 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);
}
Sehen Sie sich den folgenden Beispielcode an, um einen Zeitplan für inkrementelle Sicherungen zu erstellen: 
// 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

Sehen Sie sich den folgenden Beispielcode an, um einen Zeitplan für die vollständige Sicherung zu erstellen: 

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

Um einen vollständigen Sicherungsplan zu erstellen, beachten Sie bitte den folgenden Beispielcode: 

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}")
Um einen inkrementellen Sicherungsplan zu erstellen, beachten Sie bitte den folgenden Beispielcode: 
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}")

Sicherungszeitplan abrufen

Console

  1. Rufen Sie in der Google Cloud Console die Seite Instanzen für Spanner auf.

Zur Seite „Spanner-Instanzen“

  1. Klicken Sie auf die Instanz, die die Datenbank enthält.

  2. Klicken Sie auf die Datenbank.

  3. Klicken Sie im Navigationsmenü auf Sicherung/Wiederherstellung.

  4. Klicken Sie auf den Tab Zeitpläne, um alle Sicherungszeitpläne und die zugehörigen Informationen aufzurufen.

gcloud

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • PROJECT_ID: Projekt-ID.
  • INSTANCE_ID: Instanz-ID.
  • DATABASE_ID: die Datenbank-ID.
  • SCHEDULE_ID: die ID des Sicherungszeitplans.

Führen Sie folgenden Befehl aus:

Linux, macOS oder 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

Sie sollten eine Antwort ähnlich der folgenden erhalten:

{
  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 Version 1

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Projekt-ID.
  • INSTANCE_ID: Instanz-ID.
  • DATABASE_ID: die Datenbank-ID.
  • SCHEDULE_ID: die ID des Sicherungszeitplans.

HTTP-Methode und URL: 

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "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"
}

Clientbibliotheken

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

Sicherungszeitpläne auflisten

Console

  1. Rufen Sie in der Google Cloud Console die Seite Instanzen für Spanner auf.

Zur Seite „Spanner-Instanzen“

  1. Klicken Sie auf die Instanz, die die Datenbank enthält.

  2. Klicken Sie auf die Datenbank.

  3. Klicken Sie im Navigationsmenü auf Sicherung/Wiederherstellung.

  4. Klicken Sie auf den Tab Zeitpläne, um alle Sicherungszeitpläne und die zugehörigen Informationen aufzurufen.

gcloud

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • PROJECT_ID: Projekt-ID.
  • INSTANCE_ID: Instanz-ID.
  • DATABASE_ID: die Datenbank-ID.

Führen Sie folgenden Befehl aus:

Linux, macOS oder 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

Sie sollten eine Antwort ähnlich der folgenden erhalten:


  

    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 Version 1

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Projekt-ID.
  • INSTANCE_ID: Instanz-ID.
  • DATABASE_ID: die Datenbank-ID.

HTTP-Methode und URL: 

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "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"
    }
  ]
}

Clientbibliotheken

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

Sicherungszeitplan aktualisieren

Console

  1. Rufen Sie in der Google Cloud Console die Seite Instanzen für Spanner auf.

Zur Seite „Spanner-Instanzen“

  1. Klicken Sie auf die Instanz, die die Datenbank enthält.

  2. Klicken Sie auf die Datenbank.

  3. Klicken Sie im Navigationsmenü auf Sicherung/Wiederherstellung.

  4. Klicken Sie auf den Tab Zeitpläne.

  5. Wählen Sie Weitere Aktionen für Ihren Sicherungsplan und klicken Sie auf Aktualisieren.

  6. Sie können die Häufigkeit und die Aufbewahrungsdauer des Sicherungszeitplans aktualisieren. Wenn es sich um einen Zeitplan für vollständige Sicherungen handelt, können Sie auch den Verschlüsselungstyp aktualisieren.

  7. Klicken Sie auf Speichern.

gcloud

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • SCHEDULE_ID: die ID des Sicherungszeitplans.
  • PROJECT_ID: Projekt-ID.
  • INSTANCE_ID: die ID der Instanz, für die Sie den Sicherungszeitplan ändern möchten.
  • DATABASE_ID: Die ID der Datenbank, für die Sie den Sicherungszeitplan ändern möchten.
  • RETENTION_DURATION: die Aufbewahrungsdauer der gemäß dem Zeitplan erstellten Backups.
  • CRONTAB_EXPRESSION: der Crontab-Ausdruck für die Häufigkeit des Backup-Zeitplans. Wenn Sie beispielsweise möchten, dass die Datensicherung alle 12 Stunden erfolgt, können Sie 0 12 * * * verwenden.
  • ENCRYPTION_TYPE: der Verschlüsselungstyp der durch den Sicherungsplan erstellten Backups. Gültige Werte sind USE_DATABASE_ENCRYPTION, GOOGLE_DEFAULT_ENCRYPTION oder CUSTOMER_MANAGED_ENCRYPTION. Wenn Sie CUSTOMER_MANAGED_ENCRYPTION verwenden, müssen Sie kmsKeyName oder kmsKeyNames angeben.

Führen Sie folgenden Befehl aus:

Linux, macOS oder 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 Version 1

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Projekt-ID.
  • INSTANCE_ID: die ID der Instanz, für die Sie den Sicherungszeitplan ändern möchten.
  • DATABASE_ID: die ID der Datenbank, für die Sie den Sicherungsplan ändern möchten.
  • SCHEDULE_ID: die ID des Sicherungszeitplans.
  • RETENTION_DURATION: Die Aufbewahrungsdauer der Sicherungen, die durch den Zeitplan erstellt werden. Wenn Sie beispielsweise eine Aufbewahrungsdauer von einem Tag wünschen, geben Sie 86400s an.
  • ENCRYPTION_TYPE: der Verschlüsselungstyp der durch den Sicherungsplan erstellten Backups. Mögliche Werte sind USE_DATABASE_ENCRYPTION, GOOGLE_DEFAULT_ENCRYPTION oder CUSTOMER_MANAGED_ENCRYPTION. Wenn Sie CUSTOMER_MANAGED_ENCRYPTION verwenden, müssen Sie kmsKeyName oder kmsKeyNames angeben.

HTTP-Methode und URL: 

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-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

  {
    "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"
  }

Clientbibliotheken

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

Sicherungszeitplan löschen

Console

  1. Rufen Sie in der Google Cloud Console die Seite Instanzen für Spanner auf.

Zur Seite „Spanner-Instanzen“

  1. Klicken Sie auf die Instanz, die die Datenbank enthält.

  2. Klicken Sie auf die Datenbank.

  3. Klicken Sie im Navigationsmenü auf Sicherung/Wiederherstellung.

  4. Wählen Sie für Ihren Sicherungszeitplan Weitere Aktionen und dann Löschen aus.

  5. Geben Sie den Namen des Sicherungszeitplans ein.

  6. Klicken Sie auf Bestätigen.

gcloud

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • SCHEDULE_ID: die ID des Sicherungszeitplans.
  • PROJECT_ID: Projekt-ID.
  • INSTANCE_ID: die ID der Instanz, für die Sie den Sicherungsplan löschen möchten.
  • DATABASE_ID: Die ID der Datenbank, in der Sie den Sicherungszeitplan löschen möchten.

Führen Sie folgenden Befehl aus:

Linux, macOS oder 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 Version 1

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Projekt-ID.
  • INSTANCE_ID: die ID der Instanz, für die Sie den Sicherungsplan löschen möchten.
  • DATABASE_ID: Die ID der Datenbank, in der Sie den Sicherungszeitplan löschen möchten.
  • SCHEDULE_ID: die Backup-Zeitplan-ID.

HTTP-Methode und URL: 

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten einen erfolgreichen Statuscode (2xx) und eine leere Antwort als Ausgabe erhalten.

Clientbibliotheken

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-Zugriffssteuerungsrichtlinie festlegen

Sie können eine Zugriffsrichtlinie für Identity and Access Management (IAM) festlegen, um zu bestimmen, wer Zugriff auf den Sicherungsplan hat.

gcloud

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • SCHEDULE_ID: die ID des Sicherungszeitplans.
  • PROJECT_ID: Projekt-ID.
  • INSTANCE_ID: Instanz-ID.
  • DATABASE_ID: die Datenbank-ID.

Führen Sie folgenden Befehl aus:

Linux, macOS oder 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

Sie sollten eine Antwort ähnlich der folgenden erhalten:

Updated IAM policy for backupSchedule [SCHEDULE_ID].
bindings:
- members:
  - user:test@google.com
  role: roles/editor
etag: BwYi82k-fho=
version: 1
Nachfolgend finden Sie eine Beispieldatei policy.json, die Sie zusammen mit diesem Google Cloud CLI-Befehl verwenden können: 
{
"version": 1,
"etag": "BwYi8ypICC0=",
"bindings": [
  {
    "role": "roles/editor",
    "members": [
      "user:test@gmail.com"
    ]
  }
]
}

REST Version 1

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Projekt-ID.
  • INSTANCE_ID: Instanz-ID.
  • DATABASE_ID: die Datenbank-ID.
  • SCHEDULE_ID: die ID des Sicherungszeitplans.

HTTP-Methode und URL: 

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

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

IAM-Zugriffssteuerungsrichtlinie abrufen

gcloud

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • SCHEDULE_ID: die ID des Sicherungszeitplans.
  • PROJECT_ID: Projekt-ID.
  • INSTANCE_ID: Instanz-ID.
  • DATABASE_ID: die Datenbank-ID.

Führen Sie folgenden Befehl aus:

Linux, macOS oder 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

Sie sollten eine Antwort ähnlich der folgenden erhalten:

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

REST Version 1

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • INSTANCE_ID: Instanz-ID.
  • DATABASE_ID: die Datenbank-ID.
  • SCHEDULE_ID: die Backup-Zeitplan-ID.
  • PROJECT_ID: Projekt-ID.

HTTP-Methode und URL: 

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Nächste Schritte