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

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

Prérequis

Avant de configurer votre transfert, assurez-vous d'avoir configuré les éléments suivants :

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
Sans agent par défaut Cette option utilise un transfert géré sans agent depuis S3. Amazon vous facture les frais de sortie.

Suivez les instructions de cette page pour utiliser cette option.
Distribution CloudFront Utiliser 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 à ceux des transferts directs depuis S3. Pour en savoir plus, consultez les tarifs de CloudFront et les 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é par Google Transférez vos données sur un réseau géré par Google. Vous ne payez pas de frais de sortie S3. À la place, vous payez un tarif par Gio à Google Cloud, ce qui peut réduire les coûts de transfert. Consultez la page des tarifs pour plus d'informations. Des frais d'exploitation peuvent toujours vous être facturés par AWS (par exemple, pour les appels LIST ou GET). Pour en savoir plus, consultez leur tarification.

Tous les transferts de projets sur le réseau privé géré partagent la même bande passante. En cas d'utilisation intensive, votre transfert peut ralentir. Les transferts de fichiers volumineux sont plus affectés que ceux de petits fichiers.

Cette option n'est disponible que pour certaines régions AWS et n'est pas compatible avec les régions AWS GovCloud.

Pour en savoir plus, consultez Transférer des données via un réseau privé géré par Google.
Réseau privé géré par le client Transférez vos données sur un réseau privé géré par le client. Utilisez interconnexion cross-cloud ou interconnexion partenaire existante, ou achetez et utilisez une nouvelle connexion. Les interconnexions fournissent une connexion physique dédiée entre Google Cloud et Amazon S3 ou Azure.

Pour en savoir plus, consultez Transférer des données depuis AWS ou Azure via un réseau privé géré par le client.
Basée sur des agents Valide pour tous les stockages compatibles 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-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
Les transferts utilisant le réseau privé géré par Google sont compatibles avec les régions AWS suivantes :
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 		 

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 sur lesquels le service de transfert de stockage doit agir. Pour en savoir plus, consultez Transférer des fichiers ou objets spécifiques à l'aide d'un fichier manifeste.
Filtrer les objets sources par préfixe, heure de dernière modification ou classe de stockage

Vous pouvez choisir d'inclure ou d'exclure des objets du transfert en fonction du nom de fichier et du chemin d'accès, de la date de dernière modification ou de la classe de stockage.

Par défaut, les objets des classes de stockage standards et non d'archivage, y compris Glacier Instant Retrieval (GLACIER_IR), sont transférés, et les objets Glacier Deep Archive (DEEP_ARCHIVE) sont transférés s'ils sont restaurés. Les objets Glacier Flexible Retrieval (GLACIER) sont ignorés par défaut.

Pour en savoir plus sur les préfixes, consultez Filtrer les objets sources par préfixe. Pour en savoir plus sur les classes de stockage, consultez Filtrer les objets sources par classe de stockage.

Les filtres temporels incluent :

  • Temps minimum et maximum écoulés depuis la dernière modification. Les deux acceptent une valeur en secondes pour filtrer les objets qui ont été ou n'ont pas été modifiés au cours d'une certaine période.
  • "Dernière modification depuis" et "Dernière modification avant", qui acceptent toutes deux une valeur dateTime.

Sachez que les filtres temporels pour les transferts S3 s'appuient sur la définition de l'heure de dernière modification d'AWS, qui correspond à l'heure à laquelle un objet commence à être importé. Étant donné qu'un objet n'est pas disponible tant que l'importation n'est pas terminée, vous pouvez trouver des objets dont la date de dernière modification correspond à vos critères de filtrage, mais qui sont toujours en cours d'importation. Ces objets ne seront pas inclus dans votre job de transfert. Pour éviter tout problème, nous vous recommandons de suivre ces conseils :

  • Au lieu de filtres temporels, utilisez des transferts basés sur des événements pour transférer les objets dès qu'ils sont disponibles.
  • Pour éviter que des objets ne soient manquants dans les transferts récurrents, la période d'analyse de la "date de dernière modification" doit être supérieure à la planification récurrente. Par exemple, pour un job exécuté toutes les heures, une période d'analyse de deux heures fournit un tampon.
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 la Google Cloud CLI.

Notez que tous les paramètres de classe de stockage sont ignorés si la classe automatique est activée sur 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 depuis 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 Conservation des métadonnées pour savoir quelles métadonnées peuvent être conservées et comment configurer votre transfert.

Transferts basés sur des événements
Le service de transfert de stockage peut écouter les notifications d'événements Amazon S3 envoyées à Amazon SQS pour transférer automatiquement les données ajoutées ou mises à jour dans l'emplacement source. Pour en savoir plus, consultez 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 jobs 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 job de transfert. Les noms de ressources peuvent être propagés aux noms d'autres ressources Google Cloud et peuvent être exposés aux systèmes internes de Google en dehors de votre projet.

Console Google Cloud

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

    Accéder au service de transfert de stockage

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

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

  4. Pour le Type de destination, sélectionnez Google Cloud Storage.

  5. Sélectionnez votre mode de planification. Les transferts par lot s'exécutent de manière ponctuelle ou planifiée. Les transferts basés sur des é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 des événements, suivez les instructions de la page Transferts basés sur des é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 la console de gestion AWS.

  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. Sélectionnez votre méthode d'authentification Amazon Web Services (AWS). Pour en savoir plus, consultez Configurer l'accès à une source : Amazon S3.

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

    • Clé d'accès : saisissez votre clé d'accès dans le champ ID de clé d'accès et le secret associé à votre clé d'accès dans le champ Clé d'accès secrète.

    • Rôle IAM AWS pour la fédération d'identité : saisissez votre ARN dans le champ ARN du rôle IAM AWS, en respectant la syntaxe suivante :

      • Régions AWS standards :

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

      • Régions AWS GovCloud :

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

      Remplacez les éléments suivants :

      • AWS_ACCOUNT : ID de compte AWS sans trait d'union.
      • AWS_ROLE_NAME : nom du rôle AWS. Si votre organisation utilise des chemins d'accès pour organiser les rôles, incluez le chemin d'accès avec le nom du rôle. Exemple : developers/transfer_user.

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

  10. 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 au format suivant :

    • Régions AWS standards :

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

    • Régions AWS GovCloud :

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

  11. Vous pouvez également choisir de filtrer les objets par préfixe, par date de dernière modification ou par classe de stockage. 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 "Inclure" de file inclut tous les fichiers commençant par my-test-bucket/path/file.

  12. Cliquez sur Étape suivante.

  13. 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 Icône Bucket Créer un bucket.

  14. Cliquez sur Étape suivante.

  15. 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 d'une heure que vous sélectionnez.

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

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

      • Exécuter chaque semaine : exécute un transfert chaque semaine, à partir d'une 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 à intervalles réguliers de Heures, Jours ou Semaines.

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

      • Exécuter à la demande : ne déclenche pas d'exécution lors de la création de ce job de transfert. Vous devrez démarrer le job manuellement.

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

      • Dès maintenant : lance le transfert après avoir cliqué sur Créer.
      • À partir du : démarre le transfert à la date et à l'heure que vous sélectionnez. Cliquez sur Calendrier pour afficher un calendrier permettant de sélectionner la date de début.

  16. Cliquez sur Étape suivante.

  17. 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 jobs.

    2. Vous pouvez éventuellement fournir un fichier manifeste pour spécifier les objets exacts à transférer.

    3. Sous Options de métadonnées, sélectionnez la classe de stockage et le comportement de date de création souhaités. Pour en savoir plus, consultez la section Conservation des métadonnées.

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

      • Jamais : n'écrase pas un fichier de destination si le fichier source porte le même nom. Le fichier source est ignoré.
      • 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.

    5. 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. Si un fichier source n'est pas transféré, par exemple parce qu'il existe déjà dans la destination, il n'est pas supprimé.

        Important : Si vous n'avez pas de sauvegarde locale, cette action est irréversible.

      • Supprimer les fichiers de la destination s'ils ne sont pas également à la source : si les fichiers du bucket Cloud Storage de destination ne se trouvent pas également dans la source, supprimez-les du bucket Cloud Storage.

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

    6. Choisissez des options de routage réseau :

      • Utiliser un réseau public : les transferts de données sont effectués via des routes d'appairage Internet public standards entre Amazon S3 et Google Cloud. Toutes les commandes d'API, les en-têtes d'authentification et les flux de données d'objets sont chiffrés de bout en bout en transit à l'aide du protocole HTTPS avec Transport Layer Security (TLS 1.3).
      • Utiliser un réseau privé géré : les données transitent par un routage privé sécurisé provisionné automatiquement par Google, ce qui réduit les frais de sortie Internet AWS et contourne les points de terminaison Internet publics sans nécessiter de configuration d'interconnexion physique. Cette option n'est disponible que pour certaines régions AWS et n'est pas compatible avec les régions AWS GovCloud. Consultez Transférer via un réseau privé géré par Google.
      • Utiliser votre propre réseau privé : les données transitent par votre propre infrastructure de connectivité hybride préconfigurée (telle que Cloud Interconnect, Cloud VPN ou AWS Direct Connect) via des adresses IP privées. Consultez Transférer via un réseau privé géré par le client.

    7. Sous Options de journalisation, sélectionnez Activer la journalisation dans Cloud Logging si vous souhaitez générer un enregistrement précis des actions effectuées sur chaque fichier transféré. Des frais Cloud Logging s'appliquent. Pour en savoir plus, consultez Consigner les actions de transfert.

    8. Si vous le souhaitez, sélectionnez Suivre l'état de l'opération de transfert via les notifications Cloud Pub/Sub, sélectionnez votre titre Pub/Sub, puis choisissez les événements qui déclenchent des notifications. Pour en savoir plus, consultez la section Notifications Pub/Sub.

    9. Sous Sélectionner un type de compte de service, sélectionnez l'identité à utiliser :

      • Agent de service du service de transfert de stockage : l'agent de service par défaut géré par Google se voit automatiquement accorder l'accès aux buckets source et de destination.
      • Agent de service géré par l'utilisateur : utilisez un compte de service personnalisé que vous avez créé. Avant de sélectionner cette option, assurez-vous que votre compte de service dispose d'un accès au bucket source, au bucket de destination et à Pub/Sub. Consultez Utiliser un agent de service géré par l'utilisateur.

  18. Cliquez sur Créer pour créer la tâche de transfert.

gcloud CLI

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"

Remplacez les éléments suivants :

  • 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 vers 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 relatif à un fichier local de votre ordinateur qui inclut les identifiants AWS pour la source de transfert.

    En fonction de votre méthode d'authentification, mettez en forme le fichier JSON comme suit :

    • Clés d'accès AWS :
    {
    "accessKeyId": "AWS_ACCESS_KEY_ID",
    "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
}
    • Identité fédérée (ARN du rôle IAM AWS) :
    {
    "roleArn": "arn:aws:iam::AWS_ACCOUNT_ID:role/AWS_ROLE_NAME"
}

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, --exclude-prefixes, --match-glob, les conditions basées sur l'heure dans --include-modified-[before | after]-[absolute | relative] et --include-storage-classes. Si vous avez spécifié un dossier avec votre source, les filtres de préfixe sont relatifs à ce dossier. Pour en savoir plus, consultez Filtrer les objets sources par préfixe et Filtrer les objets sources par classe de stockage.

  • 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 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 montrent comment utiliser le service de transfert de stockage via l'API REST.

Lorsque vous configurez ou modifiez des jobs 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 programmation d'un job de transfert, consultez Programmation.

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

Pour vous authentifier à l'aide d'une identité fédérée plutôt que de clés d'accès, spécifiez :

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

au lieu de l'objet awsAccessKey. Consultez S'authentifier à l'aide de l'identité fédérée.

Transfert sans agent

L'exemple suivant crée un job de transfert à l'aide de la configuration standard sans agent. 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"
      }
  }
}

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

Pour en savoir plus, consultez Transférer depuis S3 via CloudFront.

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

Pour en savoir plus, consultez Transfert via un réseau privé géré par Google.

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 jobs de transfert de façon automatisée, l'heure doit être au format UTC. Pour en savoir plus sur la spécification de la programmation d'un job de transfert, consultez Programmation.

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