Übertragung von Amazon S3 zu Cloud Storage

Auf dieser Seite erfahren Sie, wie Sie Übertragungsjobs von Amazon S3 zu Cloud Storage erstellen und starten.

Berechtigungen konfigurieren

Bevor Sie eine Übertragung erstellen, müssen Sie Berechtigungen für Ihren Amazon S3-Bucket konfigurieren. Weitere Informationen finden Sie unter Zugriff auf eine Quelle konfigurieren: Amazon S3.

Außerdem müssen Sie Berechtigungen für die folgenden Google Cloud-Entitäten konfigurieren:

	Das Nutzerkonto, mit dem die Übertragung erstellt wird. Das ist das Konto, mit dem Sie in der Google Cloud Console angemeldet sind, oder das Konto, das bei der Authentifizierung in der gcloud CLI angegeben wird. Das Nutzerkonto kann ein reguläres Nutzerkonto oder ein nutzerverwaltetes Dienstkonto sein.
	Das von Google verwaltete Dienstkonto, auch als Dienst-Agent bezeichnet, das vom Storage Transfer Service verwendet wird. Dieses Konto wird in der Regel anhand seiner E-Mail-Adresse identifiziert, die das Format [e-mail] hat.

Eine Anleitung finden Sie unter Berechtigungen für die agentenlose Weiterleitung.

Optionen für ausgehenden Traffic

Der Storage Transfer Service bietet mehrere Optionen, um Ihre S3-Daten zu Cloud Storage zu übertragen.

Option für ausgehenden Traffic	Beschreibung
Standardmäßig ohne Agent	Bei dieser Option wird eine verwaltete, agentenlose Übertragung von S3 verwendet. Die Gebühren für ausgehenden Traffic werden Ihnen von Amazon in Rechnung gestellt. Folgen Sie der Anleitung auf dieser Seite, um diese Option zu verwenden.
CloudFront-Distribution	Verwenden Sie eine Amazon CloudFront-Distribution als Pfad für ausgehenden Traffic. Bei der Datenübertragung über CloudFront können niedrigere AWS-Kosten für ausgehenden Traffic anfallen als bei der direkten Übertragung von S3. Weitere Informationen finden Sie unter CloudFront-Preise und S3-Ausgabekosten. Folgen Sie der Anleitung unter Übertragung von S3 über CloudFront, um die Bereitstellung einzurichten und eine Übertragung zu erstellen.
Verwaltetes privates Netzwerk	Daten über ein von Google verwaltetes Netzwerk übertragen. Sie zahlen keine S3-Ausgabegebühren, sondern einen Preis pro GiB an Google Cloud. Weitere Informationen finden Sie auf der Seite Preise. Es können weiterhin Betriebskosten von AWS in Rechnung gestellt werden (z.B. LIST oder GET) an. Weitere Informationen finden Sie in den Preisübersichten der jeweiligen Anbieter. Alle Übertragungen von Projekten über das verwaltete private Netzwerk teilen sich dieselbe Bandbreite. Bei hoher Auslastung kann die Übertragung langsamer sein. Übertragungen mit großen Dateien sind stärker betroffen als solche mit kleinen Dateien. Folgen Sie der Anleitung auf dieser Seite, um diese Option zu verwenden. Geben Sie in der Google Cloud Console die Option Verwaltetes privates Netzwerk oder in der REST API das Feld managedPrivateNetwork an. Die gcloud CLI und Clientbibliotheken unterstützen keine verwalteten Übertragungen über private Netzwerke. Siehe die unterstützten Regionen.
Agentengesteuert	Gültig für alle S3-kompatiblen Speicher, einschließlich Amazon S3. Wenn Sie Agent-Software auf Maschinen mit Zugriff auf Ihre S3-Buckets installieren, können Sie den Netzwerkpfad und die Bandbreite steuern. Für diese Option sind Kundenservicemitarbeiter und Agent-Pools erforderlich. Folgen Sie der Anleitung unter Übertragung von S3-kompatiblen Quellen, um diese Option zu verwenden.

Unterstützte Regionen

Storage Transfer Service unterstützt die folgenden Amazon S3-Regionen:

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

Übertragungen über das verwaltete private Netzwerk werden in den folgenden AWS-Regionen unterstützt:

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

Übertragungsoptionen

Die folgenden Storage Transfer Service-Funktionen sind für Übertragungen von S3 nach Cloud Storage verfügbar

Bestimmte Dateien mithilfe eines Manifests übertragen

Sie können eine Liste von Dateien an den Storage Transfer Service übergeben. Weitere Informationen finden Sie unter Bestimmte Dateien oder Objekte mithilfe eines Manifests übertragen.

Speicherklasse angeben

Sie können die Cloud Storage-Speicherklasse angeben, die für Ihre Daten im Ziel-Bucket verwendet werden soll. REST-Details finden Sie in den Optionen für StorageClass. Sie können auch das Flag --custom-storage-class mit der Google Cloud CLI verwenden.

Alle Speicherklasseneinstellungen werden ignoriert, wenn für den Zielbucket Autoclass aktiviert ist. Wenn Autoclass aktiviert ist, werden Objekte, die in den Bucket übertragen werden, anfangs auf „Standard Storage“ gesetzt.

Metadaten beibehalten

Wenn Sie Dateien aus S3 übertragen, kann Storage Transfer Service optional bestimmte Attribute als benutzerdefinierte Metadaten beibehalten.

Im Abschnitt Amazon S3 zu Cloud Storage des Artikels Metadatenaufbewahrung finden Sie weitere Informationen dazu, welche Metadaten aufbewahrt werden können und wie Sie die Übertragung konfigurieren.

Ereignisgesteuerte Übertragungen

Der Storage Transfer Service kann Amazon S3-Ereignisbenachrichtigungen empfangen, die an Amazon SQS gesendet werden, um Daten automatisch zu übertragen, die am Speicherort der Quelle hinzugefügt oder aktualisiert wurden. Weitere Informationen finden Sie unter Ereignisgesteuerte Übertragungen.

Logging und Monitoring

Übertragungen von S3 können in Cloud Logging und Cloud Monitoring angezeigt werden. Weitere Informationen finden Sie unter Cloud Logging für Storage Transfer Service und Übertragungsjobs überwachen. Sie können auch Pub/Sub-Benachrichtigungen konfigurieren.

Übertragung erstellen

Der Storage Transfer Service bietet mehrere Schnittstellen, über die eine Übertragung erstellt werden kann.

Der Name des Übertragungsjobs darf keine vertraulichen Informationen wie personenidentifizierbare Informationen oder Sicherheitsdaten enthalten. Ressourcennamen können an die Namen anderer Google Cloud-Ressourcen weitergegeben und für interne Google-Systeme außerhalb Ihres Projekts freigegeben werden.

Google Cloud Console

1. Rufen Sie in der Google Cloud Console die Seite Storage Transfer Service auf.

   Storage Transfer Service aufrufen

2. Klicken Sie auf Übertragung erstellen. Die Seite Übertragungsjob erstellen wird angezeigt.

3. Wählen Sie unter Quelltyp die Option Amazon S3 aus.

4. Wählen Sie als Zieltyp Google Cloud Storage aus.

5. Wählen Sie den Planungsmodus aus. Batch-Übertragungen werden einmalig oder geplant ausgeführt. Bei ereignisgesteuerten Übertragungen wird die Quelle kontinuierlich überwacht und Daten werden übertragen, wenn sie hinzugefügt oder geändert werden.

   Folgen Sie der Anleitung unter Ereignisgesteuerte Übertragungen, um eine ereignisgesteuerte Übertragung zu konfigurieren.

6. Klicken Sie auf Nächster Schritt.

7. Geben Sie im Feld Bucket- oder Ordnername den Namen des Quell-Buckets ein.

   Der Bucket-Name ist der Name, der in der AWS Management Console angezeigt wird.

8. Wenn Sie eine CloudFront-Distribution für die Übertragung von S3 verwenden, geben Sie den Domainnamen der Distribution in das Feld CloudFront-Domain ein. Beispiel: https://dy1h2n3l4ob56.cloudfront.net. Informationen zum Konfigurieren einer CloudFront-Distribution findest du unter Übertragung von S3 über CloudFront.

9. Wenn Sie für diese Übertragung ein verwaltetes privates Netzwerk verwenden möchten, klicken Sie das Kästchen an. Weitere Informationen finden Sie unter Ausgehende Optionen.

10. Wählen Sie Ihre AWS-Authentifizierungsmethode (Amazon Web Services) aus. Weitere Informationen finden Sie unter Zugriff auf eine Quelle konfigurieren: Amazon S3.

    • Zugriffsschlüssel: Geben Sie Ihren Zugriffsschlüssel in das Feld Zugriffsschlüssel-ID und das Secret, das Ihrem Zugriffsschlüssel zu geordnet ist, im Feld Secret-Zugriffsschlüssel ein.

    • AWS-IAM-Rolle für Identitätsföderation: Geben Sie Ihren ARN in das Feld ARN der AWS-IAM-Rolle mit der folgenden Syntax ein:

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

      Wobei:

      • ACCOUNT: Die AWS-Konto-ID ohne Bindestriche.
      • ROLE-NAME-WITH-PATH: Der Name der AWS-Rolle, einschließlich des Pfads.

      Weitere Informationen zu ARNs finden Sie unter IAM-ARNs.

    • Secret-Ressource: Wählen Sie diese Option aus, um in Secret Manager gespeicherte Amazon-Anmeldedaten zu verwenden. Wählen Sie ein Secret aus der Liste aus oder geben Sie eins manuell im Format projects/PROJECT_NUMBER/secrets/SECRET_NAME ein.

11. Wenn es sich um eine ereignisgesteuerte Übertragung handelt, geben Sie den ARN der Amazon SQS-Warteschlange ein. Dieser muss das folgende Format haben:

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

12. Optional können Sie Objekte nach Präfix oder nach dem Datum der letzten Änderung filtern. Wenn Sie einen Ordner als Quellspeicherort angegeben haben, beziehen sich Präfixfilter auf diesen Ordner. Wenn Ihre Quelle beispielsweise my-test-bucket/path/ ist, werden mit einem Einschlussfilter von file alle Dateien eingeschlossen, die mit my-test-bucket/path/file beginnen.

13. Klicken Sie auf Nächster Schritt.

14. Geben Sie im Feld Bucket oder Ordner den Ziel-Bucket und optional den Ordnernamen ein. Sie können auch auf Durchsuchen klicken, um einen Bucket aus einer Liste der vorhandenen Buckets im aktuellen Projekt auszuwählen. Klicken Sie zum Erstellen eines neuen Buckets auf  Neuen Bucket erstellen.

15. Klicken Sie auf Next step (Nächster Schritt).

16. Wählen Sie die Einstellungen für den Übertragungsjob aus.

    1. Geben Sie im Feld Beschreibung eine Beschreibung der Übertragung ein. Geben Sie als Best Practice eine aussagekräftige Beschreibung ein, damit Sie die Jobs unterscheiden können.

    2. Wählen Sie unter Metadatenoptionen die Standardoptionen aus oder klicken Sie auf Optionen auswählen und auswählen, um Werte für alle unterstützten Metadaten anzugeben. Weitere Informationen finden Sie unter Metadatenaufbewahrung.

    3. Wählen Sie unter Wann überschreiben? eine der folgenden Optionen aus:

       • Falls unterschiedlich: Überschreibt Zieldateien, wenn die Quelldatei mit demselben Namen unterschiedliche ETags oder Prüfsummenwerte hat.

       • Immer: Zieldateien werden immer geschrieben, wenn die Quelldatei denselben Namen hat, auch wenn sie identisch sind.

    4. Wählen Sie unter Löschzeitpunkt eine der folgenden Optionen aus:

       • Nie: Dateien werden niemals aus der Quelle oder dem Ziel gelöscht.

       • Datei nach der Übertragung aus der Quelle löschen: Dateien werden aus der Quelle gelöscht, nachdem sie an das Ziel übertragen wurden.

         Wichtig: Wenn Sie keine lokale Sicherung haben, kann diese Aktion nicht rückgängig gemacht werden.

       • Dateien aus dem Ziel löschen, wenn sie nicht auch in der Quelle sind: Wenn sich Dateien im Cloud Storage-Ziel-Bucket nicht auch in der Quelle befinden, löschen Sie die Dateien aus dem Cloud Storage-Bucket.

         Mit dieser Option wird sichergestellt, dass der Cloud Storage-Ziel-Bucket genau mit Ihrer Quelle übereinstimmt.

    5. Wählen Sie unter Benachrichtigungsoptionen Ihr Pub/Sub-Thema und die Ereignisse aus, die Sie benachrichtigen möchten. Weitere Informationen finden Sie unter Pub/Sub-Benachrichtigungen.

17. Klicken Sie auf Nächster Schritt.

18. Wählen Sie die gewünschten Zeitplanoptionen aus:

    Hinweis: Storage Transfer Service zeigt Zeitpläne für Übertragungsjobs in Ihrer lokalen Zeitzone an, speichert diese Uhrzeiten jedoch in UTC (koordinierter Weltzeit). Wenn an Ihrem Standort die Sommerzeit gilt, ändert sich der Zeitplan für Übertragungsjobs möglicherweise zu Beginn bzw. am Ende der Sommerzeit.

    1. Wählen Sie in der Drop-down-Liste Einmal ausführen eine der folgenden Optionen aus:

       • Einmal ausführen: Führt eine einzelne Übertragung aus, beginnend zu einem von Ihnen ausgewählten Zeitpunkt.

       • Täglich ausführen: Führt jeden Tag eine Übertragung zu einem von Ihnen ausgewählten Zeitpunkt aus.

         Sie können ein optionales Enddatum eingeben oder Enddatum leer lassen, um die Übertragung kontinuierlich auszuführen.

       • Jede Woche ausführen: Führt eine Übertragung wöchentlich aus, beginnend zu einem von Ihnen ausgewählten Zeitpunkt.

       • Mit benutzerdefinierter Frequenz ausführen: Führt eine Übertragung mit der von Ihnen ausgewählten Häufigkeit wird aus. Sie können die Übertragung in regelmäßigen Abständen gemessen in Stunden, Tagen oder Wochen wiederholen.

         Sie können ein optionales Enddatum eingeben oder Enddatum leer lassen, um die Übertragung kontinuierlich auszuführen.

    2. Wählen Sie in der Drop-down-Liste Jetzt starten eine der folgenden Optionen aus:

       • Jetzt starten: Damit wird die Übertragung gestartet, nachdem Sie auf Erstellen geklickt haben.

       • Ab dem: Die Übertragung wird an dem ausgewählten Datum und zur ausgewählten Uhrzeit gestartet. Klicken Sie auf Kalender, um einen Kalender aufzurufen und das Startdatum auszuwählen.

    3. Klicken Sie zum Erstellen des Übertragungsjobs auf Erstellen.

gcloud-CLI

Verwenden Sie zum Erstellen eines neuen Übertragungsjobs den Befehl gcloud transfer jobs create. Das Erstellen eines neuen Jobs initiiert die angegebene Übertragung, sofern weder ein Zeitplan noch --do-not-run angegeben ist.

Die gcloud CLI unterstützt keine Übertragungen über CloudFront oder ein verwaltetes privates Netzwerk.

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

Wobei:

• S3_BUCKET_NAME ist die Datenquelle für diese Übertragung. Optional können Sie einen Pfad angeben: s3://S3_BUCKET_NAME/S3_FOLDER_PATH

• STORAGE_BUCKET_NAME ist der Cloud Storage-Bucket, in den die Daten übertragen werden sollen. Geben Sie zum Übertragen in ein bestimmtes Verzeichnis gs://STORAGE_BUCKET_NAME/STORAGE_FOLDER_PATH/ an, einschließlich des abschließenden Schrägstrichs.

• --source-creds-file gibt den relativen Pfad zu einer lokalen Datei auf Ihrem Computer an, die AWS-Anmeldedaten für die Übertragungsquelle enthält. Der Inhalt muss im folgenden JSON-Format vorliegen:

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

Weitere Optionen:

• --do-not-run verhindert, dass Storage Transfer Service nach dem Senden des Befehls den Job ausführt. Zum Ausführen des Jobs aktualisieren Sie ihn, um einen Zeitplan hinzuzufügen, oder verwenden jobs run, um ihn manuell zu starten.

• --manifest-file gibt den Pfad zu einer CSV-Datei in Cloud Storage an, die eine Liste der Dateien enthält, die von Ihrer Quelle übertragen werden sollen. Informationen zur Formatierung von Manifestdateien finden Sie unter Bestimmte Dateien oder Objekte mithilfe eines Manifests übertragen.

• Jobinformationen: Sie können --name und --description angeben.

• Zeitplan: Geben Sie --schedule-starts, --schedule-repeats-every und --schedule-repeats-until oder --do-not-run an.

• Objektbedingungen: Mit Bedingungen können Sie bestimmen, welche Objekte übertragen werden. Dazu gehören --include-prefixes und --exclude-prefixes sowie die zeitbasierten Bedingungen in --include-modified-[before | after]-[absolute | relative]. Wenn Sie einen Ordner mit Ihrer Quelle angegeben haben, sind Präfixfilter relativ zu diesem Ordner. Weitere Informationen finden Sie unter Quellobjekte nach Präfix filtern.

• Übertragungsoptionen: Bestimmen Sie, ob Zieldateien überschrieben werden sollen (--overwrite-when=different oderalways) und ob bestimmte Dateien während oder nach der Übertragung gelöscht werden sollen (--delete-from=destination-if-unique odersource-after-transfer); welche Metadatenwerte beibehalten werden (--preserve-metadata); und legen Sie optional eine Speicherklasse für übertragene Objekte fest (--custom-storage-class).

• Benachrichtigungen: Konfigurieren Sie Pub/Sub-Benachrichtigungen für Übertragungen mit --notification-pubsub-topic, --notification-event-types und --notification-payload-format.

• Cloud Logging: Aktivieren Sie Cloud Logging mit --log-actions und --log-action-states. Weitere Informationen finden Sie unter Cloud Logging für Storage Transfer Service.

Führen Sie gcloud transfer jobs create --help aus oder sehen Sie sich die gcloud-Referenzdokumentation an, um alle Optionen aufzurufen.

REST

Die folgenden Beispiele zeigen, wie Sie den Storage Transfer Service über die REST API verwenden.

Wenn Sie Übertragungsjobs mithilfe der Storage Transfer Service API konfigurieren oder bearbeiten, muss die Zeit in UTC angegeben werden. Weitere Informationen zum Festlegen des Zeitplans eines Übertragungsjobs finden Sie unter Zeitplan.

Geben Sie beim Erstellen von Übertragungsjobs nicht das Präfix s3:// für bucketName in Amazon Source-Bucket-Quellnamen an.

Übertragung ohne Kundenservicemitarbeiter

Im folgenden Beispiel wird ein Übertragungsjob mit der standardmäßigen agentlosen Konfiguration erstellt. Weitere Informationen finden Sie in der Referenz transferJobs.create.

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

Weitere Authentifizierungsoptionen finden Sie unter Zugriff auf eine Quelle konfigurieren: Amazon S3.

CloudFront-Distribution

Wenn Sie von S3 über eine CloudFront-Bereitstellung übertragen, geben Sie den Domainnamen der Bereitstellung als Wert für das Feld transferSpec.awsS3DataSource.cloudfrontDomain an:

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

Verwaltetes privates Netzwerk

Wenn Sie eine Übertragung von S3 über ein von Google verwaltetes privates Netzwerk ausführen möchten, geben Sie das Feld transferSpec.awsS3DataSource.managedPrivateNetwork an:

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

Clientbibliotheken

Die folgenden Beispiele zeigen, wie Sie den Storage Transfer Service programmatisch mit Go, Java, Node.js und Python verwenden.

Wenn Sie Übertragungsjobs programmatisch konfigurieren oder bearbeiten, muss die Zeit in UTC angegeben werden. Weitere Informationen zum Festlegen des Zeitplans eines Übertragungsjobs finden Sie unter Zeitplan.

Weitere Informationen zu den Storage Transfer Service-Clientbibliotheken finden Sie unter Erste Schritte mit Storage Transfer Service-Clientbibliotheken.

Übertragung von Amazon S3 zu Cloud Storage

In diesem Beispiel erfahren Sie, wie Sie Dateien von Amazon S3 in einen Cloud Storage-Bucket verschieben.

Geben Sie beim Erstellen von Übertragungsjobs nicht das Präfix s3:// für bucketName in Amazon Source-Bucket-Quellnamen an.

Die Clientbibliotheken des Storage Transfer Service unterstützen keine Übertragungen über CloudFront oder ein verwaltetes privates Netzwerk.

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

Sie suchen nach älteren Beispielen? Weitere Informationen finden Sie im Migration Transfer Service-Migrationsleitfaden.

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

Sie suchen nach älteren Beispielen? Weitere Informationen finden Sie im Migration Transfer Service-Migrationsleitfaden.

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