Cette page a été traduite par l'API Cloud Translation.

Créer des transferts

Cette page vous explique comment créer et démarrer des tâches de transfert.

Pour savoir si votre source et votre destination (également appelée récepteur) sont compatibles avec le service de transfert de stockage, consultez la page Sources et récepteurs compatibles.

Agents et pools d'agents

Selon la source et la destination, vous devrez peut-être créer et configurer un pool d'agents, et installer des agents sur une machine ayant accès à la source ou à la destination.

Les transferts depuis Amazon S3, Microsoft Azure, des listes d'URL ou Cloud Storage vers Cloud Storage ne nécessitent pas d'agents ni de pools d'agents.
Les transferts dont la source et/ou la destination sont un système de fichiers, ou à partir d'un stockage compatible avec S3, nécessitent des agents et des pools d'agents. Consultez la page Gérer les pools d'agents pour obtenir des instructions.

Avant de commencer

Avant de configurer vos transferts, assurez-vous d'avoir configuré l'accès:

Pour les utilisateurs et les comptes de service :
- Transferts sans agent
- Transferts basés sur des agents
À vos données sources et à votre destination.

Si vous utilisez des commandes gcloud, installez gcloud CLI.

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

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

Accéder au service de transfert de stockage
Cliquez sur Créer une tâche de transfert. La page Créer une tâche de transfert s'affiche.
Choisissez une source :
Cloud Storage
Votre compte utilisateur doit disposer de l'autorisation storage.buckets.get pour sélectionner les buckets source et de destination. Vous pouvez également saisir directement le nom du bucket. Pour en savoir plus, consultez la page Résoudre les problèmes d'accès.
1. Sous Type de source, sélectionnez Cloud Storage.
2. Sélectionnez un type de destination.
3. Si votre destination est Cloud Storage, 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 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.
4. Cliquez sur Étape suivante.
5. Sélectionnez un bucket et (éventuellement) un dossier dans ce bucket en effectuant l'une des opérations suivantes:
  - Saisissez le nom et le chemin d'accès du bucket Cloud Storage existant dans le champ Bucket ou dossier sans le préfixe gs://. Exemple : my-test-bucket/path/to/files. Pour spécifier un bucket Cloud Storage d'un autre projet, saisissez le nom exact dans le champ Nom du bucket.
  - Pour sélectionner une liste de buckets existants dans vos projets, cliquez sur Parcourir, puis sélectionnez un bucket.
    
    Lorsque vous cliquez sur Parcourir, vous pouvez sélectionner les buckets d'autres projets en cliquant sur l'ID du projet, puis en sélectionnant le nouvel ID de projet et le bucket.
  - Pour créer un bucket, cliquez sur Créer un bucket.
6. S'il s'agit d'un transfert basé sur les événements, saisissez le nom de l'abonnement Pub/Sub, qui se présente sous le format suivant:
  projects/PROJECT_NAME/subscriptions/SUBSCRIPTION_ID
7. 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.
8. Cliquez sur Étape suivante.
Amazon S3
Consultez la section Transférer des données depuis Amazon S3 vers Cloud Storage.

Stockage compatible S3
Consultez la section Transférer des données depuis un espace de stockage compatible S3 vers Cloud Storage.
Microsoft Azure Blob Storage
Le service de transfert de stockage peut transférer des données depuis les régions Microsoft Azure Storage suivantes :
- Amériques:USA Est, USA Est 2, USA Ouest, USA Ouest 2, USA Ouest 3, USA Centre, USA Centre Nord, USA Centre Sud, USA Centre Ouest, Canada Centre, Canada Est, Brésil Sud
- Asie-Pacifique : Australia Central (Australie centre), Australia East (Australie est), Australia Southeast (Australie sud-est), Inde Centre, Inde Sud, Inde Ouest, Asie Sud-Est, Asie Est, Japon Est, Japon Ouest, Corée Sud, Corée Centre
- Europe, Moyen-Orient, Afrique (EMEA) : Allemagne Centre Ouest, France Centre, Norvège Est, Suède Centre, Suisse Nord, Europe Nord, Europe Ouest, Royaume-Uni Sud, Royaume-Uni Ouest, Qatar Centre, Émirats arabes unis Nord, Afrique du Sud Nord
1. Sous Type de source, sélectionnez Azure Blob Storage ou Data Lake Storage Gen2.
2. Cliquez sur Next step (Étape suivante).
3. Renseignez les champs suivants :
  1. Nom du compte de stockage : nom du compte Microsoft Azure Storage source.
    
    Le nom du compte de stockage s'affiche sur le portail Microsoft Azure Storage sous Tous les services > Stockage > Comptes de stockage.
  2. Nom du conteneur — le nom du conteneur Microsoft Azure Storage.
    
    Le nom du conteneur s'affiche sur le portail Microsoft Azure Storage sous Explorateur de stockage > Conteneurs d'objets blob.
  3. Signature d'accès partagé (SAP) — le jeton SAP Microsoft Azure Storage créé à partir d'une règle d'accès stockée. Pour en savoir plus, consultez la page Accorder un accès limité aux ressources Azure Storage à l'aide des signatures d'accès partagé (SAP).
    Le délai d'expiration par défaut pour les jetons SAP est de 8 heures. Lorsque vous créez votre jeton SAP, veillez à définir un délai d'expiration raisonnable vous permettant de finaliser votre transfert.
    Attention : Les jetons SAP de base ne peuvent pas être révoqués. Le seul moyen d'invalider un jeton de base est de supprimer de votre compte la clé d'accès au stockage. Nous vous recommandons vivement de créer des jetons SAP à partir de règles d'accès stockées. Vous pourrez ainsi révoquer une règle pour invalider un jeton SAP. Pour en savoir plus, consultez la page Bonnes pratiques lors de l'utilisation de SAP.
    
    Remarque : Lorsque vous créez une clé SAP, évitez d'inclure une restriction d'adresses IP. Le service de transfert de stockage utilise différentes adresses IP et n'est pas compatible avec la restriction d'adresses IP.
4. 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.
5. Cliquez sur Étape suivante.
Système de fichiers
1. Sous Type de source, sélectionnez Système de fichiers POSIX.
2. Sélectionnez un type de destination, puis cliquez sur Étape suivante.
3. Sélectionnez un pool d'agents existant ou sélectionnez Créer un pool d'agents et suivez les instructions pour créer un pool d'agents.
4. Spécifiez le chemin d'accès complet du répertoire du système de fichiers.
5. Cliquez sur Étape suivante.
HDFS
Consultez Transférer des données de HDFS vers Cloud Storage.
Liste d'URL
1. Sous Type de source, sélectionnez Liste d'URL, puis cliquez sur Étape suivante.
2. Sous URL du fichier TSV, spécifiez l'URL d'un fichier de valeurs séparées par des tabulations (TSV). Pour en savoir plus sur la création d'un fichier TSV, consultez la page Créer une liste d'URL.
3. 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.
4. Cliquez sur Étape suivante.
Choisir une destination
Cloud Storage
1. 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.
2. Cliquez sur Next step (Étape suivante).
3. Sélectionnez les paramètres de la tâche de transfert. Certaines options ne sont disponibles que pour certaines combinaisons source/récepteur.
  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.
4. Cliquez sur Next step (Étape suivante).
Système de fichiers
1. Sélectionnez un pool d'agents existant ou sélectionnez Créer un pool d'agents et suivez les instructions pour créer un pool d'agents.
2. Spécifiez le chemin d'accès complet au répertoire de destination.
3. Cliquez sur Next step (Étape suivante).
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é.

gcloud transfer jobs create \
  SOURCE DESTINATION

Où :

SOURCE est la source de données pour ce transfert. Le format de chaque source est le suivant :
- Cloud Storage : gs://BUCKET_NAME. Pour effectuer un transfert à partir d'un dossier spécifique, spécifiez gs://BUCKET_NAME/FOLDER_PATH/, y compris la barre oblique finale.
- Amazon S3 : s3://BUCKET_NAME/FOLDER_PATH
- Stockage compatible S3: s3://BUCKET_NAME. Le nom du bucket est relatif au point de terminaison. Par exemple, si vos données se trouvent dans https://us-east-1.example.com/folder1/bucket_a, saisissez s3://folder1/bucket_a.
- Microsoft Azure Storage : https://myaccount.blob.core.windows.net/CONTAINER_NAME
- Liste d'URL: https://PATH_TO_URL_LIST ou http://PATH_TO_URL_LIST
- Système de fichiers POSIX : posix:///PATH. Il doit s'agir d'un chemin absolu à partir de la racine de la machine hôte de l'agent.
- HDFS: hdfs:///PATH
DESTINATION a l'une des valeurs suivantes :
- Cloud Storage : gs://BUCKET_NAME. Pour effectuer un transfert dans un répertoire spécifique, spécifiez gs://BUCKET_NAME/FOLDER_PATH/, y compris la barre oblique finale.
- Système de fichiers POSIX : posix:///PATH. Il doit s'agir d'un chemin absolu à partir de la racine de la machine hôte de l'agent.

Si le transfert nécessite des agents de transfert, les options suivantes sont disponibles:

--source-agent-pool spécifie le pool d'agents sources à utiliser pour ce transfert. Obligatoire pour les transferts provenant d'un système de fichiers.
--destination-agent-pool spécifie le pool d'agents de destination à utiliser pour ce transfert. Obligatoire pour les transferts vers un système de fichiers.
--intermediate-storage-path est le chemin d'accès à un bucket Cloud Storage, au format gs://my-intermediary-bucket. Obligatoire pour les transferts entre deux systèmes de fichiers. Pour en savoir plus sur la création du bucket intermédiaire, consultez la section Créer un bucket Cloud Storage en tant qu'intermédiaire.

Des options supplémentaires vous sont proposées :

--source-creds-file spécifie le chemin d'accès lié à un fichier local de votre ordinateur qui inclut les identifiants AWS ou Azure pour la source de transfert. Pour en savoir plus sur la mise en forme des fichiers d'identifiants, consultez la documentation de référence sur TransferSpec.
--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, --description et --source-creds-file.
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.

Les conditions d'objet ne sont pas compatibles avec les transferts impliquant des systèmes de fichiers.
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 pour les transferts sans agent ou les transferts à partir de sources compatibles avec S3, avec --log-actions et --log-action-states. Pour en savoir plus, consultez la section Cloud Logging pour le service de transfert de stockage.

Les transferts depuis des sources compatibles S3 utilisent également les options suivantes:

--source-endpoint (obligatoire) spécifie le point de terminaison de votre système de stockage. Exemple :s3.example.com Contactez votre fournisseur pour connaître la mise en forme à respecter. Ne spécifiez pas le protocole (http:// ou https://).
--source-signing-region spécifie une région pour les requêtes de signature. Vous pouvez omettre cette option si votre fournisseur de stockage ne nécessite pas de région de signature.
--source-auth-method spécifie la méthode d'authentification à utiliser. Les valeurs valides sont AWS_SIGNATURE_V2 ou AWS_SIGNATURE_V4. Pour plus d'informations, reportez-vous à la documentation d'Amazon sur SigV4 et SigV2.
--source-request-model spécifie le style d'adressage à utiliser. Les valeurs valides sont PATH_STYLE ou VIRTUAL_HOSTED_STYLE. Le style avec chemin utilise le format https://s3.example.com/BUCKET_NAME/KEY_NAME. Le style hébergé virtuellement utilise le format https://BUCKET_NAME.s3.example.com/KEY_NAME.
--source-network-protocol spécifie le protocole réseau que les agents doivent utiliser pour cette tâche. Les valeurs valides sont HTTP ou HTTPS.
--source-list-api spécifie la version de l'API de listing S3 pour renvoyer des objets du bucket. Les valeurs valides sont LIST_OBJECTS ou LIST_OBJECTS_V2. Pour plus d'informations, reportez-vous à la documentation d'Amazon sur ListObjectsV2 et ListObjects.

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

Examples

Cloud Storage vers système de fichiers

Pour transférer des données d'un bucket Cloud Storage vers un système de fichiers, spécifiez les éléments suivants.

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

Système de fichiers vers système de fichiers

Pour transférer des données entre deux systèmes de fichiers, vous devez spécifier un pool d'agents source, un pool d'agents de destination et un bucket Cloud Storage intermédiaire via lequel les données sont transmises.

Pour en savoir plus sur le bucket intermédiaire, consultez la section Créer un bucket Cloud Storage en tant qu'intermédiaire.

Ensuite, spécifiez les trois ressources suivantes lorsque vous appelez transfer jobs create :

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

REST

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.

Transférer des données entre buckets Cloud Storage

Dans cet exemple, vous allez apprendre à déplacer des fichiers d'un bucket Cloud Storage à un autre. Par exemple, vous pouvez déplacer les données d'un bucket dans un autre emplacement.

Effectuez une requête à l'aide de la méthode transferJobs.create:

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

Réponse:

200 OK
{
  "transferJob": [
      {
          "creationTime": "2015-01-01T01:01:00.000000000Z",
          "description": "YOUR DESCRIPTION",
          "name": "transferJobs/JOB_ID",
          "status": "ENABLED",
          "lastModificationTime": "2015-01-01T01:01:00.000000000Z",
          "projectId": "PROJECT_ID",
          "schedule": {
              "scheduleStartDate": {
                  "day": 1,
                  "month": 1,
                  "year": 2015
              },
              "startTimeOfDay": {
                  "hours": 1,
                  "minutes": 1
              }
          },
          "transferSpec": {
              "gcsDataSource": {
                  "bucketName": "GCS_SOURCE_NAME",
              },
              "gcsDataSink": {
                  "bucketName": "GCS_NEARLINE_SINK_NAME"
              },
              "objectConditions": {
                  "minTimeElapsedSinceLastModification": "2592000.000s"
              },
              "transferOptions": {
                  "deleteObjectsFromSourceAfterTransfer": true
              }
          }
      }
  ]
}

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

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

Transfert entre Microsoft Azure Blob Storage et Cloud Storage

Dans cet exemple, vous apprendrez à déplacer des fichiers de Microsoft Azure Storage vers un bucket Cloud Storage, à l'aide d'un jeton de signature d'accès partagé (SAP) Microsoft Azure Storage.

Pour en savoir plus sur Microsoft Azure Storage SAS, consultez la section Accorder un accès limité aux ressources Azure Storage à l'aide de signatures d'accès partagé (SAP).

Avant de commencer, consultez les pages Configurer l'accès à Microsoft Azure Storage et Tarification pour comprendre les implications de ce type de transfert.

Effectuez une requête à l'aide de la méthode transferJobs.create :

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "schedule": {
      "scheduleStartDate": {
          "day": 14,
          "month": 2,
          "year": 2020
      },
      "scheduleEndDate": {
          "day": 14
          "month": 2,
          "year": 2020
      },
      "startTimeOfDay": {
          "hours": 1,
          "minutes": 1
      }
  },
  "transferSpec": {
      "azureBlobStorageDataSource": {
          "storageAccount": "AZURE_SOURCE_NAME",
          "azureCredentials": {
              "sasToken": "AZURE_SAS_TOKEN",
          },
          "container": "AZURE_CONTAINER",
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}

Réponse:

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

Transférer depuis un système de fichiers

Consultez Transférer des données d'un système de fichiers vers Cloud Storage.

Spécifier les chemins d'accès source et de destination

Les chemins d'accès source et de destination vous permettent de spécifier les répertoires source et de destination lorsque vous transférez des données vers votre bucket Cloud Storage. Par exemple, supposons que vous disposez des fichiers file1.txt et file2.txt et d'un bucket Cloud Storage nommé B. Si vous définissez un chemin de destination nommé my-stuff, les fichiers sont placés sous gs://B/my-stuff/file1.txt et gs://B/my-stuff/file2.txt une fois le transfert terminé.

Spécifier un chemin d'accès source

Pour spécifier un chemin source lors de la création d'une tâche de transfert, ajoutez un champ path au champ gcsDataSource dans votre spécification TransferSpec :

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

Dans cet exemple :

SOURCE_BUCKET : bucket Cloud Storage source.
SOURCE_PATH : chemin d'accès Cloud Storage source.

Spécifier un chemin de destination

Pour spécifier un dossier de destination lorsque vous créez une tâche de transfert, ajoutez un champ path au champ gcsDataSink dans la spécification TransferSpec :

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

Dans cet exemple :

DESTINATION_BUCKET : bucket Cloud Storage de destination.
DESTINATION_PATH: chemin d'accès Cloud Storage de destination.

Exemple de requête complète

Voici un exemple de requête complète :

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

}

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 entre buckets Cloud Storage

Dans cet exemple, vous allez apprendre à déplacer des fichiers d'un bucket Cloud Storage à un autre. Par exemple, vous pouvez déplacer les données d'un bucket dans un autre emplacement.

Go

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

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

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

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

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

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

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

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

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

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

Java

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

import com.google.protobuf.Duration;
import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto.CreateTransferJobRequest;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
import com.google.storagetransfer.v1.proto.TransferTypes.ObjectConditions;
import com.google.storagetransfer.v1.proto.TransferTypes.Schedule;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob.Status;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferOptions;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferSpec;
import com.google.type.Date;
import com.google.type.TimeOfDay;
import java.io.IOException;
import java.util.Calendar;

public class TransferToNearline {
  /**
   * Creates a one-off transfer job that transfers objects in a standard GCS bucket that are more
   * than 30 days old to a Nearline GCS bucket.
   */
  public static void transferToNearline(
      String projectId,
      String jobDescription,
      String gcsSourceBucket,
      String gcsNearlineSinkBucket,
      long startDateTime)
      throws IOException {

    // Your Google Cloud Project ID
    // String projectId = "your-project-id";

    // A short description of this job
    // String jobDescription = "Sample transfer job of old objects to a Nearline GCS bucket.";

    // The name of the source GCS bucket to transfer data from
    // String gcsSourceBucket = "your-gcs-source-bucket";

    // The name of the Nearline GCS bucket to transfer old objects to
    // String gcsSinkBucket = "your-nearline-gcs-bucket";

    // What day and time in UTC to start the transfer, expressed as an epoch date timestamp.
    // If this is in the past relative to when the job is created, it will run the next day.
    // long startDateTime =
    //     new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2000-01-01 00:00:00").getTime();

    // Parse epoch timestamp into the model classes
    Calendar startCalendar = Calendar.getInstance();
    startCalendar.setTimeInMillis(startDateTime);
    // Note that this is a Date from the model class package, not a java.util.Date
    Date date =
        Date.newBuilder()
            .setYear(startCalendar.get(Calendar.YEAR))
            .setMonth(startCalendar.get(Calendar.MONTH) + 1)
            .setDay(startCalendar.get(Calendar.DAY_OF_MONTH))
            .build();
    TimeOfDay time =
        TimeOfDay.newBuilder()
            .setHours(startCalendar.get(Calendar.HOUR_OF_DAY))
            .setMinutes(startCalendar.get(Calendar.MINUTE))
            .setSeconds(startCalendar.get(Calendar.SECOND))
            .build();

    TransferJob transferJob =
        TransferJob.newBuilder()
            .setDescription(jobDescription)
            .setProjectId(projectId)
            .setTransferSpec(
                TransferSpec.newBuilder()
                    .setGcsDataSource(GcsData.newBuilder().setBucketName(gcsSourceBucket))
                    .setGcsDataSink(GcsData.newBuilder().setBucketName(gcsNearlineSinkBucket))
                    .setObjectConditions(
                        ObjectConditions.newBuilder()
                            .setMinTimeElapsedSinceLastModification(
                                Duration.newBuilder().setSeconds(2592000 /* 30 days */)))
                    .setTransferOptions(
                        TransferOptions.newBuilder().setDeleteObjectsFromSourceAfterTransfer(true)))
            .setSchedule(Schedule.newBuilder().setScheduleStartDate(date).setStartTimeOfDay(time))
            .setStatus(Status.ENABLED)
            .build();

    // Create a Transfer Service client
    StorageTransferServiceClient storageTransfer = StorageTransferServiceClient.create();

    // Create the transfer job
    TransferJob response =
        storageTransfer.createTransferJob(
            CreateTransferJobRequest.newBuilder().setTransferJob(transferJob).build());

    System.out.println("Created transfer job from standard bucket to Nearline bucket:");
    System.out.println(response.toString());
  }
}

Node.js


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

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

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

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

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

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

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

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

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

createDailyNearline30DayMigration();

Python

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
from google.protobuf.duration_pb2 import Duration


def create_daily_nearline_30_day_migration(
    project_id: str,
    description: str,
    source_bucket: str,
    sink_bucket: str,
    start_date: datetime,
):
    """Create a daily migration from a GCS bucket to a Nearline GCS bucket
    for objects untouched for 30 days."""

    client = storage_transfer.StorageTransferServiceClient()

    # The ID of the Google Cloud Platform Project that owns the job
    # project_id = 'my-project-id'

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

    # Google Cloud Storage source bucket name
    # source_bucket = 'my-gcs-source-bucket'

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

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "schedule": {
                    "schedule_start_date": {
                        "day": start_date.day,
                        "month": start_date.month,
                        "year": start_date.year,
                    }
                },
                "transfer_spec": {
                    "gcs_data_source": {
                        "bucket_name": source_bucket,
                    },
                    "gcs_data_sink": {
                        "bucket_name": sink_bucket,
                    },
                    "object_conditions": {
                        "min_time_elapsed_since_last_modification": Duration(
                            seconds=2592000  # 30 days
                        )
                    },
                    "transfer_options": {
                        "delete_objects_from_source_after_transfer": True
                    },
                },
            }
        }
    )

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

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

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

Transfert entre Microsoft Azure Blob Storage et Cloud Storage

Dans cet exemple, vous apprendrez à déplacer des fichiers de Microsoft Azure Storage vers un bucket Cloud Storage, à l'aide d'un jeton de signature d'accès partagé (SAP) Microsoft Azure Storage.

Pour en savoir plus sur Microsoft Azure Storage SAS, consultez la section Accorder un accès limité aux ressources Azure Storage à l'aide de signatures d'accès partagé (SAP).

Avant de commencer, consultez les pages Configurer l'accès à Microsoft Azure Storage et Tarification pour comprendre les implications de ce type de transfert.

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour le service de transfert de stockage, consultez la page Bibliothèques clientes du service de transfert de stockage. Pour en savoir plus, consultez la documentation de référence de l'API Go du service de transfert de stockage.

Pour vous authentifier auprès du service de transfert de stockage, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

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

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

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

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

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

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

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

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

Java

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

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

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

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

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

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

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

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

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

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

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

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

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

Node.js


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

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

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

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

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

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

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

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

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

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

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

transferFromBlobStorage();

Python

from datetime import datetime

from google.cloud import storage_transfer


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

    # Initialize client that will be used to create storage transfer requests.
    # This client only needs to be created once, and can be reused for
    # multiple requests.
    client = storage_transfer.StorageTransferServiceClient()

    # The ID of the Google Cloud Platform Project that owns the job
    # project_id = 'my-project-id'

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

    # Azure Storage Account name
    # azure_storage_account = 'accountname'

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

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

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

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

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

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

Transférer depuis un système de fichiers

Consultez Transférer des données d'un système de fichiers vers Cloud Storage.

Créer des transferts

Agents et pools d'agents

Avant de commencer

Créer un transfert

Console Google Cloud

Cloud Storage

Amazon S3

Stockage compatible S3

Microsoft Azure Blob Storage

Système de fichiers

HDFS

Liste d'URL

Cloud Storage

Système de fichiers

CLI gcloud

Examples

Amazon S3 vers Cloud Storage

Stockage compatible S3 vers Cloud Storage

Système de fichiers vers Cloud Storage

Cloud Storage vers système de fichiers

Système de fichiers vers système de fichiers

REST

Transférer des données entre buckets Cloud Storage

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

Transfert entre Microsoft Azure Blob Storage et Cloud Storage

Transférer depuis un système de fichiers

Spécifier les chemins d'accès source et de destination

Bibliothèques clientes

Transférer des données entre buckets Cloud Storage

Go

Java

Node.js

Python

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

Transfert entre Microsoft Azure Blob Storage et Cloud Storage

Go

Java

Node.js

Python

Transférer depuis un système de fichiers