Übertragung von Amazon S3 zu Cloud Storage

Auf dieser Seite wird beschrieben, 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 wurde. Dies ist das Konto, das in der Google Cloud Console angemeldet ist, oder das Konto, das bei der Authentifizierung bei der gcloud-Befehlszeile angegeben wurde. Das Nutzerkonto kann ein reguläres Nutzerkonto oder ein vom Nutzer verwaltetes Dienstkonto sein.
	Das von Google verwaltete Dienstkonto, auch Dienst-Agent genannt, das von Storage Transfer Service verwendet wird. Dieses Konto wird in der Regel durch seine E-Mail-Adresse im Format [e-mail] identifiziert.

Eine Anleitung finden Sie unter Übertragungsberechtigungen ohne Agent.

Optionen für ausgehenden Traffic

Storage Transfer Service bietet mehrere Optionen zum Übertragen Ihrer S3-Daten zu Cloud Storage.

Option für ausgehenden Traffic	Beschreibung
Standardmäßig ohne Agent	Bei dieser Option wird eine verwaltete Übertragung ohne Agent von S3 verwendet. Ausgehender Traffic wird 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 Datenübertragungen über CloudFront können die Kosten für ausgehenden AWS-Traffic im Vergleich zur direkten Übertragung von S3 geringer ausfallen. Weitere Informationen finden Sie unter CloudFront-Preise und Gebühren für ausgehenden S3-Traffic. Folgen Sie der Anleitung unter Übertragung von S3 über CloudFront, um Ihre Distribution einzurichten und eine Übertragung zu erstellen.
Verwaltetes privates Netzwerk	Übertragen Sie Ihre Daten über ein von Google verwaltetes Netzwerk. Sie zahlen keine Gebühren für ausgehenden S3-Traffic. Stattdessen zahlen Sie einen Preis pro GiB an Google Cloud. Weitere Informationen finden Sie auf der Seite Preise. Möglicherweise werden Ihnen weiterhin Vorgangsgebühren von AWS (z.B. LIST- oder GET-Aufrufe). Weitere Informationen finden Sie in der jeweiligen Preisliste. Übertragungen aller Projekte über das verwaltete private Netzwerk verwenden die gleiche Bandbreite. In Zeiten hoher Auslastung kann sich die Übertragung verlangsamen. Übertragungen mit großen Dateien sind stärker betroffen als Übertragungen 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 die Clientbibliotheken unterstützen keine verwalteten privaten Netzwerkübertragungen. Hier finden Sie die unterstützten Regionen.
Vom Kundenservicemitarbeiter gesteuert	Gültig für alle S3-kompatiblen Speicher, einschließlich Amazon S3. Durch die Installation der Agent-Software auf Maschinen mit Zugriff auf Ihre S3-Buckets können Sie den Netzwerkpfad und die Bandbreite steuern. Für diese Option sind Agents und Agent-Pools erforderlich. Folgen Sie der Anleitung unter Aus S3-kompatiblen Quellen übertragen, 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 unterstützen die folgenden AWS-Regionen:

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

Übertragungsoptionen

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

Bestimmte Dateien mithilfe eines Manifests übertragen

Sie können eine Liste von Dateien übergeben, die Storage Transfer Service verarbeitet. 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.

Beachten Sie, dass alle Einstellungen für Speicherklassen ignoriert werden, wenn Autoclass für den Ziel-Bucket aktiviert ist. Wenn Autoclass aktiviert ist, werden Objekte, die in den Bucket übertragen werden, anfangs auf Standard Storage festgelegt.

Metadaten beibehalten

Beim Übertragen von Dateien aus S3 kann Storage Transfer Service optional bestimmte Attribute als benutzerdefinierte Metadaten beibehalten.

Weitere Informationen dazu, welche Metadaten beibehalten werden können und wie Sie die Übertragung konfigurieren, finden Sie im Abschnitt Amazon S3 zu Cloud Storage unter Metadatenerhaltung.

Ereignisgesteuerte Übertragungen

Storage Transfer Service kann auf Amazon S3-Ereignisbenachrichtigungen warten, die an Amazon SQS gesendet wurden, um Daten, die am Quellort hinzugefügt oder aktualisiert wurden, automatisch zu übertragen. Weitere Informationen finden Sie unter Ereignisgesteuerte Übertragungen.

Logging und Monitoring

Übertragungen von S3 können in Cloud Logging und Cloud Monitoring angesehen 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

Storage Transfer Service bietet mehrere Schnittstellen zum Erstellen einer Übertragung.

Der Name des Übertragungsjobs sollte keine vertraulichen Informationen wie personenidentifizierbare Informationen oder Sicherheitsdaten enthalten. Ressourcennamen können an die Namen anderer Google Cloud-Ressourcen weitergegeben und außerhalb Ihres Projekts für Google-interne Systeme 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 werden die Quell- und Übertragungsdaten kontinuierlich überwacht, 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 Namen der Distributionsdomain in das Feld CloudFront-Domain ein. Beispiel: https://dy1h2n3l4ob56.cloudfront.net. Informationen zum Konfigurieren einer CloudFront-Distribution finden Sie unter Übertragung von S3 über CloudFront.

9. Klicken Sie das Kästchen an, um ein verwaltetes privates Netzwerk für diese Übertragung zu verwenden. Weitere Informationen finden Sie unter Optionen für ausgehenden Traffic.

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 mit der folgenden Syntax in das Feld AWS-IAM-Rolle 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 Amazon-Anmeldedaten zu verwenden, die in Secret Manager gespeichert sind. Wählen Sie ein Secret aus der Liste aus oder geben Sie manuell ein Secret im Format projects/PROJECT_NUMBER/secrets/SECRET_NAME ein.

11. Bei einer ereignisgesteuerten Übertragung geben Sie den Amazon SQS-Warteschlangen-ARN im folgenden Format ein:

    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, sind Präfixfilter relativ zu diesem Ordner. Wenn die Quelle beispielsweise my-test-bucket/path/ ist, schließt ein Einschließen-Filter von file alle Dateien ein, 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 Zeiten aber in UTC (koordinierter Weltzeit). Wenn für Sie die Sommerzeit gilt, ändert sich möglicherweise der Zeitplan für Übertragungsjobs zu Beginn oder 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 das Feld Enddatum leer lassen, um die Übertragung kontinuierlich auszuführen.

       • Jede Woche ausführen: Es wird wöchentlich eine Übertragung ausgeführt, die zu einem von Ihnen ausgewählten Zeitpunkt beginnt.

       • 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 das Feld 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 mit dem Startdatum aufzurufen.

    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 übertragen werden soll. 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 mit der Quelle einen Ordner angegeben haben, gelten die 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

In den folgenden Beispielen wird gezeigt, wie Sie Storage Transfer Service über die REST API verwenden.

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

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

Übertragung ohne Agent

Im folgenden Beispiel wird ein Übertragungsjob mit der Agent-Standardkonfiguration erstellt. Weitere Informationen finden Sie in der Referenz zu 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 Daten von S3 über eine CloudFront-Distribution übertragen, geben Sie den Namen der Distributionsdomain als Wert im 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

Geben Sie für die Übertragung von S3 über ein von Google verwaltetes privates Netzwerk 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 Storage Transfer Service programmatisch mit Go, Java, Node.js und Python verwenden können.

Wenn Sie Übertragungsjobs programmatisch konfigurieren oder bearbeiten, muss die Zeit in UTC angegeben werden. Weitere Informationen zum Angeben 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 S3-Bucket-Quellnamen an.

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

Einfach loslegen (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}")