Transferencias desde Amazon S3 a Cloud Storage

En esta página, se muestra cómo crear y comenzar trabajos de transferencia de Amazon S3 a Cloud Storage.

Configura permisos

Antes de crear una transferencia, debes configurar los permisos en tu bucket de Amazon S3. Consulta Configura el acceso a una fuente: Amazon S3 para obtener más detalles.

También debes configurar permisos para las siguientes entidades de Google Cloud:

	La cuenta de usuario que se usa para crear la transferencia. Esta es la cuenta con la que se accedió a la consola de Google Cloud o la cuenta 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 el 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 [e-mail].

Consulta Permisos de transferencia sin agente para obtener instrucciones.

Opciones de salida

El Servicio de transferencia de almacenamiento proporciona varias opciones para transferir tus datos de S3 a Cloud Storage.

Opción de salida	Descripción
Predeterminada sin agentes	Esta opción usa una transferencia administrada sin agente desde S3. Se te cobra la salida de Amazon. Sigue las instrucciones que se indican en esta página para usar esta opción.
Distribución de CloudFront	Usa una distribución de Amazon CloudFront como ruta de salida. Las transferencias de datos a través de CloudFront pueden beneficiarse de costos más bajos de salida de AWS en comparación con las transferencias directas desde S3. Consulta los precios de CloudFront y los cargos de salida de S3 para obtener más detalles. Sigue las instrucciones en Transferencias desde S3 a través de CloudFront para configurar la distribución y crear una transferencia.
Red privada administrada	Transfiere tus datos a través de una red administrada por Google. No pagas cargos de salida de S3; en cambio, pagas una tarifa por GiB a Google Cloud. Consulta la página de Precios para obtener más detalles. Es posible que aún se te cobren cargos por operaciones de AWS (p.ej., LIST o GET); consulta los precios para obtener más información. Las transferencias de todos los proyectos en la red privada administrada comparten el mismo ancho de banda. En los momentos de uso elevado, la transferencia puede lentarse. Las transferencias con archivos grandes se ven más afectadas que las que tienen archivos pequeños. Sigue las instrucciones de esta página para usar esta opción. Especifica la opción Red privada administrada en la consola de Google Cloud o el campo managedPrivateNetwork en la API de REST. Gcloud CLI y las bibliotecas cliente no admiten transferencias de red privada administradas. Consulta las regiones compatibles.
Basado en agentes	Válido para todo el almacenamiento compatible con S3, incluido Amazon S3. Mediante la instalación del software de agente en las máquinas con acceso a tus buckets de S3, puedes controlar la ruta de acceso de la red y el ancho de banda. Esta opción requiere agentes y grupos de agentes. Sigue las instrucciones en Transfiere datos desde fuentes compatibles con S3 para usar esta opción.

Regiones admitidas

El Servicio de transferencia de almacenamiento admite las siguientes regiones de 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

Las transferencias que se realizan a través de la red privada administrada admiten las siguientes regiones de AWS:

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

Opciones de transferencia

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

Cómo transferir archivos específicos con un manifiesto

Puedes pasar una lista de archivos para que actúe el Servicio de transferencia de almacenamiento. Para obtener más información, consulta Cómo transferir objetos o archivos específicos con un manifiesto.

Especifica la clase de almacenamiento

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

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

Conservación de metadatos

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

Consulta la sección de Amazon S3 a Cloud Storage en Conservación de metadatos para obtener detalles sobre qué metadatos se pueden conservar y cómo configurar tu transferencia.

Transferencias controladas por eventos

El Servicio de transferencia de almacenamiento puede escuchar las notificaciones de eventos de Amazon S3 que se envían a Amazon SQS para transferir de forma automática los datos que se agregaron o actualizaron en la ubicación de origen. Consulta Transferencias controladas por eventos para obtener más información.

Registro y supervisión

Las transferencias de S3 se pueden ver en Cloud Logging y Cloud Monitoring. Consulta Cloud Logging para el Servicio de transferencia de almacenamiento y Supervisa trabajos de transferencia si deseas obtener más detalles. También puedes configurar las notificaciones de Pub/Sub.

Crear una transferencia

El Servicio de transferencia de almacenamiento proporciona varias interfaces para crear una transferencia.

No incluyas información sensible, como información de identificación personal (PII) o datos de seguridad en el nombre de tu trabajo de transferencia. Los nombres de los recursos se pueden propagar a los nombres de otros recursos de Google Cloud y se pueden exponer a sistemas internos de Google fuera de tu proyecto.

Consola de Google Cloud

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

   Ir al Servicio de transferencia de almacenamiento

2. Haz clic en Crear trabajo de transferencia. Se muestra la página Crea un trabajo de transferencia.

3. En Tipo de fuente, selecciona Amazon S3.

4. En Tipo de destino, selecciona Google Cloud Storage.

5. Selecciona tu Modo de programación. Las transferencias por lotes se ejecutan una sola vez o de forma programada. Las transferencias controladas por eventos supervisan de forma continua la fuente y transfieren los datos cuando se agregan o modifican.

   Para configurar una transferencia controlada por eventos, sigue las instrucciones en Transferencias controladas por eventos.

6. Haz clic en Próximo paso.

7. En el campo Nombre del bucket o de la carpeta, ingresa el nombre del bucket de origen.

   El nombre del bucket es el nombre que aparece en la consola de administración de AWS.

8. Si usas una distribución de CloudFront para transferir desde S3, ingresa el nombre de dominio de distribución en el campo Dominio de CloudFront. Por ejemplo, https://dy1h2n3l4ob56.cloudfront.net Consulta Transferencia desde S3 a través de CloudFront para configurar una distribución de CloudFront.

9. Si quieres usar una red privada administrada para esta transferencia, selecciona la casilla de verificación. Consulta Opciones de salida para obtener más detalles.

10. Selecciona el método de autenticación de Amazon Web Services (AWS). Consulta Configura el acceso a una fuente: Amazon S3 para obtener más detalles.

    • Clave de acceso: Ingresa tu clave de acceso en el ID de la clave de acceso el secreto asociado con tu clave de acceso en Clave de acceso secreta.

    • Función de IAM de AWS para la federación de identidades: Ingresa tu ARN en el campo ARN de función IAM de AWS con la siguiente sintaxis:

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

      Aquí:

      • ACCOUNT: El ID de la cuenta de AWS sin guiones.
      • ROLE-NAME-WITH-PATH: El nombre del rol de AWS, incluida la ruta de acceso.

      Para obtener más información sobre los ARN, consulta ARN de IAM.

    • Recurso secreto: Selecciona esta opción para usar una credencial de Amazon guardada en Secret Manager. Selecciona un secreto de la lista o ingresa uno de forma manual en el formato projects/PROJECT_NUMBER/secrets/SECRET_NAME.

11. Si se trata de una transferencia controlada por eventos, ingresa el ARN de la cola de Amazon SQS, que toma el siguiente formato:

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

12. De manera opcional, elige filtrar objetos por prefijo o por fecha de última modificación. Si especificaste una carpeta como la ubicación de origen, los filtros de prefijo serán relativos a esa carpeta. Por ejemplo, si la fuente es my-test-bucket/path/, un filtro de inclusión de file incluirá todos los archivos que comiencen con my-test-bucket/path/file.

13. Haz clic en Próximo paso.

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

15. Haga clic en Siguiente paso.

16. Elige la configuración del trabajo de transferencia.

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

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

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

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

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

17. Haz clic en Próximo paso.

18. Elige tus opciones de programación:

    Nota: El Servicio de transferencia de almacenamiento muestra los programas de trabajos de transferencia en tu zona horaria local, pero almacena esas horas en hora universal coordinada (UTC). Si te ves afectado por el horario de verano (DST), es posible que experimentes un cambio en el programa del trabajo de transferencia cuando comience o finalice el DST.

    1. En la lista desplegable Ejecutar una vez, selecciona una de las siguientes opciones:

       • Ejecutar una vez: Ejecuta una sola transferencia, a la vez a una hora seleccionada.

       • Ejecutar todos los días: Ejecuta una transferencia a diario a partir de la hora que selecciones.

         Puedes ingresar una Fecha de finalización opcional o dejar la Fecha de finalización en blanco para ejecutar la transferencia de forma continua.

       • Ejecutar cada semana: ejecuta una transferencia semanalmente, a partir de una hora que selecciones.

       • Ejecutar con frecuencia personalizada: Ejecuta una transferencia a la frecuencia que seleccionas. Puedes elegir repetir la transferencia a un intervalo regular de horas, días o semanas.

         Puedes ingresar una Fecha de finalización opcional o dejar la Fecha de finalización en blanco para ejecutar la transferencia de forma continua.

    2. En la lista desplegable A partir de ahora, selecciona una de las siguientes opciones:

       • Inicio ahora: Inicia la transferencia después de hacer clic en Crear.

       • A partir del: inicia la transferencia en la fecha y hora que seleccionaste. Haz clic en Calendario para mostrar un calendario en el que seleccionar la fecha de inicio.

    3. Para crear tu trabajo de transferencia, haz clic en Crear.

gcloud CLI

Para crear un nuevo trabajo de transferencia, usa el comando gcloud transfer jobs create. La creación de un trabajo nuevo inicia la transferencia especificada, a menos que se especifique un programa o --do-not-run.

Gcloud CLI no admite transferencias a través de CloudFront o una red privada administrada.

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

Aquí:

• S3_BUCKET_NAME es la fuente de datos de esta transferencia. De manera opcional, puedes incluir una ruta: s3://S3_BUCKET_NAME/S3_FOLDER_PATH

• STORAGE_BUCKET_NAME es el bucket de Cloud Storage al que se realizará la transferencia. Para transferir a un directorio en particular, especifica gs://STORAGE_BUCKET_NAME/STORAGE_FOLDER_PATH/, incluida la barra diagonal final.

• --source-creds-file especifica la ruta de acceso relativa a un archivo local en tu máquina que incluye credenciales de AWS para la fuente de transferencia. El contenido debe estar en el siguiente formato JSON:

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

Las opciones adicionales incluyen:

• --do-not-run evita que el Servicio de transferencia de almacenamiento ejecute el trabajo cuando se envía el comando. Si deseas ejecutar el trabajo, actualízalo para agregar una programación o usa jobs run a fin de iniciarlo de forma manual.

• --manifest-file especifica la ruta a un archivo CSV en Cloud Storage, que contiene una lista de archivos para transferir de tu fuente. Para formatear archivos de manifiesto, consulta Transfiere archivos o objetos específicos con un manifiesto.

• Información del trabajo: puedes especificar --name y --description.

• Programa: Especifica --schedule-starts, --schedule-repeats-every, y --schedule-repeats-until o --do-not-run.

• Condiciones de objetos: Usa condiciones para determinar qué objetos se transfieren. Estos incluyen --include-prefixes y --exclude-prefixes, y las condiciones basadas en el tiempo en --include-modified-[before | after]-[absolute | relative]. Si especificaste una carpeta con la fuente, los filtros de prefijo son relativos a esa carpeta. Consulta Filtra objetos de origen por prefijo para obtener más información.

• Opciones de transferencia: Especifica si deseas reemplazar los archivos de destino (--overwrite-when=different o always) y si deseas borrar ciertos archivos durante o después de la transferencia (--delete-from=destination-if-unique o source-after-transfer). Especifica qué valores de metadatos se deben conservar (--preserve-metadata) y, de manera opcional, puedes configurar una clase de almacenamiento en los objetos transferidos (--custom-storage-class).

• Notificaciones: Configura las notificaciones de Pub/Sub para transferencias con --notification-pubsub-topic, --notification-event-types y --notification-payload-format.

• Cloud Logging: Habilita Cloud Logging con --log-actions y --log-action-states. Consulta Cloud Logging para el Servicio de transferencia de almacenamiento si deseas obtener más detalles.

Para ver todas las opciones, ejecuta gcloud transfer jobs create --help o consulta la documentación de referencia de gcloud.

REST

En los siguientes ejemplos, se muestra cómo usar el Servicio de transferencia de almacenamiento a través de la API de REST.

Cuando configuras o editas los trabajos de transferencia con la API del Servicio de transferencia de almacenamiento, la hora debe estar en UTC. Para obtener más información sobre cómo especificar la programación de un trabajo de transferencia, consulta Programa.

Cuando crees trabajos de transferencia, no incluyas el prefijo s3:// para bucketName en los nombres de origen del bucket de Amazon S3.

Transferencia sin agente

En el siguiente ejemplo, se crea un trabajo de transferencia con la configuración estándar sin agentes. Consulta la referencia transferJobs.create para obtener más información.

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

Consulta Configura el acceso a una fuente: Amazon S3 para obtener otras opciones de autenticación.

Distribución de CloudFront

Si transfieres desde S3 a través de una distribución de CloudFront, especifica el nombre de dominio de distribución como el valor del 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"
      }
  }
}

Red privada administrada

Para transferir desde S3 mediante una red privada administrada por Google, especifica el 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 cliente

En los siguientes ejemplos, se muestra cómo usar el Servicio de transferencia de almacenamiento de manera programática con Go, Java, Node.js y Python.

Cuando configuras o editas los trabajos de transferencia de manera programática, la hora debe estar en UTC. Para obtener más información sobre cómo especificar la programación de un trabajo de transferencia, consulta Programa.

Para obtener más información sobre las bibliotecas cliente del Servicio de transferencia de almacenamiento, consulta Comienza a usar las bibliotecas cliente del Servicio de transferencia de almacenamiento.

Transferencias desde Amazon S3 a Cloud Storage

En este ejemplo, aprenderás cómo mover archivos desde Amazon S3 a un bucket de Cloud Storage.

Cuando crees trabajos de transferencia, no incluyas el prefijo s3:// para bucketName en los nombres de origen del bucket de Amazon S3.

Las bibliotecas cliente del Servicio de transferencia de almacenamiento no admiten transferencias a través de CloudFront o de una red privada administrada.

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

¿Buscas muestras anteriores? Consulta la Guía de migración del Servicio de transferencia de almacenamiento.

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

¿Buscas muestras anteriores? Consulta la Guía de migración del Servicio de transferencia de almacenamiento.

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