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. Permettono di consolidare i dati di progetti separati, spostarli in una posizione di backup o per modificare la posizione dei tuoi dati.

Quando utilizzare Storage Transfer Service

Google Cloud offre diverse opzioni per trasferire dati tra di archiviazione dei bucket Cloud Storage. Consigliamo di attenerti alle seguenti linee guida:

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

• Trasferimento di più di 1 TB: usa Storage Transfer Service. Storage Transfer Service è un di trasferimento gestito che offre sicurezza, affidabilità, e prestazioni ottimali. Elimina la necessità di ottimizzare e gestire gli script, e gestire i nuovi tentativi.

Questa guida illustra le best practice per il trasferimento di dati tra Bucket Cloud Storage usando Storage Transfer Service.

Definisci una strategia di trasferimento

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

Scegli un nome per il bucket

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

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

In entrambi i casi, devi pianificare il tempo di riposo e fornire agli utenti un adeguato preavviso il tempo di inattività sta per arrivare. Leggi le seguenti spiegazioni per capire quali la scelta migliore per te.

Nuovo nome bucket

Con un nuovo nome per il bucket, devi aggiornare tutto il codice e i servizi che utilizzano bucket attuale. Il modo in cui esegui questa operazione dipende da come sono state create le tue applicazioni di cui è stato eseguito il deployment.

Per alcune configurazioni questo approccio potrebbe avere meno tempi di inattività, ma richiede più tempo garantire una transizione senza problemi. La procedura prevede i seguenti passaggi:

1. Copia dei dati in un nuovo bucket di archiviazione in corso.
2. Avvio del tempo di riposo.
3. Aggiornamento delle applicazioni in modo che punti al nuovo bucket.
4. Verificare che tutto funzioni come previsto e che tutti i sistemi pertinenti e gli account hanno accesso al bucket.
5. Eliminazione del bucket originale.
6. Fine del tempo di riposo.

Mantieni nome bucket

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

1. Copia dei dati in un bucket di archiviazione temporaneo in corso...
2. Avvio del tempo di riposo.
3. Eliminazione del bucket originale in corso.
4. È in corso la creazione di un nuovo bucket con lo stesso nome del bucket originale.
5. Copia dei dati nel nuovo bucket dal bucket temporaneo in corso.
6. Eliminazione del bucket temporaneo in corso...
7. Verificare che tutto funzioni come previsto e che tutti i sistemi pertinenti e gli account hanno accesso al bucket.
8. Fine del tempo di riposo.

Attenzione: i nomi dei bucket devono essere univoci a livello globale. c'è il rischio che qualcun altro prenda in seguito il nome del bucket che ti serve il vecchio bucket, ma prima di crearne uno nuovo. Assicurati di creare il nuovo bucket subito dopo aver eliminato quello precedente.

Riduci al minimo il tempo di inattività

Storage Transfer Service non blocca le letture o le scritture sull'origine o sulla destinazione durante un trasferimento.

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

1. Trasferimento seed: esegui un trasferimento collettivo senza bloccare le operazioni di lettura/scrittura sulla sorgente.

2. Sincronizzazione trasferimento: dopo aver completato la prima esecuzione, blocca la lettura/scrittura il bucket di origine ed eseguire un altro trasferimento. Trasferimenti di Storage Transfer Service sono incrementali per impostazione predefinita, quindi questo secondo trasferimento trasferisce solo i dati che è cambiato durante il trasferimento di origine.

Ottimizza la velocità di trasferimento

Quando stimi la durata di un job di trasferimento, considera la possibile colli di bottiglia. Ad esempio, se l'origine ha miliardi di file di piccole dimensioni, la velocità di trasferimento sarà legata a QPS. Se gli oggetti sono di grandi dimensioni, potrebbe essere un collo di bottiglia.

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

Se la località, la classe di archiviazione e la chiave di crittografia sono uguali, Storage Transfer Service non crea una nuova copia dei byte. viene invece creato una nuova voce di metadati che rimanda al blob di origine. Di conseguenza, la stessa posizione e le copie in classe di un ampio corpus vengono completate molto rapidamente e Limite di QPS.

Anche le eliminazioni sono operazioni esclusive dei metadati. Per questi trasferimenti, il caricamento in contemporanea il trasferimento suddividendolo in più job di piccole dimensioni può aumentare la velocità.

Conserva i metadati

I seguenti metadati degli oggetti vengono conservati durante il trasferimento dei dati tra 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 mantenuto. come campo di metadati personalizzato con la chiave x-goog-reserved-source-generation, che puoi modificare o rimuovere in un secondo momento.

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

• ACL (acl)
• Classe di archiviazione (storageClass)
• CMEK (kmsKey)
• trattenuta temporanea (temporaryHold)
• Data/ora creazione oggetto (customTime)

Consulta la documentazione di riferimento dell'API TransferSpec per ulteriori dettagli.

I seguenti campi dei metadati non vengono conservati:

• Ora ultimo aggiornamento (updated)
• etag
• componentCount

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

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

Per ulteriori dettagli su cosa viene o 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 devi usare l'interfaccia a riga di comando gcloud o l'API REST per trasferire i tuoi dati, combinati con la funzionalità manifest di Storage Transfer Service.

Per trasferire tutte le versioni dell'oggetto:

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

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

   Questo comando elenca in genere circa 1000 oggetti al secondo.

2. Suddividi il file JSON in due file CSV, uno con versioni non correnti e un'altra con le versioni live:

   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. Abilita il controllo delle versioni degli oggetti su del bucket di destinazione.

4. Trasferisci prima le versioni non correnti passando il parametro non-current-object-manifest.csv file manifest come il valore del campo transferManifest.

5. Quindi, trasferisci le versioni pubblicate nello stesso modo, specificando live-object-manifest.csv come file manifest.

Configura le opzioni di trasferimento

Alcune delle opzioni a tua disposizione durante la configurazione del trasferimento sono le seguenti: che segue:

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

• Filtri: puoi utilizzare prefissi di inclusione ed esclusione per limitare gli oggetti Storage Transfer Service opera. Questa opzione può essere utilizzata per suddividere un trasferimento in più job di trasferimento in modo che possano essere eseguiti in parallelo. Consulta Ottimizza la velocità di trasferimento informazioni.

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

Trasferire i dati

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

Creazione di un nuovo bucket

Prima di iniziare il trasferimento, crea un bucket di archiviazione. Per assistenza, visita la pagina location_considerations scegliendo una località del bucket appropriata.

Potresti voler copiare alcuni dei metadati dei 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.

Copia oggetti nel nuovo bucket

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

Le seguenti istruzioni sono per il caso d'uso di base del trasferimento di oggetti da un bucket all'altro e deve essere modificato in base alle tue esigenze.

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

Console Google Cloud

Utilizza Cloud Storage Transfer Service dall'interno Console Google Cloud:

1. Apri la pagina Trasferisci nella console Google Cloud.

   Aperto alla pagina Trasferisci

2. Fai clic su Crea job di trasferimento.

3. Segui la procedura dettagliata, facendo clic su Passaggio successivo mentre per completare ogni passaggio:

   • Per iniziare: utilizza Google Cloud Storage come Tipo di origine. e Destination Type (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 ti interessa.

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

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

   • Opzioni di pianificazione: puoi ignorare questa sezione.

4. Dopo aver completato la procedura dettagliata, fai clic su Crea.

   Questo avvia il processo di copia degli oggetti dal bucket precedente quello nuovo. Questa procedura potrebbe richiedere del tempo; Tuttavia, dopo aver fatto clic Crea, puoi uscire dalla console Google Cloud.

   Per visualizzare l'avanzamento del trasferimento:

   Apri la pagina Trasferisci nella console Google Cloud.

   Aperto alla pagina Trasferisci

   Scopri come ottenere informazioni dettagliate sugli errori relativi a Storage Transfer Service non riuscito nella console Google Cloud, vedi Risoluzione dei problemi.

5. Una volta completato il trasferimento, non devi fare nulla per eliminare dal vecchio bucket se hai selezionato la casella di controllo Elimina oggetti di origine casella di controllo al termine del trasferimento durante la configurazione. Tuttavia, puoi anche eliminare il vecchio bucket, che devi eseguire separatamente.

Interfaccia a riga di comando gcloud

Installa gcloud CLI

Se non l'hai già fatto, installare lo strumento a riga di comando gcloud.

Quindi, chiama gcloud init per inizializzare lo strumento e specificare il tuo ID progetto e account utente. Consulta Inizializzare Cloud SDK per ulteriori dettagli.

gcloud init

Aggiungi l'account di servizio alla cartella di destinazione

Devi aggiungere l'account di servizio Storage Transfer Service al bucket di destinazione prima di creare un trasferimento. A questo scopo, utilizza 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

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

Crea 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 sia una pianificazione o --do-not-run è specificato.

gcloud transfer jobs create SOURCE DESTINATION

Dove:

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

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

Altre opzioni includono:

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

• Pianifica: specifica --schedule-starts, --schedule-repeats-every e --schedule-repeats-until o --do-not-run.

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

• Opzioni di trasferimento: specifica se sovrascrivere i file di destinazione (--overwrite-when=different o always) e decidere se eliminare determinate durante o dopo il trasferimento (--delete-from=destination-if-unique o source-after-transfer); specificare quali [metadati da conservare]metadati; e facoltativamente, impostare una classe di archiviazione sugli oggetti trasferiti (--custom-storage-class).

• Notifiche: configura 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 come spostare file da un file Cloud Storage a un altro bucket. Ad esempio, puoi spostare i dati in un bucket location.

Nota: la procedura è la stessa se il bucket si trova in un'altra località progetto.

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 come spostare file da un file Cloud Storage a un altro bucket. Ad esempio, puoi replicare i dati in un bucket location.

Nota: la procedura è la stessa se il bucket si trova in un'altra località progetto.

Per saperne di più sulle librerie client di Storage Transfer Service, consulta Guida introduttiva alle librerie client di Storage Transfer Service.

Java

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

Verifica gli oggetti copiati

Una volta completato il trasferimento, ti consigliamo di eseguire altri dati e controlli di integrità.

• Verifica che gli oggetti siano stati copiati correttamente verificando i metadati sugli oggetti, come checksum e dimensioni.

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

Inizia a utilizzare il bucket di destinazione

Una volta completata e verificata la migrazione, aggiorna le applicazioni esistenti o carichi di lavoro, in modo che utilizzino il nome del bucket di destinazione. Controllare i log di accesso ai dati in Cloud Audit Logs per assicurarti che operazioni di modifica e lettura degli oggetti.

Elimina il bucket originale

Quando tutto ha funzionato bene, elimina il bucket originale.

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

Pianifica eliminazione degli oggetti

Per pianificare l'eliminazione degli oggetti in una data successiva, utilizza una combinazione di job di trasferimento pianificato e deleteObjectsUniqueInSink = true .

Il job di trasferimento deve essere configurato in modo da trasferire un bucket vuoto nel bucket che contengono i tuoi oggetti. In questo modo Storage Transfer Service elenca gli oggetti e per iniziare a eliminarle. Poiché le eliminazioni sono un'operazione esclusiva dei metadati, il trasferimento è limitato solo a QPS. Per velocizzare la procedura, suddividi il trasferimento in più lavori, ognuno dei quali agisce su un insieme distinto di prefissi.

In alternativa, Google Cloud offre pianificatore cron job gestito. Per ulteriori informazioni, vedi Pianificare il job di trasferimento Google Cloud STS con Cloud Scheduler.