Restablecer copia de seguridad

En esta página, se describen las operaciones de restablecimiento de Spanner y se explica cómo restablecer una base de datos. Para obtener más información sobre el restablecimiento de bases de datos en Spanner, consulta Descripción general del restablecimiento.

Puedes restablecer la copia de seguridad en la instancia de destino si usa la misma edición o una de nivel superior que la instancia de copia de seguridad de origen. De manera alternativa, puedes restablecerla en cualquier instancia con la misma configuración y una edición que sea igual o de nivel superior que la instancia de origen.

Puedes restablecer una base de datos de Spanner con lo siguiente:

• En la Google Cloud consola de.
• Con Google Cloud CLI.
• Con bibliotecas cliente.
• Con las REST o RPC APIs.

Antes de comenzar

• En los ejemplos de gcloud CLI de esta página, se supone que hiciste lo siguiente:

  • Ya configuraste gcloud CLI para usarlo con Spanner. Si no tienes experiencia en el uso de gcloud CLI con Spanner, consulta Comienza a usar Spanner con gcloud CLI.
  • Configuraste gcloud CLI con tu proyecto. Por ejemplo:

    gcloud config set core/project PROJECT_ID
    

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

• Para obtener los permisos que necesitas para restablecer una base de datos a partir de una copia de seguridad, pídele a tu administrador que te otorgue los siguientes roles de IAM en la instancia:

  • Todos: Administrador de restablecimiento de Cloud Spanner (roles/spanner.restoreAdmin)
  Nota: Los roles básicos de IAM también pueden contener permisos para restablecer una base de datos a partir de una copia de seguridad. No deberías otorgar roles básicos en un entorno de producción, pero puedes otorgarlos en un entorno de desarrollo o de prueba.

Restablece una base de datos a partir de una copia de seguridad

Console

1. Ve a la página Instancias de Spanner en la Google Cloud consola de.

Ir a la página Instancias de Spanner

1. Haz clic en la instancia que contiene la base de datos para abrir su página Descripción general.

2. Haz clic en la base de datos para abrir su página Descripción general.

3. En el panel de navegación, haz clic en Copia de seguridad/Restablecimiento.

4. Haz clic en el botón Acciones de la copia de seguridad seleccionada y, luego, selecciona Restablecer.

5. Selecciona una instancia de destino compatible y asígnale un nombre a tu nueva base de datos.

6. Haz clic en el botón Restablecer.

Para verificar el progreso de la operación, consulta el indicador de progreso, como se muestra en la página de operaciones:

Si la operación tarda demasiado, puedes cancelarla. Para obtener más información, consulta Cancela una operación de instancia de larga duración .

Nota: Si restableces una base de datos a partir de una copia de seguridad o una copia de seguridad copiada, la operación de restablecimiento aparece en la instancia que contiene la base de datos restablecida, no en la que contiene la copia de seguridad.

gcloud

Para restablecer una base de datos, usa 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

Notas de uso:

• El comando se muestra de inmediato debido a la marca --async. Sin la marca, el comando esperará a que se complete la operación de restablecimiento.
• Si las instancias de origen y destino son diferentes, deben tener la misma configuración de instancia.
• Si la base de datos de destino ya existe, la operación fallará.
• Los valores posibles para encryption_type son USE_DATABASE_ENCRYPTION, GOOGLE_DEFAULT_ENCRYPTION o CUSTOMER_MANAGED_ENCRYPTION. Si usas CUSTOMER_MANAGED_ENCRYPTION, debes especificar un kmsKeyName.

Bibliotecas cliente

Con la siguiente muestra de código, se restablece una base de datos de una copia de seguridad determinada y espera a que se complete la operación de restablecimiento (una operación con RestoreDatabaseMetadata) para completar. La base de datos restablecida se crea en la misma instancia que la copia de seguridad. Una vez completada, la muestra recupera e imprime información de restablecimiento de la base de datos.

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

Nota: Los ejemplos de código de la interfaz de la biblioteca cliente anterior para Java se archivan en 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()}.`,
);

Nota: Los ejemplos de código de la interfaz de la biblioteca cliente anterior para Node.js se archivan en 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
    );
}

Nota: Los ejemplos de código de la interfaz de la biblioteca cliente anterior para PHP se archivan en 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,
        )
    )

Nota: Los ejemplos de código de la interfaz de la biblioteca cliente anterior para Python se archivan en 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}"

Recupera una tabla específica de una copia de seguridad

Si necesitas recuperar una tabla específica de una copia de seguridad, puedes restablecer la copia de seguridad en una base de datos nueva, exportar esa tabla única de la base de datos nueva y, luego, importar esa tabla a tu base de datos original. Este enfoque minimiza la carga en la base de datos original durante el proceso de exportación.

1. Restablece la copia de seguridad en una base de datos nueva y separada.

2. Opcional: Borra las filas que se crearon después de la marca de tiempo de recuperación.

   El proceso de importación no borra automáticamente las filas que se agregaron a la tabla después de que se creó la copia de seguridad. Por lo tanto, si deseas que la tabla recuperada coincida exactamente con el estado de la copia de seguridad, debes borrar de forma manual las filas que se crearon después de la marca de tiempo de la copia de seguridad.

3. Exporta la tabla específica de la base de datos nueva con la plantilla de Dataflow de Spanner a Avro Avro. Para obtener más información, consulta Exporta un subconjunto de tablas.

4. Importa la tabla exportada a tu base de datos original con la plantilla de Dataflow de Avro de Cloud Storage a Spanner. Para obtener más información, consulta Importa datos.