Trasferimento tra bucket Cloud Storage

Storage Transfer Service può essere utilizzato per trasferire grandi quantità di dati tra i bucket Cloud Storage, all'interno dello stesso progetto Google Cloud o tra progetti diversi.

Le migrazioni dei bucket sono utili in diversi scenari. Possono essere utilizzate per consolidare i dati di progetti separati, per spostare i dati in una località di backup o per modificare la località dei dati.

Quando utilizzare Storage Transfer Service

Google Cloud offre diverse opzioni per trasferire i dati tra i bucket Cloud Storage. Ti consigliamo di seguire queste linee guida:

  • Trasferimento di meno di 1 TB: usa gcloud. Per istruzioni, consulta Spostare e rinominare i bucket.

  • Trasferimento di più di 1 TB: usa Storage Transfer Service. Storage Transfer Service è un'opzione di trasferimento gestita che offre sicurezza, affidabilità e prestazioni pronte all'uso. Elimina la necessità di ottimizzare e gestire gli script e di gestire i tentativi.

Questa guida illustra le best practice per il trasferimento dei dati tra i bucket Cloud Storage utilizzando Storage Transfer Service.

Definire una strategia di trasferimento

L'aspetto della strategia di trasferimento dipende dalla complessità della situazione. Assicurati di includere le seguenti considerazioni nel tuo piano.

Scegliere un nome bucket

Per spostare i dati in un bucket di archiviazione con una località diversa, scegli uno dei seguenti approcci:

  • Nuovo nome bucket. Aggiorna le applicazioni in modo che puntino a un bucket di archiviazione con un nome diverso.
  • Mantieni il nome del bucket. Sostituisci il bucket di archiviazione per mantenere il nome corrente, il che significa che non devi aggiornare le applicazioni.

In entrambi i casi, devi pianificare i tempi di inattività e informare gli utenti che si verificheranno tempi di inattività. Esamina le seguenti spiegazioni per capire quale scelta è la migliore per te.

Nuovo nome bucket

Con un nuovo nome bucket, devi aggiornare tutto il codice e i servizi che utilizzano il bucket corrente. La procedura dipende da come vengono create e sottoposte a deployment le applicazioni.

Per alcune configurazioni, questo approccio potrebbe comportare tempi di inattività inferiori, ma richiede più lavoro per garantire una transizione senza problemi. Comporta i seguenti passaggi:

  1. Copia dei dati in un nuovo bucket di archiviazione.
  2. Avvio dei tempi di inattività.
  3. Aggiornamento delle applicazioni in modo che puntino al nuovo bucket.
  4. Verifica che tutto funzioni come previsto e che tutti i sistemi e gli account pertinenti abbiano accesso al bucket.
  5. Eliminazione del bucket originale.
  6. Termine dei tempi di inattività.

Mantieni il nome del bucket

Utilizza questo approccio se preferisci non modificare il codice in modo che punti a un nuovo nome bucket. Comporta i seguenti passaggi:

  1. Copia dei dati in un bucket di archiviazione temporaneo.
  2. Avvio dei tempi di inattività.
  3. Eliminazione del bucket originale.
  4. Creazione di un nuovo bucket con lo stesso nome del bucket originale.
  5. Copia dei dati nel nuovo bucket dal bucket temporaneo.
  6. Eliminazione del bucket temporaneo.
  7. Verifica che tutto funzioni come previsto e che tutti i sistemi e gli account pertinenti abbiano accesso al bucket.
  8. Termine dei tempi di inattività.

Ridurre al minimo i tempi di inattività

Storage Transfer Service non blocca le operazioni di lettura o scrittura sui bucket di origine o di destinazione durante un trasferimento.

Se scegli di bloccare manualmente le operazioni di lettura/scrittura sul bucket, puoi ridurre al minimo i tempi di inattività trasferendo i dati in due passaggi: seeding e sincronizzazione.

  1. Trasferimento di seeding: esegui un trasferimento collettivo senza bloccare le operazioni di lettura/scrittura sull' origine.

  2. Trasferimento di sincronizzazione: al termine della prima esecuzione, blocca le operazioni di lettura/scrittura su l bucket di origine ed esegui un altro trasferimento. Per impostazione predefinita, i trasferimenti di Storage Transfer Service sono incrementali, quindi questo secondo trasferimento trasferisce solo i dati modificati durante il trasferimento di seeding.

Ottimizzare la velocità di trasferimento

Quando stimi la durata di un job di trasferimento, tieni conto dei possibili colli di bottiglia. Ad esempio, se l'origine contiene miliardi di file di piccole dimensioni, la velocità di trasferimento sarà limitata dalle QPS. Se le dimensioni degli oggetti sono grandi, la larghezza di banda potrebbe essere il collo di bottiglia.

I limiti di larghezza di banda sono impostati a livello di regione e vengono allocati in modo equo tra tutti i progetti. Se è disponibile una larghezza di banda sufficiente, Storage Transfer Service può completare circa 1000 attività per job di trasferimento al secondo. In questo caso, puoi accelerare un trasferimento suddividendo il job in più job di trasferimento di piccole dimensioni, ad esempio utilizzando i prefissi di inclusione ed esclusione per trasferire determinati file.

Nei casi in cui la località, la classe di archiviazione e la chiave di crittografia sono le stesse, Storage Transfer Service non crea una nuova copia dei byte, ma crea una nuova voce di metadati che punta al blob di origine. Di conseguenza, le copie di un corpus di grandi dimensioni nella stessa località e classe vengono completate molto rapidamente e sono limitate solo dalle QPS.

Anche le eliminazioni sono operazioni solo sui metadati. Per questi trasferimenti, la parallelizzazione del trasferimento suddividendolo in più job di piccole dimensioni può aumentare la velocità.

Conservare i metadati

I seguenti metadati degli oggetti vengono conservati durante il trasferimento dei dati tra i bucket Cloud Storage con Storage Transfer Service:

  • Metadati personalizzati creati dall'utente.
  • Campi di metadati a chiave fissa di Cloud Storage, come Cache-Control, Content-Disposition, Content-Type e Custom-Time.
  • Dimensioni dell'oggetto.
  • Il numero di generazione viene conservato come campo di metadati personalizzati con la chiave x-goog-reserved-source-generation, che puoi modificare o rimuovere in un secondo momento.

I seguenti campi di metadati possono essere conservati facoltativamente durante il trasferimento tramite l'API:

  • ACL (acl)
  • Classe di archiviazione (storageClass)
  • CMEK (kmsKey)
  • Trattenuta temporanea (temporaryHold)
  • Ora di creazione dell'oggetto (customTime)

Per ulteriori dettagli, consulta il riferimento API TransferSpec

I seguenti campi di metadati non vengono conservati:

  • Ora dell'ultimo aggiornamento (updated)
  • etag
  • componentCount

Se conservata, l'ora di creazione dell'oggetto viene memorizzata come campo personalizzato, customTime. L'ora updated dell'oggetto viene reimpostata al momento del trasferimento, quindi viene reimpostato anche il tempo trascorso dall'oggetto nella sua classe di archiviazione. Ciò significa che un oggetto in Coldline Storage, dopo il trasferimento, deve esistere di nuovo per 90 giorni nella destinazione per evitare addebiti per l'eliminazione anticipata.

Puoi applicare i criteri del ciclo di vita basati su createTime utilizzando customTime. I valori customTime esistenti vengono sovrascritti.

Per ulteriori dettagli su ciò che viene conservato e ciò che non viene conservato, consulta Conservazione dei metadati.

Gestire gli oggetti sottoposti al controllo delle versioni

Se vuoi trasferire tutte le versioni degli oggetti di archiviazione e non solo l' ultima, puoi utilizzare la funzionalità manifest di Storage Transfer Service.

Per trasferire tutte le versioni degli oggetti:

  1. Elenca gli oggetti del bucket e copiali in un file JSON:

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

    In genere, questo comando elenca circa 1000 oggetti al secondo.

  2. Copia gli oggetti non correnti in un file 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. Attiva il controllo delle versioni degli oggetti su il bucket di destinazione.

  4. Trasferisci le versioni non correnti con le seguenti opzioni di trasferimento:

    • Specifica il file manifest .
    • Scegli di sovrascrivere sempre gli oggetti nel sink (OVERWRITE_WHEN=always). Tieni presente che in rari casi questa operazione può creare versioni duplicate di un file.
    • Conserva i metadati timeCreated (MetdataOptions.timeCreated=TIME_CREATED_PRESERVE_AS_CUSTOM_TIME).

  5. Trasferisci le versioni live utilizzando un normale job di trasferimento.

Configurare le opzioni di trasferimento

Di seguito sono riportate alcune delle opzioni disponibili durante la configurazione del trasferimento:

  • Logging: Cloud Logging fornisce log dettagliati dei singoli oggetti, consentendoti di verificare lo stato del trasferimento ed eseguire ulteriori controlli di integrità dei dati.

  • Filtro: puoi utilizzare i prefissi di inclusione ed esclusione per limitare gli oggetti su cui opera Storage Transfer Service. Questa opzione può essere utilizzata per suddividere un trasferimento in più job di trasferimento in modo che possano essere eseguiti in parallelo. Per ulteriori informazioni, consulta Ottimizzare la velocità di trasferimento.

  • Opzioni di trasferimento: Puoi configurare il trasferimento in modo da sovrascrivere gli elementi esistenti nel bucket di destinazione, eliminare gli oggetti nella destinazione che non esistono nel set di trasferimento o eliminare gli oggetti trasferiti dall'origine.

Trasferire i dati

Dopo aver definito la tua strategia di trasferimento, puoi eseguire il trasferimento stesso.

Creare un nuovo bucket

Prima di iniziare il trasferimento, crea un bucket di archiviazione. Consulta location_considerations per scegliere una località del bucket appropriata.

Potresti voler copiare alcuni dei metadati del bucket quando crei il nuovo bucket. Consulta Recuperare i metadati del bucket per scoprire come visualizzare i metadati del bucket di origine, in modo da poter applicare le stesse impostazioni al nuovo bucket.

Copiare gli oggetti nel nuovo bucket

Puoi copiare gli oggetti dal bucket di origine a un nuovo bucket utilizzando la Google Cloud console, l'interfaccia a riga di comando gcloud CLI, l'API REST o le librerie client. L'approccio scelto dipende dalla strategia di trasferimento.

Le seguenti istruzioni riguardano il caso d'uso di base del trasferimento di oggetti da un bucket a un altro e devono essere modificate in base alle tue esigenze.

Non includere informazioni sensibili come quelle che consentono l'identificazione personale (PII) oppure dati di sicurezza nel nome del job di trasferimento. I nomi delle risorse possono essere propagati ai nomi di altre risorse Google Cloud e possono essere esposti a sistemi interni di Google al di fuori del tuo progetto.

Google Cloud Console

Utilizza il Cloud Storage Transfer Service dalla Google Cloud console:

  1. Apri la pagina Trasferimento nella Google Cloud console.

    Apri la pagina Trasferimento

  2. Fai clic su Crea job di trasferimento.

  3. Segui la procedura dettagliata passo passo, facendo clic su Passaggio successivo al termine di ogni passaggio:

    • Inizia: utilizza Google Cloud Storage come Tipo di origine e Tipo di destinazione.

    • Scegli un'origine: inserisci direttamente il nome del bucket desiderato oppure fai clic su Sfoglia per trovare e selezionare il bucket che vuoi.

    • Scegli una destinazione: inserisci direttamente il nome del bucket desiderato oppure fai clic su Sfoglia per trovare e selezionare il bucket che vuoi.

    • Scegli le impostazioni: seleziona l'opzione Elimina i file dall'origine dopo il trasferimento.

    • Opzioni di pianificazione: puoi ignorare questa sezione.

  4. Al termine della procedura dettagliata passo passo, fai clic su Crea.

    Viene avviato il processo di copia degli oggetti dal vecchio bucket a quello nuovo. Questo processo potrebbe richiedere del tempo; tuttavia, dopo aver fatto clic su Crea, puoi uscire dalla Google Cloud console.

    Per visualizzare l'avanzamento del trasferimento:

    Apri la pagina Trasferimento nella Google Cloud console.

    Apri la pagina Trasferimento

    Per scoprire come ottenere informazioni dettagliate sugli errori relativi alle operazioni di Storage Transfer Service non riuscite nella Google Cloud console, consulta Risoluzione dei problemi.

  5. Al termine del trasferimento, non devi fare nulla per eliminare gli oggetti dal vecchio bucket se hai selezionato la casella di controllo Elimina gli oggetti di origine al termine del trasferimento durante la configurazione. Tuttavia, potresti anche voler eliminare il vecchio bucket, che devi fare separatamente.

Gcloud CLI

Installare la gcloud CLI

Se non l'hai ancora fatto, installa lo strumento a riga di comando gcloud.

Quindi, chiama gcloud init per inizializzare lo strumento e specificare l'ID progetto e l'account utente. Per ulteriori dettagli, consulta Inizializzare Cloud SDK per maggiori informazioni.

gcloud init

Aggiungere il account di servizio alla cartella di destinazione

Prima di creare un trasferimento, devi aggiungere il account di servizio di Storage Transfer Service al bucket di destinazione. Per farlo, utilizza gcloud storage buckets add-iam-policy-binding:

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

Per istruzioni sull'utilizzo della Google Cloud console o dell'API, consulta Utilizzare le autorizzazioni IAM nella documentazione di Cloud Storage.

Creare il job di trasferimento

Per creare un nuovo job di trasferimento, utilizza il comando gcloud transfer jobs create. La creazione di un nuovo job avvia il trasferimento specificato, a meno che non venga specificata una pianificazione o --do-not-run.

gcloud transfer jobs create SOURCE DESTINATION

Sostituisci quanto segue:

  • SOURCE è l'origine dati per questo trasferimento, nel formato gs://BUCKET_NAME.

  • DESTINATION è il nuovo bucket, nel formato gs://BUCKET_NAME.

Le opzioni aggiuntive includono:

  • Informazioni sul job: puoi specificare --name e --description.

  • Pianificazione: specifica --schedule-starts, --schedule-repeats-every e --schedule-repeats-until oppure --do-not-run.

  • Condizioni degli oggetti: utilizza le condizioni per determinare quali oggetti vengono trasferiti. Questi includono --include-prefixes e --exclude-prefixes, nonché le condizioni basate sul tempo in --include-modified-[before | after]-[absolute | relative].

  • Opzioni di trasferimento: specifica se sovrascrivere i file di destinazione (--overwrite-when=different o always) e se eliminare determinati file durante o dopo il trasferimento (--delete-from=destination-if-unique o source-after-transfer); specifica i valori dei metadati da conservare (--preserve-metadata); e facoltativamente, imposta una classe di archiviazione sugli oggetti trasferiti (--custom-storage-class).

  • Notifiche: configura le notifiche Pub/Sub per i trasferimenti con --notification-pubsub-topic, --notification-event-types e --notification-payload-format.

Per visualizzare tutte le opzioni, esegui gcloud transfer jobs create --help.

Ad esempio, per trasferire tutti gli oggetti con il prefisso folder1:

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

REST

In questo esempio, imparerai a spostare i file da un bucket Cloud Storage a un altro. Ad esempio, puoi spostare i dati in un bucket in un'altra località.

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

Risposta:

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

Librerie client

In questo esempio, imparerai a spostare i file da un bucket Cloud Storage a un altro. Ad esempio, puoi replicare i dati in un bucket in un'altra località.

Per ulteriori informazioni sulle librerie client di Storage Transfer Service, consulta Iniziare a utilizzare le librerie client di Storage Transfer Service.

Java

Cerchi esempi precedenti? Consulta la Guida alla migrazione di Storage Transfer Service. 

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

Cerchi esempi precedenti? Consulta la Guida alla migrazione di Storage Transfer Service. 

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

Verificare gli oggetti copiati

Al termine del trasferimento, ti consigliamo di eseguire ulteriori controlli di integrità dei dati.

  • Verifica che gli oggetti siano stati copiati correttamente controllando i metadati degli oggetti, come i checksum e le dimensioni.

  • Verifica che sia stata copiata la versione corretta degli oggetti. Storage Transfer Service offre un'opzione predefinita per verificare che gli oggetti siano copie. Se hai attivato la registrazione, visualizza i log per verificare se tutti gli oggetti sono stati copiati correttamente, inclusi i relativi campi di metadati.

Iniziare a utilizzare il bucket di destinazione

Al termine della migrazione e della verifica, aggiorna le applicazioni o i workload esistenti in modo che utilizzino il nome del bucket di destinazione. Controlla gli audit log di accesso ai dati in Cloud Audit Logs per assicurarti che le operazioni modifichino e leggano correttamente gli oggetti.

Eliminare il bucket originale

Quando tutto funziona correttamente, elimina il bucket originale.

Storage Transfer Service offre la possibilità di eliminare gli oggetti dopo che sono stati trasferiti specificando deleteObjectsFromSourceAfterTransfer: true nella configurazione del job o selezionando l'opzione nella Google Cloud console.

Pianificare l'eliminazione degli oggetti

Per pianificare l'eliminazione degli oggetti in un secondo momento, utilizza una combinazione di un job di trasferimento pianificato e l' deleteObjectsUniqueInSink = true opzione.

Il job di trasferimento deve essere configurato per trasferire un bucket vuoto nel bucket contenente gli oggetti. In questo modo, Storage Transfer Service elenca gli oggetti e inizia a eliminarli. Poiché le eliminazioni sono operazioni solo sui metadati, il job di trasferimento è limitato solo dalle QPS. Per velocizzare la procedura, suddividi il trasferimento in più job, ognuno dei quali agisce su un insieme distinto di prefissi.

In alternativa, Google Cloud offre uno strumento di pianificazione dei job cron gestito. Per ulteriori informazioni, consulta Pianificare il job di trasferimento STS di Google Cloud con Cloud Scheduler.