Cette page a été traduite par l'API Cloud Translation.

Créer et gérer des planifications de sauvegarde

Cette page décrit les opérations de planification de sauvegarde Spanner et explique comment configurer un calendrier de sauvegarde pour votre base de données.

Avant de commencer

Pour obtenir les autorisations nécessaires pour créer et gérer des planifications de sauvegarde, demandez à votre administrateur de vous accorder le les rôles IAM suivants sur l'instance:
- Créer, afficher, mettre à jour et supprimer des planifications de sauvegarde : Administrateur de sauvegardes Cloud Spanner (roles/spanner.backupAdmin)
- Créer et afficher des planifications de sauvegarde: Rédacteur de sauvegardes Cloud Spanner (roles/spanner.backupWriter)
Remarque:IAM de base peuvent également contenir des autorisations permettant de créer et de gérer des planifications de sauvegarde. Les rôles de base ne doivent pas être attribués dans un environnement de production, mais ils peuvent être attribués dans un environnement de développement ou de test.

Créer une programmation de sauvegarde

Console

Dans la console Google Cloud, accédez à la page Instances de Spanner.

Accéder à la page "Instances Spanner"
Cliquez sur l'instance contenant la base de données.
Cliquez sur la base de données.
Dans le menu de navigation, cliquez sur Sauvegarder/Restaurer.
Cliquez sur Créer un planning de sauvegarde.
Remplissez le formulaire, puis cliquez sur Créer.

gcloud

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

SCHEDULE_ID: ID du planning des sauvegardes.
PROJECT_ID : ID du projet.
INSTANCE_ID: ID de l'instance sur laquelle vous souhaitez créer le planning des sauvegardes.
DATABASE_ID : ID de la base de données dans laquelle vous souhaitez créer la planification de sauvegarde.
RETENTION_DURATION: durée de conservation de les sauvegardes créées par la programmation. Par exemple, si vous souhaitez que la durée de conservation soit de jour, vous pouvez utiliser 86400s.
CRONTAB_EXPRESSION: L'expression crontab pour la fréquence du planning des sauvegardes. Par exemple, si vous souhaitez la fréquence de programmation des sauvegardes toutes les 12 heures, vous pouvez utiliser 0 12 * * *.
BACKUP_TYPE : indique s'il s'agit d'un calendrier de sauvegarde complète ou d'un calendrier de sauvegarde incrémentielle. Les valeurs possibles sont full-backup ou incremental-backup.
ENCRYPTION_TYPE : type de chiffrement des sauvegardes créées par la planification de sauvegarde. Les valeurs valides sont USE_DATABASE_ENCRYPTION, GOOGLE_DEFAULT_ENCRYPTION ou CUSTOMER_MANAGED_ENCRYPTION. Si vous utilisez CUSTOMER_MANAGED_ENCRYPTION, vous devez spécifier un kmsKeyName. Si le type de sauvegarde est incremental-backup, le type de chiffrement doit être GOOGLE_DEFAULT_ENCRYPTION.

Exécutez la commande suivante :

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

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PROJECT_ID : ID du projet.
INSTANCE_ID: ID de l'instance sur laquelle vous souhaitez créer le planning des sauvegardes.
DATABASE_ID: ID de la base de données dans laquelle vous souhaitez créer le planning des sauvegardes.
SCHEDULE_ID : ID de planification de la sauvegarde.
BACKUP_TYPE : indique s'il s'agit d'un calendrier de sauvegarde complète ou d'un calendrier de sauvegarde incrémentielle. Les valeurs possibles sont fullBackupSpec ou incrementalBackupSpec.
ENCRYPTION_TYPE : type de chiffrement des sauvegardes créées par la planification de sauvegarde. Les valeurs possibles sont USE_DATABASE_ENCRYPTION, GOOGLE_DEFAULT_ENCRYPTION ou CUSTOMER_MANAGED_ENCRYPTION. Si vous utilisez CUSTOMER_MANAGED_ENCRYPTION, vous devez spécifier un kmsKeyName. Si le type de sauvegarde est incremental-backup, le type de chiffrement est doit être GOOGLE_DEFAULT_ENCRYPTION.
RETENTION_DURATION: la durée de conservation des sauvegardes créées par la planification.

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Vous devriez recevoir une réponse JSON de ce type :

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

Bibliothèques clientes

C#

Pour créer un planning de sauvegarde complète, consultez l'exemple de code suivant:

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;
    }
}

Pour créer un planning de sauvegarde incrémentielle, consultez l'exemple de code suivant:

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++

Pour créer une planification de sauvegarde complète, consultez l'exemple de code suivant :

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());
}

Pour créer un planning de sauvegarde incrémentielle, consultez l'exemple de code suivant:

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

Pour créer un planning de sauvegarde complète, consultez l'exemple de code suivant:


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
}

Pour créer une planification de sauvegarde incrémentielle, consultez l'exemple de code suivant :


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

Pour créer une planification de sauvegarde complète, consultez l'exemple de code suivant :


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()));
    }
  }
}

Pour créer une planification de sauvegarde incrémentielle, consultez l'exemple de code suivant :


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

Pour créer un planning de sauvegarde complète, consultez l'exemple de code suivant:

// 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);
}

Pour créer une planification de sauvegarde incrémentielle, consultez l'exemple de code suivant :

// 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);
}

Python

Pour créer une planification de sauvegarde complète, consultez l'exemple de code suivant :

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

Pour créer un planning de sauvegarde incrémentielle, consultez l'exemple de code suivant:

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

Obtenir un planning de sauvegarde

Console

Dans la console Google Cloud, accédez à la page Instances de Spanner.

Accéder à la page "Instances Spanner"
Cliquez sur l'instance contenant la base de données.
Cliquez sur la base de données.
Dans le menu de navigation, cliquez sur Sauvegarder/Restaurer.
Cliquez sur l'onglet Planifications pour afficher tous les calendriers de sauvegarde et leurs informations.

gcloud

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

PROJECT_ID : ID du projet.
INSTANCE_ID : ID de l'instance.
DATABASE_ID: ID de la base de données.
SCHEDULE_ID : ID de planification de la sauvegarde.

Exécutez la commande suivante :

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

Vous devriez obtenir un résultat semblable à celui-ci :

{
  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

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PROJECT_ID : ID du projet.
INSTANCE_ID : ID de l'instance.
DATABASE_ID: ID de la base de données.
SCHEDULE_ID : ID de planification de la sauvegarde.

Méthode HTTP et URL :

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

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Exécutez la commande suivante :

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)

Exécutez la commande suivante :

$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

Vous devriez recevoir une réponse JSON de ce type :

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

Bibliothèques clientes

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

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

Lister les programmations de sauvegarde

Console

Dans la console Google Cloud, accédez à la page Instances de Spanner.

Accéder à la page "Instances Spanner"
Cliquez sur l'instance contenant la base de données.
Cliquez sur la base de données.
Dans le menu de navigation, cliquez sur Sauvegarder/Restaurer.
Cliquez sur l'onglet Planifications pour afficher tous les calendriers de sauvegarde et leurs informations.

gcloud

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

PROJECT_ID : ID du projet.
INSTANCE_ID : ID de l'instance.
DATABASE_ID : ID de la base de données.

Exécutez la commande suivante :

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

Vous devriez obtenir un résultat semblable à celui-ci :


  
    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

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PROJECT_ID : ID du projet.
INSTANCE_ID : ID de l'instance.
DATABASE_ID: ID de la base de données.

Méthode HTTP et URL :

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

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Exécutez la commande suivante :

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)

Exécutez la commande suivante :

$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

Vous devriez recevoir une réponse JSON de ce type :

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

Bibliothèques clientes

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

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

Mettre à jour un planning de sauvegarde

Console

Dans la console Google Cloud, accédez à la page Instances de Spanner.

Accéder à la page "Instances Spanner"
Cliquez sur l'instance contenant la base de données.
Cliquez sur la base de données.
Dans le menu de navigation, cliquez sur Sauvegarder/Restaurer.
Cliquez sur l'onglet Planifications.
Sélectionnez Autres actions pour votre planification de sauvegarde, puis cliquez sur Mettre à jour.
Vous pouvez modifier la fréquence et la durée de conservation du calendrier des sauvegardes. S'il s'agit d'une planification de sauvegarde complète, vous pouvez également modifier le type de chiffrement.
Cliquez sur Enregistrer.

gcloud

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

SCHEDULE_ID: ID du planning des sauvegardes.
PROJECT_ID : ID du projet.
INSTANCE_ID: ID de l'instance pour laquelle vous souhaitez modifier le planning des sauvegardes.
DATABASE_ID: ID de la base de données dans laquelle vous souhaitez modifier le planning des sauvegardes.
RETENTION_DURATION: la durée de conservation des sauvegardes créées par la planification.
CRONTAB_EXPRESSION : expression crontab pour la fréquence de planification des sauvegardes. Par exemple, si vous souhaitez que la fréquence de planification de la sauvegarde soit toutes les 12 heures, vous pouvez utiliser 0 12 * * *.
ENCRYPTION_TYPE : type de chiffrement des sauvegardes créées par la planification de sauvegarde. Les valeurs valides sont USE_DATABASE_ENCRYPTION, GOOGLE_DEFAULT_ENCRYPTION ou CUSTOMER_MANAGED_ENCRYPTION. Si vous utilisez CUSTOMER_MANAGED_ENCRYPTION, vous devez spécifier un kmsKeyName. Si le type de sauvegarde est incremental-backup, le type de chiffrement doit être GOOGLE_DEFAULT_ENCRYPTION.

Exécutez la commande suivante :

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

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PROJECT_ID : ID du projet.
INSTANCE_ID: ID de l'instance pour laquelle vous souhaitez modifier le planning des sauvegardes.
DATABASE_ID : ID de la base de données pour laquelle vous souhaitez modifier la planification des sauvegardes.
SCHEDULE_ID : ID de planification de la sauvegarde.
RETENTION_DURATION: durée de conservation de les sauvegardes créées par la programmation. Par exemple, si vous voulez que la durée de conservation soit d'un jour, spécifiez 86400s.
ENCRYPTION_TYPE : type de chiffrement des sauvegardes créées par la planification de sauvegarde. Les valeurs possibles sont USE_DATABASE_ENCRYPTION et GOOGLE_DEFAULT_ENCRYPTION. ou CUSTOMER_MANAGED_ENCRYPTION. Si vous utilisez CUSTOMER_MANAGED_ENCRYPTION, vous devez spécifier un kmsKeyName. Si le type de sauvegarde est incremental-backup, le type de chiffrement doit être GOOGLE_DEFAULT_ENCRYPTION

Méthode HTTP et 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

Corps JSON de la requête :

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

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Vous devriez recevoir une réponse JSON de ce type :

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

Bibliothèques clientes

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

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

Supprimer un planning de sauvegarde

Console

Dans la console Google Cloud, accédez à la page Instances de Spanner.

Accéder à la page "Instances Spanner"
Cliquez sur l'instance contenant la base de données.
Cliquez sur la base de données.
Dans le menu de navigation, cliquez sur Sauvegarder/Restaurer.
Sélectionnez Autres actions pour votre planning de sauvegarde, puis cliquez sur Supprimer.
Saisissez le nom du calendrier de sauvegarde.
Cliquez sur Confirmer.

gcloud

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

SCHEDULE_ID: ID du planning des sauvegardes.
PROJECT_ID : ID du projet.
INSTANCE_ID : ID de l'instance pour laquelle vous souhaitez supprimer la planification de sauvegarde.
DATABASE_ID : ID de la base de données dans laquelle vous souhaitez supprimer la planification de sauvegarde.

Exécutez la commande suivante :

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

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PROJECT_ID : ID du projet.
INSTANCE_ID : ID de l'instance pour laquelle vous souhaitez supprimer la planification de sauvegarde.
DATABASE_ID : ID de la base de données dans laquelle vous souhaitez supprimer la planification de sauvegarde.
SCHEDULE_ID: ID du planning des sauvegardes.

Méthode HTTP et URL :

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

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Exécutez la commande suivante :

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)

Exécutez la commande suivante :

$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

Vous devriez recevoir un code d'état indiquant le succès de l'opération (2xx), ainsi qu'une réponse vide.

Bibliothèques clientes

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

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

Définir une stratégie de contrôle des accès IAM

Vous pouvez définir une stratégie d'accès IAM pour spécifier qui a accès le calendrier des sauvegardes.

gcloud

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

SCHEDULE_ID: ID du planning des sauvegardes.
PROJECT_ID : ID du projet.
INSTANCE_ID : ID de l'instance.
DATABASE_ID : ID de la base de données.

Exécutez la commande suivante :

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

Vous devriez obtenir un résultat semblable à celui-ci :

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

Vous trouverez ci-dessous un exemple de fichier policy.json que vous pouvez utiliser avec cette commande de la CLI gcloud :

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

REST v1

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PROJECT_ID : ID du projet.
INSTANCE_ID : ID de l'instance.
DATABASE_ID: ID de la base de données.
SCHEDULE_ID : ID de planification de la sauvegarde.

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Vous devriez recevoir une réponse JSON de ce type :

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

Obtenir une stratégie de contrôle d'accès IAM

gcloud

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

SCHEDULE_ID: ID du planning des sauvegardes.
PROJECT_ID : ID du projet.
INSTANCE_ID : ID de l'instance.
DATABASE_ID : ID de la base de données.

Exécutez la commande suivante :

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

Vous devriez obtenir un résultat semblable à celui-ci :

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

REST v1

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

INSTANCE_ID : ID de l'instance.
DATABASE_ID: ID de la base de données.
SCHEDULE_ID : ID de planification de la sauvegarde.
PROJECT_ID : ID du projet.

Méthode HTTP et URL :

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

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Exécutez la commande suivante :

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)

Exécutez la commande suivante :

$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

Vous devriez recevoir une réponse JSON de ce type :

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

Étape suivante

Présentation des sauvegardes