Übertragung von Amazon S3 zu Cloud Storage

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

Berechtigungen konfigurieren

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

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

	Das Nutzerkonto, mit dem die Übertragung erstellt wurde. Dies ist die das in der Google Cloud Console angemeldet ist, oder das Konto, die bei der Authentifizierung bei der gcloud-Befehlszeile angegeben wird. Das Nutzerkonto kann ein normales Nutzerkonto oder ein vom Nutzer verwaltetes Dienstkonto sein.
	Das von Google verwaltete Dienstkonto, auch als Dienst bezeichnet Agent, der vom Storage Transfer Service verwendet wird. Dieses Konto ist im Allgemeinen durch seine E-Mail-Adresse, die das Format [e-mail]

Weitere Informationen finden Sie unter Übertragungsberechtigungen ohne Agent für instructions.

Optionen für ausgehenden Traffic

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

Option für ausgehenden Traffic	Beschreibung
Standardmäßig ohne Agent	Für diese Option wird eine verwaltete Übertragung ohne Agent verwendet von S3. Ausgehender Traffic wird Ihnen von Amazon in Rechnung gestellt. Folgen Sie dazu der Anleitung auf dieser Seite. Option.
CloudFront-Distribution	Amazon CloudFront-Distribution als ausgehenden Traffic verwenden Pfad. Datenübertragungen über CloudFront können niedrigeren Kosten für ausgehenden AWS-Traffic im Vergleich zu direkt von S3 übertragen. Weitere Informationen finden Sie unter CloudFront-Preise und Gebühren für ausgehenden S3-Traffic . Folgen Sie dazu der Anleitung unter Von S3 über CloudFront übertragen und eine Übertragung erstellen.
Verwaltetes privates Netzwerk	Übertragen Sie Ihre Daten über eine von Google verwaltete Netzwerk. Sie zahlen keinen S3-Ausgang Gebühren zahlen Sie einen Preis pro GiB, Google Cloud Weitere Informationen finden Sie unter Preise. . Dir werden möglicherweise weiterhin Kosten in Rechnung gestellt Betriebsgebühren von AWS (z.B. LIST oder GET -Aufrufe); finden Sie in der jeweiligen Preisliste. Alle Projekte Übertragungen über die verwaltete private Netzwerkfreigabe dieselbe Bandbreite haben. In Zeiten hoher Auslastung kann die Übertragung langsam ist. Übertragungen mit großen Dateien sind stärker betroffen als diese mit kleinen Dateien. Folgen Sie der Anleitung auf dieser Seite, um diese Option zu verwenden. Definieren in der Google Cloud Console über die Option Verwaltetes privates Netzwerk oder Das Feld managedPrivateNetwork in der REST API Die gcloud CLI und Clientbibliotheken unterstützen kein verwaltetes privates Netzwerk Übertragungen. Weitere Informationen finden Sie in der unterstützten Regionen.
Vom Kundenservicemitarbeiter gesteuert	Gültig für alle S3-kompatiblen Speicher, einschließlich Amazon S3. Von Installation der Agent-Software auf Computern mit Zugriff zu Ihren S3-Buckets hinzufügen, können Sie Pfad und Bandbreite. Für diese Option sind Kundenservicemitarbeiter erforderlich und Agent-Pools. Befolgen Sie die Anweisungen unter Zur Verwendung aus S3-kompatiblen Quellen übertragen für diese Option.

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

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.

Speicherklasse angeben

Sie können die Cloud Storage-Speicherklasse zur Verwendung für Ihre Daten im Ziel Bucket. Weitere Informationen finden Sie in der <ph type="x-smartling-placeholder"></ph> StorageClass-Optionen für REST-Details oder die --custom-storage-class-Flag mit der Google Cloud CLI.

Alle Einstellungen für Speicherklassen werden ignoriert, Für den Bucket ist Autoclass aktiviert. Wenn Autoclass ist aktiviert. Objekte, die in den Bucket übertragen werden, werden zuerst auf „Standard Storage“ eingestellt ist.

Metadaten beibehalten

Beim Übertragen von Dateien aus S3 kann Storage Transfer Service Bestimmte Attribute können optional als benutzerdefinierte Metadaten beibehalten werden.

Weitere Informationen finden Sie im Abschnitt Amazon S3 zu Cloud Storage <ph type="x-smartling-placeholder"></ph> Beibehaltung von Metadaten mit Details dazu, welche Metadaten beibehalten werden und wie Sie die Übertragung konfigurieren.

Ereignisgesteuerte Übertragungen

Storage Transfer Service kann Amazon S3-Ereignisbenachrichtigungen überwachen, die an Amazon SQS zur automatischen Übertragung von Daten, die hinzugefügt oder aktualisiert wurden am Quellspeicherort befinden. Weitere Informationen finden Sie unter Ereignisgesteuert .

Logging und Monitoring

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

Übertragung erstellen

Storage Transfer Service bietet mehrere Schnittstellen zum Erstellen eines übertragen werden.

Geben Sie keine vertraulichen Daten wie personenidentifizierbare Informationen an (PII) oder Sicherheitsdaten in den Namen des Übertragungsjobs ein. Ressourcennamen können an die Namen anderer Google Cloud-Ressourcen weitergegeben und Google-internen Systemen außerhalb Ihres Projekts zu implementieren.

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 auf einer einmalig oder planmäßig durchgeführt. Kontinuierliche ereignisgesteuerte Übertragungen die Quelle überwachen und Daten übertragen, wenn sie hinzugefügt oder geändert werden.

   Um eine ereignisgesteuerte Übertragung zu konfigurieren, folgen Sie der Anleitung unter Ereignisgesteuerte Übertragungen:

6. Klicken Sie auf Nächster Schritt.

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

   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 im Feld CloudFront-Domain den Namen der Distributionsdomain ein. ein. Beispiel: https://dy1h2n3l4ob56.cloudfront.net. Weitere Informationen finden Sie unter Übertragung von S3 über CloudFront um eine CloudFront-Distribution zu konfigurieren.

9. Wenn Sie für diese Übertragung ein verwaltetes privates Netzwerk verwenden möchten, wählen Sie das . 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 Konfigurieren Sie den Zugriff auf eine Quelle: 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 AWS IAM-Rolle ARN mit der folgenden Syntax:

      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. in Secret Manager gespeichert. Wählen Sie ein Secret aus der Liste aus oder manuell im Format projects/PROJECT_NUMBER/secrets/SECRET_NAME

11. Bei einer ereignisgesteuerten Übertragung geben Sie den Amazon SQS-Wert ein. Warteschlangen-ARN, der das folgende Format hat:

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

12. Optional: Objekte nach Präfix filtern oder nach Datum der letzten Änderung. Wenn Sie einen Ordner als Quellspeicherort angegeben haben, werden Präfixfilter verwendet. relativ zu diesem Ordner. Wenn Ihre Quelle beispielsweise my-test-bucket/path/ ist, wird ein Der Einschließen-Filter von file enthält alle Dateien, die mit beginnen my-test-bucket/path/file

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 Ihrem in der lokalen Zeitzone, speichert diese jedoch in koordinierter Weltzeit (koordinierte Weltzeit) (UTC) Wenn bei Ihnen die Sommerzeit gilt, kann es passieren, sich der Zeitplan für Übertragungsjobs zu Beginn oder am Ende der Sommerzeit ändert.

    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 Enddatum beibehalten. leer, um die Übertragung kontinuierlich auszuführen.

       • Jede Woche ausführen: Die Übertragung wird wöchentlich gestartet, wobei die Übertragung jeweils beginnt. die Sie auswählen.

       • 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 Enddatum beibehalten. leer, 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 anzuzeigen, in dem Sie den Startdatum.

    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 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. Sie können optional einen Pfad enthalten: s3://S3_BUCKET_NAME/S3_FOLDER_PATH

• STORAGE_BUCKET_NAME ist der zu übertragende Cloud Storage-Bucket. in die Sie hineinversetzen können. 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 mit AWS-Anmeldedaten für die Übertragungsquelle. Inhalt muss das folgende JSON-Format haben:

  {
    "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 hat, sind Präfixfilter relativ zu diesem Ordner. Weitere Informationen finden Sie unter Quellobjekte nach Präfix filtern. Informationen.

• Ü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 verwenden. API.

Wenn Sie Übertragungsjobs mit der Methode Storage Transfer Service API verwenden möchten, muss die Zeit in UTC angegeben werden. Weitere Informationen zu Angabe 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.

Übertragung ohne Agent

Im folgenden Beispiel wird ein Übertragungsjob mit dem standardmäßigen Agent ohne Agent erstellt. Konfiguration. Weitere Informationen finden Sie in der transferJobs.create finden Sie weitere Informationen.

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 Informationen finden Sie unter Zugriff auf eine Quelle konfigurieren: Amazon S3 finden Sie weitere Authentifizierungsoptionen.

CloudFront-Distribution

Wenn Sie Daten von S3 über eine CloudFront-Distribution übertragen möchten, geben Sie den Namen der Verteilungsdomain als Wert des Feld 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"
      }
  }
}

Verwaltetes privates Netzwerk

Geben Sie für die Übertragung von S3 über ein von Google verwaltetes privates Netzwerk die Feld 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"
      }
  }
}

Clientbibliotheken

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

Wenn Sie Übertragungsjobs programmatisch konfigurieren oder bearbeiten, muss die Zeit in UTC. Weitere Informationen zu Angabe 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.

Die Storage Transfer Service-Clientbibliotheken unterstützen keine Übertragungen über CloudFront- oder 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}")