Transferir do Amazon S3 para o Cloud Storage

Nesta página, mostramos como criar e iniciar jobs de transferência do Amazon S3 para o Cloud Storage.

Configurar permissões

Antes de criar uma transferência, configure permissões no bucket do Amazon S3. Consulte Configurar o acesso a uma origem: Amazon S3 para ver mais detalhes.

Também é necessário configurar permissões para as seguintes entidades do Google Cloud:

	A conta de usuário que está sendo usada para criar a transferência. Essa é a conta conectada ao console do Google Cloud ou a conta especificada para a autenticação na CLI "gcloud". A conta de usuário pode ser uma conta normal ou uma conta de serviço gerenciado pelo usuário.
	A conta serviço gerenciado pelo Google, também conhecida como o agente de serviço, usada pelo Serviço de transferência do Cloud Storage. Essa conta geralmente é identificada pelo endereço de e-mail, que usa o formato [e-mail].

Consulte as instruções em Permissões de transferência sem agente.

Opções de saída

O Serviço de transferência do Cloud Storage oferece várias opções para transferir os dados do S3 para o Cloud Storage.

Opção de saída	Descrição
Padrão sem agente	Essa opção usa uma transferência gerenciada e sem agente do S3. A saída é cobrada pela Amazon. Siga as instruções nesta página para usar essa opção.
Distribuição do CloudFront	Use uma distribuição do Amazon CloudFront como um caminho de saída. As transferências de dados pelo CloudFront podem se beneficiar de custos de saída mais baixos da AWS em comparação com a transferência diretamente do S3. Consulte os preços do CloudFront e as cobranças de saída do S3 para mais detalhes. Siga as instruções em Transferir do S3 pelo CloudFront para configurar sua distribuição e criar uma transferência.
Rede privada gerenciada	Transfira seus dados por uma rede gerenciada pelo Google. Você não paga cobranças de saída do S3. Em vez disso, você paga uma taxa por GiB para o Google Cloud. Consulte os detalhes na página Preços. Ainda será possível receber cobranças de operações da AWS (por exemplo, chamadas LIST ou GET). Consulte os preços para mais detalhes. As transferências de todos os projetos na rede privada gerenciada compartilham a mesma largura de banda. Em períodos de alto uso, a transferência pode ficar lenta. As transferências com arquivos grandes são mais afetadas do que as com arquivos pequenos. Siga as instruções nesta página para usar essa opção. Especifique a opção Rede privada gerenciada no Console do Google Cloud ou o campo managedPrivateNetwork na API REST. A CLI gcloud e as bibliotecas de cliente não são compatíveis com transferências de rede privada gerenciadas. Consulte as regiões com suporte.
Orientado por agente	Válida para todo o armazenamento compatível com S3, incluindo Amazon S3. Ao instalar o software do agente em máquinas com acesso aos buckets S3, é possível controlar o caminho da rede e a largura de banda. Esta opção requer agentes e pools de agentes. Siga as instruções em Transferir de fontes compatíveis com S3 para usar essa opção.

Regiões compatíveis

O Serviço de transferência do Cloud Storage é compatível com as seguintes regiões do Amazon S3:

af-south-1 ap-east-1 ap-northeast-1 ap-northeast-2 ap-northeast-3 ap-south-1 ap-south-2 ap-southeast-1 ap-southeast-2 ap-southeast-3

ap-southeast-4 ca-central-1 ca-west-1 eu-central-1 eu-central-2 eu-north-1 eu-south-1 eu-south-2 eu-west-1 eu-west-2

eu-west-3 il-central-1 me-central-1 me-south-1 sa-east-1 us-east-1 us-east-2 us-west-1 us-west-2

As transferências usando a rede privada gerenciada são compatíveis com as seguintes regiões da AWS:

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

Opções de transferência

Os seguintes recursos do Serviço de transferência do Cloud Storage estão disponíveis para transferências do S3 para o Cloud Storage.

Transferir arquivos específicos usando um manifesto

É possível transmitir uma lista de arquivos para o Serviço de transferência do Cloud Storage realizar ações. Consulte Transferir arquivos ou objetos específicos usando um manifesto para saber mais detalhes.

Especificar a classe de armazenamento

É possível especificar a classe de armazenamento do Cloud Storage a ser usada para seus dados no bucket de destino. Consulte as opções StorageClass para ver detalhes da REST ou use a sinalização --custom-storage-class com a Google Cloud CLI.

Todas as configurações de classe de armazenamento serão ignoradas se o bucket de destino tiver a Classe automática ativada. Se a classe automática estiver ativada, os objetos transferidos para o bucket serão inicialmente definidos como Standard Storage.

Preservação de metadados

Ao transferir arquivos do S3, o Serviço de transferência do Cloud Storage tem a opção de preservar determinados atributos como metadados personalizados.

Consulte a seção Amazon S3 para Cloud Storage de Preservação de metadados para ver detalhes sobre quais metadados podem ser preservados e como configurar sua transferência.

Transferências baseadas em eventos

O Serviço de transferência do Cloud Storage pode detectar notificações de evento do Amazon S3 enviadas ao Amazon SQS para transferir automaticamente os dados adicionados ou atualizados no local de origem. Consulte Transferências orientadas a eventos para mais informações.

Geração de registros e monitoramento

As transferências do S3 podem ser visualizadas no Cloud Logging e no Cloud Monitoring. Para mais detalhes, consulte Cloud Logging para o Serviço de transferência do Cloud Storage e Monitorar jobs de transferência. Também é possível configurar notificações do Pub/Sub.

Criar uma transferência

O Serviço de transferência do Cloud Storage oferece várias interfaces para criar uma transferência.

Não inclua informações sensíveis, como informações de identificação pessoal (PII, na sigla em inglês) ou dados de segurança no nome do job de transferência. Os nomes dos recursos podem ser propagados para os nomes de outros recursos do Google Cloud e podem ser expostos aos sistemas internos do Google fora do seu projeto.

Console do Google Cloud

1. Acesse a página Serviço de transferência do Cloud Storage no Console do Google Cloud.

   Acessar o Serviço de transferência do Cloud Storage

2. Clique em Criar job de transferência. Será exibida a página Criar um job de transferência.

3. Em Tipo de origem, selecione Amazon S3.

4. Como Tipo de destino, selecione Google Cloud Storage.

5. Selecione o Modo de programação. As transferências em lote são executadas uma única vez ou de maneira programada. As transferências orientadas por eventos monitoram continuamente a origem e transferem os dados quando eles são adicionados ou modificados.

   Para configurar uma transferência orientada por eventos, siga as instruções em Transferências orientadas por eventos.

6. Clique em Próxima etapa.

7. No campo Bucket or folder name, insira o nome do bucket de origem.

   O nome do bucket é o nome exibido no AWS Management Console.

8. Se você estiver usando uma distribuição do CloudFront para transferir do S3, insira o nome de domínio de distribuição no campo CloudFront domain. Por exemplo, https://dy1h2n3l4ob56.cloudfront.net. Consulte Transferir do S3 pelo CloudFront para configurar uma distribuição do CloudFront.

9. Para usar uma rede privada gerenciada para esta transferência, marque a caixa de seleção. Consulte Opções de saída para mais detalhes.

10. Selecione o método de autenticação da Amazon Web Services (AWS). Consulte Configurar o acesso a uma origem: Amazon S3 para ver mais detalhes.

    • Token de acesso: Digite sua chave de acesso naID da chave de acesso e o secret associado à sua chave de acesso no Chave de acesso do secret.

    • Papel do AWS IAM para federação de identidade: insira seu ARN no campo ARN do papel do IAM da AWS com a seguinte sintaxe:

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

      Em que:

      • ACCOUNT: o ID da conta da AWS sem hifens.
      • ROLE-NAME-WITH-PATH: o nome do papel da AWS, incluindo o caminho.

      Para mais informações sobre ARNs, consulte ARNs do IAM.

    • Recurso secret: selecione essa opção para usar uma credencial da Amazon salva no Secret Manager. Selecione um secret na lista ou insira um manualmente no formato projects/PROJECT_NUMBER/secrets/SECRET_NAME.

11. Se for uma transferência orientada por eventos, insira o ARN da fila do Amazon SQS, que tem o seguinte formato:

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

12. Opcionalmente, filtre objetos por prefixo ou data da última modificação. Se você especificou uma pasta como seu local de origem, os filtros de prefixo são relativos a essa pasta. Por exemplo, se a origem for my-test-bucket/path/, um filtro de inclusão de file incluirá todos os arquivos que começam com my-test-bucket/path/file.

13. Clique em Próxima etapa.

14. No campo Bucket ou pasta, insira o bucket de destino e, opcionalmente, o nome da pasta ou clique em Procurar para selecionar um bucket de uma lista de buckets no seu projeto atual. Para criar um novo intervalo, clique em Criar novo intervalo.

15. Clique em Próxima etapa.

16. Escolha as configurações do job de transferência.

    1. No campo Descrição, insira uma descrição da transferência. Como prática recomendada, insira uma descrição significativa e exclusiva para que você possa distinguir os jobs.

    2. Em Opções de metadados, use as opções padrão ou clique em Ver e selecionar opções para especificar valores a todos os metadados compatíveis. Consulte Preservação de metadados para mais detalhes.

    3. Em Quando substituir, selecione uma destas opções:

       • Se diferente: substitui os arquivos de destino se o arquivo de origem com o mesmo nome tiver valores de ETags ou de soma de verificação diferentes.

       • Sempre: sempre grava arquivos de destino quando o arquivo de origem tem o mesmo nome, mesmo que sejam idênticos.

    4. Em Quando excluir, selecione uma destas opções:

       • Nunca: nunca exclua arquivos da origem ou do destino.

       • Excluir o arquivo da origem após a transferência: exclua os arquivos da origem após a transferência para o destino.

         Importante: se você não tiver backup local, essa opção será uma ação não reversível.

       • Excluir arquivos do destino se eles não estiverem na origem: se os arquivos no bucket do Cloud Storage de destino também não estiverem na origem, exclua os arquivos do Cloud Storage. bucket.

         Essa opção garante que o bucket de destino do Cloud Storage corresponda exatamente à sua origem.

    5. Em Opções de notificação, selecione o tópico do Pub/Sub e os eventos a serem notificados. Consulte Notificações do Pub/Sub para mais detalhes.

17. Clique em Próxima etapa.

18. Escolha as opções de programação:

    Observação: o Serviço de transferência do Cloud Storage mostra as programações dos jobs de transferência no horário local, mas armazena esses horários no Tempo Universal Coordenado (UTC, na sigla em inglês). Se você estiver em um local com horário de verão, poderá ocorrer uma alteração na programação dos jobs de transferência no início ou no fim do horário de verão.

    1. Na lista suspensa Executar uma vez, selecione uma das seguintes opções:

       • Executar uma vez: executa uma única transferência, começando em um horário selecionado por você.

       • Executar todos os dias: executa uma transferência diária, a partir do horário selecionado.

         É possível inserir uma Data de término opcional ou deixar a Data de término em branco para executar a transferência continuamente.

       • Executar toda semana: executa uma transferência semanal a partir de um horário selecionado.

       • Executar com frequência personalizada: executa uma transferência na frequência selecionada. É possível repetir a transferência em um intervalo regular de Horas, Dias ou Semanas.

         É possível inserir uma Data de término opcional ou deixar a Data de término em branco para executar a transferência continuamente.

    2. Na lista suspensa Iniciando agora, selecione uma das seguintes opções:

       • Iniciando agora: inicia a transferência depois que você clica em Criar.

       • A partir de: inicia a transferência na data e hora selecionadas. Clique em Agenda para ver uma agenda e selecionar a data de início.

    3. Para criar o job de transferência, clique em Criar.

CLI da gcloud

Para criar um novo job de transferência, use o comando gcloud transfer jobs create. A criação de um novo job inicia a transferência especificada, a menos que uma programação ou --do-not-run seja especificado.

A CLI gcloud não aceita transferências pelo CloudFront ou por rede privada gerenciada.

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

Em que:

• S3_BUCKET_NAME é a fonte de dados dessa transferência; Também é possível incluir um caminho: s3://S3_BUCKET_NAME/S3_FOLDER_PATH

• STORAGE_BUCKET_NAME é o bucket do Cloud Storage para onde a transferência será feita. Para fazer a transferência para um diretório específico, especifique gs://STORAGE_BUCKET_NAME/STORAGE_FOLDER_PATH/, incluindo a barra final.

• --source-creds-file especifica o caminho relativo a um arquivo local na sua máquina que inclui credenciais da AWS para a origem da transferência. O conteúdo precisa estar no seguinte formato JSON:

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

As opções adicionais incluem:

• --do-not-run impede que o Serviço de transferência do Cloud Storage execute o job após o envio do comando. Para executar o job, atualize-o para adicionar uma programação ou use jobs run para iniciá-lo manualmente.

• --manifest-file especifica o caminho para um arquivo CSV no Cloud Storage contendo uma lista de arquivos a serem transferidos da sua origem. Para formatar o arquivo de manifesto, consulte Transferir arquivos ou objetos específicos usando um manifesto.

• Informações do job: é possível especificar --name e --description.

• Programação: especifique --schedule-starts, --schedule-repeats-every e --schedule-repeats-until ou --do-not-run.

• Condições de objeto: use condições para determinar quais objetos são transferidos. Elas incluem --include-prefixes e --exclude-prefixes, além das condições baseadas em tempo em --include-modified-[before | after]-[absolute | relative]. Se você especificar uma pasta com sua origem, os filtros de prefixo serão relativos a essa pasta. Consulte Filtrar objetos de origem por prefixo para mais informações.

• Opções de transferência: especifique se você quer substituir os arquivos de destino (--overwrite-when=different ou always) e se quer excluir determinados arquivos durante ou após a transferência (--delete-from=destination-if-unique ou source-after-transfer), especificar quais valores de metadados preservar (--preserve-metadata) e, opcionalmente, definir uma classe de armazenamento em objetos transferidos (--custom-storage-class).

• Notificações: configure as notificações de Pub/Sub para transferências com --notification-pubsub-topic, --notification-event-types e --notification-payload-format.

• Cloud Logging: ative o Cloud Logging com --log-actions e --log-action-states. Consulte Cloud Logging para o Serviço de transferência do Cloud Storage para mais detalhes.

Para ver todas as opções, execute gcloud transfer jobs create --help ou consulte a documentação de referência de gcloud.

REST

Veja nas amostras a seguir como usar o Serviço de transferência do Cloud Storage com a API REST.

Ao configurar ou editar jobs de transferência usando a API Storage Transfer Service, o horário precisa estar em UTC. Saiba como especificar a programação de um job de transferência em Programação.

Ao criar jobs de transferência, não inclua o prefixo s3:// no bucketName dos nomes de origem do bucket do Amazon S3.

Transferência sem agente

No exemplo a seguir, criamos um job de transferência usando a configuração padrão sem agente. Consulte a referência de transferJobs.create para mais detalhes.

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

Consulte Configurar o acesso a uma origem: Amazon S3 para ver outras opções de autenticação.

Distribuição do CloudFront

Se você estiver transferindo do S3 por uma distribuição do CloudFront, especifique o nome de domínio de distribuição como o valor do campo transferSpec.awsS3DataSource.cloudfrontDomain:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "transferSpec": {
      "awsS3DataSource": {
          "bucketName": "AWS_SOURCE_NAME",
          "cloudfrontDomain": "https://dy1h2n3l4ob56.cloudfront.net",
          "awsAccessKey": {
            "accessKeyId": "AWS_ACCESS_KEY_ID",
            "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
          }
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}

Rede privada gerenciada

Para transferir do S3 usando uma rede privada gerenciada pelo Google, especifique o campo transferSpec.awsS3DataSource.managedPrivateNetwork:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "transferSpec": {
      "awsS3DataSource": {
          "bucketName": "AWS_SOURCE_NAME",
          "managedPrivateNetwork": TRUE,
          "awsAccessKey": {
            "accessKeyId": "AWS_ACCESS_KEY_ID",
            "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
          }
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}

Bibliotecas de cliente

Veja nas amostras a seguir como usar o Serviço de transferência do Cloud Storage de maneira programática com Go, Java, Node.js e Python.

Ao configurar ou editar jobs de transferência de maneira programática, o horário precisa estar em UTC. Saiba como especificar a programação de um job de transferência em Programação.

Para mais informações sobre as bibliotecas de cliente do Serviço de transferência do Cloud Storage, consulte Primeiros passos com as bibliotecas de cliente do Serviço de transferência do Cloud Storage.

Transferir do Amazon S3 para o Cloud Storage

Neste exemplo, você aprenderá a mover arquivos do Amazon S3 para um bucket do Cloud Storage.

Ao criar jobs de transferência, não inclua o prefixo s3:// no bucketName dos nomes de origem do bucket do Amazon S3.

As bibliotecas de cliente do Serviço de transferência do Cloud Storage não são compatíveis com transferências pelo CloudFront ou por redes privadas gerenciadas.

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

Procurando amostras mais antigas? Consulte o Guia de migração do serviço de transferência do Cloud Storage.

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

Procurando amostras mais antigas? Consulte o Guia de migração do serviço de transferência do Cloud Storage.

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