Transférer des données depuis Amazon S3 vers Cloud Storage

Cette page vous explique comment créer et démarrer des tâches de transfert d'Amazon S3 vers Cloud Storage.

Configurer les autorisations

Avant de créer un transfert, vous devez configurer des autorisations sur votre bucket Amazon S3. Pour en savoir plus, consultez Configurer l'accès à une source: Amazon S3.

Vous devez également configurer les autorisations pour les entités Google Cloud suivantes:

	Compte utilisateur utilisé pour créer le transfert. Il s'agit du compte connecté à la console Google Cloud ou du compte spécifié lors de l'authentification à la CLI gcloud. Le compte utilisateur peut être un compte utilisateur standard ou un compte de service géré par l'utilisateur.
	Compte de service géré par Google, également appelé agent de service, utilisé par le service de transfert de stockage. Ce compte est généralement identifié par son adresse e-mail, qui utilise le format [e-mail].

Pour obtenir des instructions, consultez la section Autorisations de transfert sans agent.

Options de sortie

Le service de transfert de stockage propose plusieurs options pour transférer vos données S3 vers Cloud Storage.

Option de sortie	Description
Par défaut, sans agent	Cette option utilise un transfert géré, sans agent, à partir de S3. Amazon vous facture les sorties. Suivez les instructions de cette page pour utiliser cette option.
Distribution CloudFront	Utilisez une distribution Amazon CloudFront comme chemin de sortie. Les transferts de données via CloudFront peuvent bénéficier de coûts de sortie AWS inférieurs par rapport au transfert direct depuis S3. Pour en savoir plus, consultez les pages Tarifs de CloudFront et Frais de sortie S3. Suivez les instructions de la section Transférer depuis S3 via CloudFront pour configurer votre distribution et créer un transfert.
Réseau privé géré	Transférez vos données via un réseau géré par Google. Vous ne payez aucuns frais de sortie S3. À la place, vous payez un tarif par Go à Google Cloud. Pour en savoir plus, consultez la page Tarifs. Des frais d'exploitation peuvent toujours vous être facturés par AWS (par exemple, LIST ou GET) ; consultez leurs tarifs pour en savoir plus. Tous les transferts des projets via le réseau privé géré partagent la même bande passante. En cas d'utilisation intensive, votre transfert peut ralentir. Les transferts avec de gros fichiers sont plus affectés que ceux avec de petits fichiers. Suivez les instructions de cette page pour utiliser cette option. Spécifiez l'option Réseau privé géré dans la console Google Cloud ou le champ managedPrivateNetwork dans l'API REST. Gcloud CLI et les bibliothèques clientes ne sont pas compatibles avec les transferts de réseau privé gérés. Consultez les régions disponibles.
Basé sur un agent	Valide pour tous les stockages compatibles avec S3, y compris Amazon S3. En installant un logiciel d'agent sur les machines ayant accès à vos buckets S3, vous pouvez contrôler le chemin d'accès au réseau et la bande passante. Cette option nécessite des agents et des pools d'agents. Suivez les instructions de la section Transfert depuis des sources compatibles S3 pour utiliser cette option.

Régions où le service est disponible

Le service de transfert de stockage est compatible avec les régions Amazon S3 suivantes:

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

Les transferts via le réseau privé géré sont compatibles avec les régions AWS suivantes:

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

Options de transfert

Les fonctionnalités suivantes du service de transfert de stockage sont disponibles pour les transferts de S3 vers Cloud Storage :

Transférer des fichiers spécifiques à l'aide d'un fichier manifeste

Vous pouvez transmettre une liste de fichiers à traiter par le service de transfert de stockage. Pour en savoir plus, consultez la section Transférer des fichiers ou des objets spécifiques à l'aide d'un fichier manifeste.

Spécifier la classe de stockage

Vous pouvez spécifier la classe de stockage Cloud Storage à utiliser pour vos données dans le bucket de destination. Pour en savoir plus sur REST, consultez les options StorageClass ou utilisez l'option --custom-storage-class avec Google Cloud CLI.

Notez que tous les paramètres de classe de stockage sont ignorés si la classe automatique Autoclass est activée pour le bucket de destination. Si la classe automatique est activée, les objets transférés dans le bucket sont initialement définis sur le stockage standard.

Conservation des métadonnées

Lors du transfert de fichiers à partir de S3, le service de transfert de stockage peut éventuellement conserver certains attributs en tant que métadonnées personnalisées.

Consultez la section Amazon S3 vers Cloud Storage de la page Préservation des métadonnées pour en savoir plus sur les métadonnées pouvant être conservées et sur la configuration de votre transfert.

Transferts basés sur les événements

Le service de transfert de stockage peut écouter les notifications d'événement Amazon S3 envoyées à Amazon SQS pour transférer automatiquement les données ajoutées ou mises à jour à l'emplacement source. Pour en savoir plus, consultez la section Transferts basés sur des événements.

Journalisation et surveillance

Les transferts depuis S3 peuvent être consultés dans Cloud Logging et Cloud Monitoring. Pour en savoir plus, consultez Cloud Logging pour le service de transfert de stockage et Surveiller les tâches de transfert. Vous pouvez également configurer des notifications Pub/Sub.

Créer un transfert

Le service de transfert de stockage fournit plusieurs interfaces permettant de créer un transfert.

N'incluez pas d'informations sensibles telles que des informations permettant d'identifier personnellement l'utilisateur ou des données de sécurité dans le nom de votre tâche de transfert. Les noms de ressources peuvent être propagés aux noms d'autres ressources Google Cloud et peuvent être exposés à des systèmes internes à Google en dehors de votre projet.

Console Google Cloud

1. Accédez à la page Service de transfert de stockage dans Google Cloud Console.

   Accéder au service de transfert de stockage

2. Cliquez sur Créer une tâche de transfert. La page Créer une tâche de transfert s'affiche.

3. Sous Type de source, sélectionnez Amazon S3.

4. Sélectionnez Google Cloud Storage comme Type de destination.

5. Sélectionnez le mode de planification souhaité. Les transferts par lot s'exécutent de manière ponctuelle ou planifiée. Les transferts basés sur les événements surveillent en permanence la source et transfèrent les données lorsqu'elles sont ajoutées ou modifiées.

   Pour configurer un transfert basé sur les événements, suivez les instructions de la section Transferts basés sur les événements.

6. Cliquez sur Étape suivante.

7. Dans le champ Nom du bucket ou du dossier, saisissez le nom du bucket source.

   Le nom du bucket est celui qui apparaît dans AWS Management Console.

8. Si vous utilisez une distribution CloudFront pour effectuer un transfert depuis S3, saisissez le nom de domaine de la distribution dans le champ Domaine CloudFront. Exemple :https://dy1h2n3l4ob56.cloudfront.net Consultez Transférer depuis S3 via CloudFront pour configurer une distribution CloudFront.

9. Pour utiliser un réseau privé géré pour ce transfert, cochez la case. Pour en savoir plus, consultez la section Options de sortie.

10. Sélectionnez votre méthode d'authentification Amazon Web Services (AWS). Pour en savoir plus, consultez la page Configurer l'accès à une source: Amazon S3.

    • Clé d'accès: saisissez votre clé d'accès dansID de clé d'accès et le secret associé à votre clé d'accès dans le champs Clé d'accès du secret.

    • Rôle IAM AWS pour la fédération d'identité: saisissez votre ARN dans le champ AWS IAM role ARN (ARN du rôle IAM AWS) avec la syntaxe suivante:

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

      Où :

      • ACCOUNT: ID du compte AWS sans tiret.
      • ROLE-NAME-WITH-PATH: nom du rôle AWS incluant le chemin d'accès.

      Pour en savoir plus sur les ARN, consultez la page ARN d'IAM.

    • Ressource secrète: sélectionnez cette option pour utiliser des identifiants Amazon enregistrés dans Secret Manager. Sélectionnez un secret dans la liste ou saisissez-en un manuellement au format projects/PROJECT_NUMBER/secrets/SECRET_NAME.

11. S'il s'agit d'un transfert basé sur des événements, saisissez l'ARN de la file d'attente Amazon SQS, qui se présente sous le format suivant:

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

12. Vous pouvez également choisir de filtrer les objets par préfixe ou par date de dernière modification. Si vous avez spécifié un dossier comme emplacement source, les filtres de préfixe sont relatifs à ce dossier. Par exemple, si votre source est my-test-bucket/path/, un filtre d'inclusion de file inclut tous les fichiers commençant par my-test-bucket/path/file.

13. Cliquez sur Étape suivante.

14. Dans le champ Bucket ou dossier, saisissez le nom du bucket de destination et (éventuellement) le nom du dossier, ou cliquez sur Parcourir pour sélectionner un bucket dans une liste existante de buckets de votre projet actuel. Pour créer un bucket, cliquez sur  Créer un bucket.

15. Cliquez sur Next step (Étape suivante).

16. Sélectionnez les paramètres de la tâche de transfert.

    1. Dans le champ Description, saisissez une description du transfert. Nous vous recommandons de saisir une description pertinente et unique afin de pouvoir différencier les tâches.

    2. Sous Options de métadonnées, choisissez d'utiliser les options par défaut, ou cliquez sur Afficher et sélectionner des options pour spécifier des valeurs pour toutes les métadonnées acceptées. Pour en savoir plus, consultez la section Conservation des métadonnées.

    3. Sous Écrasement, sélectionnez l'une des options suivantes :

       • S'ils sont différents : écrase les fichiers de destination si le fichier source du même nom contient d'autres ETags ou valeurs de somme de contrôle.

       • Toujours : écrit toujours les fichiers de destination lorsque le fichier source porte le même nom, même s'ils sont identiques.

    4. Sous Dans quel contexte effectuer des suppressions, sélectionnez l'une des options suivantes :

       • Jamais : ne supprime jamais les fichiers de la source ou de la destination.

       • Supprimer les fichiers de la source après leur transfert : supprime les fichiers de la source après leur transfert vers la destination.

         Important : Si vous ne disposez pas d'une sauvegarde locale, cette option est une action irréversible.

       • Supprimer les fichiers de la destination s'ils ne figurent pas dans la source : si les fichiers du bucket Cloud Storage de destination ne figurent pas dans la source, supprimez-les du bucket.

         Cette option garantit que le bucket Cloud Storage de destination correspond exactement à votre source.

    5. Sous Options de notification, sélectionnez votre sujet Pub/Sub et les événements pour lesquels vous souhaitez recevoir des notifications. Pour en savoir plus, consultez la section Notifications Pub/Sub.

17. Cliquez sur Étape suivante.

18. Choisissez vos options de planification :

    Remarque :Le service de transfert de stockage affiche le calendrier des tâches de transfert dans votre fuseau horaire local, mais il les stocke au format UTC (Universal Time Coordinated). Si vous êtes concerné par l'heure d'été, il est possible que le calendrier soit modifié lors du passage à l'heure d'été ou du retour à l'heure d'hiver.

    1. Dans la liste déroulante Exécuter une fois, sélectionnez l'une des options suivantes :

       • Exécuter une fois : exécute un seul transfert, à partir de l'heure que vous sélectionnez.

       • Exécuter tous les jours : exécute un transfert tous les jours, à l'heure que vous sélectionnez.

         Vous pouvez saisir une date de fin ou laisser le champ Date de fin vide pour exécuter continuellement le transfert.

       • Exécuter toutes les semaines: exécute un transfert toutes les semaines, à partir de l'heure que vous sélectionnez.

       • Exécuter avec une fréquence personnalisée : exécute un transfert à la fréquence que vous sélectionnez. Vous pouvez choisir de répéter le transfert à des intervalles réguliers d'heures, de jours ou de semaines.

         Vous pouvez saisir une date de fin ou laisser le champ Date de fin vide pour exécuter continuellement le transfert.

    2. Dans la liste déroulante À partir de maintenant, sélectionnez l'une des options suivantes :

       • À partir de maintenant : lance le transfert lorsque vous cliquez sur Créer.

       • À partir de : lance le transfert à la date et à l'heure que vous sélectionnez. Cliquez sur Calendrier pour afficher un calendrier et sélectionner la date de début.

    3. Pour créer votre tâche de transfert, cliquez sur Créer.

CLI gcloud

Pour créer une tâche de transfert, utilisez la commande gcloud transfer jobs create. La création d'une tâche lance le transfert spécifié, sauf si un calendrier ou une valeur --do-not-run est spécifié.

La gcloud CLI n'est pas compatible avec les transferts via CloudFront ou un réseau privé géré.

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

Où :

• S3_BUCKET_NAME est la source de données pour ce transfert. Vous pouvez éventuellement inclure un chemin d'accès :s3://S3_BUCKET_NAME/S3_FOLDER_PATH

• STORAGE_BUCKET_NAME est le bucket Cloud Storage dans lequel effectuer le transfert. Pour effectuer un transfert dans un répertoire spécifique, spécifiez gs://STORAGE_BUCKET_NAME/STORAGE_FOLDER_PATH/, y compris la barre oblique finale.

• --source-creds-file spécifie le chemin d'accès relatif à un fichier local de votre ordinateur qui inclut les identifiants AWS pour la source de transfert. Le contenu doit être au format JSON suivant:

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

Des options supplémentaires vous sont proposées :

• --do-not-run empêche le service de transfert de stockage d'exécuter la tâche lors de l'envoi de la commande. Pour exécuter la tâche, mettez-la à jour pour ajouter une planification ou utilisez jobs run pour la démarrer manuellement.

• --manifest-file spécifie le chemin d'accès à un fichier CSV dans Cloud Storage contenant une liste des fichiers à transférer depuis votre source. Pour en savoir plus sur la mise en forme du fichier manifeste, consultez la section Transférer des fichiers ou objets spécifiques à l'aide d'un fichier manifeste.

• Informations sur la tâche: vous pouvez spécifier --name et --description.

• Programmation: spécifiez --schedule-starts, --schedule-repeats-every, --schedule-repeats-until ou --do-not-run.

• Conditions des objets: utilisez les conditions pour déterminer les objets à transférer. Cela inclut --include-prefixes et --exclude-prefixes, ainsi que les conditions basées sur l'heure dans --include-modified-[before | after]-[absolute | relative]. Si vous avez spécifié un dossier avec votre source, les filtres de préfixe sont relatifs à ce dossier. Pour en savoir plus, consultez la section Filtrer les objets sources par préfixe.

• Options de transfert : indiquez si vous souhaitez remplacer les fichiers de destination (--overwrite-when=different ou always) et si vous souhaitez supprimer certains fichiers pendant ou après le transfert (--delete-from=destination-if-unique ou source-after-transfer) ; indiquez quelles valeurs de métadonnées sont à conserver (--preserve-metadata) ; et éventuellement définissez une classe de stockage sur des objets transférés (--custom-storage-class).

• Notifications: configurez des notifications Pub/Sub pour les transferts avec --notification-pubsub-topic, --notification-event-types et --notification-payload-format.

• Cloud Logging: activez Cloud Logging avec --log-actions et --log-action-states. Pour en savoir plus, consultez la section Cloud Logging pour le service de transfert de stockage.

Pour afficher toutes les options, exécutez gcloud transfer jobs create --help ou reportez-vous à la documentation de référence gcloud.

REST

Les exemples suivants vous montrent comment utiliser le service de transfert de stockage via l'API REST.

Lorsque vous configurez ou modifiez des tâches de transfert à l'aide de l'API Storage Transfer Service, l'heure doit être au format UTC. Pour en savoir plus sur la spécification de la planification d'une tâche de transfert, consultez la section Planifier.

Lors de la création de tâches de transfert, n'incluez pas le préfixe s3:// pour bucketName dans les noms sources des buckets Amazon S3.

Transfert sans agent

L'exemple suivant crée une tâche de transfert à l'aide de la configuration sans agent standard. Pour en savoir plus, consultez la documentation de référence sur 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"
      }
  }
}

Pour découvrir d'autres options d'authentification, consultez la page Configurer l'accès à une source: Amazon S3.

Distribution CloudFront

Si vous effectuez un transfert depuis S3 via une distribution CloudFront, spécifiez le nom de domaine de la distribution comme valeur du champ 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"
      }
  }
}

Réseau privé géré

Pour effectuer un transfert depuis S3 à l'aide d'un réseau privé géré par Google, spécifiez le champ 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"
      }
  }
}

Bibliothèques clientes

Les exemples suivants vous montrent comment utiliser le service de transfert de stockage de manière automatisée avec Go, Java, Node.js et Python.

Lorsque vous configurez ou modifiez des tâches de transfert de façon automatisée, l'heure doit être au format UTC. Pour en savoir plus sur la spécification de la planification d'une tâche de transfert, consultez la section Planifier.

Pour en savoir plus sur les bibliothèques clientes du service de transfert de stockage, consultez la page Premiers pas avec les bibliothèques clientes du service de transfert de stockage.

Transférer des données depuis Amazon S3 vers Cloud Storage

Dans cet exemple, vous allez apprendre à déplacer des fichiers depuis Amazon S3 vers un bucket Cloud Storage.

Lors de la création de tâches de transfert, n'incluez pas le préfixe s3:// pour bucketName dans les noms sources des buckets Amazon S3.

Les bibliothèques clientes du service de transfert de stockage ne sont pas compatibles avec les transferts via CloudFront ou un réseau privé géré.

Go

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

Vous recherchez des exemples plus anciens ? Consultez le guide de migration du service de transfert de stockage.

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

Vous recherchez des exemples plus anciens ? Consultez le guide de migration du service de transfert de stockage.

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