Transferir do Amazon S3 para o Cloud Storage

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

Configurar permissões

Antes de criar uma transferência, você precisa configurar permissões no Amazon S3 do Google Cloud. Consulte Configurar o acesso a uma fonte: Amazon S3 para mais detalhes.

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

	A conta de usuário usada para criar a transferência Essa é a conta com login no console do Google Cloud ou a conta especificada ao fazer a autenticação na CLI "gcloud". A conta de usuário pode ser uma conta de usuário comum ou uma conta de serviço gerenciada pelo usuário.
	A conta de serviço gerenciada pelo Google, também conhecida como 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 Permissões de transferência sem agente para instruções.

Opções de saída

O Storage Transfer Service oferece várias opções para transferir seus 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 Amazon cobra a saída. Siga as instruções desta página para usar essa opção.
Distribuição do CloudFront	Usar uma distribuição do Amazon CloudFront como saída caminho. As transferências de dados pelo CloudFront podem se beneficiam de custos mais baixos de saída da AWS em comparação com transferidos diretamente do S3. Consulte os detalhes em Preços do CloudFront e Custos de saída do S3. 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 plataforma gerenciada pelo Google em uma rede VPC. Você não paga a saída do S3 charges; Em vez disso, você paga uma taxa por GiB Google Cloud. Consulte a página de preços para mais detalhes. Você ainda pode receber cobranças cobranças operacionais da AWS (por exemplo, LIST ou GET calls); consulte os preços para mais detalhes. Todas as transferências dos projetos pela rede particular gerenciada compartilham a mesma largura de banda. Em períodos de uso elevado, a transferência pode lentamente. As transferências com arquivos grandes são mais afetadas do que as com arquivos pequenos. Siga as instruções desta página para usar essa opção. Especificar a opção Rede privada gerenciada no console do Google Cloud ou o campo managedPrivateNetwork na API REST. CLI gcloud e as bibliotecas de cliente não dão suporte a redes privadas gerenciadas transferências de dados. Consulte a regiões com suporte.
Orientada por agentes	Válido para todo o armazenamento compatível com S3, incluindo o Amazon S3. De a instalação de software de agente em máquinas com acesso aos buckets do S3, controle a rede e largura de banda. Essa 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 que usam 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 de S3 para Cloud Storage

Transferir arquivos específicos usando um manifesto

É possível transmitir uma lista de arquivos para o Storage Transfer Service. Consulte Transfira arquivos específicos ou objetos usando um manifesto para ver mais detalhes.

Especificar a classe de armazenamento

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

Todas as configurações de classe de armazenamento serão ignoradas se o destino bucket tem 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 pode como opção, é possível preservar determinados atributos como metadados personalizados.

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

Transferências baseadas em eventos

O Serviço de transferência do Cloud Storage pode detectar as notificações de eventos do Amazon S3 enviadas Amazon SQS para transferir automaticamente dados que foram 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 vistas no Cloud Logging e Cloud Monitoring: Consulte Cloud Logging para o Serviço de transferência do Cloud Storage e Monitorar transferência jobs para saber mais detalhes. Também é possível configurar Pub/Sub notificações.

Criar uma transferência

O Serviço de transferência do Cloud Storage fornece 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 nessa transferência, marque a caixa de seleção. Consulte as 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 fonte: Amazon S3 para 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 IAM da AWS 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. Você também pode optar por filtrar objetos por prefixo ou pela data da última modificação. Se você especificou uma pasta como local de origem, os filtros de prefixo são relativos à pasta. Por exemplo, se a origem for my-test-bucket/path/, um filtro de inclusão de file vai 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 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 por meio de CloudFront ou 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; Você pode incluir um caminho opcionalmente: s3://S3_BUCKET_NAME/S3_FOLDER_PATH

• STORAGE_BUCKET_NAME é o bucket do Cloud Storage para transferência. 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 para um arquivo local na 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ê especificou uma pasta com a origem, os filtros de prefixo sã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 os 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

O exemplo a seguir cria um job de transferência usando a configuração padrão sem agente. Consulte a referência 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 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 aceitam transferências CloudFront ou rede privada gerenciada.

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