Trasferimento da Amazon S3 a Cloud Storage

Questa pagina mostra come creare e avviare job di trasferimento da Amazon S3 a Cloud Storage.

Prerequisiti

Prima di configurare il trasferimento, assicurati di aver configurato quanto segue:

• Autorizzazioni utente: assicurati che il tuo account utente o il tuo service account gestito dall'utente disponga dell'autorizzazione per configurare i job di trasferimento. Consulta Autorizzazioni dell'utente richieste.
• Autorizzazioni S3 di origine: configura l'accesso ai tuoi dati in Amazon S3 utilizzando le credenziali di accesso o l'identità federata. Consulta Configura l'accesso a un'origine: Amazon S3.
• Autorizzazioni per il bucket di destinazione: concedi le autorizzazioni richieste per il bucket Cloud Storage di destinazione. Consulta Configura l'accesso a un sink: Cloud Storage.

Opzioni di traffico in uscita

Storage Transfer Service offre diverse opzioni per trasferire i dati S3 in Cloud Storage.

Opzione di traffico in uscita	Descrizione
Senza agente predefinito	Questa opzione utilizza un trasferimento gestito senza agenti da S3. Amazon ti addebita il traffico in uscita. Segui le istruzioni riportate in questa pagina per utilizzare questa opzione.
Distribuzione CloudFront	Utilizza una distribuzione Amazon CloudFront come percorso in uscita. I trasferimenti di dati tramite CloudFront possono beneficiare di costi di traffico in uscita di AWS inferiori rispetto al trasferimento diretto da S3. Per i dettagli, consulta Prezzi di CloudFront e Tariffe per il traffico in uscita di S3. Segui le istruzioni riportate in Trasferisci da S3 tramite CloudFront per configurare la distribuzione e creare un trasferimento.
Rete privata gestita da Google	Trasferisci i dati su una rete gestita da Google. Non paghi costi di traffico in uscita S3, ma una tariffa per GiB a Google Cloud, riducendo potenzialmente i costi di trasferimento. Per maggiori dettagli, consulta la pagina dei prezzi. Potrebbero comunque essere applicati costi operativi da AWS (ad es.chiamate LIST o GET). Per maggiori dettagli, consulta i prezzi. I trasferimenti di tutti i progetti sulla rete privata gestita condividono la stessa larghezza di banda. In periodi di utilizzo elevato, il trasferimento potrebbe rallentare. I trasferimenti con file di grandi dimensioni sono più interessati rispetto a quelli con file di piccole dimensioni. Questa opzione è disponibile solo per alcune regioni AWS e non è supportata per le regioni AWS GovCloud. Per maggiori dettagli, consulta Trasferimento su una rete privata gestita da Google.
Rete privata gestita dal cliente	Trasferisci i dati su una rete privata gestita dal cliente. Utilizza una connessione Cross-Cloud Interconnect o Partner Interconnect esistente oppure acquistane e utilizzane una nuova. Le connessioni Interconnect forniscono una connessione fisica dedicata tra Google Cloud e Amazon S3 o Azure. Per i dettagli, consulta Trasferisci da AWS o Azure su una rete privata gestita dal cliente.
Basato sugli agenti	Valido per tutto lo spazio di archiviazione compatibile con S3, incluso Amazon S3. Installando il software dell'agente su macchine con accesso ai tuoi bucket S3, puoi controllare il percorso di rete e la larghezza di banda. Questa opzione richiede agenti e pool di agenti. Per utilizzare questa opzione, segui le istruzioni riportate in Trasferisci da origini compatibili con S3.

Aree geografiche supportate

Storage Transfer Service supporta le seguenti regioni Amazon S3:

af-south-1 ap-east-1 ap-east-2 ap-northeast-1 ap-northeast-2 ap-northeast-3 ap-south-1 ap-south-2 ap-southeast-1 ap-southeast-2

ap-southeast-3 ap-southeast-4 ap-southeast-5 ca-central-1 ca-west-1 eu-central-1 eu-central-2 eu-north-1 eu-south-1 eu-south-2

eu-west-1 eu-west-2 eu-west-3 il-central-1 me-central-1 me-south-1 sa-east-1

us-east-1 us-east-2 us-west-1 us-west-2 us-gov-east-1 us-gov-west-1

I trasferimenti che utilizzano la rete privata gestita da Google supportano le seguenti regioni AWS:

ap-east-1 ap-northeast-1 ap-northeast-2 ap-northeast-3 ap-south-1 ap-south-2 ap-southeast-1 ca-central-1 ca-west-1 eu-central-1 eu-central-2

eu-north-1 eu-south-1 eu-south-2 eu-west-1 eu-west-2 eu-west-3 us-east-1 us-east-2 us-west-1 us-west-2

Opzioni di trasferimento

Le seguenti funzionalità di Storage Transfer Service sono disponibili per i trasferimenti da S3 a Cloud Storage

Trasferisci file specifici utilizzando un manifest

Puoi passare un elenco di file su cui Storage Transfer Service può agire. Per maggiori dettagli, consulta Trasferisci file o oggetti specifici utilizzando un manifest.

Filtra gli oggetti di origine per prefisso, ora dell'ultima modifica o classe di archiviazione

Puoi scegliere di includere o escludere oggetti dal trasferimento in base al nome file e al percorso, all'ora dell'ultima modifica o alla classe di archiviazione.

Per impostazione predefinita, vengono trasferiti gli oggetti nelle classi di archiviazione standard e di archiviazione dei dati ad accesso sporadico, tra cui Glacier Instant Retrieval (GLACIER_IR), mentre gli oggetti Glacier Deep Archive (DEEP_ARCHIVE) vengono trasferiti se ripristinati. Gli oggetti Glacier Flexible Retrieval (GLACIER) vengono ignorati per impostazione predefinita.

Per saperne di più sui prefissi, consulta Filtra gli oggetti di origine per prefisso. Per saperne di più sulle classi di archiviazione, consulta Filtra gli oggetti di origine in base alla classe di archiviazione.

I filtri basati sul tempo includono:

• Tempo minimo e massimo trascorso dall'ultima modifica. Entrambi accettano un valore in secondi per filtrare gli oggetti che sono stati o non sono stati modificati entro un determinato periodo di tempo.
• Last modified since (Ultima modifica dal) e Last modified before (Ultima modifica prima del), che accettano entrambi un valore dateTime.

Tieni presente che i filtri basati sul tempo per i trasferimenti S3 si basano sulla definizione di "ora dell'ultima modifica" di AWS, ovvero l'ora in cui inizia il caricamento di un oggetto. Poiché un oggetto non è disponibile fino al termine del caricamento, potresti trovare oggetti la cui ora dell'ultima modifica soddisfa i criteri di filtro, ma che sono ancora in fase di caricamento. Questi oggetti non verranno inclusi nel job di trasferimento. Per evitare problemi, ti consigliamo di:

• Anziché i filtri basati sul tempo, utilizza i trasferimenti basati su eventi per trasferire gli oggetti non appena diventano disponibili.
• Per evitare oggetti mancanti nei trasferimenti ricorrenti, la finestra temporale "ora dell'ultima modifica" deve essere maggiore della pianificazione ricorrente. Ad esempio, per un job eseguito ogni ora, una finestra temporale di due ore fornisce un buffer.

Specifica la classe di archiviazione

Puoi specificare la classe di archiviazione di Cloud Storage da utilizzare per i dati nel bucket di destinazione. Consulta le opzioni StorageClass per i dettagli su REST o utilizza il flag --custom-storage-class con Google Cloud CLI.

Tieni presente che le impostazioni della classe di archiviazione vengono ignorate se il bucket di destinazione ha Autoclass abilitato. Se Autoclass è abilitata, gli oggetti trasferiti nel bucket vengono inizialmente impostati su Standard Storage.

Conservazione dei metadati

Quando trasferisci file da S3, Storage Transfer Service può facoltativamente conservare determinati attributi come metadati personalizzati.

Consulta la sezione Da Amazon S3 a Cloud Storage di Conservazione dei metadati per informazioni dettagliate su quali metadati possono essere conservati e su come configurare il trasferimento.

Trasferimenti basati su eventi

Storage Transfer Service può ascoltare le notifiche degli eventi di Amazon S3 inviate ad Amazon SQS per trasferire automaticamente i dati aggiunti o aggiornati nella località di origine. Per informazioni, consulta Trasferimenti basati su eventi.

Logging e monitoraggio

I trasferimenti da S3 possono essere visualizzati in Cloud Logging e Cloud Monitoring. Per maggiori dettagli, consulta Cloud Logging per Storage Transfer Service e Monitora i job di trasferimento. Puoi anche configurare le notifiche Pub/Sub.

Crea un trasferimento

Storage Transfer Service offre più interfacce tramite le quali creare un trasferimento.

Non includere nell'ID progetto informazioni sensibili come quelle che consentono l'identificazione personale (PII) oppure dati di sicurezza. I nomi delle risorse possono essere propagati ai nomi di altre risorse Google Cloud e possono essere esposti ai sistemi interni di Google esterni al 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. Viene visualizzata la pagina Crea un job di trasferimento.

3. In Tipo di origine, seleziona Amazon S3.

4. Come Tipo di destinazione, seleziona Google Cloud Storage.

5. Seleziona la modalità di programmazione. I trasferimenti in batch vengono eseguiti una tantum o in base a una pianificazione. I trasferimenti basati su eventi monitorano continuamente l'origine e trasferiscono i dati quando vengono aggiunti o modificati.

   Per configurare un trasferimento basato su eventi, segui le istruzioni riportate in Trasferimenti basati su eventi.

6. Fai clic su Passaggio successivo.

7. Nel campo Nome bucket o cartella, inserisci il nome del bucket di origine.

   Il nome del bucket è il nome visualizzato nella Console di gestione AWS.

8. Se utilizzi una distribuzione CloudFront per il trasferimento da S3, inserisci il nome di dominio della distribuzione nel campo Dominio CloudFront. Ad esempio, https://dy1h2n3l4ob56.cloudfront.net. Consulta Trasferimento da S3 tramite CloudFront per configurare una distribuzione CloudFront.

9. Seleziona il metodo di autenticazione di Amazon Web Services (AWS). Per maggiori dettagli, consulta Configura l'accesso a un'origine: Amazon S3.

   • Risorsa secret: seleziona questa opzione per utilizzare una credenziale Amazon salvata in Secret Manager. Seleziona un secret dall'elenco o inseriscine uno manualmente nel formato projects/PROJECT_NUMBER/secrets/SECRET_NAME.

   • Chiave di accesso: inserisci la chiave di accesso nel campo ID chiave di accesso e il secret associato alla chiave di accesso nel campo Chiave di accesso segreta.

   • Ruolo AWS IAM per la federazione delle identità: inserisci l'ARN nel campo ARN del ruolo AWS IAM con la seguente sintassi:

     • Regioni AWS standard:

       arn:aws:iam::AWS_ACCOUNT:role/AWS_ROLE_NAME

     • Regioni AWS GovCloud:

       arn:aws-us-gov:iam::AWS_ACCOUNT:role/AWS_ROLE_NAME

     Sostituisci quanto segue:

     • AWS_ACCOUNT: l'ID account AWS senza trattini.
     • AWS_ROLE_NAME: il nome del ruolo AWS. Se la tua organizzazione utilizza i percorsi per organizzare i ruoli, includi il percorso con il nome del ruolo. Ad esempio, developers/transfer_user.

     Per saperne di più sugli ARN, consulta ARN IAM.

10. Se si tratta di un trasferimento basato su eventi, inserisci l'ARN della coda Amazon SQS, che ha il seguente formato:

    • Regioni AWS standard:

      arn:aws:sqs:us-east-1:1234567890:event-queue

    • Regioni AWS GovCloud:

      arn:aws-us-gov:sqs:us-gov-east-1:1234567890:event-queue

11. Facoltativamente, scegli di filtrare gli oggetti per prefisso, per data dell'ultima modifica o per classe di archiviazione. Se hai specificato una cartella come posizione di origine, i filtri dei prefissi sono relativi a quella cartella. Ad esempio, se l'origine è my-test-bucket/path/, un filtro di inclusione di file include tutti i file che iniziano con my-test-bucket/path/file.

12. Fai clic su Passaggio successivo.

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

14. Fai clic su Passaggio successivo.

15. Scegli le opzioni di programmazione:

    Nota: Storage Transfer Service visualizza le pianificazioni dei job di trasferimento nel tuo fuso orario locale, ma memorizza gli orari nel fuso orario UTC (Universal Time Coordinated). Se ti trovi in una zona in cui viene applicata l'ora legale, potresti riscontrare una modifica della pianificazione dei job di trasferimento quando l'ora legale inizia o termina.

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

       • Esegui una volta: esegue un singolo trasferimento, a partire da un'ora selezionata.

       • Esegui ogni giorno: esegue un trasferimento ogni giorno, a partire da un'ora selezionata da te.

         Puoi inserire una Data di fine facoltativa o lasciare vuoto il campo Data di fine per eseguire il trasferimento in modo continuo.

       • Esegui ogni settimana: esegue un trasferimento ogni settimana, a partire da un'ora selezionata.

       • Esegui con frequenza personalizzata: esegue un trasferimento con una frequenza selezionata da te. Puoi scegliere di ripetere il trasferimento a intervalli regolari di ore, giorni o settimane.

         Puoi inserire una Data di fine facoltativa o lasciare vuoto il campo Data di fine per eseguire il trasferimento in modo continuo.

       • Esegui on demand: non attiva un'esecuzione quando viene creato questo job di trasferimento. Dovrai avviare manualmente il job.

    2. Nell'elenco a discesa A partire da ora, seleziona una delle seguenti opzioni:

       • Inizia ora: avvia il trasferimento dopo aver fatto clic su Crea.
       • A partire dal: avvia il trasferimento nella data e nell'ora selezionate. Fai clic su Calendario per visualizzare un calendario da cui selezionare la data di inizio.

16. Fai clic su Passaggio successivo.

17. Scegli le impostazioni per il job di trasferimento.

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

    2. Facoltativamente, fornisci un manifest per specificare gli oggetti esatti da trasferire.

    3. In Opzioni metadati, seleziona la classe di archiviazione e il comportamento della data e ora di creazione che preferisci. Per maggiori dettagli, consulta Conservazione dei metadati.

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

       • Mai: non sovrascrive un file di destinazione se il file di origine ha lo stesso nome. Il file di origine viene ignorato.
       • 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 ha lo stesso nome, anche se sono identici.

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

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

       • Elimina i file dall'origine dopo il trasferimento: elimina i file dall'origine dopo il trasferimento alla destinazione. Se un file di origine non viene trasferito, ad esempio perché esiste già nella destinazione, non viene eliminato.

         Importante: se non hai un backup locale, questa opzione è un'azione irreversibile.

       • Elimina i file dalla destinazione se non sono presenti anche nell'origine: se i file nel bucket Cloud Storage di destinazione non sono presenti anche nell'origine, elimina i file dal bucket Cloud Storage.

         Questa opzione garantisce che il bucket Cloud Storage di destinazione corrisponda esattamente all'origine.

    6. Scegli le opzioni di routing di rete:

       • Utilizza la rete pubblica: i trasferimenti di dati avvengono tramite route di peering internet pubblico standard tra Amazon S3 e Google Cloud. Tutti i comandi API, le intestazioni di autenticazione e i flussi di dati degli oggetti sono criptati end-to-end in transito utilizzando HTTPS con Transport Layer Security (TLS 1.3).
       • Utilizza una rete privata gestita: i dati vengono trasmessi tramite un routing privato sicuro di cui Google esegue automaticamente il provisioning, riducendo i costi del traffico in uscita verso internet di AWS e bypassando gli endpoint internet pubblici senza richiedere la configurazione di un'interconnessione fisica. Questa opzione è disponibile solo per alcune regioni AWS e non è supportata per le regioni AWS GovCloud. Consulta Trasferimento su una rete privata gestita da Google.
       • Utilizza la tua rete privata: i dati attraversano la tua infrastruttura di connettività ibrida preconfigurata (come Cloud Interconnect, Cloud VPN o AWS Direct Connect) tramite indirizzi IP privati. Consulta Trasferimento su una rete privata gestita dal cliente.

    7. In Opzioni di logging, seleziona Abilita il logging in Cloud Logging se vuoi generare un record granulare delle azioni eseguite su ogni file trasferito. Si applicano i costi di Cloud Logging. Per maggiori dettagli, consulta Azioni di trasferimento dei log.

    8. Facoltativamente, seleziona Ricevi aggiornamenti sullo stato dell'operazione di trasferimento tramite notifiche Cloud Pub/Sub, seleziona l'argomento Pub/Sub e scegli gli eventi che attivano le notifiche. Per maggiori dettagli, consulta Notifiche Pub/Sub.

    9. In Scegli account di servizio account, seleziona l'identità da utilizzare:

       • Agente di servizio Storage Transfer Service: all'agente di servizio predefinito gestito da Google viene concesso automaticamente l'accesso ai bucket di origine e di destinazione.
       • Agente di servizio gestito dall'utente: utilizza un service account personalizzato che hai creato. Prima di selezionare questa opzione, assicurati che al tuo account di servizio sia stato concesso l'accesso al bucket di origine, al bucket di destinazione e a Pub/Sub. Consulta Utilizza un agente di servizio gestito dall'utente.

18. Fai clic su Crea per creare il job di trasferimento.

gcloud CLI

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 CLI non supporta i trasferimenti tramite CloudFront o una rete privata gestita.

gcloud transfer jobs create \
  s3://S3_BUCKET_NAME gs://STORAGE_BUCKET_NAME \
  --source-creds-file="relative_path/to/creds.json"

Sostituisci quanto segue:

• S3_BUCKET_NAME è l'origine dati per questo trasferimento. Se vuoi, puoi includere un percorso: s3://S3_BUCKET_NAME/S3_FOLDER_PATH

• STORAGE_BUCKET_NAME è il bucket Cloud Storage in cui eseguire il trasferimento. Per eseguire il trasferimento in una directory specifica, specifica gs://STORAGE_BUCKET_NAME/STORAGE_FOLDER_PATH/, inclusa la barra finale.

• --source-creds-file specifica il percorso relativo di un file locale sulla tua macchina che include le credenziali AWS per l'origine del trasferimento.

  A seconda del metodo di autenticazione, formatta il file JSON come segue:

  • Chiavi di accesso AWS:

  {
      "accessKeyId": "AWS_ACCESS_KEY_ID",
      "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
  }

  • Identità federata (ARN del ruolo AWS IAM):

  {
      "roleArn": "arn:aws:iam::AWS_ACCOUNT_ID:role/AWS_ROLE_NAME"
  }

Tra le altre opzioni ci sono:

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

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

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

• Pianificazione: 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 trasferiti. Queste includono --include-prefixes, --exclude-prefixes, --match-glob, le condizioni basate sul tempo in --include-modified-[before | after]-[absolute | relative] e --include-storage-classes. Se hai specificato una cartella con l'origine, i filtri dei prefissi sono relativi a quella cartella. Per saperne di più, consulta Filtra gli oggetti di origine per prefisso e Filtra gli oggetti di origine per classe di archiviazione.

• 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 quali valori dei metadati conservare (--preserve-metadata); facoltativamente, imposta una classe di archiviazione per gli 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.

• Cloud Logging: abilita Cloud Logging con --log-actions e --log-action-states. Per maggiori dettagli, consulta Cloud Logging per Storage Transfer Service.

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

REST

I seguenti esempi mostrano come utilizzare Storage Transfer Service tramite l'API REST.

Quando configuri o modifichi i job di trasferimento utilizzando l'API Storage Transfer Service, l'ora deve essere in formato UTC. Per saperne di più su come specificare la pianificazione di un job di trasferimento, consulta Pianificazione.

Quando crei job di trasferimento, non includere il prefisso s3:// per bucketName nei nomi dei bucket Amazon S3 di origine.

Per eseguire l'autenticazione utilizzando l'identità federata anziché le chiavi di accesso, specifica:

"roleArn": "arn:aws:iam::AWS_ACCOUNT_ID:role/AWS_ROLE_NAME"

anziché l'oggetto awsAccessKey. Consulta Esegui l'autenticazione utilizzando l'identità federata.

Trasferimento senza agente

L'esempio seguente crea un job di trasferimento utilizzando la configurazione standard senza agenti. Per ulteriori dettagli, consulta la documentazione di riferimento di transferJobs.create.

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "transferSpec": {
      "awsS3DataSource": {
          "bucketName": "AWS_SOURCE_NAME",
          "awsAccessKey": {
            "accessKeyId": "AWS_ACCESS_KEY_ID",
            "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
          }
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}

Distribuzione CloudFront

Se stai eseguendo il trasferimento da S3 tramite una distribuzione CloudFront, specifica il nome di dominio della distribuzione come valore del campo transferSpec.awsS3DataSource.cloudfrontDomain:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "transferSpec": {
      "awsS3DataSource": {
          "bucketName": "AWS_SOURCE_NAME",
          "cloudfrontDomain": "https://dy1h2n3l4ob56.cloudfront.net",
          "awsAccessKey": {
            "accessKeyId": "AWS_ACCESS_KEY_ID",
            "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
          }
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}

Per maggiori dettagli, consulta Trasferisci da S3 tramite CloudFront.

Rete privata gestita

Per eseguire il trasferimento da S3 utilizzando una rete privata gestita da Google, specifica il campo transferSpec.awsS3DataSource.managedPrivateNetwork:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "transferSpec": {
      "awsS3DataSource": {
          "bucketName": "AWS_SOURCE_NAME",
          "managedPrivateNetwork": true,
          "awsAccessKey": {
            "accessKeyId": "AWS_ACCESS_KEY_ID",
            "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
          }
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}

Per maggiori dettagli, consulta Trasferimento su una rete privata gestita da Google.

Librerie client

I seguenti esempi 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 in formato UTC. Per saperne di più su come specificare la pianificazione di un job di trasferimento, consulta Pianificazione.

Per ulteriori informazioni sulle librerie client di Storage Transfer Service, consulta Introduzione alle librerie client di Storage Transfer Service.

Trasferimento da Amazon S3 a Cloud Storage

In questo esempio, imparerai a spostare i file da Amazon S3 a un bucket Cloud Storage.

Quando crei job di trasferimento, non includere il prefisso s3:// per bucketName nei nomi dei bucket Amazon S3 di origine.

Le librerie client di Storage Transfer Service non supportano i trasferimenti tramite CloudFront o una rete privata gestita.

Vai

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

	storagetransfer "cloud.google.com/go/storagetransfer/apiv1"
	"cloud.google.com/go/storagetransfer/apiv1/storagetransferpb"
	"google.golang.org/genproto/googleapis/type/date"
	"google.golang.org/genproto/googleapis/type/timeofday"
)

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

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

	// 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()

	// A description of this job
	jobDescription := "Transfers objects from an AWS bucket to a GCS bucket"

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

	// The AWS access key credential, should be accessed via environment variable for security
	awsAccessKeyID := os.Getenv("AWS_ACCESS_KEY_ID")

	// The AWS secret key credential, should be accessed via environment variable for security
	awsSecretKey := os.Getenv("AWS_SECRET_ACCESS_KEY")

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId:   projectID,
			Description: jobDescription,
			TransferSpec: &storagetransferpb.TransferSpec{
				DataSource: &storagetransferpb.TransferSpec_AwsS3DataSource{
					AwsS3DataSource: &storagetransferpb.AwsS3Data{
						BucketName: awsSourceBucket,
						AwsAccessKey: &storagetransferpb.AwsAccessKey{
							AccessKeyId:     awsAccessKeyID,
							SecretAccessKey: awsSecretKey,
						}},
				},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsSinkBucket}},
			},
			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", awsSourceBucket, gcsSinkBucket, resp.Name)
	return resp, nil
}

Java

Stai cercando esempi precedenti? Consulta la guida alla migrazione di Storage Transfer Service.

import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto.CreateTransferJobRequest;
import com.google.storagetransfer.v1.proto.TransferTypes.AwsAccessKey;
import com.google.storagetransfer.v1.proto.TransferTypes.AwsS3Data;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
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.TransferSpec;
import com.google.type.Date;
import com.google.type.TimeOfDay;
import java.io.IOException;
import java.util.Calendar;

public class TransferFromAws {

  // Creates a one-off transfer job from Amazon S3 to Google Cloud Storage.
  public static void transferFromAws(
      String projectId,
      String jobDescription,
      String awsSourceBucket,
      String gcsSinkBucket,
      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 from S3 to GCS.";

    // The name of the source AWS bucket to transfer data from
    // String awsSourceBucket = "yourAwsSourceBucket";

    // The name of the GCS bucket to transfer data to
    // String gcsSinkBucket = "your-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();

    // The ID used to access your AWS account. Should be accessed via environment variable.
    String awsAccessKeyId = System.getenv("AWS_ACCESS_KEY_ID");

    // The Secret Key used to access your AWS account. Should be accessed via environment variable.
    String awsSecretAccessKey = System.getenv("AWS_SECRET_ACCESS_KEY");

    // Set up source and sink
    TransferSpec transferSpec =
        TransferSpec.newBuilder()
            .setAwsS3DataSource(
                AwsS3Data.newBuilder()
                    .setBucketName(awsSourceBucket)
                    .setAwsAccessKey(
                        AwsAccessKey.newBuilder()
                            .setAccessKeyId(awsAccessKeyId)
                            .setSecretAccessKey(awsSecretAccessKey)))
            .setGcsDataSink(GcsData.newBuilder().setBucketName(gcsSinkBucket))
            .build();

    // 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 startDate =
        Date.newBuilder()
            .setYear(startCalendar.get(Calendar.YEAR))
            .setMonth(startCalendar.get(Calendar.MONTH) + 1)
            .setDay(startCalendar.get(Calendar.DAY_OF_MONTH))
            .build();
    TimeOfDay startTime =
        TimeOfDay.newBuilder()
            .setHours(startCalendar.get(Calendar.HOUR_OF_DAY))
            .setMinutes(startCalendar.get(Calendar.MINUTE))
            .setSeconds(startCalendar.get(Calendar.SECOND))
            .build();
    Schedule schedule =
        Schedule.newBuilder()
            .setScheduleStartDate(startDate)
            .setScheduleEndDate(startDate)
            .setStartTimeOfDay(startTime)
            .build();

    // Set up the transfer job
    TransferJob transferJob =
        TransferJob.newBuilder()
            .setDescription(jobDescription)
            .setProjectId(projectId)
            .setTransferSpec(transferSpec)
            .setSchedule(schedule)
            .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 AWS to GCS:");
    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'

// AWS S3 source bucket name
// awsSourceBucket = 'my-s3-source-bucket'

// AWS Access Key ID
// awsAccessKeyId = 'AKIA...'

// AWS Secret Access Key
// awsSecretAccessKey = 'HEAoMK2.../...ku8'

// 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 Amazon S3 to Google Cloud Storage.
 */
async function transferFromS3() {
  // 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: {
        awsS3DataSource: {
          bucketName: awsSourceBucket,
          awsAccessKey: {
            accessKeyId: awsAccessKeyId,
            secretAccessKey: awsSecretAccessKey,
          },
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
        },
      },
    },
  });

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

transferFromS3();

Python

Stai cercando esempi precedenti? Consulta la guida alla migrazione di Storage Transfer Service.

from datetime import datetime

from google.cloud import storage_transfer


def create_one_time_aws_transfer(
    project_id: str,
    description: str,
    source_bucket: str,
    aws_access_key_id: str,
    aws_secret_access_key: str,
    sink_bucket: str,
):
    """Creates a one-time transfer job from Amazon S3 to Google Cloud
    Storage."""

    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'

    # AWS S3 source bucket name
    # source_bucket = 'my-s3-source-bucket'

    # AWS Access Key ID
    # aws_access_key_id = 'AKIA...'

    # AWS Secret Access Key
    # aws_secret_access_key = 'HEAoMK2.../...ku8'

    # 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": {
                    "aws_s3_data_source": {
                        "bucket_name": source_bucket,
                        "aws_access_key": {
                            "access_key_id": aws_access_key_id,
                            "secret_access_key": aws_secret_access_key,
                        },
                    },
                    "gcs_data_sink": {
                        "bucket_name": sink_bucket,
                    },
                },
            }
        }
    )

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