Transfiere entre depósitos de Cloud Storage

El Servicio de transferencia de almacenamiento se puede usar para transferir grandes cantidades de datos entre buckets de Cloud Storage, dentro del mismo proyecto de Google Cloud o entre diferentes proyectos.

Las migraciones de buckets son útiles en varias situaciones. Se pueden usar para consolidar datos de proyectos separados, mover datos a una ubicación de copia de seguridad o cambiar la ubicación de tus datos.

Cuándo usar el Servicio de transferencia de almacenamiento

Google Cloud ofrece varias opciones para transferir datos entre depósitos de Cloud Storage. Recomendamos los siguientes lineamientos:

• Transferencia de menos de 1 TB: usa gsutil o gcloud Para obtener instrucciones, consulta Mueve y cambia el nombre de los buckets.

• Transferencia de más de 1 TB: usa el Servicio de transferencia de almacenamiento. El Servicio de transferencia de almacenamiento es una opción de transferencia administrada que proporciona seguridad, confiabilidad y rendimiento listos para usar. Elimina la necesidad de optimizar y mantener secuencias de comandos, y controlar los reintentos.

En esta guía, se analizan las prácticas recomendadas para transferir datos entre buckets de Cloud Storage mediante el Servicio de transferencia de almacenamiento.

Define una estrategia de transferencia

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

Elige un nombre de bucket

Para mover tus datos a un bucket de almacenamiento con una ubicación diferente, elige uno de los siguientes enfoques:

• Nombre del bucket nuevo. Actualiza tus aplicaciones para que apunten a un bucket de almacenamiento con un nombre diferente.
• Conserva el nombre del bucket. Reemplaza tu bucket de almacenamiento para mantener el nombre actual, lo que significa que no necesitas actualizar tus aplicaciones.

En ambos casos, debes planificar el tiempo de inactividad y avisar a tus usuarios de que se trata de un tiempo de inactividad. Revisa las siguientes explicaciones para comprender cuál es la mejor opción para ti.

Nombre del bucket nuevo

Con un nombre de bucket nuevo, debes actualizar todo el código y los servicios que usan tu bucket actual. La forma de hacerlo depende de cómo se compilan y se implementan tus aplicaciones.

Para ciertas configuraciones, este enfoque puede tener menos tiempo de inactividad, pero requiere más trabajo a fin de garantizar una transición sin problemas. Este proceso incluye los siguientes pasos:

1. Copiando tus datos a un bucket de almacenamiento nuevo
2. Iniciando el tiempo de descanso.
3. Actualizando tus aplicaciones para que apunten al bucket nuevo.
4. Verificar que todo funcione como se espera y que todos los sistemas y cuentas relevantes tengan acceso al bucket
5. Borrar el bucket original
6. Finalizando tu tiempo de inactividad.

Conservar el nombre del bucket

Usa este enfoque si prefieres no cambiar tu código para que apunte a un nombre de bucket nuevo. Este proceso incluye los siguientes pasos:

1. Copiar tus datos en un bucket de almacenamiento temporal
2. Iniciando el tiempo de descanso.
3. Borrando tu bucket original.
4. Crear un bucket nuevo con el mismo nombre que tu bucket original
5. Copia los datos en tu bucket nuevo desde el bucket temporal.
6. Borrar el bucket temporal
7. Verificar que todo funcione como se espera y que todos los sistemas y cuentas relevantes tengan acceso al bucket
8. Finalizando tu tiempo de inactividad.

Precaución: Los nombres de buckets deben ser únicos a nivel global. Existe el riesgo de que otra persona tome el nombre del bucket que necesitas después de borrar el bucket anterior, pero antes de crear el nuevo. Asegúrate de crear el bucket nuevo inmediatamente después de borrar el anterior.

Reducir el tiempo de inactividad

El Servicio de transferencia de almacenamiento no bloquea las lecturas o escrituras en los buckets de origen o destino durante una transferencia.

Si eliges bloquear de forma manual las operaciones de lectura o escritura en tu bucket, puedes minimizar el tiempo de inactividad mediante la transferencia de tus datos en dos pasos: semilla y sincronización.

1. Transferencia de origen: Realiza una transferencia masiva sin bloquear la lectura o escritura en la fuente.

2. Transferencia de sincronización: Después de que se complete la primera ejecución, bloquea la lectura o escritura en el bucket de origen y realiza otra transferencia. Las transferencias del Servicio de transferencia de almacenamiento son incrementales de forma predeterminada, por lo que esta segunda transferencia solo transfiere los datos que cambiaron durante la transferencia de origen.

Optimiza la velocidad de transferencia

Cuando se estima cuánto tarda un trabajo de transferencia, ten en cuenta los posibles cuellos de botella. Por ejemplo, si la fuente tiene miles de millones de archivos pequeños, entonces la velocidad de transferencia estará vinculada a las QPS. Si los tamaños de objetos son grandes, el ancho de banda puede ser el cuello de botella.

Los límites de ancho de banda se establecen a nivel de la región y se asignan de manera equitativa entre todos los proyectos. Si hay suficiente ancho de banda disponible, el Servicio de transferencia de almacenamiento puede completar alrededor de 1,000 tareas por trabajo de transferencia por segundo. En este caso, puedes acelerar una transferencia si divides tu trabajo en varios trabajos de transferencia pequeños, por ejemplo, mediante incluir y excluir prefijos para transferir ciertos archivos.

En los casos en que la ubicación, la clase de almacenamiento y la clave de encriptación sean iguales, el Servicio de transferencia de almacenamiento no crea una copia nueva de los bytes, sino una nueva entrada de metadatos que apunta al BLOB de origen. Como resultado, las mismas copias de ubicación y clase de un gran corpus se completan con rapidez y solo están vinculadas a QPS.

Las eliminaciones también son operaciones de solo metadatos. Para estas transferencias, la paralelización de la transferencia mediante su división en varios trabajos pequeños puede aumentar la velocidad.

Conservar los metadatos

Los siguientes metadatos de objetos se conservan cuando se transfieren datos entre buckets de Cloud Storage con el Servicio de transferencia de almacenamiento:

• Metadatos personalizados creados por el usuario.
• 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 más adelante o quitar.

De manera opcional, los siguientes campos de metadatos se pueden conservar cuando realizas transferencias con la API:

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

Consulta la referencia de la API de TransferSpec para obtener más detalles.

No se conservan los siguientes campos de metadatos:

• Hora de ú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 cuando se transfiere, por lo que también se restablece el tiempo que el objeto pasó en su clase de almacenamiento. Esto significa que un objeto en Coldline Storage, después de la transferencia, debe volver a existir durante 90 días en el destino para evitar cargos por eliminación anticipada.

Puedes aplicar las políticas de ciclo de vida basadas en createTime mediante customTime. Se reemplazan los valores customTime existentes.

Para obtener más información sobre lo que se conserva y lo que no, consulta Preservación de metadatos.

Cómo controlar el control de versiones de objetos

Si deseas transferir todas las versiones de tus objetos de almacenamiento y no solo las más recientes, debes usar la CLI de gcloud o la API de REST para transferir tus datos, junto con la función de manifiesto del Servicio de transferencia de almacenamiento.

Para transferir todas las versiones de objetos, haz lo siguiente:

1. Enumera los objetos de bucket y cópialos en un archivo JSON:

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

   Por lo general, este comando enumera alrededor de 1,000 objetos por segundo.

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

   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 el control de versiones de objetos en el bucket de destino.

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

5. Luego, transfiere las versiones publicadas de la misma manera y especifica live-object-manifest.csv como el archivo de manifiesto.

Configura las opciones de transferencia

Algunas de las opciones disponibles cuando configuras tu transferencia son las siguientes:

• Registro: Cloud Logging proporciona registros detallados de objetos individuales, lo que te permite verificar el estado de las transferencias y realizar verificaciones adicionales de integridad de los datos.

• Filtrado: Puedes usar prefijos de inclusión y exclusión para limitar los objetos en los que opera el Servicio de transferencia de almacenamiento. Esta opción se puede usar para dividir una transferencia en varios trabajos de transferencia a fin de que puedan ejecutarse en paralelo. Consulta Cómo optimizar la velocidad de transferencia para obtener más información.

• Opciones de transferencia: Puedes configurar tu transferencia para reemplazar elementos existentes en el bucket de destino, borrar objetos en el destino que no existen en el conjunto de transferencia o borrar objetos transferidos del origen.

Transfiere tus datos

Después de definir tu estrategia de transferencia, puedes realizar la transferencia por sí misma.

Crea un bucket nuevo

Antes de comenzar la transferencia, crea un bucket de almacenamiento. Consulta location_considerations para obtener ayuda sobre cómo elegir una ubicación de bucket adecuada.

Es posible que desees copiar algunos de los metadatos del bucket cuando crees el bucket nuevo. Consulta Obtén metadatos del bucket para aprender a mostrar los metadatos del bucket de origen, de modo que puedas aplicar la misma configuración a tu bucket nuevo.

Copia objetos en el bucket nuevo

Puedes copiar objetos del bucket de origen a uno nuevo mediante la consola de Google Cloud, la CLI de gcloud, la API de REST o las bibliotecas cliente. El enfoque que elijas dependerá de tu estrategia de transferencia.

Las siguientes instrucciones corresponden al caso de uso básico de la transferencia de objetos de un bucket a otro y deben modificarse para satisfacer tus necesidades.

No incluyas información sensible, como información de identificación personal (PII) o datos de seguridad, en el nombre de tu 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 del proyecto.

Consola de Google Cloud

Usa el Servicio de transferencia de almacenamiento de Cloud desde la consola de Google Cloud:

1. Abre la página Transferencia en la consola de Google Cloud.

   Abrir la página de Transferencias

2. Haz clic en Crear trabajo de transferencia.

3. Sigue la explicación detallada y haz clic en Siguiente a medida que completas cada uno de los siguientes pasos:

   • Cómo comenzar: Usa Google Cloud Storage como Tipo de fuente y Tipo de destino.

   • Elige una fuente: Ingresa el nombre del bucket que deseas directamente o haz clic en Explorar para buscar y seleccionar el bucket que deseas.

   • Elige un destino: ingresa el nombre del bucket deseado de forma directa o haz clic en Examinar para buscar y seleccionar el bucket que deseas.

   • Selecciona la configuración: Selecciona la opción Borrar archivos desde la fuente después de la transferencia.

   • Opciones de programación: Puedes ignorar esta sección.

4. Después de completar la explicación paso a paso, haz clic en Crear.

   Así, comienza el proceso de copia de objetos desde tu bucket anterior al nuevo. Este proceso puede tomar un tiempo; sin embargo, después de hacer clic en Crear, puedes salir de la consola de Google Cloud.

   Para ver el progreso de la transferencia, haz lo siguiente:

   Abre la página Transferencia en la consola de Google Cloud.

   Abrir la página de Transferencias

   Para aprender a obtener información detallada sobre las operaciones fallidas del Servicio de transferencia de almacenamiento en la consola de Google Cloud, consulta Solución de problemas.

5. Una vez que se completa la transferencia, no necesitas hacer nada para borrar los objetos de tu bucket anterior si seleccionaste la casilla de verificación Borrar objetos de origen después de que se complete la transferencia durante la configuración. Sin embargo, también puedes borrar tu bucket anterior, lo que debes hacer por separado.

gcloud CLI

Instala la CLI de gcloud

Si aún no lo has hecho, instala la herramienta de línea de comandos de gcloud.

Luego, llama a gcloud init para inicializar la herramienta y especificar el ID del proyecto y la cuenta de usuario. Consulta Cómo inicializar el SDK de Cloud para obtener más detalles.

gcloud init

Agrega la cuenta de servicio a tu carpeta de destino

Debes agregar la cuenta de servicio del Servicio de transferencia de almacenamiento a tu bucket de destino antes de crear una transferencia. Para hacerlo, usa gsutil iam ch:

gsutil iam ch serviceAccount:[e-mail]:roles/storage.admin gs://bucket_name

Para obtener instrucciones sobre cómo usar la consola de Google Cloud o la API, consulta Usa los permisos de IAM en la documentación de Cloud Storage.

Crea el trabajo de transferencia

Para crear un trabajo de transferencia nuevo, usa el comando gcloud transfer jobs create. La creación de un trabajo nuevo inicia la transferencia especificada, a menos que se especifique una programación o --do-not-run.

gcloud transfer jobs create SOURCE DESTINATION

Aquí:

• SOURCE es la fuente de datos para esta transferencia, en el formato gs://BUCKET_NAME.

• DESTINATION es tu bucket nuevo, con el formato gs://BUCKET_NAME.

Las opciones adicionales incluyen:

• Información del trabajo: puedes especificar --name y --description.

• Programa: Especifica --schedule-starts, --schedule-repeats-every, y --schedule-repeats-until o --do-not-run.

• Condiciones de objetos: Usa condiciones para determinar qué objetos se transfieren. Estos incluyen --include-prefixes y --exclude-prefixes, y las condiciones basadas en el tiempo en --include-modified-[before | after]-[absolute | relative].

• Opciones de transferencia: Especifica si deseas reemplazar los archivos de destino (--overwrite-when=different o always) y si borrar ciertos archivos durante o después de la transferencia (--delete-from=destination-if-unique o source-after-transfer), especifica qué [valores de metadatos se conservarán]los metadatos y, de forma opcional, configura una clase de almacenamiento en los objetos transferidos (--custom-storage-class).

• Notificaciones: Configura las notificaciones de Pub/Sub para transferencias con --notification-pubsub-topic, --notification-event-types y --notification-payload-format.

Para ver todas las opciones, ejecuta gcloud transfer jobs create --help.

Por ejemplo, para transferir todos los objetos con el prefijo folder1, haz lo siguiente:

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

REST

En este ejemplo, aprenderás cómo mover archivos desde un bucket de Cloud Storage a otro. Por ejemplo, puedes replicar datos en un bucket en otra ubicación.

Nota: El proceso es el mismo si el bucket se encuentra en un proyecto diferente.

Realiza la solicitud con transferJobs create:

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

Respuesta:

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

Bibliotecas cliente

En este ejemplo, aprenderás cómo mover archivos desde un bucket de Cloud Storage a otro. Por ejemplo, puedes replicar datos en un bucket en otra ubicación.

Nota: El proceso es el mismo si el bucket se encuentra en un proyecto diferente.

Para obtener más información sobre las bibliotecas cliente del Servicio de transferencia de almacenamiento, consulta Comienza a usar las bibliotecas cliente del Servicio de transferencia de almacenamiento.

Java

¿Buscas muestras anteriores? Consulta la Guía de migración del Servicio de transferencia de almacenamiento.

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

Python

¿Buscas muestras anteriores? Consulta la Guía de migración del Servicio de transferencia de almacenamiento.

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

Verifica los objetos copiados

Una vez que se complete la transferencia, recomendamos realizar verificaciones adicionales de integridad de los datos.

• Valida que los objetos se copiaron de forma correcta mediante la verificación de los metadatos en los objetos, como las sumas de verificación y el tamaño.

• Verifica que se haya copiado la versión correcta de los objetos. El Servicio de transferencia de almacenamiento ofrece una opción lista para usar para verificar que los objetos sean copias. Si habilitaste el registro, visualiza los registros para verificar si todos los objetos se copiaron de forma correcta, incluidos los campos de metadatos correspondientes.

Comienza a usar el bucket de destino

Una vez completada y verificada la migración, actualiza las aplicaciones o cargas de trabajo existentes para que usen el nombre del bucket de destino. Consulta los registros de acceso a los datos en los registros de auditoría de Cloud para asegurarte de que las operaciones modifiquen y lean objetos de forma correcta.

Borra el bucket original

Una vez que todo funcione bien, borra el bucket original.

El Servicio de transferencia de almacenamiento ofrece la opción de borrar objetos después de transferirlos mediante la especificación de deleteObjectsFromSourceAfterTransfer: true en la configuración del trabajo o la selección de la opción en la consola de Google Cloud.

Programa la eliminación de objetos

Para programar la eliminación de tus objetos en una fecha posterior, usa una combinación de un trabajo de transferencia programado y la opción deleteObjectsUniqueInSink = true.

El trabajo de transferencia debe configurarse para transferir un bucket vacío al bucket que contiene tus objetos. Esto hace que el Servicio de transferencia de almacenamiento enumere los objetos y comience a borrarlos. Como las eliminaciones son una operación de solo metadatos, el trabajo de transferencia solo está vinculado a QPS. Para acelerar el proceso, divide la transferencia en varios trabajos, cada uno con un conjunto distinto de prefijos.

Como alternativa, Google Cloud ofrece un programador de trabajos cron administrado. Para obtener más información, consulta Programa el trabajo de transferencia de Google Cloud STS con Cloud Scheduler.