Se usó la API de Cloud Translation para traducir esta página.

Transfiere desde un almacenamiento compatible con S3 a Cloud Storage

El Servicio de transferencia de almacenamiento admite transferencias desde sistemas de almacenamiento de objetos en la nube o locales que sean compatibles con la API de Amazon S3.

El Servicio de transferencia de almacenamiento accede a tus datos en el almacenamiento compatible con S3 mediante agentes de transferencia que se implementan en VMs cercanas a la fuente de datos. Estos agentes se ejecutan en un contenedor de Docker y pertenecen a un grupo de agentes, que es una colección de agentes que usan la misma configuración y que trasladan los datos de forma colectiva en paralelo.

Esta función te permite migrar del almacenamiento local o de objetos en la nube a Cloud Storage, archivar datos para liberar capacidad de almacenamiento local, replicar los datos en Google Cloud para la continuidad empresarial o transferir datos a Google Cloud para su análisis y procesamiento. Para los clientes que migran de AWS S3 a Cloud Storage, esta función brinda una opción para controlar las rutas de red a Google Cloud, lo que genera cargos de transferencia de datos salientes considerablemente menores.

Antes de comenzar

Antes de configurar las transferencias, completa los siguientes pasos:

Instala la CLI de gcloud.
Cumple con los requisitos para las transferencias del sistema de archivos, incluida la instalación de Docker en la máquina del agente de transferencia.

Obtén credenciales de origen

La transferencia desde un almacenamiento compatible con S3 requiere un ID de clave de acceso y una clave de acceso secreta.

Los pasos para obtenerlos dependen de tu proveedor de almacenamiento.

La cuenta desde la que se generan el ID y la clave requiere uno de los siguientes permisos:

Permiso de solo lectura en los objetos de origen, si no quieres borrar objetos en la fuente
Acceso completo a los objetos de origen, si decides borrar objetos en la fuente como parte de la transferencia

Una vez que hayas creado la cuenta, agregado permisos y descargado el ID de la clave de acceso y la clave de acceso secreta, almacénalos en un lugar seguro.

Configura los permisos de Google Cloud

Antes de crear una transferencia, debes configurar los permisos de las siguientes entidades:

	La cuenta de usuario que se usa para crear la transferencia Esta es la cuenta con la que accediste a la consola de Google Cloud o la que se especifica cuando se realiza la autenticación en la CLI de "gcloud". La cuenta de usuario puede ser una cuenta de usuario normal o una cuenta de servicio administrada por el usuario.
	La cuenta de servicio administrada por Google, también conocida como agente de servicio, que usa el Servicio de transferencia de almacenamiento. Por lo general, esta cuenta se identifica por su dirección de correo electrónico, que usa el formato `project-PROJECT_NUMBER@storage-transfer-service.iam.gserviceaccount.com`.
	La cuenta de agente de transferencia que proporciona permisos de Google Cloud para los agentes de transferencia Las cuentas de agente de transferencia usan las credenciales del usuario que las instala o las credenciales de una cuenta de servicio administrada por el usuario para autenticarse.

Consulta Permisos de transferencia basados en agentes para obtener instrucciones.

Opciones de transferencia

Las siguientes funciones del Servicio de transferencia de almacenamiento están disponibles para las transferencias de almacenamiento compatible con S3 a Cloud Storage:

Transfiere archivos específicos con un manifiesto

Puedes pasar una lista de archivos para que el Servicio de transferencia de almacenamiento los procese. Consulta Transfiere archivos o objetos específicos con un manifiesto para obtener más detalles.

Especifica la clase de almacenamiento

Puedes especificar la clase de almacenamiento de Cloud Storage que deseas usar para tus datos en el bucket de destino. Consulta las opciones de StorageClass para obtener detalles sobre REST o usa la marca --custom-storage-class con Google Cloud CLI.

Ten en cuenta que se ignora cualquier configuración de clase de almacenamiento si el bucket de destino tiene habilitada Autoclass. Si Autoclass está habilitada, los objetos transferidos al bucket se configuran inicialmente en Standard Storage.

Conservación de metadatos

Cuando se transfieren archivos desde el almacenamiento compatible con S3, el Servicio de transferencia de almacenamiento puede conservar de manera opcional ciertos atributos como metadatos personalizados.

Consulta la sección Amazon S3 o almacenamiento compatible con S3 a Cloud Storage de Preservación de metadatos para obtener detalles sobre qué metadatos se pueden preservar y cómo configurar la transferencia.

Registro y supervisión

Las transferencias desde el almacenamiento compatible con S3 se pueden ver en Cloud Logging y Cloud Monitoring. Consulta Cloud Logging para el Servicio de transferencia de almacenamiento y Cómo supervisar trabajos de transferencia para obtener más información. También puedes configurar notificaciones de Pub/Sub.

Crea un grupo de agentes

No incluyas información sensible, como información de identificación personal (PII) ni datos de seguridad, en el nombre del grupo de agentes ni en el prefijo de ID del agente. Los nombres de los recursos se pueden propagar a los nombres de otros recursos de Google Cloud y pueden exponerse a sistemas internos de Google fuera de tu proyecto.

Para crear un grupo de agentes, haz lo siguiente:

Consola de Google Cloud

En la consola de Google Cloud, ve a la página Grupos de agentes.

Ir a los grupos de agentes

Se mostrará la página Grupos de agentes, que enumera tus grupos de agentes existentes.
Haz clic en Crear otro grupo.
Asigna un nombre a tu grupo y, de manera opcional, una descripción.
Puedes optar por establecer un límite de ancho de banda que se aplicará al grupo en general. El ancho de banda especificado en MB/s se dividirá entre todos los agentes del grupo. Para obtener más información, consulta Administrar el ancho de banda de red.
Haga clic en Crear.

API de REST

Usa projects.agentPools.create:

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

Aquí:

PROJECT_ID: Es el ID del proyecto en el que creas el grupo de agentes.
AGENT_POOL_ID: Es el ID del grupo de agentes que creas.

Si un grupo de agentes se detuvo en el estado Creating durante más de 30 minutos, recomendamos borrar el grupo de agentes y volver a crearlo.

Revocar los permisos necesarios del Servicio de transferencia de almacenamiento de un proyecto mientras un grupo de agentes está en el estado Creating genera un comportamiento de servicio incorrecto.

gcloud CLI

Para crear un grupo de agentes con la herramienta de línea de comandos de gcloud, ejecuta [gcloud transfer agent-pools create][agent-pools-create].

gcloud transfer agent-pools create AGENT_POOL

Las siguientes opciones están disponibles:

AGENT_POOL es un identificador único y permanente para este grupo.
--no-async bloquea otras tareas en tu terminal hasta que se cree el grupo. Si no se incluye, la creación de grupos se ejecuta de forma asíncrona.
--bandwidth-limit define cuánto ancho de banda de MB/s debe estar disponible para los agentes de este grupo. Un límite de ancho de banda se aplica a todos los agentes de un grupo y puede ayudar a evitar que la carga de trabajo de transferencia del grupo interrumpa otras operaciones que comparten el ancho de banda. Por ejemplo, ingresa “50” para establecer un límite de ancho de banda de 50 MB/s. Si dejas esta marca sin especificar, los agentes del grupo usarán todo el ancho de banda disponible para ellos.
--display-name es un nombre modificable que te ayuda a identificar este grupo. Puedes incluir detalles que podrían no caber en el nombre completo del recurso del grupo.

Instala los agentes de transferencia

Los agentes de transferencia son agentes de software que coordinan las actividades de transferencia desde tu fuente a través del Servicio de transferencia de almacenamiento. Se deben instalar en un sistema con acceso a tus datos de origen.

gcloud CLI

Para instalar agentes que se usarán con una fuente compatible con S3 mediante la CLI de gcloud, usa el comando transfer agents install.

Debes proporcionar credenciales de acceso, ya sea como variables de entorno como los valores de AWS_ACCESS_KEY_ID y AWS_SECRET_ACCESS_KEY, o almacenadas como credenciales predeterminadas en los archivos de configuración de tu sistema.

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

Para ejecutar agentes mediante una clave de cuenta de servicio, usa la opción --creds-file:

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

Crear un trabajo de transferencia

Consola de Google Cloud

Sigue estos pasos para crear una transferencia de una fuente compatible con S3 a un bucket de Cloud Storage.

Ve a la página Servicio de transferencia de almacenamiento en la consola de Google Cloud.

Ir al Servicio de transferencia de almacenamiento
Haz clic en Crear trabajo de transferencia. Se muestra la página Crea un trabajo de transferencia.
Selecciona Almacenamiento de objetos compatible con S3 como el Tipo de fuente. El destino debe ser Google Cloud Storage.

Haz clic en Próximo paso.

Configura la fuente

Especifica la información obligatoria para esta transferencia:
1. Selecciona el grupo de agentes que configuraste para esta transferencia.
2. Ingresa el Nombre del bucket en relación con el extremo. Por ejemplo, si los datos residen en las siguientes ubicaciones:
  
  https://example.com/bucket_a
  
  Ingresa: bucket_a
3. Ingresa el extremo. No incluyas el protocolo (http:// o https://) ni el nombre del bucket. Por ejemplo:
  
  example.com
Especifica los atributos opcionales para esta transferencia:
1. Ingresa la región de firma que se usará para firmar las solicitudes.
2. Elige el proceso de firma para esta solicitud.
3. Selecciona el estilo de dirección. Esto determina si el nombre del bucket se proporciona en formato de ruta de acceso (p.ej., https://example.com/bucket-name/key-name) o de estilo de alojamiento virtual (p.ej., https://bucket-name.example.com/key-name). Para obtener más información, lee Alojamiento virtual de buckets en la documentación de Amazon.
4. Selecciona el protocolo de red.
5. Selecciona la versión de la API de fichas que deseas usar. Consulta la documentación de ListObjectsV2 y ListObjects para obtener más información.
Haz clic en Próximo paso.

Configura tu sink

En el campo Bucket o carpeta, ingresa el bucket de destino y el nombre de la carpeta (opcional) o haz clic en Explorar para seleccionar un bucket de una lista de buckets existentes en tu proyecto actual. Para crear un bucket nuevo, haz clic en Crear nuevo bucket.
Haz clic en Próximo paso.

Elige la configuración de transferencia

En el campo Descripción, ingresa una descripción de la transferencia. Como práctica recomendada, ingresa una descripción que sea significativa y única para que puedas distinguir los trabajos.
En Opciones de metadatos, selecciona las opciones predeterminadas o haz clic en Ver y seleccionar opciones para especificar los valores de todos los metadatos admitidos. Consulta Conservación de metadatos para obtener más información.
En Cuándo reemplazar, selecciona una de las siguientes opciones:
- Si es diferente: Reemplaza los archivos de destino si el archivo de origen con el mismo nombre tiene diferentes ETags o valores de suma de verificación.
- Siempre: Siempre escribe archivos de destino cuando el archivo de origen tiene el mismo nombre, incluso si son idénticos.
En Cuándo borrar, selecciona una de las siguientes opciones:
- Nunca: Nunca borres archivos de origen o de destino.
- Borrar archivos de la fuente después de la transferencia: Borra los archivos de la fuente después de transferirlos al destino.
  
  Importante: Si no tienes una copia de seguridad local, esta opción es una acción no reversible.
- Borra los archivos del destino si no están también en el origen: Si los archivos en el bucket de Cloud Storage de destino no están también en el origen, borra los archivos del bucket de Cloud Storage.
  
  Esta opción garantiza que el bucket de destino de Cloud Storage coincida exactamente con tu fuente.
En Opciones de notificación, selecciona tu tema de Pub/Sub y los eventos a los que deseas notificar. Consulta las notificaciones de Pub/Sub para obtener más detalles.
Haz clic en Próximo paso.

Programa la transferencia

Puedes programar la transferencia para que se ejecute solo una vez o configurar una transferencia recurrente.

Haz clic en Crear para crear el trabajo de transferencia.

gcloud CLI

Antes de usar la CLI de gcloud para crear una transferencia, sigue las instrucciones que se indican en Configura el acceso a un receptor de Cloud Storage.

Para usar la CLI de gcloud y crear una transferencia desde una fuente compatible con S3 a un bucket de Cloud Storage, usa el siguiente 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

Las siguientes marcas son obligatorias:

--source-agent-pool es el nombre del grupo de agentes que se usará para esta transferencia.
--source-endpoint especifica el extremo de tu sistema de almacenamiento. Por ejemplo, s3.us-east.example.com Consulta con tu proveedor el formato correcto. No incluyas el protocolo (p.ej., https://) o el nombre del bucket.

Las marcas restantes son opcionales:

--source-signing-region especifica una región para firmar solicitudes. Omite esta marca si tu proveedor de almacenamiento no requiere una región de firma.
--source-auth-method especifica el método de autenticación que se usará. Los valores válidos son AWS_SIGNATURE_V2 o AWS_SIGNATURE_V4. Consulta la documentación de SigV4 y SigV2 de Amazon para obtener más información.
--source-request-model especifica el estilo de asignación que se usará. Los valores válidos son PATH_STYLE o VIRTUAL_HOSTED_STYLE. El estilo de ruta usa el formato https://s3.REGION.example.com/BUCKET_NAME/KEY_NAME. El estilo de alojamiento virtual usa el formato `https://BUCKET_NAME.s3.REGION.example.com/KEY_NAME.
--source-network-protocol especifica el protocolo de red que los agentes deben usar para este trabajo. Los valores válidos son HTTP o HTTPS.
--source-list-api especifica la versión de la API de S3 para mostrar objetos del bucket. Los valores válidos son LIST_OBJECTS o LIST_OBJECTS_V2. Consulta la documentación de ListObjectsV2 y ListObjects de Amazon para obtener más información.

Para obtener más opciones de trabajos de transferencia, ejecuta gcloud transfer jobs create --help o consulta la documentación de referencia de gcloud.

API de REST

Antes de usar la API de REST para crear una transferencia, sigue las instrucciones que se indican en Configura el acceso a un destino de Cloud Storage.

Para crear una transferencia desde una fuente compatible con S3 con la API de REST, crea un objeto JSON similar al siguiente ejemplo.

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

Consulta la referencia de la API de AwsS3CompatibleData para obtener descripciones de los campos.

Bibliotecas cliente

Antes de usar las bibliotecas cliente para crear una transferencia, sigue las instrucciones que se indican en Cómo configurar el acceso a un destino de Cloud Storage.

Go

Para obtener información sobre cómo instalar y usar la biblioteca cliente del Servicio de transferencia de almacenamiento, consulta las Bibliotecas cliente del Servicio de transferencia de almacenamiento. Si deseas obtener más información, consulta la documentación de referencia de la API de Go del Servicio de transferencia de almacenamiento.

Para autenticarte en el Servicio de transferencia de almacenamiento, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 obtener información sobre cómo instalar y usar la biblioteca cliente del Servicio de transferencia de almacenamiento, consulta las Bibliotecas cliente del Servicio de transferencia de almacenamiento. Si deseas obtener más información, consulta la documentación de referencia de la API de Java del Servicio de transferencia de almacenamiento.

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 obtener información sobre cómo instalar y usar la biblioteca cliente del Servicio de transferencia de almacenamiento, consulta las Bibliotecas cliente del Servicio de transferencia de almacenamiento. Si deseas obtener más información, consulta la documentación de referencia de la API de Node.js del Servicio de transferencia de almacenamiento.


// 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 obtener información sobre cómo instalar y usar la biblioteca cliente del Servicio de transferencia de almacenamiento, consulta las Bibliotecas cliente del Servicio de transferencia de almacenamiento. Si deseas obtener más información, consulta la documentación de referencia de la API de Python del Servicio de transferencia de almacenamiento.

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

Preguntas frecuentes

¿Hay un costo por transferir desde el almacenamiento compatible con S3?

Las transferencias de almacenamiento compatible con S3 no incurren en la tarifa de "Transferencias del Servicio de transferencia de almacenamiento que requieren agentes". Consulta Precios para ver otras tarifas que se puedan cobrar. También es posible que se apliquen cargos operacionales y de transferencia de datos salientes de tu proveedor de servicios en la nube de origen.

¿Cloud Logging es compatible con las transferencias de almacenamiento compatibles con S3?

Sí, puedes habilitar Cloud Logging para tus transferencias. Para ello, sigue las instrucciones que se indican en Cloud Logging para el Servicio de transferencia de almacenamiento.

¿Se admiten las transferencias con un manifiesto?

Sí, los archivos de manifiesto son compatibles con las transferencias compatibles con S3.

Si agrego un objeto al bucket de origen después de que se inició el trabajo, ¿se transfiere ese objeto?

El Servicio de transferencia de almacenamiento realiza una operación de lista en el bucket de origen para calcular la diferencia con el destino. Si la operación de lista ya se completó cuando se agrega el objeto nuevo, se omite hasta la próxima transferencia.

¿El Servicio de transferencia de almacenamiento realiza la coincidencia de sumas de verificación en fuentes compatibles con S3?

El Servicio de transferencia de almacenamiento depende de los datos de suma de verificación que muestra la fuente. Para el almacenamiento compatible con S3, el Servicio de transferencia de almacenamiento espera que la Etag del objeto sea el hash MD5 del objeto.

Sin embargo, los objetos que se transfirieron al almacenamiento compatible con S3 con la carga multiparte de S3 no tienen ETags de MD5. En este caso, el Servicio de transferencia de almacenamiento usa el tamaño del archivo para validar el objeto transferido.

¿Qué rendimiento se puede lograr para las transferencias desde el almacenamiento compatible con S3?

Para escalar la capacidad de procesamiento de transferencia, agrega más agentes de transferencia. Te recomendamos que uses 3 agentes para la tolerancia a errores y para completar un canal de menos de 10 Gbps. Para escalar más, agrega más agentes. Los agentes se pueden agregar y quitar mientras se está realizando una transferencia.

¿Dónde se deben implementar los agentes de transferencia para transferir datos de Amazon S3 a Cloud Storage?

Puedes instalar agentes en Amazon EC2 o EKS en la misma región que tu bucket. También puedes ejecutar agentes en Google Cloud en la región más cercana.