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 consolider les données de projets distincts, déplacer les données vers un emplacement de sauvegarde, ou 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:

• Transférer moins de 1 To: utilisez gcloud. Pour obtenir des instructions, se référer à Déplacez et renommez 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. Il élimine le besoin d'optimiser et de gérer des scripts, et gérer les 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 actuelle. Veillez à inclure les considérations suivantes dans votre plan.

Choisir un nom de bucket

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

• Nouveau nom de bucket. Mettre à jour vos applications pour qu'elles pointent vers un bucket de stockage avec 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 les temps d'arrêt et informer vos utilisateurs de manière appropriée ce temps d'arrêt arrive. Consultez les explications suivantes pour identifier qui vous convient le mieux.

Nouveau nom de bucket

Avec un nouveau nom de bucket, vous devez mettre à jour l'ensemble du code et des services qui utilisent votre bucket actuel. La marche à suivre dépend de la création de vos applications déployés.

Pour certaines configurations, cette approche peut entraîner moins de temps d'arrêt, mais nécessite plus afin d'assurer une transition en douceur. Voici les étapes à suivre:

1. copier vos données dans un nouveau bucket de stockage ;
2. Démarrage du temps de pause...
3. Mettre à jour vos applications pour qu'elles pointent vers le nouveau bucket
4. en vérifiant que tout fonctionne comme prévu et que tous les systèmes pertinents et comptes ont accès au bucket.
5. Supprimer le bucket d'origine
6. Fin de votre temps de pause.

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 bucket son nom. Voici les étapes à suivre:

1. copier vos données dans un bucket de stockage temporaire ;
2. Démarrage du temps de pause...
3. Suppression du bucket d'origine...
4. Créer un bucket portant le même nom que votre bucket d'origine
5. Copiez les données du bucket temporaire dans le nouveau bucket.
6. Supprimer le bucket temporaire
7. en vérifiant que tout fonctionne comme prévu et que tous les systèmes pertinents et comptes ont accès au bucket.
8. Fin de votre temps de pause.

Attention :Les noms de buckets doivent être uniques au niveau mondial. Il y a un risque que quelqu'un d'autre puisse prendre le nom de bucket dont vous avez besoin après supprimer votre ancien bucket, mais avant d'en créer un nouveau. Veillez à créer le nouveau bucket immédiatement après avoir supprimé l'ancien.

Minimiser les temps d'arrêt

Le service de transfert de stockage ne verrouille pas les lectures ni les écritures sur la source ou la destination pendant un transfert.

Si vous choisissez de verrouiller manuellement les lectures/écritures sur votre bucket, vous pouvez réduire en transférant vos données en deux étapes: la graine et la synchronisation.

1. Transfert seed: effectuez un transfert groupé sans verrouiller la lecture/écriture sur la source.

2. Transfert de synchronisation: une fois la première exécution terminée, verrouillez le mode lecture/écriture sur le bucket source et effectuer un autre transfert. Transferts du service de transfert de stockage étant incrémentiels par défaut, ce deuxième transfert ne transfère que des données qui ont changé pendant le transfert de la graine.

Optimiser la vitesse de transfert

Lorsque vous estimez la durée d'une tâche de transfert, tenez compte des les goulots d'étranglement. Par exemple, si la source contient des milliards de petits fichiers, alors la vitesse de transfert sera limitée en 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 dans ce cas, en divisant votre job en plusieurs jobs de transfert de petite taille, par exemple Utilisez les 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 nouvelle copie des octets. à la place, une nouvelle entrée de métadonnées qui pointe vers l'objet blob source. Par conséquent, le même emplacement et les copies de classe d'un corpus volumineux sont réalisées très rapidement et ne sont Limité aux RPS.

Les suppressions sont également des opérations exclusivement de métadonnées. Pour ces transferts, vous devez exécuter le transfert en le divisant en plusieurs petites tâches peut accélérer le transfert.

Conserver les métadonnées

Les métadonnées d'objet suivantes sont conservées lors du transfert de données Buckets Cloud Storage avec 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 pourrez modifier ou supprimer ultérieurement.

Les champs de métadonnées suivants peuvent éventuellement être conservés lors du transfert à l'aide de l'API:

• LCA (acl)
• Classe de stockage (storageClass)
• Clé CMEK (kmsKey)
• Retenue temporaire (temporaryHold)
• Heure de création de l'objet (customTime)

Consultez la documentation de référence de l'API TransferSpec pour en savoir plus.

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

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

S'il est conservé, l'heure de création de l'objet est stockée en tant que champ personnalisé. customTime La durée updated de l'objet est réinitialisée lors du transfert. Par conséquent, le passé par l'objet dans sa classe de stockage est également réinitialisée. Cela signifie qu'un objet Après le transfert, le stockage Coldline doit exister à nouveau pendant 90 jours destination pour éviter des frais de suppression anticipée.

Vous pouvez appliquer vos règles de cycle de vie basées sur createTime avec customTime. Les valeurs customTime existantes sont remplacées.

Pour en savoir plus sur ce qui est préservé et ce qui ne l'est pas, consultez Conservation des métadonnées.

Gérer des objets avec gestion des versions

Si vous souhaitez transférer toutes les versions de vos objets de stockage et pas seulement les la plus récente, vous devez utiliser la CLI gcloud ou l'API REST pour transférer vos données, combinées à la fonctionnalité de fichier manifeste du service de transfert de stockage.

Pour transférer toutes les versions d'objet:

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

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

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

2. Divisez le fichier JSON en deux fichiers CSV, un fichier avec les versions obsolètes, et une autre avec les versions en ligne:

   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. Activer la gestion des versions des objets sur le bucket de destination.

4. Transférez d'abord les versions archivées en transmettant le fichier manifeste non-current-object-manifest.csv en tant que valeur du champ transferManifest.

5. Transférez ensuite les versions actives de la même manière, en spécifiant live-object-manifest.csv comme fichier manifeste.

Configurer les options de transfert

Lorsque vous configurez votre transfert, vous avez le choix entre les options suivantes : ce qui suit:

• 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 utiliser des préfixes d'inclusion et d'exclusion pour limiter les objets Le service de transfert de stockage fonctionne. Cette option permet de scinder un transfert en plusieurs jobs de transfert afin qu'ils puissent s'exécuter en parallèle. Voir Optimisez la vitesse de transfert pour des informations.

• Options de transfert: Vous pouvez configurer votre transfert de façon à écraser les éléments existants dans le bucket de destination ; de supprimer les objets de la destination qui n'existent pas dans l'ensemble de transfert ; ou supprimer les objets transférés de la source.

Transférer vos données

Après avoir 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 location_considerations pour obtenir de l'aide choisir un emplacement de bucket approprié.

Vous voudrez peut-être copier certaines des métadonnées de bucket lorsque vous créez le bucket. Consultez la section Obtenir les métadonnées d'un bucket. pour apprendre à 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 méthode la console Google Cloud, la CLI gcloud, l'API REST ou les 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. Vous devez les modifier en fonction de vos besoins.

N'incluez pas d'informations sensibles, telles que des informations permettant d'identifier personnellement l'utilisateur. ou de sécurité dans le nom de votre job de transfert. Les noms de ressources peuvent être propagés vers les noms d'autres ressources Google Cloud et peuvent être exposés aux systèmes internes de Google, en dehors de votre projet.

console Google Cloud

Utilisez le service de transfert de stockage Cloud depuis Google Cloud Console :

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

   Ouvrir la page Transfert

2. Cliquez sur Créer une tâche de transfert.

3. Suivez la procédure détaillée en cliquant sur Étape suivante à chaque étape :

   • Premiers pas: utilisez Google Cloud Storage comme type de source. et Destination Type (Type de destination).

   • Choisissez 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 : sélectionnez 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 suivie, cliquez sur Créer.

   Cette validation entraîne 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 Google Cloud Console.

   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 du service de transfert de stockage en échec, procédez comme suit : dans la console Google Cloud, consultez Dépannage

5. Une fois le transfert terminé, vous n'avez rien à faire pour supprimer le des objets de votre ancien bucket si vous avez sélectionné l'option Supprimer les objets sources une fois le transfert terminé lors de la configuration. Vous pouvez toutefois supprimer votre ancien bucket. ce que vous devez faire séparément.

CLI gcloud

Installer gcloud CLI

Si ce n'est pas déjà fait, installez l'outil de ligne de commande gcloud.

Appelez ensuite gcloud init pour initialiser l'outil et spécifier votre ID de projet et votre compte utilisateur. Consultez la page Initialiser le SDK Cloud pour en savoir plus plus de détails.

gcloud init

Ajouter le compte de service à votre dossier de destination

Vous devez ajouter le compte de service du service de transfert de stockage à votre bucket de destination avant de créer un transfert. Pour ce faire, utilisez gcloud storage buckets add-iam-policy-binding:

gcloud storage buckets add-iam-policy-binding gs://bucket_name \
--member=serviceAccount:[e-mail] \
--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 une tâche 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

Où :

• 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 écraser les fichiers de destination. (--overwrite-when=different ou always) et si vous voulez en supprimer de fichiers pendant ou après le transfert (--delete-from=destination-if-unique ou source-after-transfer) ; préciser quelles [valeurs de métadonnées à conserver]métadonnées ; et définir éventuellement une classe de stockage pour les 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.

Remarque : Le processus est le même, même si le bucket se trouve dans un projet différent.

Effectuez une requête à l'aide de la méthode 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
      }
  }
}

Réponse :

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

Bibliothèques clientes

Dans cet exemple, vous allez apprendre à déplacer des fichiers d'un bucket Cloud Storage à un autre. Par exemple, vous pouvez répliquer les données d'un bucket situé dans un autre emplacement.

Remarque : Le processus est le même, même si le bucket se trouve dans un projet différent.

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.

• de s'assurer que les objets ont été copiés correctement en vérifiant les métadonnées ; sur les objets, comme 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 offre une option prête à l'emploi pour vérifier que les objets sont des copies. Si vous avez activé logging afficher les journaux pour vérifier si tous les objets ont bien été copiés, y compris leurs champs de métadonnées correspondants.

Commencer à utiliser le bucket de destination

Une fois la migration terminée et validée, mettez à jour les applications existantes. ou charges de travail pour qu'elles utilisent le nom du bucket cible. consulter les journaux des accès aux données ; dans Cloud Audit Logs pour vous assurer que les opérations modifient et lisent correctement les objets.

Supprimer le bucket d'origine

Une fois que tout fonctionne bien, 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 planifier la suppression de vos objets à une date ultérieure, combinez un job de transfert planifié deleteObjectsUniqueInSink = true .

La tâche de transfert doit être configurée pour transférer un bucket vide dans le bucket contenant vos objets. Le service de transfert de stockage répertorie alors les objets commencer à les supprimer. Étant donné que les suppressions sont une opération de métadonnées uniquement, le transfert est limité aux RPS. Pour accélérer le processus, divisez le transfert en plusieurs des jobs, chacun agissant sur un ensemble distinct de préfixes.

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