Transferir de fontes compatíveis com S3

O Serviço de transferência do Cloud Storage oferece suporte a sistemas de armazenamento em nuvem ou no local de objetos compatíveis com a API Amazon S3.

O Serviço de transferência do Cloud Storage acessa seus dados em fontes compatíveis com a S3 usando agentes de transferência implantados em VMs próximas à fonte de dados. Esses agentes são executados em um contêiner do Docker e pertencem a um pool de agentes, que é uma coleção de agentes que usa a mesma configuração e que movem coletivamente seus dados em paralelo.

Esse recurso permite migrar do armazenamento de objetos no local ou na nuvem para o Cloud Storage, arquivar dados para liberar a capacidade de armazenamento no local, replicar dados para o Google Cloud para manter a continuidade dos negócios ou transferir dados ao Google Cloud para análise e processamento. Para clientes que estão migrando do AWS S3 para o Cloud Storage, esse recurso oferece uma opção para controlar rotas de rede para o Google Cloud, resultando em taxas consideravelmente menores de transferência de dados de saída.

Antes de começar

Antes de configurar suas transferências, siga estas etapas:

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 prefixo do ID do agente, no nome do pool de agentes ou 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.

Receber credenciais de origem

A transferência de origens compatíveis com S3 exige um ID da chave de acesso e uma chave de acesso secreta.

As etapas para acessar esses recursos dependem do seu provedor de armazenamento.

A conta que gera o ID e a chave requer uma das permissões a seguir:

  • Permissão somente leitura em objetos de origem, se não quiser excluir objetos na origem.
  • Acesso total aos objetos de origem, se você optar por excluir os objetos na origem como parte da transferência.

Depois de criar a conta, adicionar permissões e fazer o download do ID da chave de acesso e da chave de acesso secreta, armazene o ID e a chave em um local seguro.

Configurar o acesso ao bucket de destino

Siga as instruções em Configurar o acesso a um coletor: Cloud Storage para configurar o acesso ao bucket de destino.

Criar um pool de agentes

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 pool de agentes. 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.

Para criar um pool de agentes:

Console do Google Cloud

  1. No Console do Google Cloud, acesse a página Pools de agentes.

    Acessar pools de agentes

    A página Pools de agente será exibida, listando os pools de agentes atuais.

  2. Clique em Criar outro pool.

  3. Dê um nome ao pool e, se quiser, descreva-o.

  4. É possível definir um limite de largura de banda que será aplicado ao pool como um todo. A largura de banda especificada em MB/s será dividida entre todos os agentes no pool. Consulte Gerenciar largura de banda da rede para mais informações.

  5. Clique em Criar.

API REST

Use projects.agentPools.create:

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

Em que:

  • PROJECT_ID: o ID do projeto em que você está criando o pool de agentes.
  • AGENT_POOL_ID: o ID do pool de agentes que você está criando.

Se um pool de agentes ficar preso no estado Creating por mais de 30 minutos, recomendamos excluir o pool de agentes e criá-lo novamente.

Revogar as permissões necessárias do Serviço de transferência do Cloud Storage de um projeto enquanto um pool de agentes está no estado Creating leva a um comportamento de serviço incorreto.

CLI da gcloud

Para criar um pool de agentes com a ferramenta de linha de comando gcloud, execute [gcloud transfer agent-pools create][agent-pools-create].

gcloud transfer agent-pools create NAME \
  [--no-async] \
  [--bandwidth-limit=BANDWIDTH_LIMIT] \
  [--display-name=DISPLAY_NAME]

Quando as seguintes opções estiverem disponíveis:

  • NAME é um identificador exclusivo e permanente desse pool.

  • --no-async bloqueia outras tarefas no seu terminal até que o pool seja criado. Se não for incluído, a criação do pool será executada de forma assíncrona.

  • --bandwidth-limit define a largura de banda em MB/s a ser disponibilizada aos agentes deste pool. Um limite de largura de banda se aplica a todos os agentes em um pool e impede que a carga de trabalho de transferência do pool interrompa outras operações que compartilham a largura de banda. Por exemplo, digite "50" para definir um limite de largura de banda de 50 MB/s. Se a sinalização não for especificada, os agentes desse pool usarão toda a largura de banda disponível para eles.

  • --display-name é um nome modificável para ajudar você a identificar esse pool. É possível incluir detalhes que não se encaixam no nome completo exclusivo do recurso do pool.

Instalar os agentes de transferência

Os agentes de transferência são agentes de software que coordenam atividades de transferência da sua origem pelo Serviço de transferência do Cloud Storage. Eles precisam ser instalados em um sistema com acesso aos dados de origem.

CLI da gcloud

Para instalar agentes para usar com uma fonte compatível com S3 usando a CLI gcloud, use o comando transfer agents install.

Forneça as credenciais da AWS como variáveis de ambiente como os valores de AWS_ACCESS_KEY_ID e AWS_SECRET_ACCESS_KEY ou armazenadas como credenciais padrão nos arquivos de configuração do sistema.

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

Para executar agentes usando uma chave de conta de serviço, use a opção --creds-file:

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

Conceda os seguintes papéis de IAM à conta de usuário ou de serviço usada para executar os agentes de transferência:

Criar um job de transferência

Console do Google Cloud

Siga estas etapas para criar uma transferência de uma origem compatível com S3 para um bucket do Cloud Storage.

  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. Selecione Armazenamento de objetos compatível com S3 como o Tipo de origem. O destino precisa ser o Google Cloud Storage.

    Clique em Próxima etapa.

Configurar sua fonte

  1. Especifique as informações necessárias para esta transferência:

    1. Selecione o pool de agentes configurado para esta transferência.

    2. Digite o Nome do bucket relativo ao endpoint. Por exemplo, se os dados estiverem em:

      https://example.com/bucket_a

      Insira: bucket_a

    3. Insira o endpoint. Não inclua o protocolo (http:// ou https://). Por exemplo:

      example.com

  2. Especifique os atributos opcionais para esta transferência:

    1. Insira a Região de assinatura que será usada para assinar as solicitações.

    2. Escolha o processo de assinatura para essa solicitação.

    3. Selecione o Estilo de endereçamento. Isso determina se o nome do bucket é fornecido em estilo de caminho (por exemplo, https://example.com/bucket-name/key-name) ou em estilo virtual hospedado (por exemplo, https://bucket-name.example.com/key-name). Para mais informações, leia Hospedagem virtual de buckets na documentação da Amazon.

    4. Selecione o Protocolo de rede.

    5. Selecione a versão da API da ficha da empresa a ser usada. Consulte as documentações ListObjectsV2 e ListObjects para mais informações.

  3. Clique em Próxima etapa.

Configurar o coletor

  1. 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.

  2. Clique em Próxima etapa.

Escolher configurações 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.

    • 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.

  6. Clique em Próxima etapa.

Programar a transferência

É possível programar a execução da transferência apenas uma vez ou configurar uma transferência recorrente.

Clique em Criar para criar o job de transferência.

CLI da gcloud

Antes de usar a CLI gcloud para criar uma transferência, siga as instruções em Configurar o acesso a um coletor do Cloud Storage.

Use a CLI gcloud para criar uma transferência de uma fonte compatível com S3 para um bucket do Cloud Storage. Use o seguinte comando.

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

As sinalizações a seguir são necessárias:

  • --source-agent-pool é o nome do pool de agentes a ser usado para esta transferência.

  • --source-endpoint especifica o endpoint do sistema de armazenamento. Por exemplo, s3.us-east.example.com. Verifique com seu provedor a formatação correta.

As sinalizações restantes são opcionais:

  • --source-signing-region especifica uma região para assinar solicitações. Omita essa sinalização se o provedor de armazenamento não exigir uma região de assinatura.
  • --source-auth-method especifica o método de autenticação que será usado. Os valores válidos são AWS_SIGNATURE_V2 ou AWS_SIGNATURE_V4. Consulte a documentação da Amazon SigV4 e SigV2 para mais informações.
  • --source-request-model especifica o estilo de endereçamento a ser usado. Os valores válidos são PATH_STYLE ou VIRTUAL_HOSTED_STYLE. O estilo do caminho usa o formato https://s3.REGION.example.com/BUCKET_NAME/KEY_NAME. O estilo hospedado virtual usa o formato "https://BUCKET_NAME.s3.REGION.example.com/KEY_NAME".
  • --source-network-protocol especifica o protocolo de rede que os agentes precisam usar para esse job. Os valores válidos são HTTP ou HTTPS.
  • --source-list-api especifica a versão da API S3 de listagem que retorna objetos do bucket. Os valores válidos são LIST_OBJECTS ou LIST_OBJECTS_V2. Para mais informações, consulte a documentação de ListObjectsV2 e ListObjects da Amazon.

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

API REST

Antes de usar a API REST para criar uma transferência, siga as instruções em Configurar o acesso a um coletor do Cloud Storage.

Para criar uma transferência de uma fonte compatível com S3 usando a API REST, crie um objeto JSON semelhante ao exemplo a seguir.

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

Consulte a referência da API AwsS3CompatibleData para ver as descrições dos campos.

Bibliotecas de cliente

Antes de usar as bibliotecas de clientes para criar uma transferência, siga as instruções em Configurar o acesso a um coletor do Cloud Storage.

Go

Para saber como instalar e usar a biblioteca de cliente para o Serviço de transferência do Cloud Storage, consulte Bibliotecas de clientes do Serviço de transferência do Cloud Storage. Para mais informações, consulte a Documentação de referência da API Go do Serviço de transferência do Cloud Storage.

Para autenticar o Serviço de transferência do Cloud Storage, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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

Para saber como instalar e usar a biblioteca de cliente do Serviço de transferência do Cloud Storage, consulte Bibliotecas de clientes do Serviço de transferência do Cloud Storage. Para mais informações, consulte a Documentação de referência da API Java do Serviço de transferência do Cloud Storage.

Para autenticar o Serviço de transferência do Cloud Storage, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

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

Para saber como instalar e usar a biblioteca de cliente do Serviço de transferência do Cloud Storage, consulte Bibliotecas de clientes do Serviço de transferência do Cloud Storage. Para mais informações, consulte a Documentação de referência da API Node.js do Serviço de transferência do Cloud Storage.

Para autenticar o Serviço de transferência do Cloud Storage, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


// 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

Para saber como instalar e usar a biblioteca de cliente do Serviço de transferência do Cloud Storage, consulte Bibliotecas de clientes do Serviço de transferência do Cloud Storage. Para mais informações, consulte a Documentação de referência da API Python do Serviço de transferência do Cloud Storage.

Para autenticar o Serviço de transferência do Cloud Storage, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

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

Perguntas frequentes

A transferência do armazenamento compatível com S3 é cobrada?

As transferências do armazenamento compatível com S3 não geram a taxa de "Transferências de serviço de transferência do Storage que exigem agentes". Consulte Preços para ver outras taxas que possam ser incorridas. Seu provedor de nuvem de origem também pode receber cobranças operacionais e de transferência de dados.

O Cloud Logging é compatível com transferências de armazenamento compatíveis com S3?

Sim, é possível ativar o Cloud Logging para suas transferências seguindo as instruções em Cloud Logging para o Serviço de transferência do Cloud Storage.

É possível fazer transferências usando um manifesto?

Sim, os arquivos de manifesto são compatíveis com transferências compatíveis com S3.

Se eu adicionar um objeto ao bucket de origem após o início do job, ele será transferido?

O Serviço de transferência do Cloud Storage executa uma operação de lista no bucket de origem para calcular a diferença do destino. Se a operação de lista já tiver sido concluída quando o novo objeto for adicionado, esse objeto será ignorado até a próxima transferência.

O Serviço de transferência do Cloud Storage executa a correspondência de soma de verificação em fontes compatíveis com S3?

O Serviço de transferência do Cloud Storage depende dos dados de soma de verificação retornados pela origem. Para o armazenamento compatível com S3, o Serviço de transferência do Cloud Storage espera que a Etag do objeto seja o hash MD5 do objeto.

Mas os objetos que foram transferidos para o armazenamento compatível com S3 usando o upload de várias partes do S3 não têm ETags MD5. Nesse caso, o Serviço de transferência do Cloud Storage usa o tamanho do arquivo para validar o objeto transferido.

Qual capacidade de processamento pode ser alcançada para transferências do armazenamento compatível com S3?

A capacidade de transferência pode ser escalonada adicionando mais agentes de transferência. Recomendamos o uso de três agentes para tolerância a falhas e para preencher um pipeline com menos de 10 Gbps. Para aumentar o escalonamento, adicione mais agentes. É possível adicionar e remover agentes durante uma transferência em andamento.

Onde os agentes de transferência devem ser implantados para transferir dados do Amazon S3 para o Cloud Storage?

É possível instalar agentes no Amazon EC2 ou EKS na mesma região do seu bucket. Também é possível executar agentes no Google Cloud na região mais próxima.