Crea trasferimenti

Questa pagina mostra come creare e avviare job di trasferimento.

Per verificare se l'origine e la destinazione (note anche come sink) sono supportate di Storage Transfer Service, consulta Origini e sink supportati.

Agenti e pool di agenti

A seconda dell'origine e della destinazione, potrebbe essere necessario creare e configurare un pool di agenti e installare gli agenti su una macchina con accesso all'origine o destinazione.

  • Trasferimenti da Amazon S3, Microsoft Azure, elenchi di URL o Cloud Storage a Cloud Storage non richiedono agenti e pool di agenti.

  • Trasferimenti la cui origine e/o destinazione è un file system o da compatibile con S3, richiedono agenti e pool di agenti. Consulta Gestisci i pool di agenti per instructions.

Prima di iniziare

Prima di configurare i trasferimenti, assicurati di aver configurato l'accesso:

Se usi i comandi gcloud, installa l'interfaccia a riga di comando gcloud.

Crea un trasferimento

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

  1. Vai alla pagina Storage Transfer Service nella console Google Cloud.

    Vai a Storage Transfer Service

  2. Fai clic su Crea job di trasferimento. La pagina Crea un job di trasferimento visualizzati.

  3. Scegli un'origine:

    Cloud Storage

    Il tuo account utente deve avere l'autorizzazione storage.buckets.get per poter selezionare nei bucket di origine e di destinazione. In alternativa, puoi digitare il nome direttamente nel bucket. Per ulteriori informazioni, vedi Risoluzione dei problemi di accesso.

    1. In Tipo di origine, seleziona Cloud Storage.

    2. Seleziona il Tipo di destinazione.

    3. Se la tua destinazione è Cloud Storage, seleziona Modalità di pianificazione. I trasferimenti in batch vengono eseguiti su una tantum o pianificata. Trasferimenti continui basati su eventi monitorare l'origine e trasferire i dati quando vengono aggiunti o modificati.

      Per configurare un trasferimento basato su eventi, segui le istruzioni all'indirizzo Trasferimenti basati su eventi.

    4. Fai clic su Passaggio successivo.

    5. Seleziona un bucket e (facoltativamente) una cartella al suo interno eseguendo uno dei seguenti:

      • Inserisci il nome e il percorso di un bucket Cloud Storage esistente in Il campo Bucket o cartella senza il prefisso gs://. Ad esempio: my-test-bucket/path/to/files. Per specificare un bucket Cloud Storage di un altro progetto, digita il nome esattamente nel campo Nome bucket.

      • Seleziona un elenco di bucket esistenti nei tuoi progetti facendo clic su Sfoglia e seleziona un bucket.

        Quando fai clic su Sfoglia, puoi selezionare i bucket in altre per i progetti facendo clic sull'ID progetto e selezionando il nuovo ID progetto e il nuovo bucket.

      • Per creare un nuovo bucket, fai clic su Crea nuovo bucket.

    6. Se si tratta di un trasferimento basato su eventi, inserisci Nome della sottoscrizione Pub/Sub, che accetta quanto segue formato:

      projects/PROJECT_NAME/subscriptions/SUBSCRIPTION_ID
    7. Se vuoi, puoi scegliere filtrare gli oggetti per prefisso o la data dell'ultima modifica. Se hai specificato una cartella come posizione di origine, i filtri per prefisso sono relative a questa cartella. Ad esempio, se la tua origine è my-test-bucket/path/, una il filtro di inclusione di file include tutti i file che iniziano con my-test-bucket/path/file.

    8. Fai clic su Passaggio successivo.

    Amazon S3

    Consulta Trasferimento da Amazon S3 a Cloud Storage.

    Spazio di archiviazione compatibile con S3

    Consulta Trasferimento dallo spazio di archiviazione compatibile con S3 a Cloud Storage.

    Archiviazione BLOB di Microsoft Azure

    1. In Tipo di origine, seleziona Azure Blob Storage o Data Lake Storage Gen2.

    2. Fai clic su Passaggio successivo.

    3. Specifica quanto segue:

      1. Nome account spazio di archiviazione: l'account Archiviazione Microsoft Azure di origine .

        Il nome dell'account di archiviazione viene visualizzato in Archiviazione di Microsoft Azure portale in Tutti i servizi > Spazio di archiviazione > Spazio di archiviazione degli account.

      2. Nome container: il nome del container di archiviazione di Microsoft Azure.

        Il nome del container viene visualizzato nel portale di Archiviazione di Microsoft Azure in Esplora spazio di archiviazione > Container BLOB.

      3. Firma di accesso condiviso (SAS): la SAS di Microsoft Azure Storage un token creato da un criterio di accesso archiviato. Per ulteriori informazioni, consulta Concedere un accesso limitato alle risorse di Archiviazione di Azure utilizzando firme di accesso condiviso.

        La scadenza predefinita per i token SAS è di 8 ore. Quando crei il token SAS, assicurati di impostare un tempo di scadenza ragionevole che ti consenta hai completato correttamente il trasferimento.
    4. Se vuoi, puoi scegliere filtrare gli oggetti per prefisso o la data dell'ultima modifica. Se hai specificato una cartella come posizione di origine, i filtri per prefisso sono relative a questa cartella. Ad esempio, se la tua origine è my-test-bucket/path/, una il filtro di inclusione di file include tutti i file che iniziano con my-test-bucket/path/file.

    5. Fai clic su Passaggio successivo.

    File system

    1. In Source type (Tipo di origine), seleziona POSIX file system (File system POSIX).

    2. Seleziona il Tipo di destinazione e fai clic su Passaggio successivo.

    3. Seleziona un pool di agenti esistente oppure Crea pool di agenti e segui le istruzioni per creare un nuovo pool.

    4. Specifica il percorso completo della directory del file system.

    5. Fai clic su Passaggio successivo.

    HDFS

    Consulta Trasferimento da HDFS a Cloud Storage.

    Elenco URL

    1. In Tipo di origine, seleziona Elenco URL e fai clic su Passaggio successivo.

    2. Sotto URL del file TSV, fornisci l'URL a valori separati da tabulazioni (TSV). Per informazioni dettagliate, consulta Creazione di un elenco di URL su come creare il file TSV.

    3. Se vuoi, puoi scegliere filtrare gli oggetti per prefisso o la data dell'ultima modifica. Se hai specificato una cartella come posizione di origine, i filtri per prefisso sono relative a questa cartella. Ad esempio, se la tua origine è my-test-bucket/path/, una il filtro di inclusione di file include tutti i file che iniziano con my-test-bucket/path/file.

    4. Fai clic su Passaggio successivo.

  4. Scegli una destinazione:

    Cloud Storage

    1. Nel campo Bucket o cartella, inserisci il bucket di destinazione. e (facoltativamente) del nome della cartella oppure fai clic su Sfoglia per selezionare un bucket da un elenco di bucket esistenti nel tuo progetto attuale. Per creare un nuovo bucket, fai clic su Crea nuovo bucket.

    2. Fai clic su Passaggio successivo.

    3. Scegli le impostazioni per il job di trasferimento. Alcune opzioni sono disponibili disponibili per determinate combinazioni di origine e sink.

      1. Nel campo Descrizione, inserisci una descrizione del trasferimento. Come best practice, inserisci una descrizione significativa univoci in modo da poter distinguere i job.

      2. In Opzioni metadati, scegli di utilizzare le opzioni predefinite, o fai clic su Visualizza e seleziona le opzioni per specificare i valori per tutti metadati supportati. Consulta Conservazione dei metadati per maggiori dettagli.

      3. In Quando sovrascrivere, seleziona una delle seguenti opzioni:

        • Se diverso: sovrascrive i file di destinazione se il file di origine. con lo stesso nome ha valori Etag o checksum diversi.

        • Sempre: sovrascrive sempre i file di destinazione quando il file di origine. hanno lo stesso nome, anche se sono identici.

      4. In Quando eliminare, seleziona una delle seguenti opzioni:

        • Mai: non eliminare mai i file dall'origine o dalla destinazione.

        • Elimina file dall'origine dopo il trasferimento: elimina i file dall'origine dopo il trasferimento alla destinazione.

        • Elimina i file dalla destinazione se non sono anche nell'origine: se anche i file nel bucket Cloud Storage di destinazione l'origine, quindi elimina i file da Cloud Storage di sincronizzare la directory di una VM con un bucket.

          Questa opzione garantisce che il bucket Cloud Storage di destinazione corrisponde esattamente alla fonte.

      5. In Opzioni di notifica, seleziona l'argomento Pub/Sub e le per i quali inviare notifiche. Consulta Notifiche Pub/Sub per ulteriori dettagli.

    4. Fai clic su Passaggio successivo.

    File system

    1. Seleziona un pool di agenti esistente o Crea pool di agenti e segui le istruzioni per creare un nuovo pool.

    2. Specifica il percorso completo della directory di destinazione.

    3. Fai clic su Passaggio successivo.

  5. Scegli le opzioni di pianificazione:

    1. Nell'elenco a discesa Esegui una volta, seleziona una delle seguenti opzioni:

      • Esegui una volta: esegue un singolo trasferimento, a partire dal momento in cui selezionare.

      • Esegui ogni giorno: esegue un trasferimento ogni giorno, a partire da un'ora in cui selezionate.

        Puoi inserire una Data di fine facoltativa o lasciare Data di fine. vuota per eseguire il trasferimento continuamente.

      • Esegui ogni settimana: esegue un trasferimento ogni settimana, a partire da una data/ora che selezioni.

      • Esegui con frequenza personalizzata: esegue un trasferimento con una frequenza che selezionate. Puoi scegliere di ripetere il trasferimento a intervalli regolari intervallo di Ore, Giorni o Settimane.

        Puoi inserire una Data di fine facoltativa o lasciare Data di fine. vuota per eseguire il trasferimento continuamente.

    2. Dall'elenco a discesa Inizia ora, seleziona una delle seguenti opzioni:

      • A partire da ora: avvia il trasferimento dopo aver fatto clic su Crea.

      • A partire dal giorno: avvia il trasferimento nella data e nell'ora in cui selezionare. Fai clic su Calendario per visualizzare un calendario e selezionare l'opzione data di inizio.

    3. Per creare il job di trasferimento, fai clic su Crea.

Interfaccia a riga di comando gcloud

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

gcloud transfer jobs create \
  SOURCE DESTINATION

Dove:

  • SOURCE è l'origine dati per questo trasferimento. Il formato di ciascuno L'origine è:

    • Cloud Storage: gs://BUCKET_NAME. Per eseguire il trasferimento da una cartella specifica, specifica gs://BUCKET_NAME/FOLDER_PATH/, inclusa la barra finale.
    • Amazon S3: s3://BUCKET_NAME/FOLDER_PATH
    • Spazio di archiviazione compatibile con S3: s3://BUCKET_NAME. La il nome del bucket è relativo all'endpoint. Ad esempio, se i tuoi dati si trova all'indirizzo https://us-east-1.example.com/folder1/bucket_a, inserisci s3://folder1/bucket_a.
    • Archiviazione di Microsoft Azure: https://myaccount.blob.core.windows.net/CONTAINER_NAME
    • Elenco di URL: https://PATH_TO_URL_LIST o http://PATH_TO_URL_LIST
    • File system POSIX: posix:///PATH. Deve essere un percorso assoluto dalla radice della macchina host dell'agente.
    • HDFS: hdfs:///PATH

  • DESTINATION è uno di:

    • Cloud Storage: gs://BUCKET_NAME. Per trasferire in una directory specifica, gs://BUCKET_NAME/FOLDER_PATH/, inclusa la barra finale.
    • File system POSIX: posix:///PATH. Deve essere un dalla radice della macchina host dell'agente.

Se il trasferimento richiede agenti di trasferimento, sono disponibili le seguenti opzioni:

  • --source-agent-pool specifica il pool di agenti di origine da utilizzare per questa richiesta trasferimento. Richiesto per i trasferimenti provenienti da un file system.

  • --destination-agent-pool specifica il pool di agenti di destinazione da utilizzare per questo trasferimento. Necessaria per i trasferimenti a un file system.

  • --intermediate-storage-path è il percorso di un bucket Cloud Storage, in il modulo gs://my-intermediary-bucket. Obbligatorio per i trasferimenti tra due file system in-app. Consulta Crea un bucket Cloud Storage come intermediario per maggiori dettagli sulla creazione del bucket intermedio.

Altre opzioni includono:

  • --source-creds-file specifica il percorso relativo di un file locale sul tuo che include credenziali AWS o Azure per l'origine di trasferimento. Per informazioni sulla formattazione dei file di credenziali, consulta TransferSpec riferimento.

  • --do-not-run impedisce a Storage Transfer Service di eseguire il job al momento dell'invio del comando. Per eseguire il job, aggiornalo in aggiungi una programmazione o utilizza jobs run per avviarla manualmente.

  • --manifest-file specifica il percorso di un file CSV in Cloud Storage contenente un elenco di file da trasferire dall'origine. Per il file manifest formattazione, consulta Trasferisci file o oggetti specifici utilizzando un manifest.

  • Informazioni job: puoi specificare --name, --description, e --source-creds-file.

  • 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]. Se una cartella con l'origine, i filtri per prefisso sono relativi . Per ulteriori informazioni, consulta Filtrare gli oggetti di origine per prefisso informazioni.

    Le condizioni degli oggetti non sono supportate per i trasferimenti che coinvolgono i file system.

  • Opzioni di trasferimento: specifica se sovrascrivere la destinazione file (--overwrite-when=different o always) e indica se eliminare determinati file durante o dopo il trasferimento (--delete-from=destination-if-unique o source-after-transfer); specificare i valori dei metadati da conservare (--preserve-metadata); 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.

  • Cloud Logging: abilita Cloud Logging per i trasferimenti senza agenti oppure da origini compatibili con S3, con --log-actions e --log-action-states. Consulta Cloud Logging per Storage Transfer Service per maggiori dettagli.

I trasferimenti da origini compatibili con S3 utilizzano anche le seguenti opzioni:

  • --source-endpoint (obbligatorio) specifica l'endpoint del tuo sistema di archiviazione. Ad esempio, s3.example.com. Rivolgiti al tuo fornitore per conoscere formattazione corretta. Non specificare il protocollo (http:// o https://).
  • --source-signing-region specifica una regione per la firma delle richieste. Ometti questo flag se il tuo fornitore di spazio di archiviazione non richiede una regione di firma.
  • --source-auth-method specifica il metodo di autenticazione da utilizzare. Valido sono AWS_SIGNATURE_V2 o AWS_SIGNATURE_V4. Consulta Per saperne di più, consulta la documentazione di Amazon SigV4 e SigV2.
  • --source-request-model specifica lo stile di indirizzamento da utilizzare. Valori validi sono PATH_STYLE o VIRTUAL_HOSTED_STYLE. Lo stile del percorso utilizza il formato https://s3.example.com/BUCKET_NAME/KEY_NAME. Lo stile con hosting virtuale utilizza il formato `https://BUCKET_NAME.s3.example.com/KEY_NAME.
  • --source-network-protocol specifica il protocollo di rete che gli agenti per questo lavoro. I valori validi sono HTTP o HTTPS.
  • --source-list-api specifica la versione dell'API di elenco S3 per che restituiscono oggetti dal bucket. I valori validi sono LIST_OBJECTS o LIST_OBJECTS_V2. Fai riferimento a ListObjectsV2 di Amazon e documentazione di ListObjects per ulteriori informazioni.

Per visualizzare tutte le opzioni, esegui gcloud transfer jobs create --help o consulta le documentazione di riferimento gcloud.

Esempi

Da Amazon S3 a Cloud Storage

Vedi Trasferimento da Amazon S3 a Cloud Storage.

Archiviazione compatibile con S3 in Cloud Storage

Vedi Trasferimento dallo spazio di archiviazione compatibile con S3 a Cloud Storage.

Dal file system a Cloud Storage

Vedi Trasferimento da un file system a Cloud Storage.

Da Cloud Storage al file system

Per eseguire il trasferimento da un bucket Cloud Storage a un file system, specifica seguire.

gcloud transfer jobs create \
  gs://my-storage-bucket posix:///tmp/destination \
  --destination-agent-pool=my-destination-agent-pool

Da file system a file system

Per eseguire il trasferimento tra due file system, devi specificare un pool di agenti di origine, un pool di agenti di destinazione e un bucket Cloud Storage intermedio trasmessi dai dati.

Consulta Crea un bucket Cloud Storage come intermediario per i dettagli sul bucket intermedio.

Quindi, specifica queste tre risorse quando chiami transfer jobs create:

gcloud transfer jobs create \
  posix:///tmp/source/on/systemA posix:///tmp/destination/on/systemB \
  --source-agent-pool=source_agent_pool \
  --destination-agent-pool=destination_agent_pool \
  --intermediate-storage-path=gs://my-intermediary-bucket

REST

Gli esempi riportati di seguito mostrano come utilizzare Storage Transfer Service tramite REST API.

Quando configuri o modifichi i job di trasferimento utilizzando nell'API Storage Transfer Service, l'ora deve essere nel fuso orario UTC. Per ulteriori informazioni che specifica la pianificazione di un job di trasferimento, Programmazione.

Trasferimento tra bucket Cloud Storage

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.

Richiedi tramite transferJobs create:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "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_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
              }
          }
      }
  ]
}

Trasferimento da Amazon S3 a Cloud Storage

Vedi Trasferimento da Amazon S3 a Cloud Storage.

Trasferimento tra Microsoft Azure Blob Storage e Cloud Storage

In questo esempio, scoprirai come spostare file da Archiviazione di Microsoft Azure a un Bucket Cloud Storage, utilizzando un accesso condiviso a Archiviazione di Microsoft Azure di firma (SAS).

Per ulteriori informazioni su Microsoft Azure Storage SAS, vedi Concedi un accesso limitato alle risorse di Archiviazione di Azure utilizzando le firme di accesso condiviso (SAS).

Prima di iniziare, rivedi Configura l'accesso allo spazio di archiviazione di Microsoft Azure e Prezzi per comprendere le implicazioni spostando i dati da Archiviazione di Microsoft Azure a Cloud Storage.

Richiesta utilizzando transferJobs create: 

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "schedule": {
      "scheduleStartDate": {
          "day": 14,
          "month": 2,
          "year": 2020
      },
      "scheduleEndDate": {
          "day": 14
          "month": 2,
          "year": 2020
      },
      "startTimeOfDay": {
          "hours": 1,
          "minutes": 1
      }
  },
  "transferSpec": {
      "azureBlobStorageDataSource": {
          "storageAccount": "AZURE_SOURCE_NAME",
          "azureCredentials": {
              "sasToken": "AZURE_SAS_TOKEN",
          },
          "container": "AZURE_CONTAINER",
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}
Risposta: 
200 OK
{
  "transferJob": [
      {
          "creationTime": "2020-02-14T01:01:00.000000000Z",
          "description": "YOUR DESCRIPTION",
          "name": "transferJobs/JOB_ID",
          "status": "ENABLED",
          "lastModificationTime": "2020-02-14T01:01:00.000000000Z",
          "projectId": "PROJECT_ID",
          "schedule": {
              "scheduleStartDate": {
                  "day": 14
                  "month": 2,
                  "year": 2020
              },
              "scheduleEndDate": {
                  "day": 14,
                  "month": 2,
                  "year": 2020
              },
              "startTimeOfDay": {
                  "hours": 1,
                  "minutes": 1
              }
          },
          "transferSpec": {
              "azureBlobStorageDataSource": {
                  "storageAccount": "AZURE_SOURCE_NAME",
                  "azureCredentials": {
                      "sasToken": "AZURE_SAS_TOKEN",
                  },
                  "container": "AZURE_CONTAINER",
              },
              "objectConditions": {},
              "transferOptions": {}
          }
      }
  ]
}

Trasferire da un file system

Vedi Trasferimento da un file system a Cloud Storage.

Specificare i percorsi di origine e di destinazione

I percorsi di origine e di destinazione consentono di specificare i percorsi di origine e di destinazione durante il trasferimento dei dati nel bucket Cloud Storage. Per ad esempio, supponiamo di avere i file file1.txt e file2.txt e un Bucket Cloud Storage denominato B. Se imposti un percorso di destinazione denominato my-stuff, al termine del trasferimento i file si troveranno in gs://B/my-stuff/file1.txt e gs://B/my-stuff/file2.txt.

Specificare un percorso di origine

Per specificare un percorso di origine durante la creazione di un job di trasferimento, aggiungi un campo path a il campo gcsDataSource nel tuo Specifica di TransferSpec:

{
gcsDataSource: {
  bucketName: "SOURCE_BUCKET",
  path: "SOURCE_PATH/",
},
}

In questo esempio:

  • SOURCE_BUCKET: il bucket Cloud Storage di origine.
  • SOURCE_PATH: il percorso Cloud Storage di origine.

Specificare un percorso di destinazione

Per specificare una cartella di destinazione quando crei un job di trasferimento, aggiungi path al campo gcsDataSink nel tuo Specifica di TransferSpec:

{
gcsDataSink: {
  bucketName: "DESTINATION_BUCKET",
  path: "DESTINATION_PATH/",
},
}

In questo esempio:

  • DESTINATION_BUCKET: il bucket Cloud Storage di destinazione.
  • DESTINATION_PATH: il percorso Cloud Storage di destinazione.

Completa una richiesta di esempio

Di seguito è riportato un esempio di richiesta completa:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "schedule": {
      "scheduleStartDate": {
          "day": 1,
          "month": 1,
          "year": 2015
      },
      "startTimeOfDay": {
          "hours": 1,
          "minutes": 1
      }
  },
  "transferSpec": {
      "gcsDataSource": {
          "bucketName": "GCS_SOURCE_NAME",
          "path": "GCS_SOURCE_PATH",
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME",
          "path": "GCS_SINK_PATH",
      },
      "objectConditions": {
          "minTimeElapsedSinceLastModification": "2592000s"
      },
      "transferOptions": {
          "deleteObjectsFromSourceAfterTransfer": true
      }
  }

}

Librerie client

Gli esempi riportati di seguito mostrano come utilizzare Storage Transfer Service in modo programmatico con Go, Java, Node.js e Python.

Quando configuri o modifichi i job di trasferimento in modo programmatico, l'ora deve essere nel fuso orario UTC. Per ulteriori informazioni che specifica la pianificazione di un job di trasferimento, Programmazione.

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

Trasferimento tra bucket Cloud Storage

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.

Vai

import (
	"context"
	"fmt"
	"io"
	"time"

	"google.golang.org/genproto/googleapis/type/date"
	"google.golang.org/genproto/googleapis/type/timeofday"
	"google.golang.org/protobuf/types/known/durationpb"

	storagetransfer "cloud.google.com/go/storagetransfer/apiv1"
	"cloud.google.com/go/storagetransfer/apiv1/storagetransferpb"
)

func transferToNearline(w io.Writer, projectID string, gcsSourceBucket string, gcsNearlineSinkBucket string) (*storagetransferpb.TransferJob, error) {
	// Your Google Cloud Project ID
	// projectID := "my-project-id"

	// The name of the GCS bucket to transfer objects from
	// gcsSourceBucket := "my-source-bucket"

	// The name of the Nearline GCS bucket to transfer objects to
	// gcsNearlineSinkBucket := "my-sink-bucket"

	ctx := context.Background()
	client, err := storagetransfer.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("storagetransfer.NewClient: %w", err)
	}
	defer client.Close()

	// A description of this job
	jobDescription := "Transfers objects that haven't been modified in 30 days to a Nearline bucket"

	// The time to start the transfer
	startTime := time.Now().UTC()

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId:   projectID,
			Description: jobDescription,
			TransferSpec: &storagetransferpb.TransferSpec{
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsNearlineSinkBucket}},
				DataSource: &storagetransferpb.TransferSpec_GcsDataSource{
					GcsDataSource: &storagetransferpb.GcsData{BucketName: gcsSourceBucket},
				},
				ObjectConditions: &storagetransferpb.ObjectConditions{
					MinTimeElapsedSinceLastModification: &durationpb.Duration{Seconds: 2592000 /*30 days */},
				},
				TransferOptions: &storagetransferpb.TransferOptions{DeleteObjectsFromSourceAfterTransfer: true},
			},
			Schedule: &storagetransferpb.Schedule{
				ScheduleStartDate: &date.Date{
					Year:  int32(startTime.Year()),
					Month: int32(startTime.Month()),
					Day:   int32(startTime.Day()),
				},
				ScheduleEndDate: &date.Date{
					Year:  int32(startTime.Year()),
					Month: int32(startTime.Month()),
					Day:   int32(startTime.Day()),
				},
				StartTimeOfDay: &timeofday.TimeOfDay{
					Hours:   int32(startTime.Hour()),
					Minutes: int32(startTime.Minute()),
					Seconds: int32(startTime.Second()),
				},
			},
			Status: storagetransferpb.TransferJob_ENABLED,
		},
	}
	resp, err := client.CreateTransferJob(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("failed to create transfer job: %w", err)
	}
	if _, err = client.RunTransferJob(ctx, &storagetransferpb.RunTransferJobRequest{
		ProjectId: projectID,
		JobName:   resp.Name,
	}); err != nil {
		return nil, fmt.Errorf("failed to run transfer job: %w", err)
	}
	fmt.Fprintf(w, "Created and ran transfer job from %v to %v with name %v", gcsSourceBucket, gcsNearlineSinkBucket, resp.Name)
	return resp, nil
}

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

Node.js


// Imports the Google Cloud client library
const {
  StorageTransferServiceClient,
} = require('@google-cloud/storage-transfer');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of the Google Cloud Platform Project that owns the job
// projectId = 'my-project-id'

// A useful description for your transfer job
// description = 'My transfer job'

// Google Cloud Storage source bucket name
// gcsSourceBucket = 'my-gcs-source-bucket'

// Google Cloud Storage destination bucket name
// gcsSinkBucket = 'my-gcs-destination-bucket'

// Date to start daily migration
// startDate = new Date()

// Creates a client
const client = new StorageTransferServiceClient();

/**
 * Create a daily migration from a GCS bucket to another GCS bucket for
 * objects untouched for 30+ days.
 */
async function createDailyNearline30DayMigration() {
  // Runs the request and creates the job
  const [transferJob] = await client.createTransferJob({
    transferJob: {
      projectId,
      description,
      status: 'ENABLED',
      schedule: {
        scheduleStartDate: {
          day: startDate.getDate(),
          month: startDate.getMonth() + 1,
          year: startDate.getFullYear(),
        },
      },
      transferSpec: {
        gcsDataSource: {
          bucketName: gcsSourceBucket,
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
        },
        objectConditions: {
          minTimeElapsedSinceLastModification: {
            seconds: 2592000, // 30 days
          },
        },
        transferOptions: {
          deleteObjectsFromSourceAfterTransfer: true,
        },
      },
    },
  });

  console.log(`Created transferJob: ${transferJob.name}`);
}

createDailyNearline30DayMigration();

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

Trasferimento da Amazon S3 a Cloud Storage

Vedi Trasferimento da Amazon S3 a Cloud Storage.

Trasferimento tra Microsoft Azure Blob Storage e Cloud Storage

In questo esempio, scoprirai come spostare file da Archiviazione di Microsoft Azure a un Bucket Cloud Storage, utilizzando un accesso condiviso a Archiviazione di Microsoft Azure di firma (SAS).

Per ulteriori informazioni su Microsoft Azure Storage SAS, vedi Concedi un accesso limitato alle risorse di Archiviazione di Azure utilizzando le firme di accesso condiviso (SAS).

Prima di iniziare, rivedi Configura l'accesso allo spazio di archiviazione di Microsoft Azure e Prezzi per comprendere le implicazioni spostando i dati da Archiviazione di Microsoft Azure a Cloud Storage.

Go

Per scoprire come installare e utilizzare la libreria client per Storage Transfer Service, vedi Librerie client di Storage Transfer Service. Per ulteriori informazioni, consulta API Storage Transfer Service Go documentazione di riferimento.

Per eseguire l'autenticazione a Storage Transfer Service, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

import (
	"context"
	"fmt"
	"io"
	"os"

	storagetransfer "cloud.google.com/go/storagetransfer/apiv1"
	"cloud.google.com/go/storagetransfer/apiv1/storagetransferpb"
)

func transferFromAzure(w io.Writer, projectID string, azureStorageAccountName string, azureSourceContainer string, gcsSinkBucket string) (*storagetransferpb.TransferJob, error) {
	// Your Google Cloud Project ID.
	// projectID := "my-project-id"

	// The name of your Azure Storage account.
	// azureStorageAccountName := "my-azure-storage-acc"

	// The name of the Azure container to transfer objects from.
	// azureSourceContainer := "my-source-container"

	// The name of the GCS bucket to transfer objects to.
	// gcsSinkBucket := "my-sink-bucket"

	ctx := context.Background()
	client, err := storagetransfer.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("storagetransfer.NewClient: %w", err)
	}
	defer client.Close()

	// The Azure SAS token, should be accessed via environment variable for security
	azureSasToken := os.Getenv("AZURE_SAS_TOKEN")

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId: projectID,
			TransferSpec: &storagetransferpb.TransferSpec{
				DataSource: &storagetransferpb.TransferSpec_AzureBlobStorageDataSource{
					AzureBlobStorageDataSource: &storagetransferpb.AzureBlobStorageData{
						StorageAccount: azureStorageAccountName,
						AzureCredentials: &storagetransferpb.AzureCredentials{
							SasToken: azureSasToken,
						},
						Container: azureSourceContainer,
					},
				},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsSinkBucket}},
			},
			Status: storagetransferpb.TransferJob_ENABLED,
		},
	}
	resp, err := client.CreateTransferJob(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("failed to create transfer job: %w", err)
	}
	if _, err = client.RunTransferJob(ctx, &storagetransferpb.RunTransferJobRequest{
		ProjectId: projectID,
		JobName:   resp.Name,
	}); err != nil {
		return nil, fmt.Errorf("failed to run transfer job: %w", err)
	}
	fmt.Fprintf(w, "Created and ran transfer job from %v to %v with name %v", azureSourceContainer, gcsSinkBucket, resp.Name)
	return resp, nil
}

Java

Per scoprire come installare e utilizzare la libreria client per Storage Transfer Service, vedi Librerie client di Storage Transfer Service. Per ulteriori informazioni, consulta API Storage Transfer Service Java documentazione di riferimento.

Per eseguire l'autenticazione a Storage Transfer Service, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto;
import com.google.storagetransfer.v1.proto.TransferProto.RunTransferJobRequest;
import com.google.storagetransfer.v1.proto.TransferTypes.AzureBlobStorageData;
import com.google.storagetransfer.v1.proto.TransferTypes.AzureCredentials;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob.Status;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferSpec;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class TransferFromAzure {
  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    // Your Google Cloud Project ID
    String projectId = "my-project-id";

    // Your Azure Storage Account name
    String azureStorageAccount = "my-azure-account";

    // The Azure source container to transfer data from
    String azureSourceContainer = "my-source-container";

    // The GCS bucket to transfer data to
    String gcsSinkBucket = "my-sink-bucket";

    transferFromAzureBlobStorage(
        projectId, azureStorageAccount, azureSourceContainer, gcsSinkBucket);
  }

  /**
   * Creates and runs a transfer job to transfer all data from an Azure container to a GCS bucket.
   */
  public static void transferFromAzureBlobStorage(
      String projectId,
      String azureStorageAccount,
      String azureSourceContainer,
      String gcsSinkBucket)
      throws IOException, ExecutionException, InterruptedException {

    // Your Azure SAS token, should be accessed via environment variable
    String azureSasToken = System.getenv("AZURE_SAS_TOKEN");

    TransferSpec transferSpec =
        TransferSpec.newBuilder()
            .setAzureBlobStorageDataSource(
                AzureBlobStorageData.newBuilder()
                    .setAzureCredentials(
                        AzureCredentials.newBuilder().setSasToken(azureSasToken).build())
                    .setContainer(azureSourceContainer)
                    .setStorageAccount(azureStorageAccount))
            .setGcsDataSink(GcsData.newBuilder().setBucketName(gcsSinkBucket).build())
            .build();

    TransferJob transferJob =
        TransferJob.newBuilder()
            .setProjectId(projectId)
            .setStatus(Status.ENABLED)
            .setTransferSpec(transferSpec)
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources,
    // or use "try-with-close" statement to do this automatically.
    try (StorageTransferServiceClient storageTransfer = StorageTransferServiceClient.create()) {
      // Create the transfer job
      TransferJob response =
          storageTransfer.createTransferJob(
              TransferProto.CreateTransferJobRequest.newBuilder()
                  .setTransferJob(transferJob)
                  .build());

      // Run the created job
      storageTransfer
          .runTransferJobAsync(
              RunTransferJobRequest.newBuilder()
                  .setProjectId(projectId)
                  .setJobName(response.getName())
                  .build())
          .get();

      System.out.println(
          "Created and ran a transfer job from "
              + azureSourceContainer
              + " to "
              + gcsSinkBucket
              + " with "
              + "name "
              + response.getName());
    }
  }
}

Node.js

Per scoprire come installare e utilizzare la libreria client per Storage Transfer Service, vedi Librerie client di Storage Transfer Service. Per ulteriori informazioni, consulta API Storage Transfer Service Node.js documentazione di riferimento.

Per eseguire l'autenticazione a Storage Transfer Service, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 


// Imports the Google Cloud client library
const {
  StorageTransferServiceClient,
} = require('@google-cloud/storage-transfer');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of the Google Cloud Platform Project that owns the job
// projectId = 'my-project-id'

// A useful description for your transfer job
// description = 'My transfer job'

// Azure Storage Account name
// azureStorageAccount = 'accountname'

// Azure Storage Account name
// azureSourceContainer = 'my-azure-source-bucket'

// Azure Shared Access Signature token
// azureSASToken = '?sv=...'

// Google Cloud Storage destination bucket name
// gcsSinkBucket = 'my-gcs-destination-bucket'

// Creates a client
const client = new StorageTransferServiceClient();

/**
 * Creates a one-time transfer job from Azure Blob Storage to Google Cloud Storage.
 */
async function transferFromBlobStorage() {
  // Setting the start date and the end date as the same time creates a
  // one-time transfer
  const now = new Date();
  const oneTimeSchedule = {
    day: now.getDate(),
    month: now.getMonth() + 1,
    year: now.getFullYear(),
  };

  // Runs the request and creates the job
  const [transferJob] = await client.createTransferJob({
    transferJob: {
      projectId,
      description,
      status: 'ENABLED',
      schedule: {
        scheduleStartDate: oneTimeSchedule,
        scheduleEndDate: oneTimeSchedule,
      },
      transferSpec: {
        azureBlobStorageDataSource: {
          azureCredentials: {
            sasToken: azureSASToken,
          },
          container: azureSourceContainer,
          storageAccount: azureStorageAccount,
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
        },
      },
    },
  });

  console.log(
    `Created and ran a transfer job from '${azureSourceContainer}' to '${gcsSinkBucket}' with name ${transferJob.name}`
  );
}

transferFromBlobStorage();

Python

Per scoprire come installare e utilizzare la libreria client per Storage Transfer Service, vedi Librerie client di Storage Transfer Service. Per ulteriori informazioni, consulta API Storage Transfer Service Python documentazione di riferimento.

Per eseguire l'autenticazione a Storage Transfer Service, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

from datetime import datetime

from google.cloud import storage_transfer


def create_one_time_azure_transfer(
    project_id: str,
    description: str,
    azure_storage_account: str,
    azure_sas_token: str,
    source_container: str,
    sink_bucket: str,
):
    """Creates a one-time transfer job from Azure Blob Storage to Google Cloud
    Storage."""

    # Initialize client that will be used to create storage transfer requests.
    # This client only needs to be created once, and can be reused for
    # multiple requests.
    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'

    # Azure Storage Account name
    # azure_storage_account = 'accountname'

    # Azure Shared Access Signature token
    # azure_sas_token = '?sv=...'

    # Azure Blob source container name
    # source_container = 'my-azure-source-bucket'

    # Google Cloud Storage destination bucket name
    # sink_bucket = 'my-gcs-destination-bucket'

    now = datetime.utcnow()
    # Setting the start date and the end date as
    # the same time creates a one-time transfer
    one_time_schedule = {"day": now.day, "month": now.month, "year": now.year}

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "schedule": {
                    "schedule_start_date": one_time_schedule,
                    "schedule_end_date": one_time_schedule,
                },
                "transfer_spec": {
                    "azure_blob_storage_data_source": {
                        "storage_account": azure_storage_account,
                        "azure_credentials": {"sas_token": azure_sas_token},
                        "container": source_container,
                    },
                    "gcs_data_sink": {
                        "bucket_name": sink_bucket,
                    },
                },
            }
        }
    )

    result = client.create_transfer_job(transfer_job_request)
    print(f"Created transferJob: {result.name}")

Trasferire da un file system

Vedi Trasferimento da un file system a Cloud Storage.