Transferir datos entre segmentos de Cloud Storage

El Servicio de transferencia de Storage se puede usar para transferir grandes cantidades de datos entre segmentos de Cloud Storage, ya sea en el mismo proyecto Google Cloud o entre proyectos diferentes.

Las migraciones de contenedores son útiles en varios casos. Se pueden usar para consolidar datos de proyectos independientes, mover datos a una ubicación de copia de seguridad o cambiar la ubicación de los datos.

Cuándo usar el Servicio de transferencia de Storage

Google Cloud ofrece varias opciones para transferir datos entre segmentos de Cloud Storage. Te recomendamos que sigas estas directrices:

• Transferencia de menos de 1 TB: usa gcloud. Para obtener instrucciones, consulta Mover y cambiar el nombre de los contenedores.

• Transferir más de 1 TB: usa el Servicio de transferencia de Storage. El Servicio de transferencia de Storage es una opción de transferencia gestionada que ofrece seguridad, fiabilidad y rendimiento listos para usar. De este modo, no es necesario optimizar ni mantener secuencias de comandos, ni gestionar reintentos.

En esta guía se describen las prácticas recomendadas para transferir datos entre segmentos de Cloud Storage mediante el Servicio de transferencia de Storage.

Definir una estrategia de transferencia

El aspecto de tu estrategia de transferencia depende de la complejidad de tu situación. Asegúrate de incluir las siguientes consideraciones en tu plan.

Elige un nombre de segmento

Para mover tus datos a un segmento de almacenamiento con otra ubicación, elige una de las siguientes opciones:

• Nuevo nombre del segmento. Actualiza tus aplicaciones para que apunten a un segmento de almacenamiento con otro nombre.
• Mantener el nombre del segmento Sustituye el segmento de almacenamiento para conservar el nombre actual, lo que significa que no tienes que actualizar tus aplicaciones.

En ambos casos, debes planificar el tiempo de inactividad y avisar a tus usuarios con suficiente antelación. Consulta las siguientes explicaciones para saber qué opción te conviene más.

Nombre del nuevo segmento

Si cambias el nombre del segmento, debes actualizar todo el código y los servicios que usen el segmento actual. La forma de hacerlo depende de cómo se hayan creado y desplegado tus aplicaciones.

En algunas configuraciones, este enfoque puede tener menos tiempo de inactividad, pero requiere más trabajo para garantizar una transición fluida. Para ello, sigue estos pasos:

1. Copiar tus datos en un nuevo segmento de almacenamiento.
2. Estoy iniciando tu tiempo de descanso.
3. Actualizar las aplicaciones para que apunten al nuevo.
4. Verificar que todo funciona según lo previsto y que todos los sistemas y cuentas relevantes tienen acceso al contenedor.
5. Eliminando el segmento original.
6. Finalizar el tiempo de descanso.

Mantener el nombre del segmento

Utiliza este método si prefieres no cambiar el código para que apunte a un nuevo nombre de contenedor. Para ello, sigue estos pasos:

1. Copiar tus datos en un segmento de almacenamiento temporal.
2. Estoy iniciando tu tiempo de descanso.
3. Eliminar el segmento original.
4. Crear un nuevo segmento con el mismo nombre que el original.
5. Copia los datos del segmento temporal al nuevo.
6. Eliminando el segmento temporal.
7. Verificar que todo funciona según lo previsto y que todos los sistemas y cuentas relevantes tienen acceso al contenedor.
8. Finalizar el tiempo de descanso.

Minimizar el tiempo de inactividad

El Servicio de transferencia de Storage no bloquea las lecturas ni las escrituras en los contenedores de origen o de destino durante una transferencia.

Si decides bloquear manualmente las lecturas y escrituras en tu contenedor, puedes minimizar el tiempo de inactividad transfiriendo tus datos en dos pasos: inicialización y sincronización.

1. Transferencia inicial: realiza una transferencia en bloque sin bloquear la lectura o escritura en la fuente.

2. Transferencia de sincronización: una vez completada la primera ejecución, bloquea la lectura/escritura en el contenedor de origen y realiza otra transferencia. Las transferencias del Servicio de transferencia de Storage son incrementales de forma predeterminada, por lo que esta segunda transferencia solo transfiere los datos que han cambiado durante la transferencia inicial.

Optimizar la velocidad de transferencia

Al estimar la duración de una tarea de transferencia, ten en cuenta los posibles cuellos de botella. Por ejemplo, si la fuente tiene miles de millones de archivos pequeños, la velocidad de transferencia estará limitada por las QPS. Si los tamaños de los objetos son grandes, el ancho de banda podría ser el cuello de botella.

Los límites de ancho de banda se definen a nivel de región y se asignan de forma equitativa a todos los proyectos. Si hay suficiente ancho de banda disponible, el Servicio de transferencia de Storage puede completar unas 1000 tareas por trabajo de transferencia por segundo. En este caso, puedes acelerar una transferencia dividiendo el trabajo en varias tareas de transferencia pequeñas. Por ejemplo, puedes usar los prefijos de inclusión y exclusión para transferir determinados archivos.

En los casos en los que la ubicación, la clase de almacenamiento y la clave de cifrado son las mismas, el servicio de transferencia de Storage no crea una copia nueva de los bytes, sino que crea una entrada de metadatos nueva que apunta al blob de origen. Por lo tanto, las copias de un corpus grande que se encuentran en la misma ubicación y clase se completan muy rápido y solo están limitadas por las QPS.

Las eliminaciones también son operaciones de solo metadatos. En estas transferencias, paralelizar la transferencia dividiéndola en varios trabajos pequeños puede aumentar la velocidad.

Conservar metadatos

Los siguientes metadatos de objetos se conservan al transferir datos entre segmentos de Cloud Storage con el Servicio de transferencia de Storage:

• Metadatos personalizados creados por los usuarios.
• Campos de metadatos de clave fija de Cloud Storage, como Cache-Control, Content-Disposition, Content-Type y Custom-Time.
• Tamaño del objeto.
• El número de generación se conserva como un campo de metadatos personalizado con la clave x-goog-reserved-source-generation, que puedes editar o quitar más adelante.

Los siguientes campos de metadatos se pueden conservar de forma opcional al realizar transferencias mediante la API:

• LCAs (acl)
• Clase de almacenamiento (storageClass)
• CMEK (kmsKey)
• Retención temporal (temporaryHold)
• Hora de creación del objeto (customTime)

Consulta más información en la referencia de la API TransferSpec.

Los siguientes campos de metadatos no se conservan:

• Hora de la última actualización (updated)
• etag
• componentCount

Si se conserva, la hora de creación del objeto se almacena como un campo personalizado, customTime. El tiempo de updated del objeto se restablece al transferirse, por lo que también se restablece el tiempo que ha pasado en su clase de almacenamiento. Esto significa que un objeto de Coldline Storage, después de la transferencia, debe existir de nuevo durante 90 días en el destino para evitar que se apliquen cargos por eliminación anticipada.

Puedes aplicar tus políticas de ciclo de vida basadas en createTime con customTime. Se sobrescriben los valores de customTime.

Para obtener más información sobre qué se conserva y qué no, consulta el artículo Conservación de metadatos.

Gestionar objetos con versiones

Si quieres transferir todas las versiones de tus objetos de almacenamiento y no solo la más reciente, debes usar la interfaz de línea de comandos (CLI) o la API REST de gcloud para transferir tus datos, junto con la función de manifiesto del Servicio de transferencia de Storage.

Para transferir todas las versiones de objetos, sigue estos pasos:

1. Lista los objetos del segmento y cópialos en un archivo JSON:

   gcloud storage ls --all-versions --recursive --json [SOURCE_BUCKET] > object-listing.json
   

   Este comando suele mostrar unos 1000 objetos por segundo.

2. Divide el archivo JSON en dos archivos CSV: uno con las versiones no actuales y otro con las versiones activas:

   jq -r '.[] | select( .type=="cloud_object" and (.metadata | has("timeDeleted") | not)) | [.metadata.name, .metadata.generation] | @csv' object-listing.json > live-object-manifest.csv
   jq -r '.[] | select( .type=="cloud_object" and (.metadata | has("timeDeleted"))) | [.metadata.name, .metadata.generation] | @csv' object-listing.json > non-current-object-manifest.csv
   

3. Habilita la gestión de versiones de objetos en el segmento de destino.

4. Transfiere primero las versiones no actuales pasando el archivo de manifiesto non-current-object-manifest.csv como valor del campo transferManifest.

5. A continuación, transfiere las versiones activas de la misma forma, especificando live-object-manifest.csv como archivo de manifiesto.

Configurar opciones de transferencia

Estas son algunas de las opciones que tienes disponibles al configurar la transferencia:

• Registro: Cloud Logging proporciona registros detallados de objetos individuales, lo que le permite verificar el estado de la transferencia y realizar comprobaciones adicionales de integridad de los datos.

• Filtrado: puedes usar prefijos de inclusión y exclusión para limitar los objetos en los que se ejecuta el Servicio de transferencia de Storage. Esta opción se puede usar para dividir una transferencia en varias tareas de transferencia de forma que se puedan ejecutar en paralelo. Consulta más información sobre cómo optimizar la velocidad de transferencia.

• Opciones de transferencia: puede configurar la transferencia para sobrescribir los elementos que ya estén en el segmento de destino, eliminar los objetos del destino que no estén en el conjunto de transferencia o eliminar los objetos transferidos de la fuente.

Transferir tus datos

Una vez que hayas definido tu estrategia de transferencia, podrás llevar a cabo la transferencia.

Crear un nuevo segmento

Antes de iniciar la transferencia, crea un segmento de almacenamiento. Consulta location_considerations para obtener ayuda a la hora de elegir una ubicación de segmento adecuada.

Puede que quieras copiar algunos de los metadatos del contenedor cuando crees el nuevo contenedor. Consulta Obtener los metadatos de un segmento para saber cómo mostrar los metadatos del segmento de origen y, así, poder aplicar los mismos ajustes al nuevo segmento.

Copiar objetos en el nuevo contenedor

Puedes copiar objetos del bucket de origen en un nuevo bucket mediante laGoogle Cloud consola, la gcloudCLI, la API REST o las bibliotecas de cliente. El enfoque que elijas dependerá de tu estrategia de transferencia.

Las siguientes instrucciones corresponden al caso práctico básico de transferir objetos de un contenedor a otro y deben modificarse para que se ajusten a tus necesidades.

No incluyas información sensible, como información personal identificable (IPI) o datos de seguridad, en el nombre del trabajo de transferencia. Los nombres de recursos pueden propagarse a los nombres de otros recursos de Google Cloud y pueden exponerse a sistemas internos de Google fuera de tu proyecto.

gcloud init

gcloud storage buckets add-iam-policy-binding gs://bucket_name \
--member=serviceAccount:project-12345678@storage-transfer-service.iam.gserviceaccount.com \
--role=roles/storage.admin

gcloud transfer jobs create SOURCE DESTINATION

gcloud transfer jobs create gs://old-bucket gs://new-bucket \
  --include-prefixes="folder1/"

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "schedule": {
      "scheduleStartDate": {
          "day": 1,
          "month": 1,
          "year": 2025
      },
      "startTimeOfDay": {
          "hours": 1,
          "minutes": 1
      },
      "scheduleEndDate": {
          "day": 1,
          "month": 1,
          "year": 2025
      }
  },
  "transferSpec": {
      "gcsDataSource": {
          "bucketName": "GCS_SOURCE_NAME"
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      },
      "transferOptions": {
          "deleteObjectsFromSourceAfterTransfer": true
      }
  }
}

200 OK
{
  "transferJob": [
      {
          "creationTime": "2015-01-01T01:01:00.000000000Z",
          "description": "YOUR DESCRIPTION",
          "name": "transferJobs/JOB_ID",
          "status": "ENABLED",
          "lastModificationTime": "2015-01-01T01:01:00.000000000Z",
          "projectId": "PROJECT_ID",
          "schedule": {
              "scheduleStartDate": {
                  "day": 1,
                  "month": 1,
                  "year": 2015
              },
              "startTimeOfDay": {
                  "hours": 1,
                  "minutes": 1
              }
          },
          "transferSpec": {
              "gcsDataSource": {
                  "bucketName": "GCS_SOURCE_NAME",
              },
              "gcsDataSink": {
                  "bucketName": "GCS_NEARLINE_SINK_NAME"
              },
              "objectConditions": {
                  "minTimeElapsedSinceLastModification": "2592000.000s"
              },
              "transferOptions": {
                  "deleteObjectsFromSourceAfterTransfer": true
              }
          }
      }
  ]
}

import com.google.protobuf.Duration;
import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto.CreateTransferJobRequest;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
import com.google.storagetransfer.v1.proto.TransferTypes.ObjectConditions;
import com.google.storagetransfer.v1.proto.TransferTypes.Schedule;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob.Status;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferOptions;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferSpec;
import com.google.type.Date;
import com.google.type.TimeOfDay;
import java.io.IOException;
import java.util.Calendar;

public class TransferToNearline {
  /**
   * Creates a one-off transfer job that transfers objects in a standard GCS bucket that are more
   * than 30 days old to a Nearline GCS bucket.
   */
  public static void transferToNearline(
      String projectId,
      String jobDescription,
      String gcsSourceBucket,
      String gcsNearlineSinkBucket,
      long startDateTime)
      throws IOException {

    // Your Google Cloud Project ID
    // String projectId = "your-project-id";

    // A short description of this job
    // String jobDescription = "Sample transfer job of old objects to a Nearline GCS bucket.";

    // The name of the source GCS bucket to transfer data from
    // String gcsSourceBucket = "your-gcs-source-bucket";

    // The name of the Nearline GCS bucket to transfer old objects to
    // String gcsSinkBucket = "your-nearline-gcs-bucket";

    // What day and time in UTC to start the transfer, expressed as an epoch date timestamp.
    // If this is in the past relative to when the job is created, it will run the next day.
    // long startDateTime =
    //     new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2000-01-01 00:00:00").getTime();

    // Parse epoch timestamp into the model classes
    Calendar startCalendar = Calendar.getInstance();
    startCalendar.setTimeInMillis(startDateTime);
    // Note that this is a Date from the model class package, not a java.util.Date
    Date date =
        Date.newBuilder()
            .setYear(startCalendar.get(Calendar.YEAR))
            .setMonth(startCalendar.get(Calendar.MONTH) + 1)
            .setDay(startCalendar.get(Calendar.DAY_OF_MONTH))
            .build();
    TimeOfDay time =
        TimeOfDay.newBuilder()
            .setHours(startCalendar.get(Calendar.HOUR_OF_DAY))
            .setMinutes(startCalendar.get(Calendar.MINUTE))
            .setSeconds(startCalendar.get(Calendar.SECOND))
            .build();

    TransferJob transferJob =
        TransferJob.newBuilder()
            .setDescription(jobDescription)
            .setProjectId(projectId)
            .setTransferSpec(
                TransferSpec.newBuilder()
                    .setGcsDataSource(GcsData.newBuilder().setBucketName(gcsSourceBucket))
                    .setGcsDataSink(GcsData.newBuilder().setBucketName(gcsNearlineSinkBucket))
                    .setObjectConditions(
                        ObjectConditions.newBuilder()
                            .setMinTimeElapsedSinceLastModification(
                                Duration.newBuilder().setSeconds(2592000 /* 30 days */)))
                    .setTransferOptions(
                        TransferOptions.newBuilder().setDeleteObjectsFromSourceAfterTransfer(true)))
            .setSchedule(Schedule.newBuilder().setScheduleStartDate(date).setStartTimeOfDay(time))
            .setStatus(Status.ENABLED)
            .build();

    // Create a Transfer Service client
    StorageTransferServiceClient storageTransfer = StorageTransferServiceClient.create();

    // Create the transfer job
    TransferJob response =
        storageTransfer.createTransferJob(
            CreateTransferJobRequest.newBuilder().setTransferJob(transferJob).build());

    System.out.println("Created transfer job from standard bucket to Nearline bucket:");
    System.out.println(response.toString());
  }
}

from datetime import datetime

from google.cloud import storage_transfer
from google.protobuf.duration_pb2 import Duration


def create_daily_nearline_30_day_migration(
    project_id: str,
    description: str,
    source_bucket: str,
    sink_bucket: str,
    start_date: datetime,
):
    """Create a daily migration from a GCS bucket to a Nearline GCS bucket
    for objects untouched for 30 days."""

    client = storage_transfer.StorageTransferServiceClient()

    # The ID of the Google Cloud Platform Project that owns the job
    # project_id = 'my-project-id'

    # A useful description for your transfer job
    # description = 'My transfer job'

    # Google Cloud Storage source bucket name
    # source_bucket = 'my-gcs-source-bucket'

    # Google Cloud Storage destination bucket name
    # sink_bucket = 'my-gcs-destination-bucket'

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "schedule": {
                    "schedule_start_date": {
                        "day": start_date.day,
                        "month": start_date.month,
                        "year": start_date.year,
                    }
                },
                "transfer_spec": {
                    "gcs_data_source": {
                        "bucket_name": source_bucket,
                    },
                    "gcs_data_sink": {
                        "bucket_name": sink_bucket,
                    },
                    "object_conditions": {
                        "min_time_elapsed_since_last_modification": Duration(
                            seconds=2592000  # 30 days
                        )
                    },
                    "transfer_options": {
                        "delete_objects_from_source_after_transfer": True
                    },
                },
            }
        }
    )

    result = client.create_transfer_job(transfer_job_request)
    print(f"Created transferJob: {result.name}")

Verificar objetos copiados

Una vez que se haya completado la transferencia, te recomendamos que hagas comprobaciones adicionales de integridad de datos.

• Valide que los objetos se hayan copiado correctamente verificando los metadatos de los objetos, como las sumas de comprobación y el tamaño.

• Verifica que se haya copiado la versión correcta de los objetos. El Servicio de transferencia de Storage ofrece una opción predefinida para verificar que los objetos son copias. Si has habilitado el registro, consulta los registros para verificar si todos los objetos se han copiado correctamente, incluidos sus campos de metadatos correspondientes.

Empezar a usar el contenedor de destino

Una vez que se haya completado y verificado la migración, actualice las aplicaciones o cargas de trabajo que tenga para que usen el nombre del nuevo contenedor. Consulta los registros de acceso a datos en Registros de auditoría de Cloud para asegurarte de que tus operaciones modifican y leen objetos correctamente.

Eliminar el segmento original

Cuando todo funcione correctamente, elimina el contenedor original.

Storage Transfer Service ofrece la opción de eliminar objetos después de que se hayan transferido. Para ello, especifica deleteObjectsFromSourceAfterTransfer: true en la configuración del trabajo o selecciona la opción en la consola de Google Cloud .

Programar la eliminación de un objeto

Para programar la eliminación de tus objetos para una fecha posterior, usa una combinación de una tarea de transferencia programada y la opción deleteObjectsUniqueInSink = true.

La tarea de transferencia debe configurarse para transferir un contenedor vacío al contenedor que contiene tus objetos. De esta forma, el Servicio de transferencia de Storage mostrará los objetos y empezará a eliminarlos. Como las eliminaciones son una operación de solo metadatos, el trabajo de transferencia solo está limitado por las consultas por segundo. Para acelerar el proceso, divide la transferencia en varios trabajos, cada uno de los cuales actuará sobre un conjunto de prefijos distinto.

También puedes usar Google Cloud que ofrece un programador de tareas cron gestionado. Para obtener más información, consulta Programar un trabajo de transferencia de STS de Google Cloud con Cloud Scheduler.