Transférer des données entre buckets Cloud Storage

Le service de transfert de stockage permet de transférer de grandes quantités de données entre les buckets Cloud Storage, au sein d'un même projet Google Cloud ou entre différents projets.

Les migrations de buckets sont utiles dans plusieurs cas de figure. Ils peuvent être utilisés pour regrouper des données de projets distincts, pour déplacer des données vers un emplacement de sauvegarde ou pour modifier l'emplacement de vos données.

Quand utiliser le service de transfert de stockage ?

Google Cloud propose plusieurs options pour transférer des données entre plusieurs buckets Cloud Storage. Nous vous recommandons de respecter les consignes suivantes:

  • Transfert de moins de 1 To : utilisez gcloud. Pour obtenir des instructions, reportez-vous à la section Déplacer et renommer des buckets.

  • Transfert de plus de 1 To: utilisez le service de transfert de stockage. Le service de transfert de stockage est une option de transfert gérée qui offre une sécurité, une fiabilité et des performances prêtes à l'emploi. Vous évitez ainsi d'optimiser et de gérer les scripts, et de gérer les nouvelles tentatives.

Ce guide traite des bonnes pratiques lors du transfert de données entre des buckets Cloud Storage à l'aide du service de transfert de stockage.

Définir une stratégie de transfert

Votre stratégie de transfert dépend de la complexité de votre situation. Veillez à inclure les considérations suivantes dans votre plan.

Choisir un nom de bucket

Pour déplacer vos données vers un autre bucket de stockage, choisissez l'une des approches suivantes :

  • Nouveau nom de bucket. Mettez à jour vos applications pour qu'elles pointent vers un bucket de stockage portant un nom différent.
  • Conserver le nom du bucket Remplacez votre bucket de stockage pour conserver le nom actuel, ce qui signifie que vous n'avez pas besoin de mettre à jour vos applications.

Dans les deux cas, vous devez prévoir un temps d'arrêt et en informer vos utilisateurs de manière appropriée. Consultez les explications suivantes pour déterminer l'option qui vous convient le mieux.

Nouveau nom du bucket

Si vous changez le nom d'un bucket, vous devez mettre à jour l'ensemble du code et des services qui utilisent votre bucket actuel. La procédure à suivre dépend de la manière dont vos applications sont créées et déployées.

Pour certaines configurations, cette approche peut réduire les temps d'arrêt, mais elle nécessite plus de travail pour assurer une transition fluide. Il comprend les étapes suivantes :

  1. Copie de vos données dans un nouveau bucket de stockage…
  2. Démarrage de votre temps d'arrêt.
  3. Mettre à jour vos applications pour qu'elles pointent vers le nouveau bucket.
  4. Vérifier que tout fonctionne comme prévu et que tous les systèmes et comptes concernés ont accès au bucket.
  5. Suppression du bucket d'origine.
  6. Fin de votre temps d'arrêt.

Conserver le nom du bucket

Utilisez cette approche si vous préférez ne pas modifier votre code pour qu'il pointe vers un nouveau nom de bucket. Il comprend les étapes suivantes :

  1. Copie de vos données dans un bucket de stockage temporaire.
  2. Démarrage de votre temps d'arrêt.
  3. Suppression de votre bucket d'origine.
  4. Créer un bucket portant le même nom que votre bucket d'origine.
  5. Copie des données du bucket temporaire vers votre nouveau bucket.
  6. Suppression du bucket temporaire.
  7. Vérifier que tout fonctionne comme prévu et que tous les systèmes et comptes concernés ont accès au bucket.
  8. Fin de votre temps d'arrêt.

Minimiser les temps d'arrêt

Le service de transfert de stockage ne verrouille pas la lecture ni l'écriture sur les buckets sources ou de destination pendant un transfert.

Si vous choisissez de verrouiller manuellement les opérations de lecture et d'écriture sur votre bucket, vous pouvez minimiser le temps d'arrêt en transférant vos données en deux étapes : seed et synchronisation.

  1. Transfert seed : effectuez un transfert groupé sans verrouiller les lectures et les écritures sur la source.

  2. Transfert de synchronisation : une fois la première exécution terminée, verrouillez les lectures et les écritures sur le bucket source et effectuez un autre transfert. Les transferts du service de transfert de stockage sont incrémentiels par défaut. Par conséquent, ce deuxième transfert ne transfère que les données modifiées lors du transfert seed.

Optimiser la vitesse de transfert

Pour estimer le temps nécessaire à une tâche de transfert, réfléchissez aux goulots d'étranglement possibles. Par exemple, si la source contient des milliards de petits fichiers, la vitesse de transfert sera liée au RPS. Si les objets sont de grande taille, la bande passante peut constituer le goulot d'étranglement.

Les limites de bande passante sont définies au niveau de la région et sont équitablement allouées à tous les projets. Si une bande passante suffisante est disponible, le service de transfert de stockage peut effectuer environ 1 000 tâches par tâche de transfert et par seconde. Vous pouvez accélérer un transfert en divisant votre tâche en plusieurs petites tâches de transfert, par exemple en utilisant des préfixes d'inclusion et d'exclusion pour transférer certains fichiers.

Si l'emplacement, la classe de stockage et la clé de chiffrement sont identiques, le service de transfert de stockage ne crée pas de copie des octets. À la place, il crée une entrée de métadonnées pointant vers l'objet blob source. De ce fait, des copies de même emplacement et de même classe d'un corpus volumineux se produisent très rapidement et ne sont liées qu'au nombre de RPS.

Les suppressions sont également des opérations exclusivement de métadonnées. Pour ces transferts, l'exécution en parallèle en les divisant en plusieurs petites tâches peut augmenter la vitesse.

Conserver les métadonnées

Les métadonnées d'objet suivantes sont conservées lors du transfert de données entre des buckets Cloud Storage dotés du service de transfert de stockage :

  • Métadonnées personnalisées créées par l'utilisateur.
  • Champs de métadonnées à clé fixe Cloud Storage, tels que Cache-Control, Content-Disposition, Content-Type et Custom-Time
  • Taille de l'objet
  • Le numéro de génération est conservé en tant que champ de métadonnées personnalisé avec la clé x-goog-reserved-source-generation, que vous pouvez modifier ou supprimer ultérieurement.

Vous pouvez éventuellement conserver les champs de métadonnées suivants lors du transfert à l'aide de l'API :

  • LCA (acl)
  • Classe de stockage (storageClass)
  • CMEK (kmsKey)
  • Préservation temporaire (temporaryHold)
  • Date et heure de création de l'objet (timeCreated)

Pour en savoir plus, consultez la documentation de référence de l'API TransferOptions.

Les champs de métadonnées suivants ne sont pas conservés :

  • Heure de la dernière mise à jour (updated)
  • etag
  • componentCount

Si elle est conservée, la date et l'heure de création de l'objet sont stockées dans un champ personnalisé, customTime. La date de updated de l'objet est réinitialisée lors du transfert. Par conséquent, le temps passé par l'objet dans sa classe de stockage est également réinitialisé.

Vous pouvez appliquer vos règles de cycle de vie basées sur createTime à l'aide de customTime. Les valeurs customTime existantes sont écrasées.

Pour en savoir plus sur les éléments conservés et ceux qui ne le sont pas, consultez Conservation des métadonnées.

Gérer les objets avec des versions gérées

Si vous souhaitez transférer toutes les versions de vos objets de stockage et pas seulement la dernière, vous pouvez utiliser la fonctionnalité de fichier manifeste du service de transfert de stockage.

Pour transférer toutes les versions d'un objet :

  1. Répertoriez les objets de bucket et copiez-les dans un fichier JSON:

    gcloud storage ls --all-versions --recursive --json gs://SOURCE_BUCKET > object-listing.json
    

    Cette commande répertorie généralement environ 1 000 objets par seconde.

  2. Copiez les objets non actuels dans un fichier 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. Activez la gestion des versions d'objets sur le bucket de destination.

  4. Transférez les versions obsolètes avec les options de transfert suivantes :

    • Spécifiez le fichier manifeste.
    • Choisissez de toujours écraser les objets dans le récepteur (--overwrite-when=always ou transferOptions.overwriteWhen: ALWAYS dans l'API). Notez que, dans de rares cas, cela peut créer des versions en double d'un fichier.
    • Conserver les métadonnées timeCreated (metadataOptions.timeCreated: TIME_CREATED_PRESERVE_AS_CUSTOM_TIME).
  5. Transférez les versions actives à l'aide d'un job de transfert standard.

Configurer les options de transfert

Certaines des options disponibles lors de la configuration de votre transfert sont les suivantes :

  • Journalisation: Cloud Logging fournit des journaux détaillés sur les objets individuels, ce qui vous permet de vérifier l'état du transfert et d'effectuer des vérifications supplémentaires d'intégrité des données.

  • Filtrage : vous pouvez utiliser des préfixes d'inclusion et d'exclusion pour limiter les objets sur lesquels le service de transfert de stockage agit. Cette option peut être utilisée pour diviser un transfert en plusieurs jobs de transfert afin qu'ils puissent s'exécuter en parallèle. Pour en savoir plus, consultez la section Optimiser la vitesse de transfert.

  • Options de transfert : vous pouvez configurer votre transfert pour écraser des éléments existants dans le bucket de destination, supprimer les objets de la destination qui n'existent pas dans l'ensemble de transfert ou supprimer des objets transférés de la source.

Transférer vos données

Une fois que vous avez défini votre stratégie de transfert, vous pouvez effectuer le transfert lui-même.

Créer un bucket

Avant de commencer le transfert, créez un bucket de stockage.

Consultez la section Considérations sur les emplacements pour vous aider à choisir un emplacement de bucket approprié.

Vous voudrez peut-être copier certaines métadonnées de bucket lorsque vous créez le bucket. Consultez la section Obtenir les métadonnées d'un bucket pour savoir comment afficher les métadonnées du bucket source afin de pouvoir appliquer les mêmes paramètres à votre nouveau bucket.

Copier des objets dans le nouveau bucket

Vous pouvez copier des objets du bucket source vers un nouveau bucket à l'aide de la consoleGoogle Cloud , de la CLI gcloud, de l'API REST ou des bibliothèques clientes. L'approche que vous choisissez dépend de votre stratégie de transfert.

Les instructions suivantes concernent le cas d'utilisation de base du transfert d'objets d'un bucket à un autre et doivent être modifiées en fonction de vos besoins.

Console Google Cloud

Utilisez le service de transfert de stockage depuis la consoleGoogle Cloud  :

  1. Ouvrez la page "Transfert" dans la console Google Cloud .

    Ouvrir la page Transfert

  2. Cliquez sur Créer un job de transfert.
  3. Suivez la procédure détaillée en cliquant sur Étape suivante à l'issue de chaque étape :

    • Premiers pas : utilisez Cloud Storage comme type de source et type de destination.

    • Sélectionnez une source : saisissez directement le nom du bucket souhaité, ou cliquez sur Parcourir pour rechercher et sélectionner le bucket de votre choix.

    • Sélectionnez une destination : saisissez directement le nom du bucket souhaité, ou cliquez sur Parcourir pour rechercher et sélectionner le bucket de votre choix.

    • Sélectionnez les paramètres : choisissez l'option Supprimer les fichiers de la source après leur transfert.

    • Options de programmation : vous pouvez ignorer cette section.

  4. Une fois la procédure détaillée achevée, cliquez sur Créer.

    Cette validation lance la copie des fichiers de votre ancien bucket dans le nouveau. Ce processus peut prendre un certain temps. Notez cependant qu'après avoir cliqué sur Créer, vous pouvez quitter la console Google Cloud .

    Pour afficher l'avancement du transfert :

    Ouvrez la page "Transfert" dans la console Google Cloud .

    Ouvrir la page Transfert

    Pour savoir comment obtenir des informations détaillées sur les erreurs liées aux opérations du service de transfert de stockage ayant échoué dans la console Google Cloud , consultez Dépannage.

  5. Une fois le transfert terminé, vous n'avez rien à faire pour supprimer les objets de votre ancien bucket si vous avez coché la case Supprimer les fichiers de la source après leur transfert lors de la configuration. Si vous souhaitez également supprimer l'ancien bucket, vous devez effectuer une procédure distincte.

gcloud CLI

Installer Google Cloud CLI

Si ce n'est pas déjà fait, installez la Google Cloud CLI.

Appelez ensuite gcloud init pour initialiser l'outil et spécifier votre ID de projet et votre compte utilisateur. Pour en savoir plus, consultez Initialiser gcloud CLI.

gcloud init

Accorder à l'agent de service l'accès à vos buckets

Avant de créer un transfert, vous devez attribuer à l'agent de service du service de transfert de stockage les rôles requis sur les buckets source et de destination. Consultez Configurer l'accès à une source : Cloud Storage et Configurer l'accès à un récepteur : Cloud Storage. Par exemple, pour attribuer un rôle sur le bucket de destination, utilisez gcloud storage buckets add-iam-policy-binding :

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

Pour obtenir des instructions sur l'utilisation de la console Google Cloud ou de l'API, consultez la page Utiliser des autorisations IAM de la documentation Cloud Storage.

Créer la tâche de transfert

Pour créer un job de transfert, utilisez la commande gcloud transfer jobs create. La création d'un job lance le transfert spécifié, sauf si une planification ou --do-not-run est spécifié.

gcloud transfer jobs create SOURCE DESTINATION

Remplacez les éléments suivants :

  • SOURCE est la source de données de ce transfert, au format gs://BUCKET_NAME.

  • DESTINATION est votre nouveau bucket, au format gs://BUCKET_NAME.

Des options supplémentaires vous sont proposées :

  • Informations sur la tâche: vous pouvez spécifier --name et --description.

  • Programmation: spécifiez --schedule-starts, --schedule-repeats-every, --schedule-repeats-until ou --do-not-run.

  • Conditions des objets: utilisez les conditions pour déterminer les objets à transférer. Cela inclut --include-prefixes et --exclude-prefixes, ainsi que les conditions basées sur l'heure dans --include-modified-[before | after]-[absolute | relative].

  • Options de transfert : indiquez si vous souhaitez remplacer les fichiers de destination (--overwrite-when=different ou always) et si vous souhaitez supprimer certains fichiers pendant ou après le transfert (--delete-from=destination-if-unique ou source-after-transfer) ; indiquez quelles valeurs de métadonnées sont à conserver (--preserve-metadata) ; et éventuellement définissez une classe de stockage sur des objets transférés (--custom-storage-class).

  • Notifications: configurez des notifications Pub/Sub pour les transferts avec --notification-pubsub-topic, --notification-event-types et --notification-payload-format.

Pour afficher toutes les options, exécutez la commande gcloud transfer jobs create --help.

Par exemple, pour transférer tous les objets comportant le préfixe folder1:

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

REST

Dans cet exemple, vous allez apprendre à déplacer des fichiers d'un bucket Cloud Storage à un autre.

Par exemple, vous pouvez déplacer les données d'un bucket dans un autre emplacement.

Effectuez une requête à l'aide de la méthode transferJobs.create :

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

Réponse :

200 OK
{
  "name": "transferJobs/JOB_ID",
  "description": "YOUR_DESCRIPTION",
  "projectId": "PROJECT_ID",
  "transferSpec": {
      "gcsDataSource": {
          "bucketName": "GCS_SOURCE_NAME"
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      },
      "transferOptions": {
          "deleteObjectsFromSourceAfterTransfer": true
      }
  },
  "schedule": {
      "scheduleStartDate": {
          "day": DAY,
          "month": MONTH,
          "year": YEAR
      },
      "scheduleEndDate": {
          "day": DAY,
          "month": MONTH,
          "year": YEAR
      },
      "startTimeOfDay": {
          "hours": 1,
          "minutes": 1
      }
  },
  "status": "ENABLED",
  "creationTime": "2026-01-01T01:01:00.000000000Z",
  "lastModificationTime": "2026-01-01T01:01:00.000000000Z"
}

Bibliothèques clientes

Les exemples suivants créent un job de transfert quotidien qui déplace les objets non modifiés depuis 30 jours d'un bucket Cloud Storage source vers un bucket Cloud Storage Nearline.

Vous pouvez également utiliser des bibliothèques clientes pour répliquer des données dans un bucket situé dans un autre emplacement.

Pour en savoir plus sur les bibliothèques clientes du service de transfert de stockage, consultez la page Premiers pas avec les bibliothèques clientes du service de transfert de stockage.

Java

Vous recherchez des exemples plus anciens ? Consultez le guide de migration du service de transfert de stockage.

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

Vous recherchez des exemples plus anciens ? Consultez le guide de migration du service de transfert de stockage.

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

Vérifier les objets copiés

Une fois le transfert terminé, nous vous recommandons d'effectuer des vérifications supplémentaires d'intégrité des données.

  • Vérifiez que les objets ont été correctement copiés, en vérifiant les métadonnées des objets, telles que les sommes de contrôle et la taille.

  • Vérifiez que la version correcte des objets a été copiée. Le service de transfert de stockage propose une option prête à l'emploi pour vérifier que les objets sont des copies. Si vous avez activé la journalisation, affichez les journaux pour vérifier si tous les objets ont bien été copiés, y compris les champs de métadonnées correspondants.

Commencer à utiliser le bucket de destination

Une fois la migration terminée et vérifiée, mettez à jour les applications ou les charges de travail existantes afin qu'elles utilisent le nom du bucket cible. Consultez les journaux d'accès aux données dans les journaux d'audit Cloud pour vous assurer que vos opérations modifient et lisent correctement les objets.

Supprimer le bucket d'origine

Une fois que tout fonctionne correctement, supprimez le bucket d'origine.

Le service de transfert de stockage offre la possibilité de supprimer les objets après leur transfert, en spécifiant deleteObjectsFromSourceAfterTransfer: true dans la configuration de la tâche ou en sélectionnant l'option dans la console Google Cloud .

Programmer la suppression de l'objet

Pour programmer la suppression de vos objets à une date ultérieure, utilisez une combinaison de tâche de transfert planifiée et l'option deleteObjectsUniqueInSink = true.

La tâche de transfert doit être configurée pour transférer un bucket vide dans le bucket contenant vos objets. Ainsi, le service de transfert de stockage répertoriera les objets et commencera à les supprimer. Comme les suppressions sont des opérations impliquant uniquement des métadonnées, la tâche de transfert n'est liée que par RPS. Pour accélérer le processus, divisez le transfert en plusieurs jobs, chacun agissant sur un ensemble distinct de préfixes.

Google Cloud propose également un planificateur de job Cron géré. Pour en savoir plus, consultez Planifier un job de transfert STS Google Cloud avec Cloud Scheduler.