Restaurer à partir d'une sauvegarde

Cette page décrit les opérations de restauration Spanner et explique comment restaurer une base de données. Pour en savoir plus sur la restauration de bases de données dans Spanner, consultez la page Présentation de la restauration.

Vous pouvez restaurer la sauvegarde dans l'instance de destination si elle utilise la même édition ou une édition de niveau supérieur que l'instance de sauvegarde source. Vous pouvez également la restaurer dans n'importe quelle instance ayant la même configuration d'instance et une édition de même niveau ou de niveau supérieur que l'instance source.

Vous pouvez restaurer une base de données Spanner à l'aide des éléments suivants :

• Dans la Google Cloud console.
• À l'aide de Google Cloud CLI
• À l'aide des bibliothèques clientes
• À l'aide des API REST ou RPC.

Avant de commencer

• Les exemples de gcloud CLI présentés sur cette page partent des principes suivants :

  • Vous avez déjà configuré gcloud CLI pour une utilisation avec Spanner. Si vous débutez avec Spanner sur gcloud CLI, consultez la page Premiers pas avec Spanner sur gcloud CLI.
  • Vous avez configuré gcloud CLI avec votre projet. Exemple :

    gcloud config set core/project PROJECT_ID
    

  *   You have an instance named `test-instance` and a database named
      `example-db`.
  

• Pour obtenir les autorisations nécessaires pour restaurer une base de données à partir d'une sauvegarde, demandez à votre administrateur de vous accorder les rôles IAM suivants sur l'instance :

  • Tous : Administrateur de restaurations Cloud Spanner (roles/spanner.restoreAdmin)
  Remarque : Les rôles de base IAM peuvent également contenir des autorisations permettant de restaurer une base de données à partir d'une 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.

Restaurer une base de données à partir d'une sauvegarde

Console

1. Accédez à la page Instances de Spanner dans la consoleGoogle Cloud .

Accéder à la page "Instances Spanner"

1. Cliquez sur l'instance contenant la base de données pour ouvrir la page Présentation correspondante.

2. Cliquez sur la base de données pour ouvrir la page Présentation correspondante.

3. Dans le volet de navigation, cliquez sur Sauvegarde/Restauration.

4. Cliquez sur le bouton Actions de la sauvegarde sélectionnée, puis sélectionnez Restaurer.

5. Sélectionnez une instance de destination compatible et nommez votre nouvelle base de données.

6. Cliquez sur le bouton Restaurer.

Pour vérifier la progression de l'opération, consultez l'indicateur de progression, comme indiqué sur la page des opérations :

Si l'opération prend trop de temps, vous pouvez l'annuler. Pour en savoir plus, consultez la section Annuler une opération d'instance de longue durée .

Remarque : Si vous restaurez une base de données à partir d'une sauvegarde ou d'une sauvegarde copiée, l' opération de restauration apparaît dans l'instance contenant la base de données restaurée, et non dans l'instance contenant la sauvegarde.

gcloud

Pour restaurer une base de données, utilisez gcloud spanner databases restore :

gcloud spanner databases restore --async \
  --destination-instance=test-instance --destination-database=example-db-restored \
  --source-instance=test-instance --source-backup=example-db-backup-6 \
  --encryption_type=google-managed-encryption

Remarques concernant l'utilisation :

• La commande répond immédiatement en raison de l'option --async. Sans l'option, la commande attend la fin de l'opération de restauration.
• Si les instances source et de destination sont différentes, elles doivent avoir la même configuration d'instance.
• Si la base de données de destination existe déjà, l'opération échouera.
• Les valeurs possibles pour encryption_type sont USE_DATABASE_ENCRYPTION, GOOGLE_DEFAULT_ENCRYPTION ou CUSTOMER_MANAGED_ENCRYPTION. Si vous utilisez CUSTOMER_MANAGED_ENCRYPTION, vous devez spécifier un kmsKeyName.

Bibliothèques clientes

L'exemple de code suivant restaure une base de données à partir d'une sauvegarde donnée et attend la fin de l'opération de restauration (opération avec RestoreDatabaseMetadata) complète. La base de données restaurée est créée dans la même instance que la sauvegarde. Une fois l'opération terminée, l'exemple extrait et imprime des informations de restauration à partir de la base de données.

C++

void RestoreDatabase(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_id) {
  google::cloud::spanner::Database database(project_id, instance_id,
                                            database_id);
  google::cloud::spanner::Backup backup(database.instance(), backup_id);
  auto restored_db =
      client
          .RestoreDatabase(database.instance().FullName(),
                           database.database_id(), backup.FullName())
          .get();
  if (!restored_db) throw std::move(restored_db).status();
  std::cout << "Database";
  if (restored_db->restore_info().source_type() ==
      google::spanner::admin::database::v1::BACKUP) {
    auto const& backup_info = restored_db->restore_info().backup_info();
    std::cout << " " << backup_info.source_database() << " as of "
              << google::cloud::spanner::MakeTimestamp(
                     backup_info.version_time())
                     .value();
  }
  std::cout << " restored to " << restored_db->name();
  std::cout << " from backup " << backup.FullName();
  std::cout << ".\n";
}

C#

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

public class RestoreDatabaseSample
{
    public RestoreInfo RestoreDatabase(string projectId, string instanceId, string databaseId, string backupId)
    {
        // Create the DatabaseAdminClient instance.
        DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();

        InstanceName parentAsInstanceName = InstanceName.FromProjectInstance(projectId, instanceId);
        BackupName backupAsBackupName = BackupName.FromProjectInstanceBackup(projectId, instanceId, backupId);

        // Make the RestoreDatabase request.
        Operation<Database, RestoreDatabaseMetadata> response = databaseAdminClient.RestoreDatabase(parentAsInstanceName, databaseId, backupAsBackupName);

        Console.WriteLine("Waiting for the operation to finish");

        // Poll until the returned long-running operation is complete.
        var completedResponse = response.PollUntilCompleted();

        if (completedResponse.IsFaulted)
        {
            Console.WriteLine($"Database Restore Failed: {completedResponse.Exception}");
            throw completedResponse.Exception;
        }

        RestoreInfo restoreInfo = completedResponse.Result.RestoreInfo;
        Console.WriteLine(
            $"Database {restoreInfo.BackupInfo.SourceDatabase} was restored " +
            $"to {databaseId} from backup {restoreInfo.BackupInfo.Backup} " +
            $"with version time {restoreInfo.BackupInfo.VersionTime}");

        return restoreInfo;
    }
}

Go

import (
	"context"
	"fmt"
	"io"
	"regexp"

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

func restoreBackup(ctx context.Context, w io.Writer, db, backupID string) error {
	adminClient, err := database.NewDatabaseAdminClient(ctx)
	if err != nil {
		return err
	}
	defer adminClient.Close()

	matches := regexp.MustCompile("^(.*)/databases/(.*)$").FindStringSubmatch(db)
	if matches == nil || len(matches) != 3 {
		return fmt.Errorf("Invalid database id %s", db)
	}
	instanceName := matches[1]
	databaseID := matches[2]
	backupName := instanceName + "/backups/" + backupID

	// Start restoring backup to a new database.
	restoreOp, err := adminClient.RestoreDatabase(ctx, &adminpb.RestoreDatabaseRequest{
		Parent:     instanceName,
		DatabaseId: databaseID,
		Source: &adminpb.RestoreDatabaseRequest_Backup{
			Backup: backupName,
		},
	})
	if err != nil {
		return err
	}
	// Wait for restore operation to complete.
	dbObj, err := restoreOp.Wait(ctx)
	if err != nil {
		return err
	}
	// Newly created database has restore information.
	backupInfo := dbObj.RestoreInfo.GetBackupInfo()
	if backupInfo != nil {
		fmt.Fprintf(w, "Source database %s restored from backup %s\n", backupInfo.SourceDatabase, backupInfo.Backup)
	}

	return nil
}

Java

static void restoreBackup(
    DatabaseAdminClient dbAdminClient,
    String projectId,
    String instanceId,
    String backupId,
    String restoreToDatabaseId) {
  BackupName backupName = BackupName.of(projectId, instanceId, backupId);
  Backup backup = dbAdminClient.getBackup(backupName);
  // Initiate the request which returns an OperationFuture.
  System.out.println(String.format(
      "Restoring backup [%s] to database [%s]...", backup.getName(), restoreToDatabaseId));
  try {
    RestoreDatabaseRequest request =
        RestoreDatabaseRequest.newBuilder()
            .setParent(InstanceName.of(projectId, instanceId).toString())
            .setDatabaseId(restoreToDatabaseId)
            .setBackup(backupName.toString()).build();
    OperationFuture<com.google.spanner.admin.database.v1.Database, RestoreDatabaseMetadata> op =
        dbAdminClient.restoreDatabaseAsync(request);
    // Wait until the database has been restored.
    com.google.spanner.admin.database.v1.Database db = op.get();
    // Get the restore info.
    RestoreInfo restoreInfo = db.getRestoreInfo();
    BackupInfo backupInfo = restoreInfo.getBackupInfo();

    System.out.println(
        "Restored database ["
            + db.getName()
            + "] from ["
            + restoreInfo.getBackupInfo().getBackup()
            + "] with version time [" + backupInfo.getVersionTime() + "]");
  } catch (ExecutionException e) {
    throw SpannerExceptionFactory.newSpannerException(e.getCause());
  } catch (InterruptedException e) {
    throw SpannerExceptionFactory.propagateInterrupt(e);
  }
}

Remarque : Les anciens exemples de code d'interface de bibliothèque cliente pour Java sont archivés sur GitHub.

Node.js

// Imports the Google Cloud client library and precise date library
const {Spanner} = require('@google-cloud/spanner');
const {PreciseDate} = require('@google-cloud/precise-date');

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

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Gets a reference to a Cloud Spanner Database Admin Client object
const databaseAdminClient = spanner.getDatabaseAdminClient();

// Restore the database
console.log(
  `Restoring database ${databaseAdminClient.databasePath(
    projectId,
    instanceId,
    databaseId,
  )} from backup ${backupId}.`,
);
const [restoreOperation] = await databaseAdminClient.restoreDatabase({
  parent: databaseAdminClient.instancePath(projectId, instanceId),
  databaseId: databaseId,
  backup: databaseAdminClient.backupPath(projectId, instanceId, backupId),
});

// Wait for restore to complete
console.log('Waiting for database restore to complete...');
await restoreOperation.promise();

console.log('Database restored from backup.');
const [metadata] = await databaseAdminClient.getDatabase({
  name: databaseAdminClient.databasePath(projectId, instanceId, databaseId),
});
console.log(
  `Database ${metadata.restoreInfo.backupInfo.sourceDatabase} was restored ` +
    `to ${databaseId} from backup ${metadata.restoreInfo.backupInfo.backup} ` +
    'with version time ' +
    `${new PreciseDate(
      metadata.restoreInfo.backupInfo.versionTime,
    ).toISOString()}.`,
);

Remarque : Les anciens exemples de code d'interface de bibliothèque cliente pour Node.js sont archivés sur GitHub.

PHP

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

/**
 * Restore a database from a backup.
 * Example:
 * ```
 * restore_backup($projectId, $instanceId, $databaseId, $backupId);
 * ```
 * @param string $projectId The Google Cloud project ID.
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 * @param string $backupId The Spanner backup ID.
 */
function restore_backup(
    string $projectId,
    string $instanceId,
    string $databaseId,
    string $backupId
): void {
    $databaseAdminClient = new DatabaseAdminClient();

    $backupName = DatabaseAdminClient::backupName($projectId, $instanceId, $backupId);
    $instanceName = DatabaseAdminClient::instanceName($projectId, $instanceId);

    $request = new RestoreDatabaseRequest([
        'parent' => $instanceName,
        'database_id' => $databaseId,
        'backup' => $backupName
    ]);

    $operationResponse = $databaseAdminClient->restoreDatabase($request);
    $operationResponse->pollUntilComplete();

    $database = $operationResponse->operationSucceeded() ? $operationResponse->getResult() : null;
    $restoreInfo = $database->getRestoreInfo();
    $backupInfo = $restoreInfo->getBackupInfo();
    $sourceDatabase = $backupInfo->getSourceDatabase();
    $sourceBackup = $backupInfo->getBackup();
    $versionTime = $backupInfo->getVersionTime()->getSeconds();
    printf(
        'Database %s restored from backup %s with version time %s' . PHP_EOL,
        $sourceDatabase, $sourceBackup, $versionTime
    );
}

Remarque : Les anciens exemples de code d'interface de bibliothèque cliente pour PHP sont archivés sur GitHub.

Python

def restore_database(instance_id, new_database_id, backup_id):
    """Restores a database from a backup."""
    from google.cloud.spanner_admin_database_v1 import RestoreDatabaseRequest

    spanner_client = spanner.Client()
    database_admin_api = spanner_client.database_admin_api

    # Start restoring an existing backup to a new database.
    request = RestoreDatabaseRequest(
        parent=database_admin_api.instance_path(spanner_client.project, instance_id),
        database_id=new_database_id,
        backup=database_admin_api.backup_path(
            spanner_client.project, instance_id, backup_id
        ),
    )
    operation = database_admin_api.restore_database(request)

    # Wait for restore operation to complete.
    db = operation.result(1600)

    # Newly created database has restore information.
    restore_info = db.restore_info
    print(
        "Database {} restored to {} from backup {} with version time {}.".format(
            restore_info.backup_info.source_database,
            new_database_id,
            restore_info.backup_info.backup,
            restore_info.backup_info.version_time,
        )
    )

Remarque : Les anciens exemples de code d'interface de bibliothèque cliente pour Python sont archivés sur GitHub.

Ruby

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID of where to restore"
# backup_id = "Your Spanner backup ID"

require "google/cloud/spanner"
require "google/cloud/spanner/admin/database"

database_admin_client = Google::Cloud::Spanner::Admin::Database.database_admin

instance_path = database_admin_client.instance_path project: project_id, instance: instance_id

db_path = database_admin_client.database_path project: project_id,
                                              instance: instance_id,
                                              database: database_id

backup_path = database_admin_client.backup_path project: project_id,
                                                instance: instance_id,
                                                backup: backup_id

job = database_admin_client.restore_database parent: instance_path,
                                             database_id: database_id,
                                             backup: backup_path

puts "Waiting for restore backup operation to complete"

job.wait_until_done!

database = database_admin_client.get_database name: db_path
restore_info = database.restore_info
puts "Database #{restore_info.backup_info.source_database} was restored to #{database_id} from backup #{restore_info.backup_info.backup} with version time #{restore_info.backup_info.version_time}"

Récupérer une table spécifique à partir d'une sauvegarde

Si vous devez récupérer une table spécifique à partir d'une sauvegarde, vous pouvez restaurer la sauvegarde dans une nouvelle base de données, exporter cette table unique à partir de la nouvelle base de données, puis l'importer dans votre base de données d'origine. Cette approche minimise la charge sur la base de données d'origine pendant le processus d'exportation.

1. Restaurez la sauvegarde dans une nouvelle base de données distincte.

2. (Facultatif) Supprimez les lignes créées après l'horodatage de récupération.

   Le processus d'importation ne supprime pas automatiquement les lignes ajoutées à la table après la création de la sauvegarde. Par conséquent, si vous souhaitez que la table récupérée corresponde exactement à l'état de la sauvegarde, vous devez supprimer manuellement les lignes créées après l'horodatage de la sauvegarde.

3. Exportez la table spécifique à partir de la nouvelle base de données à l'aide du modèle Dataflow Spanner vers Avro. Pour en savoir plus, consultez la section Exporter un sous-ensemble de tables.

4. Importez la table exportée dans votre base de données d'origine à l'aide du modèle Dataflow Cloud Storage Avro vers Spanner. Pour en savoir plus, consultez la section Importer des données.