Trasferimento da Amazon S3 a Cloud Storage

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

Configura autorizzazioni

Prima di creare un trasferimento, devi configurare le autorizzazioni sul tuo bucket Amazon S3. Per maggiori dettagli, consulta Configurare l'accesso a un'origine: Amazon S3.

Devi anche configurare le autorizzazioni per le seguenti entità Google Cloud:

	L'account utente utilizzato per creare il trasferimento. Si tratta dell'account con cui hai eseguito l'accesso alla console Google Cloud o dell'account specificato durante l'autenticazione all'interfaccia a riga di comando "gcloud". L'account utente può essere un account utente normale o un account di servizio gestito dall'utente.
	Il service account gestito da Google, noto anche come agente di servizio, utilizzato da Storage Transfer Service. Questo account viene generalmente identificato dall'indirizzo email, che utilizza il formato [e-mail].

Per le istruzioni, consulta Autorizzazioni di trasferimento senza agente.

Opzioni di uscita

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

Opzione di uscita	Descrizione
Senza agente predefinito	Questa opzione utilizza un trasferimento senza agente gestito da S3. Il traffico in uscita ti viene addebitato da Amazon. Per utilizzare questa opzione, segui le istruzioni riportate in questa pagina.
Distribuzione CloudFront	Utilizza una distribuzione Amazon CloudFront come percorso in uscita. I trasferimenti di dati tramite CloudFront possono beneficiare di costi di uscita AWS inferiori rispetto al trasferimento diretto da S3. Per i dettagli, consulta i prezzi di CloudFront e le tariffe di uscita di S3. Segui le istruzioni riportate in Eseguire il trasferimento da S3 tramite CloudFront per configurare la distribuzione e creare un trasferimento.
Rete privata gestita	Trasferisci i dati tramite una rete gestita da Google. Non paghi costi per il traffico in uscita da S3, ma paghi una tariffa per GB a Google Cloud. Per informazioni dettagliate, consulta la pagina Prezzi. Potrebbero comunque essere addebitati costi operativi da AWS (ad es. LIST o GET chiamate); consulta i relativi prezzi per maggiori dettagli. Tutti i trasferimenti dei progetti sulla rete privata gestita condividono la stessa larghezza di banda. Nei periodi di utilizzo elevato, il trasferimento potrebbe essere più lento. I trasferimenti con file di grandi dimensioni sono interessati più di quelli con file di piccole dimensioni. Per utilizzare questa opzione, segui le istruzioni riportate in questa pagina. Specifica l'opzione Rete privata gestita nella console Google Cloud o il campo managedPrivateNetwork nell'API REST. Gcloud CLI e le librerie client non supportano i trasferimenti su reti private gestite. Consulta le regioni supportate.
Basato su agenti	Valido per tutto lo spazio di archiviazione compatibile con S3, incluso Amazon S3. Se installi il software dell'agente sulle 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 Trasferimento da origini compatibili con S3.

Aree geografiche supportate

Storage Transfer Service supporta le seguenti regioni Amazon S3:

af-south-1 ap-east-1 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 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

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

us-east-1 us-east-2 us-west-1 us-west-2 ca-west-1 ca-central-1

Opzioni di trasferimento

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

Trasferire file specifici utilizzando un manifest

Puoi passare un elenco di file su cui Storage Transfer Service deve intervenire. Per maggiori dettagli, consulta Trasferire file o oggetti specifici utilizzando un manifest.

Specifica la classe di archiviazione

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

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

Conservazione dei metadati

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

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

Trasferimenti basati su eventi

Storage Transfer Service può ascoltare le notifiche di eventi Amazon S3 inviate ad Amazon SQS per trasferire automaticamente i dati aggiunti o aggiornati nella posizione 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 Monitorare i job di trasferimento. Puoi anche configurare le notifiche Pub/Sub.

Crea un trasferimento

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

Non includere nel nome del job di trasferimento informazioni sensibili come quelle che consentono l'identificazione personale (PII) o 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 al di fuori del 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 pianificazione. I trasferimenti batch vengono eseguiti su base una tantum o pianificata. I trasferimenti basati su eventi monitorano continuamente la sorgente 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 del bucket o della 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 Trasferire da S3 tramite CloudFront per configurare una distribuzione CloudFront.

9. Per utilizzare una rete privata gestita per questo trasferimento, seleziona la corrispondente cassella di controllo. Per maggiori dettagli, consulta Opzioni di uscita.

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

    • Chiave di accesso: inserisci la chiave di accesso nel campo ID chiave di accesso e il segreto 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:

      arn:aws:iam::ACCOUNT:role/ROLE-NAME-WITH-PATH
      

      Dove:

      • ACCOUNT: l'ID account AWS senza i trattini.
      • ROLE-NAME-WITH-PATH: il nome del ruolo AWS incluso il percorso.

      Per ulteriori informazioni sugli ARN, consulta ARN IAM.

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

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

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

12. Se vuoi, puoi scegliere di filtrare gli oggetti per prefisso o per data di ultima modifica. Se hai specificato una cartella come posizione di origine, i filtri dei prefissi si riferiscono 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.

13. Fai clic su Passaggio successivo.

14. Nel campo Bucket o cartella, inserisci il bucket di destinazione e (facoltativo) il nome 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.

15. Fai clic su Passaggio successivo.

16. 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 unica per distinguere i job.

    2. In Opzioni metadati, scegli di utilizzare le opzioni predefinite o fai clic su Visualizza e seleziona opzioni per specificare i valori per tutti i metadati supportati. Per informazioni dettagliate, consulta la sezione Conservazione dei metadati.

    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 ha 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 i file dall'origine dopo il trasferimento: elimina i file dall'origine dopo il trasferimento alla destinazione.

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

       • 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, eliminali dal bucket Cloud Storage.

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

    5. In Opzioni di notifica, seleziona l'argomento Pub/Sub e gli eventi per i quali vuoi ricevere notifiche. Per maggiori dettagli, consulta la sezione Notifiche Pub/Sub.

17. Fai clic su Passaggio successivo.

18. Scegli le opzioni di pianificazione:

    Nota: il servizio di trasferimento dati mostra le pianificazioni dei job di trasferimento nel fuso orario locale, ma memorizza queste ore nel fuso orario universale coordinato (UTC). Se il tuo fuso orario è interessato dall'ora legale, potresti riscontrare una modifica della pianificazione dei job di trasferimento all'inizio o alla fine dell'ora legale.

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

       • Esegui una volta: esegui un singolo trasferimento a partire dall'ora selezionata.

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

         Puoi inserire una Data di fine facoltativa oppure lasciare vuoto il campo Data di fine per eseguire il trasferimento continuamente.

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

       • Esegui con frequenza personalizzata: esegue un trasferimento con la frequenza selezionata. Puoi scegliere di ripetere il trasferimento a un intervallo regolare di ore, giorni o settimane.

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

    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 in cui selezionare la 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 il comando gcloud transfer jobs create. La creazione di un nuovo job avvia il trasferimento specificato, a meno che non sia specificata una pianificazione o --do-not-run.

Gcloud CLI non supporta i trasferimenti tramite CloudFront o la rete privata gestita.

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

Dove:

• 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 trasferire in una directory specifica, specifica gs://STORAGE_BUCKET_NAME/STORAGE_FOLDER_PATH/, inclusa la barra finale.

• --source-creds-file specifica il percorso relativo a un file locale sulla tua macchina che include le credenziali AWS per l'origine del trasferimento. I contenuti devono essere nel seguente formato JSON:

  {
    "accessKeyId": string,
    "secretAccessKey": string
  }

Altre opzioni 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 Trasferire file o oggetti specifici utilizzando un manifest.

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

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

• Condizioni degli oggetti: utilizza le condizioni per determinare quali oggetti vengono trasferiti. Sono inclusi --include-prefixes e --exclude-prefixes, nonché le condizioni basate sul tempo in --include-modified-[before | after]-[absolute | relative]. Se hai specificato una cartella con l'origine, i filtri dei prefissi sono relativi a quella cartella. Per saperne di più, consulta Filtrare gli oggetti di origine per prefisso.

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

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

• 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

Gli esempi riportati di seguito 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 UTC. Per ulteriori informazioni su come specificare la pianificazione di un job di trasferimento, consulta la sezione Pianificazione.

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

Trasferimento senza agente

L'esempio seguente crea un job di trasferimento utilizzando la configurazione senza agente standard. 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"
      }
  }
}

Consulta Configurare l'accesso a un'origine: Amazon S3 per altre opzioni di autenticazione.

Distribuzione CloudFront

Se esegui 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"
      }
  }
}

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

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 UTC. Per ulteriori informazioni su come specificare la pianificazione di un job di trasferimento, consulta la sezione 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 come 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 delle origini dei bucket Amazon S3.

Le librerie client di Storage Transfer Service non supportano i trasferimenti tramite CloudFront o la 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

Cerchi 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

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