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

Transférer des données depuis un espace de stockage compatible S3 vers Cloud Storage

Le service de transfert de stockage accepte les transferts depuis des systèmes de stockage d'objets cloud ou sur site compatibles avec l'API Amazon S3.

Le service de transfert de stockage accède à vos données dans un stockage compatible S3 à l'aide d'agents de transfert, déployés sur des VM proches de la source de données. Ces agents s'exécutent dans un conteneur Docker et appartiennent à un pool d'agents, qui est un ensemble d'agents utilisant la même configuration et qui déplacent collectivement vos données en parallèle.

Cette fonctionnalité vous permet de migrer depuis un système de stockage d'objets cloud ou sur site vers Cloud Storage, d'archiver des données afin de libérer de la capacité de stockage sur site, de répliquer des données vers Google Cloud pour assurer la continuité des opérations ou de transférer des données vers Google Cloud à des fins d'analyse et de traitement. Pour les clients migrant d'AWS S3 vers Cloud Storage, cette fonctionnalité permet de contrôler les routes réseau vers Google Cloud, ce qui réduit considérablement les frais de transfert de données sortants.

Avant de commencer

Avant de configurer vos transferts, procédez comme suit:

Installez la CLI gcloud.
Respectez les conditions requises pour les transferts de système de fichiers, y compris en installant Docker sur la machine de l'agent de transfert.

Obtenir les identifiants sources

Le transfert depuis un espace de stockage compatible S3 nécessite un ID de clé d'accès et une clé d'accès secrète.

La procédure à suivre dépend de votre fournisseur de stockage.

Le compte à partir duquel l'ID et la clé sont générés nécessite l'une des autorisations suivantes :

Accès en lecture seule aux objets sources, si vous ne souhaitez pas supprimer ces objets sur la source.
Accès complet aux objets sources, si vous décidez de les supprimer sur la source dans le cadre du transfert.

Une fois le compte créé et les autorisations ajoutées, et après avoir téléchargé l'ID de clé d'accès et la clé d'accès secrète, stockez l'ID et la clé dans un endroit sûr.

Configurer les autorisations Google Cloud

Avant de créer un transfert, vous devez configurer les autorisations pour les entités 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 `project-PROJECT_NUMBER@storage-transfer-service.iam.gserviceaccount.com`.
	Compte de l'agent de transfert qui fournit des autorisations Google Cloud aux agents de transfert. Les comptes d'agent de transfert utilisent les identifiants de l'utilisateur qui les installe ou les identifiants d'un compte de service géré par l'utilisateur pour s'authentifier.

Pour obtenir des instructions, consultez la section Autorisations de transfert basées sur les agents.

Options de transfert

Les fonctionnalités suivantes du service de transfert de stockage sont disponibles pour les transferts depuis un stockage compatible avec 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 d'un stockage compatible avec S3, le service de transfert de stockage peut éventuellement conserver certains attributs en tant que métadonnées personnalisées.

Consultez la section Stockage Amazon S3 ou compatible avec S3 vers Cloud Storage de la section Préservation des métadonnées pour en savoir plus sur les métadonnées pouvant être conservées et sur la façon de configurer votre transfert.

Journalisation et surveillance

Les transferts à partir d'un stockage compatible 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 pool d'agents

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 pool d'agents ou dans le préfixe de l'ID de l'agent. 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.

Pour créer un pool d'agents, procédez comme suit :

console Google Cloud

Dans la console Google Cloud, accédez à la page Pools d'agents.

Accéder aux pools d'agents

La page Pools d'agents s'affiche. Elle répertorie vos pools d'agents existants.
Cliquez sur Créer un autre pool.
Nommez votre pool, puis fournissez une description si vous le souhaitez.
Vous pouvez choisir de définir une limite de bande passante qui s'appliquera au pool dans son ensemble. La bande passante spécifiée en Mo/s sera répartie entre tous les agents du pool. Pour en savoir plus, consultez la page Gérer la bande passante réseau.
Cliquez sur Create (Créer).

API REST

Utilisez la méthode projects.agentPools.create :

POST https://storagetransfer.googleapis.com/v1/projects/PROJECT_ID/agentPools?agent_pool_id=AGENT_POOL_ID

Où :

PROJECT_ID : ID du projet dans lequel vous créez le pool d'agents.
AGENT_POOL_ID : ID du pool d'agents que vous créez.

Si un pool d'agents est bloqué à l'état Creating pendant plus de 30 minutes, nous vous recommandons de le supprimer et de le recréer.

La révocation des autorisations requises pour le service de transfert de stockage d'un projet alors qu'un pool d'agents est à l'état Creating entraîne un comportement de service incorrect.

CLI gcloud

Pour créer un pool d'agents avec l'outil de ligne de commande gcloud, exécutez la commande [gcloud transfer agent-pools create][agent-pools-create].

gcloud transfer agent-pools create AGENT_POOL

Les options suivantes sont disponibles :

AGENT_POOL est l'identifiant unique et permanent de ce pool.
--no-async bloque d'autres tâches dans votre terminal jusqu'à la création du pool. Si cette option n'est pas incluse, la création du pool s'exécute de manière asynchrone.
--bandwidth-limit définit la quantité de bande passante en Mo/s à mettre à la disposition des agents de ce pool. Une limite de bande passante s'applique à tous les agents d'un pool et peut empêcher la charge de travail de transfert du pool d'interrompre les autres opérations qui partagent votre bande passante. Par exemple, saisissez "50" pour définir une limite de bande passante de 50 Mo/s. Si vous ne définissez pas cette option, les agents de ce pool utiliseront toute la bande passante disponible.
--display-name est un nom modifiable pour vous aider à identifier ce pool. Vous pouvez inclure des détails qui ne correspondent peut-être pas au nom complet de la ressource du pool.

Installer les agents de transfert

Les agents de transfert sont des agents logiciels qui coordonnent les activités de transfert depuis votre source via le service de transfert de stockage. Ils doivent être installés sur un système ayant accès à vos données sources.

CLI gcloud

Pour installer des agents à utiliser avec une source compatible S3 à l'aide de la CLI gcloud, utilisez la commande transfer agents install.

Vous devez fournir les identifiants d'accès, qui vont être des variables d'environnement utilisées comme valeurs pour AWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEY, ou bien qui vont être stockés en tant qu'identifiants par défaut dans les fichiers de configuration de votre système.

export AWS_ACCESS_KEY_ID=ID
export AWS_SECRET_ACCESS_KEY=SECRET
gcloud transfer agents install --pool=POOL_NAME

Pour exécuter des agents à l'aide d'une clé de compte de service, utilisez l'option --creds-file:

gcloud transfer agents install --pool=POOL_NAME \
  --creds-file=/relative/path/to/service-account-key.json

Créer un job de transfert

console Google Cloud

Suivez ces étapes pour créer un transfert depuis une source compatible S3 vers un bucket Cloud Storage.

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.
Sélectionnez Stockage d'objets compatible S3 comme Type de source. La destination doit être définie sur Google Cloud Storage.

Cliquez sur Next step (Étape suivante).

Configurer votre source

Spécifiez les informations requises pour ce transfert :
1. Sélectionnez le pool d'agents que vous avez configuré pour ce transfert.
2. Saisissez le nom du bucket au format relatif, selon le point de terminaison. Par exemple, si vos données résident dans le point de terminaison ci-après :
  
  https://example.com/bucket_a
  
  Saisissez : bucket_a
3. Saisissez le point de terminaison, N'incluez pas le protocole (http:// ou https://) ni le nom du bucket. Exemple :
  
  example.com
Spécifiez les attributs facultatifs pour ce transfert :
1. Saisissez la région de signature à utiliser pour la signature des requêtes.
2. Choisissez le processus de signature pour cette requête.
3. Sélectionnez le style d'adressage. Cela détermine si le nom du bucket respecte une syntaxe avec chemin (par exemple, https://example.com/bucket-name/key-name) ou bien une syntaxe avec hébergement virtuel (par exemple, https://bucket-name.example.com/key-name). Pour en savoir plus, consultez la section Hébergement virtuel de compartiments dans la documentation Amazon.
4. Sélectionnez le protocole réseau.
5. Sélectionnez la version de l'API de listing à utiliser. Reportez-vous à la documentation sur ListObjectsV2 et ListObjects pour plus d'informations.
Cliquez sur Next step (Étape suivante).

Configurer le récepteur

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.
Cliquez sur Next step (Étape suivante).

Choisir les paramètres de transfert

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.
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.
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.
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.
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.
Cliquez sur Next step (Étape suivante).

Programmer le transfert

Vous pouvez programmer votre transfert pour qu'il ne s'exécute qu'une seule fois, ou bien configurer un transfert récurrent.

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

CLI gcloud

Avant d'utiliser la CLI gcloud pour créer un transfert, suivez les instructions de la section Configurer l'accès à un récepteur Cloud Storage.

Pour utiliser la CLI gcloud afin de créer un transfert depuis une source compatible S3 vers un bucket Cloud Storage, utilisez la commande suivante.

gcloud transfer jobs create s3://SOURCE_BUCKET_NAME gs://SINK_BUCKET_NAME \
  --source-agent-pool=POOL_NAME \
  --source-endpoint=ENDPOINT \
  --source-signing-region=REGION \
  --source-auth-method=AWS_SIGNATURE_V2 | AWS_SIGNATURE_V4 \
  --source-request-model=PATH_STYLE | VIRTUAL_HOSTED_STYLE \
  --source-network-protocol=HTTP | HTTPS \
  --source-list-api=LIST_OBJECTS | LIST_OBJECTS_V2

Les options suivantes sont obligatoires :

--source-agent-pool est le nom du pool d'agents à utiliser pour ce transfert.
--source-endpoint spécifie le point de terminaison de votre système de stockage. Par exemple, s3.us-east.example.com. Contactez votre fournisseur pour connaître la mise en forme à respecter. N'incluez pas le protocole (par exemple, https://) ou le nom du bucket.

Les options restantes sont facultatives :

--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.REGION.example.com/BUCKET_NAME/KEY_NAME. Le style hébergé virtuellement utilise le format https://BUCKET_NAME.s3.REGION.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 découvrir d'autres options associées aux tâches de transfert, exécutez la commande gcloud transfer jobs create --help ou consultez la documentation de référence gcloud.

API REST

Avant d'utiliser l'API REST pour créer un transfert, suivez les instructions de la section Configurer l'accès à un récepteur Cloud Storage.

Pour créer un transfert à partir d'une source compatible S3 à l'aide de l'API REST, créez un objet JSON semblable à l'exemple suivant.

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  ...
  "transferSpec": {
    "source_agent_pool_name":"POOL_NAME",
    "awsS3CompatibleData": {
      "region":"us-east-1",
      "s3Metadata":{
        "protocol": "NETWORK_PROTOCOL_HTTPS",
        "requestModel": "REQUEST_MODEL_VIRTUAL_HOSTED_STYLE",
        "authMethod": "AUTH_METHOD_AWS_SIGNATURE_V4"
      },
      "endpoint": "example.com",
      "bucketName": "BUCKET_NAME",
      "path": "PATH",
    },
    "gcsDataSink": {
      "bucketName": "SINK_NAME",
      "path": "SINK_PATH"
    },
    "transferOptions": {
      "deleteObjectsFromSourceAfterTransfer": false
    }
  }
}

Consultez la documentation de référence de l'API AwsS3CompatibleData pour obtenir une description des champs.

Bibliothèques clientes

Avant d'utiliser les bibliothèques clientes pour créer un transfert, suivez les instructions de la section Configurer l'accès à un collecteur Cloud Storage.

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"

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

func transferFromS3CompatibleSource(w io.Writer, projectID string, sourceAgentPoolName string, sourceBucketName string, sourcePath string, gcsSinkBucket string, gcsPath string) (*storagetransferpb.TransferJob, error) {
	// Your project id.
	// projectId := "my-project-id"

	// The agent pool associated with the S3 compatible data source. If not provided, defaults to the default agent.
	// sourceAgentPoolName := "projects/my-project/agentPools/transfer_service_default"

	// The S3 compatible bucket name to transfer data from.
	//sourceBucketName = "my-bucket-name"

	// The S3 compatible path (object prefix) to transfer data from.
	//sourcePath = "path/to/data"

	// The ID of the GCS bucket to transfer data to.
	//gcsSinkBucket = "my-sink-bucket"

	// The GCS path (object prefix) to transfer data to.
	//gcsPath = "path/to/data"

	// The S3 region of the source bucket.
	region := "us-east-1"

	// The S3 compatible endpoint.
	endpoint := "us-east-1.example.com"

	// The S3 compatible network protocol.
	protocol := storagetransferpb.S3CompatibleMetadata_NETWORK_PROTOCOL_HTTPS

	// The S3 compatible request model.
	requestModel := storagetransferpb.S3CompatibleMetadata_REQUEST_MODEL_VIRTUAL_HOSTED_STYLE

	// The S3 Compatible auth method.
	authMethod := storagetransferpb.S3CompatibleMetadata_AUTH_METHOD_AWS_SIGNATURE_V4

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

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId: projectID,
			TransferSpec: &storagetransferpb.TransferSpec{
				SourceAgentPoolName: sourceAgentPoolName,
				DataSource: &storagetransferpb.TransferSpec_AwsS3CompatibleDataSource{
					AwsS3CompatibleDataSource: &storagetransferpb.AwsS3CompatibleData{
						BucketName: sourceBucketName,
						Path:       sourcePath,
						Endpoint:   endpoint,
						Region:     region,
						DataProvider: &storagetransferpb.AwsS3CompatibleData_S3Metadata{
							S3Metadata: &storagetransferpb.S3CompatibleMetadata{
								AuthMethod:   authMethod,
								RequestModel: requestModel,
								Protocol:     protocol,
							},
						},
					}},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{
						BucketName: gcsSinkBucket,
						Path:       gcsPath,
					},
				},
			},
			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", sourceBucketName, gcsSinkBucket, resp.Name)
	return resp, nil
}

Java

import static com.google.storagetransfer.v1.proto.TransferTypes.S3CompatibleMetadata.AuthMethod;
import static com.google.storagetransfer.v1.proto.TransferTypes.S3CompatibleMetadata.NetworkProtocol;
import static com.google.storagetransfer.v1.proto.TransferTypes.S3CompatibleMetadata.RequestModel;

import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto;
import com.google.storagetransfer.v1.proto.TransferTypes;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferSpec;
import java.io.IOException;

public class TransferFromS3CompatibleSource {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Your project id
    String projectId = "my-project-id";

    // The agent pool associated with the S3 compatible data source. If not provided, defaults to
    // the default agent
    String sourceAgentPoolName = "projects/my-project-id/agentPools/transfer_service_default";

    // The S3 compatible bucket name to transfer data from
    String sourceBucketName = "my-bucket-name";

    // The S3 compatible path (object prefix) to transfer data from
    String sourcePath = "path/to/data";

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

    // The GCS path (object prefix) to transfer data to
    String gcsPath = "path/to/data";

    // The S3 region of the source bucket
    String region = "us-east-1";

    // The S3 compatible endpoint
    String endpoint = "us-east-1.example.com";

    // The S3 compatible network protocol
    NetworkProtocol protocol = NetworkProtocol.NETWORK_PROTOCOL_HTTPS;

    // The S3 compatible request model
    RequestModel requestModel = RequestModel.REQUEST_MODEL_VIRTUAL_HOSTED_STYLE;

    // The S3 Compatible auth method
    AuthMethod authMethod = AuthMethod.AUTH_METHOD_AWS_SIGNATURE_V4;

    transferFromS3CompatibleSource(
        projectId,
        sourceAgentPoolName,
        sourceBucketName,
        sourcePath,
        region,
        endpoint,
        protocol,
        requestModel,
        authMethod,
        gcsSinkBucket,
        gcsPath);
  }

  public static void transferFromS3CompatibleSource(
      String projectId,
      String sourceAgentPoolName,
      String sourceBucketName,
      String sourcePath,
      String region,
      String endpoint,
      NetworkProtocol protocol,
      RequestModel requestModel,
      AuthMethod authMethod,
      String gcsSinkBucket,
      String gcsPath)
      throws IOException {
    TransferJob transferJob =
        TransferJob.newBuilder()
            .setProjectId(projectId)
            .setTransferSpec(
                TransferSpec.newBuilder()
                    .setSourceAgentPoolName(sourceAgentPoolName)
                    .setAwsS3CompatibleDataSource(
                        TransferTypes.AwsS3CompatibleData.newBuilder()
                            .setRegion(region)
                            .setEndpoint(endpoint)
                            .setBucketName(sourceBucketName)
                            .setPath(sourcePath)
                            .setS3Metadata(
                                TransferTypes.S3CompatibleMetadata.newBuilder()
                                    .setProtocol(protocol)
                                    .setRequestModel(requestModel)
                                    .setAuthMethod(authMethod)
                                    .build())
                            .build())
                    .setGcsDataSink(
                        GcsData.newBuilder().setBucketName(gcsSinkBucket).setPath(gcsPath).build()))
            .setStatus(TransferJob.Status.ENABLED)
            .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());

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

Node.js


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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// Useful enums for AWS S3-Compatible Transfers
// const {AuthMethod, NetworkProtocol, RequestModel} = storageTransfer.protos.google.storagetransfer.v1.S3CompatibleMetadata;

// Your project id
// const projectId = 'my-project';

// The agent pool associated with the S3-compatible data source. Defaults to the default agent
// const sourceAgentPoolName = 'projects/my-project/agentPools/transfer_service_default';

// The S3-compatible bucket name to transfer data from
// const sourceBucketName = "my-bucket-name";

// The S3-compatible path (object prefix) to transfer data from
// const sourcePath = "path/to/data/";

// The ID of the GCS bucket to transfer data to
// const gcsSinkBucket = "my-sink-bucket";

// The GCS path (object prefix) to transfer data to
// const gcsPath = "path/to/data/";

// The S3 region of the source bucket
// const region = 'us-east-1';

// The S3-compatible endpoint
// const endpoint = "us-east-1.example.com";

// The S3-compatible network protocol
// const protocol = NetworkProtocol.NETWORK_PROTOCOL_HTTPS;

// The S3-compatible request model
// const requestModel = RequestModel.REQUEST_MODEL_VIRTUAL_HOSTED_STYLE;

// The S3-compatible auth method
// const authMethod = AuthMethod.AUTH_METHOD_AWS_SIGNATURE_V4;

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

/**
 * Creates a transfer from an AWS S3-compatible source to GCS
 */
async function transferFromS3CompatibleSource() {
  // Runs the request and creates the job
  const [transferJob] = await client.createTransferJob({
    transferJob: {
      projectId,
      transferSpec: {
        sourceAgentPoolName,
        awsS3CompatibleDataSource: {
          region,
          s3Metadata: {
            authMethod,
            protocol,
            requestModel,
          },
          endpoint,
          bucketName: sourceBucketName,
          path: sourcePath,
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
          path: gcsPath,
        },
      },
      status: 'ENABLED',
    },
  });

  await client.runTransferJob({
    jobName: transferJob.name,
    projectId,
  });

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

transferFromS3CompatibleSource();

Python

from google.cloud import storage_transfer

AuthMethod = storage_transfer.S3CompatibleMetadata.AuthMethod
NetworkProtocol = storage_transfer.S3CompatibleMetadata.NetworkProtocol
RequestModel = storage_transfer.S3CompatibleMetadata.RequestModel


def transfer_from_S3_compat_to_gcs(
    project_id: str,
    description: str,
    source_agent_pool_name: str,
    source_bucket_name: str,
    source_path: str,
    gcs_sink_bucket: str,
    gcs_path: str,
    region: str,
    endpoint: str,
    protocol: NetworkProtocol,
    request_model: RequestModel,
    auth_method: AuthMethod,
) -> None:
    """Creates a transfer from an AWS S3-compatible source to GCS"""

    client = storage_transfer.StorageTransferServiceClient()

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

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

    # The agent pool associated with the S3-compatible data source.
    # Defaults to 'projects/{project_id}/agentPools/transfer_service_default'
    # source_agent_pool_name = 'projects/my-project/agentPools/my-agent'

    # The S3 compatible bucket name to transfer data from
    # source_bucket_name = "my-bucket-name"

    # The S3 compatible path (object prefix) to transfer data from
    # source_path = "path/to/data/"

    # The ID of the GCS bucket to transfer data to
    # gcs_sink_bucket = "my-sink-bucket"

    # The GCS path (object prefix) to transfer data to
    # gcs_path = "path/to/data/"

    # The S3 region of the source bucket
    # region = 'us-east-1'

    # The S3-compatible endpoint
    # endpoint = "us-east-1.example.com"

    # The S3-compatible network protocol
    # protocol = NetworkProtocol.NETWORK_PROTOCOL_HTTPS

    # The S3-compatible request model
    # request_model = RequestModel.REQUEST_MODEL_VIRTUAL_HOSTED_STYLE

    # The S3-compatible auth method
    # auth_method = AuthMethod.AUTH_METHOD_AWS_SIGNATURE_V4

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "transfer_spec": {
                    "source_agent_pool_name": source_agent_pool_name,
                    "aws_s3_compatible_data_source": {
                        "region": region,
                        "s3_metadata": {
                            "auth_method": auth_method,
                            "protocol": protocol,
                            "request_model": request_model,
                        },
                        "endpoint": endpoint,
                        "bucket_name": source_bucket_name,
                        "path": source_path,
                    },
                    "gcs_data_sink": {
                        "bucket_name": gcs_sink_bucket,
                        "path": gcs_path,
                    },
                },
            }
        }
    )

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

Questions fréquentes

Le transfert depuis un espace de stockage compatible S3 est-il payant ?

Les transferts depuis un espace de stockage compatible S3 ne sont pas soumis aux frais associés aux transferts effectués via le service de transfert de stockage et nécessitant des agents. Consultez la section Tarifs pour tous les autres frais potentiellement applicables. Des frais de transfert de données sortantes et des frais d'exploitation peuvent également vous être facturés par votre fournisseur cloud source.

Cloud Logging est-il compatible avec les transferts de stockage compatibles S3 ?

Oui, vous pouvez activer Cloud Logging pour vos transferts en suivant les instructions de la section Cloud Logging pour le service de transfert de stockage.

Les transferts utilisant un fichier manifeste sont-ils acceptés ?

Oui, les fichiers manifestes sont compatibles avec les transferts compatibles S3.

Si j'ajoute un objet au bucket source après le démarrage de la tâche, cet objet est-il transféré ?

Le service de transfert de stockage effectue une opération de listing sur le bucket source pour calculer la différence par rapport à la destination. Si l'opération de listing est déjà terminée lorsque le nouvel objet est ajouté, cet objet va être ignoré jusqu'au transfert suivant.

Le service de transfert de stockage effectue-t-il une mise en correspondance des sommes de contrôle sur les sources compatibles S3 ?

Le service de transfert de stockage exploite les données de somme de contrôle renvoyées par la source. Pour un stockage compatible S3, le service de transfert de stockage s'attend à ce que l'ETag de l'objet corresponde au hachage MD5 de l'objet.

Cependant, tous les objets transférés vers un stockage compatible S3 à l'aide de la fonctionnalité S3 d'importation en plusieurs parties ne comportent pas d'ETag MD5. Dans ce cas, le service de transfert de stockage se base sur la taille du fichier pour valider l'objet transféré.

Quels sont les débits atteignables pour les transferts à partir d'un stockage compatible S3 ?

Vous pouvez ajuster le débit de votre transfert en ajoutant d'autres agents de transfert. Nous vous recommandons d'utiliser trois agents pour assurer une bonne tolérance aux pannes et pour exploiter correctement un pipeline d'une capacité allant jusqu'à 10 Gbit/s. Pour augmenter encore le débit, ajoutez d'autres agents. Vous pouvez ajouter et supprimer des agents pendant un transfert.

Où les agents de transfert doivent-ils être déployés pour transférer des données depuis Amazon S3 vers Cloud Storage ?

Vous pouvez installer des agents dans Amazon EC2 ou EKS, dans la même région que votre bucket. Vous pouvez également exécuter des agents sur Google Cloud dans la région la plus proche.