Transferencias desde Amazon S3 a Cloud Storage

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

Requisitos previos

Antes de configurar la transferencia, asegúrate de haber configurado lo siguiente:

Opciones de salida

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

Opción de salida Descripción
Sin agentes predeterminado Esta opción usa una transferencia administrada y sin agentes desde S3. Amazon te cobra por la salida.

Sigue las instrucciones de 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 de salida de AWS más bajos en comparación con la transferencia directa desde S3. Consulta los precios de CloudFront y los cargos de salida de S3 para obtener más detalles.

Sigue las instrucciones que se indican en Transfiere desde S3 a través de CloudFront para configurar tu distribución y crear una transferencia.
Red privada administrada por Google Transfiere tus datos a través de una red administrada por Google. No pagas cargos de salida de S3, sino una tarifa por GiB a Google Cloud, lo que podría reducir los costos de transferencia. Consulta la página de Precios para obtener más detalles. Es posible que aún se te cobren cargos operativos de AWS (p. ej., llamadas a LIST o GET). Consulta sus precios para obtener más detalles.

Todas las transferencias de los proyectos a través de la red privada administrada comparten el mismo ancho de banda. En momentos de uso intensivo, es posible que la transferencia se ralentice. Las transferencias con archivos grandes se ven más afectadas que aquellas con archivos pequeños.

Esta opción solo está disponible para algunas regiones de AWS y no se admite para las regiones de AWS GovCloud.

Consulta Transferencia a través de una red privada administrada por Google para obtener más detalles.
Red privada administrada por el cliente Transfiere tus datos a través de una red privada administrada por el cliente. Usa Cross‑Cloud Interconnect o de interconexión de socio existente, o compra y usa una conexión nueva. Las interconexiones proporcionan una conexión física dedicada entre Google Cloud y Amazon S3 o Azure.

Consulta Transfiere desde AWS o Azure a través de una red privada administrada por el cliente para obtener más detalles.
Impulsado por agentes Válido para todo el almacenamiento compatible con S3, incluido Amazon S3. Si instalas el software del agente en máquinas con acceso a tus buckets de S3, puedes controlar la ruta de red y el ancho de banda. Esta opción requiere agentes y grupos de agentes.

Sigue las instrucciones que se indican en Transfiere 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-east-2
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
ap-southeast-5
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
us-gov-east-1
us-gov-west-1
Las transferencias que usan la red privada administrada por Google admiten las siguientes regiones de AWS:
ap-east-1
ap-northeast-1
ap-northeast-2
ap-northeast-3
ap-south-1
ap-south-2
ap-southeast-1
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
us-east-1
us-east-2
us-west-1
us-west-2
 

Opciones de transferencia

Las siguientes funciones del Servicio de transferencia de almacenamiento están disponibles para las transferencias de 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 realice acciones. Consulta Transfiere objetos o archivos específicos con un manifiesto para obtener más detalles.
Filtrar objetos de origen por prefijo, hora de última modificación o clase de almacenamiento

Puedes incluir o excluir objetos de la transferencia según el nombre de archivo y la ruta de acceso, la hora de la última modificación o la clase de almacenamiento.

De forma predeterminada, se transfieren los objetos de las clases de almacenamiento estándar y no de archivo, incluido Glacier Instant Retrieval (GLACIER_IR), y se transfieren los objetos de Glacier Deep Archive (DEEP_ARCHIVE) si se restablecen. Los objetos de Glacier Flexible Retrieval (GLACIER) se omiten de forma predeterminada.

Para obtener más información sobre los prefijos, consulta Filtra objetos de origen por prefijo. Para obtener más información sobre las clases de almacenamiento, consulta Filtra objetos de origen por clase de almacenamiento.

Entre los filtros basados en el tiempo, se incluyen los siguientes:

  • Tiempo mínimo y máximo transcurrido desde la última modificación. Ambos aceptan un valor en segundos para filtrar objetos que se modificaron o no dentro de un período determinado.
  • Última modificación desde y última modificación antes, que aceptan un valor dateTime.

Ten en cuenta que los filtros basados en el tiempo para las transferencias de S3 se basan en la definición de AWS de "hora de última modificación", que es la hora en que un objeto comienza su carga. Dado que un objeto no está disponible hasta que finaliza la carga, es posible que encuentres objetos cuya hora de última modificación cumpla con tus criterios de filtro, pero que aún se estén subiendo. Estos objetos no se incluirán en tu trabajo de transferencia. Para evitar problemas, te recomendamos lo siguiente:

  • En lugar de filtros basados en el tiempo, usa transferencias basadas en eventos para transferir objetos a medida que estén disponibles.
  • Para evitar que falten objetos en las transferencias recurrentes, la ventana de visualización de la "hora de la última modificación" debe ser mayor que el programa recurrente. Por ejemplo, para un trabajo que se ejecuta cada hora, una ventana de visualización de dos horas proporciona un búfer.
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 se ignorará cualquier configuración de clase de almacenamiento si el bucket de destino tiene habilitada la 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 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 de Conservación de metadatos para obtener detalles sobre qué metadatos se pueden conservar y cómo configurar la transferencia.

Transferencias basadas en 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 automáticamente los datos que se agregaron o actualizaron en la ubicación de origen. Consulta Transferencias basadas en eventos para obtener información.
Registro y supervisión
Las transferencias desde S3 se pueden ver en Cloud Logging y Cloud Monitoring. Consulta Cloud Logging para el Servicio de transferencia de almacenamiento y Supervisa los trabajos de transferencia para 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 a través de las cuales se puede crear una transferencia.

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 de forma única o programada. Las transferencias controladas por eventos supervisan de forma continua la fuente y transfieren datos cuando se agregan o modifican.

    Para configurar una transferencia controlada por eventos, sigue las instrucciones que se indican 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 como 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 la 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. 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.

    • Recurso de Secret: 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 con el formato projects/PROJECT_NUMBER/secrets/SECRET_NAME.

    • Clave de acceso: Ingresa tu clave de acceso en el campo ID de clave de acceso y el secreto asociado a tu clave de acceso en el campo Clave de acceso secreta.

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

      • Regiones de AWS estándar:

        arn:aws:iam::AWS_ACCOUNT:role/AWS_ROLE_NAME
      • Regiones de AWS GovCloud:

        arn:aws-us-gov:iam::AWS_ACCOUNT:role/AWS_ROLE_NAME

      Reemplaza lo siguiente:

      • AWS_ACCOUNT: Es el ID de cuenta de AWS sin guiones.
      • AWS_ROLE_NAME: Es el nombre del rol de AWS. Si tu organización usa rutas de acceso para organizar los roles, incluye la ruta de acceso con el nombre del rol. Por ejemplo, developers/transfer_user.

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

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

    • Regiones de AWS estándar:

      arn:aws:sqs:us-east-1:1234567890:event-queue
    • Regiones de AWS GovCloud:

      arn:aws-us-gov:sqs:us-gov-east-1:1234567890:event-queue
  11. De manera opcional, elige filtrar objetos por prefijo, por fecha de última modificación o por clase de almacenamiento. Si especificaste una carpeta como ubicación de origen, los filtros de prefijo son relativos a esa carpeta. Por ejemplo, si tu fuente es my-test-bucket/path/, un filtro de inclusión de file incluye todos los archivos que comienzan con my-test-bucket/path/file.

  12. Haz clic en Próximo paso.

  13. 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 Ícono de bucket Crear nuevo bucket.

  14. Haz clic en Próximo paso.

  15. Elige tus opciones de programación:

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

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

      • Ejecutar una vez: Ejecuta una sola transferencia, que comienza en el momento que selecciones.
      • Ejecutar todos los días: Ejecuta una transferencia todos los días, a partir de la hora que selecciones.

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

      • Ejecutar cada semana: Ejecuta una transferencia semanal, a partir de la hora que selecciones.
      • Ejecutar con frecuencia personalizada: Ejecuta una transferencia con la frecuencia que selecciones. Puedes elegir repetir la transferencia en un intervalo regular de Horas, Días o Semanas.

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

      • Ejecutar a pedido: No se activará una ejecución cuando se cree este trabajo de transferencia. Deberás iniciar el trabajo de forma manual.
    2. En la lista desplegable A partir de ahora, selecciona una de las siguientes opciones:

      • A partir de ahora: Inicia la transferencia después de hacer clic en Crear.
      • Comienza el: Inicia la transferencia en la fecha y hora que selecciones. Haz clic en Calendario para mostrar un calendario y seleccionar la fecha de inicio.
  16. Haz clic en Próximo paso.

  17. 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. De manera opcional, proporciona un manifiesto para especificar los objetos exactos que se transferirán.

    3. En Opciones de metadatos, selecciona la clase de almacenamiento deseada y el comportamiento de la hora de creación. Consulta Conservación de metadatos para obtener más información.

    4. En Cuándo reemplazar, selecciona una de las siguientes opciones:

      • Nunca: No reemplaza un archivo de destino si el archivo de origen tiene el mismo nombre. Se omite el archivo de origen.
      • 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 comprobación.
      • Siempre: Siempre reemplaza los archivos de destino cuando el archivo de origen tiene el mismo nombre, incluso si son idénticos.
    5. En Cuándo borrar, selecciona una de las siguientes opciones:

      • Nunca: Nunca borra archivos del origen ni del destino.
      • Borrar archivos de la fuente después de la transferencia: Borra los archivos de la fuente después de transferirlos al destino. Si no se transfiere un archivo de origen, por ejemplo, porque ya existe en el destino, no se borra.

        Importante: Si no tienes una copia de seguridad local, esta opción es una acción irreversible.

      • Borrar archivos del destino si no están también en el origen: Si los archivos del bucket de Cloud Storage de destino no están también en el origen, bórralos del bucket de Cloud Storage.

        Esta opción garantiza que el bucket de destino de Cloud Storage coincida exactamente con tu fuente.

    6. Elige opciones de enrutamiento de red:

      • Usa la red pública: La transferencia de datos se realiza a través de rutas de intercambio de tráfico de Internet públicas estándar entre Amazon S3 y Google Cloud. Todos los comandos de la API, los encabezados de autenticación y los flujos de datos de objetos se encriptan de extremo a extremo en tránsito con HTTPS con seguridad de la capa de transporte (TLS 1.3).
      • Usa una red privada administrada: Los datos fluyen a través de un enrutamiento privado seguro aprovisionado automáticamente por Google, lo que reduce los cargos de salida de Internet de AWS y omite los extremos públicos de Internet sin necesidad de configurar una interconexión física. Esta opción solo está disponible para algunas regiones de AWS y no se admite en las regiones de AWS GovCloud. Consulta Transferencia a través de una red privada administrada por Google.
      • Utiliza tu propia red privada: Los datos atraviesan tu propia infraestructura de conectividad híbrida preconfigurada (como Cloud Interconnect, Cloud VPN o AWS Direct Connect) a través de direcciones IP privadas. Consulta Transferencia por una red privada administrada por el cliente.
    7. En Opciones de registro, selecciona Habilitar el registro en Cloud Logging si quieres generar un registro detallado de las acciones realizadas en cada archivo transferido. Se aplican los costos de Cloud Logging. Consulta Registra acciones de transferencia para obtener más detalles.

    8. De manera opcional, selecciona Obtén actualizaciones del estado de la operación de transferencia a través de notificaciones de Cloud Pub/Sub), selecciona tu tema de Pub/Sub y elige qué eventos activan las notificaciones. Consulta Notificaciones de Pub/Sub para obtener más detalles.

    9. En Elige el tipo de cuenta de servicio, selecciona la identidad que usarás:

      • Agente de servicio del Servicio de transferencia de almacenamiento: Se otorga acceso automáticamente al agente de servicio administrado por Google predeterminado a los buckets de origen y destino.
      • Agente de servicio administrado por el usuario: Usa una cuenta de servicio personalizada que hayas creado. Antes de seleccionar esta opción, asegúrate de que a tu cuenta de servicio se le haya otorgado acceso al bucket de origen, al bucket de destino y a Pub/Sub. Consulta Usa un agente de servicio administrado por el usuario.
  18. Haz clic en Crear para crear el trabajo de transferencia.

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.

La gcloud CLI no admite transferencias a través de CloudFront ni de la red privada administrada.

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

Reemplaza lo siguiente:

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

  • STORAGE_BUCKET_NAME es el bucket de Cloud Storage al que se transferirán los datos. 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.

    Según tu método de autenticación, asigna el formato al archivo JSON de la siguiente manera:

    • Claves de acceso de AWS:
    {
        "accessKeyId": "AWS_ACCESS_KEY_ID",
        "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
    }
    • Identidad federada (ARN del rol de IAM de AWS):
    {
        "roleArn": "arn:aws:iam::AWS_ACCOUNT_ID:role/AWS_ROLE_NAME"
    }

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, --exclude-prefixes, --match-glob, las condiciones basadas en el tiempo en --include-modified-[before | after]-[absolute | relative] y --include-storage-classes. Si especificaste una carpeta con tu fuente, los filtros de prefijo son relativos a esa carpeta. Consulta Filtra objetos de origen por prefijo y Filtra objetos de origen por clase de almacenamiento 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 para 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 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 Programación.

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

Para autenticar con la identidad federada en lugar de las claves de acceso, especifica lo siguiente:

"roleArn": "arn:aws:iam::AWS_ACCOUNT_ID:role/AWS_ROLE_NAME"

en lugar del objeto awsAccessKey. Consulta Autentica con la identidad federada.

Transferencia sin agentes

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

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

Distribución de CloudFront

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

Consulta Transfiere desde S3 a través de CloudFront para obtener más detalles.

Red privada administrada

Para transferir desde S3 con 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"
      }
  }
}

Consulta Transferencia por una red privada administrada por Google para obtener más detalles.

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 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 Programación.

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 fuentes de bucket de Amazon S3.

Las bibliotecas cliente del Servicio de transferencia de almacenamiento no admiten transferencias a través de CloudFront ni de la 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}")