Übertragung von Amazon S3 zu Cloud Storage

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

Vorbereitung

Bevor Sie die Übertragung konfigurieren, müssen Sie Folgendes eingerichtet haben:

  • Nutzerberechtigungen: Ihr Nutzerkonto oder vom Nutzer verwaltetes Dienstkonto muss die Berechtigung zum Konfigurieren von Übertragungsjobs haben. Weitere Informationen finden Sie unter Erforderliche Nutzerberechtigungen.
  • S3-Berechtigungen für die Quelle: Konfigurieren Sie den Zugriff auf Ihre Daten in Amazon S3 mithilfe von Zugriffsanmeldedaten oder einer föderierten Identität. Weitere Informationen finden Sie unter Zugriff auf eine Quelle konfigurieren: Amazon S3.
  • Berechtigungen für den Ziel-Bucket: Gewähren Sie die erforderlichen Berechtigungen für Ihren Cloud Storage-Ziel-Bucket. Weitere Informationen finden Sie unter Zugriff auf eine Senke konfigurieren: Cloud Storage.

Optionen für ausgehenden Traffic

Storage Transfer Service bietet mehrere Optionen für die Übertragung Ihrer S3-Daten zu Cloud Storage.

Option für ausgehenden Traffic Beschreibung
Standard-Agentless Bei dieser Option wird eine verwaltete, agentenlose Übertragung von S3 verwendet. Amazon stellt Ihnen ausgehenden Traffic in Rechnung.

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 AWS-Kosten für ausgehenden Traffic im Vergleich zu direkten Übertragungen von S3 niedriger sein. Weitere Informationen finden Sie unter CloudFront-Preise und S3-Gebühren für ausgehenden Traffic.

Folgen Sie der Anleitung unter Übertragung von S3 über CloudFront, um Ihre Verteilung einzurichten und eine Übertragung zu erstellen.
Von Google verwaltetes privates Netzwerk Übertragen Sie Ihre Daten über ein von Google verwaltetes Netzwerk. Sie zahlen keine Gebühren für ausgehenden S3-Traffic, sondern einen Preis pro GiB an Google Cloud, was die Übertragungskosten senken kann. Weitere Informationen zu den Preisen erhalten Sie in der Preisübersicht. Möglicherweise fallen weiterhin Betriebskosten von AWS an (z. B. LIST- oder GET-Aufrufe). Weitere Informationen finden Sie in der Preisübersicht von AWS.

Alle Übertragungen von Projekten über das verwaltete private Netzwerk teilen sich dieselbe Bandbreite. In Zeiten hoher Auslastung kann die Übertragung langsamer sein. Übertragungen mit großen Dateien sind stärker betroffen als Übertragungen mit kleinen Dateien.

Diese Option ist nur für ausgewählte AWS-Regionen verfügbar und wird für AWS GovCloud-Regionen nicht unterstützt.

Weitere Informationen finden Sie unter Übertragung über ein von Google verwaltetes privates Netzwerk.
Vom Kunden verwaltetes privates Netzwerk Übertragen Sie Ihre Daten über ein vom Kunden verwaltetes privates Netzwerk. Verwenden Sie eine vorhandene Cross-Cloud Interconnect- oder Partner Interconnect-Verbindung oder erwerben und verwenden Sie eine neue Verbindung. Interconnect-Verbindungen stellen eine dedizierte physische Verbindung zwischen Google Cloud und Amazon S3 oder Azure her.

Weitere Informationen finden Sie unter Übertragung von AWS oder Azure über ein vom Kunden verwaltetes privates Netzwerk.
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 Agents und Agent-Pools erforderlich.

Folgen Sie der Anleitung unter Von S3-kompatiblen Quellen übertragen, um diese Option zu verwenden.

Unterstützte Regionen

Der Storage Transfer Service unterstützt die folgenden Amazon S3-Regionen:
af-south-1
ap-east-1
ap-east-2
ap-northeast-1
ap-northeast-2
ap-northeast-3
ap-south-1
ap-south-2
ap-southeast-1
ap-southeast-2 		ap-southeast-3
ap-southeast-4
ap-southeast-5
ca-central-1
ca-west-1
eu-central-1
eu-central-2
eu-north-1
eu-south-1
eu-south-2 		eu-west-1
eu-west-2
eu-west-3
il-central-1
me-central-1
me-south-1
sa-east-1 		us-east-1
us-east-2
us-west-1
us-west-2
us-gov-east-1
us-gov-west-1
Übertragungen über das von Google verwaltete private Netzwerk unterstützen die folgenden AWS-Regionen:
ap-east-1
ap-northeast-1
ap-northeast-2
ap-northeast-3
ap-south-1
ap-south-2
ap-southeast-1
ca-central-1
ca-west-1
eu-central-1
eu-central-2
 eu-north-1
eu-south-1
eu-south-2
eu-west-1
eu-west-2
eu-west-3
us-east-1
us-east-2
us-west-1
us-west-2 		 

Übertragungsoptionen

Die folgenden Storage Transfer Service-Funktionen 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, auf denen Storage Transfer Service Aktionen ausführen kann. Weitere Informationen finden Sie unter Bestimmte Dateien oder Objekte mithilfe eines Manifests übertragen.
Quellobjekte nach Präfix, Zeitpunkt der letzten Änderung oder Speicherklasse filtern

Sie können Objekte anhand des Dateinamens und -pfads, der letzten Änderungszeit oder der Speicherklasse in die Übertragung ein- oder ausschließen.

Standardmäßig werden Objekte in Standard- und Nicht-Archivspeicherklassen, einschließlich Glacier Instant Retrieval (GLACIER_IR), übertragen. Glacier Deep Archive-Objekte (DEEP_ARCHIVE) werden übertragen, wenn sie wiederhergestellt werden. Glacier Flexible Retrieval-Objekte (GLACIER) werden standardmäßig übersprungen.

Weitere Informationen zu Präfixen finden Sie unter Quellobjekte nach Präfix filtern. Weitere Informationen zu Speicherklassen finden Sie unter Quellobjekte nach Speicherklasse filtern.

Zeitbasierte Filter:

  • Mindest- und Höchstzeit, die seit der letzten Änderung verstrichen ist. Beide akzeptieren einen Wert in Sekunden, um Objekte zu filtern, die innerhalb eines bestimmten Zeitraums geändert wurden oder nicht.
  • „Zuletzt geändert seit“ und „Zuletzt geändert vor“, die beide einen dateTime-Wert akzeptieren.

Beachten Sie, dass zeitbasierte Filter für S3-Übertragungen auf der AWS-Definition von „Zeitpunkt der letzten Änderung“ basieren. Dies ist der Zeitpunkt, zu dem der Upload eines Objekts beginnt. Da ein Objekt erst nach Abschluss des Uploads verfügbar ist, kann es sein, dass Sie Objekte finden, deren Zeitpunkt der letzten Änderung Ihren Filterkriterien entspricht, die aber noch hochgeladen werden. Diese Objekte werden nicht in den Übertragungsjob aufgenommen. Um Probleme zu vermeiden, empfehlen wir Folgendes:

  • Verwenden Sie anstelle von zeitbasierten Filtern ereignisgesteuerte Übertragungen, um Objekte zu übertragen, sobald sie verfügbar sind.
  • Damit bei wiederkehrenden Übertragungen keine Objekte fehlen, sollte das Lookback-Window für die „Zeit der letzten Änderung“ größer sein als der wiederkehrende Zeitplan. Bei einem Job, der jede Stunde ausgeführt wird, bietet ein Lookback-Fenster von zwei Stunden beispielsweise einen Puffer.
Speicherklasse angeben
Sie können die Cloud Storage-Speicherklasse angeben, die für Ihre Daten im Ziel-Bucket verwendet werden soll. Weitere Informationen zu REST 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 Speicherklasseneinstellungen ignoriert werden, wenn für den Ziel-Bucket Autoclass aktiviert ist. Wenn Autoclass aktiviert ist, werden in den Bucket übertragene Objekte anfänglich 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 unter Metadaten beibehalten finden Sie weitere Informationen dazu, welche Metadaten beibehalten werden können und wie Sie die Übertragung konfigurieren.

Ereignisgesteuerte Übertragungen
Storage Transfer Service kann Amazon S3-Ereignisbenachrichtigungen abhören, die an Amazon SQS gesendet werden, um Daten, die am Quellspeicherort 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 angezeigt werden. Weitere Informationen finden Sie unter Cloud Logging für den 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 Sie eine Übertragung erstellen können.

Der Name des Übertragungsjobs sollte keine vertraulichen Informationen wie z. B. personenidentifizierbare Informationen oder Sicherheitsdaten enthalten. Ressourcennamen können an die Namen anderer Google Cloud-Ressourcen weitergegeben und für Google-interne Systeme außerhalb Ihres Projekts verfügbar gemacht 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 die Option Google Cloud Storage aus.

  5. Wählen Sie den Planungsmodus aus. Batchübertragungen werden einmalig oder nach einem Zeitplan 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, wie er 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-Verteilung finden Sie unter Übertragung von S3 über CloudFront.

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

    • 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 eines manuell im Format projects/PROJECT_NUMBER/secrets/SECRET_NAME ein.

    • Zugriffsschlüssel: Geben Sie Ihren Zugriffsschlüssel in das Feld Zugriffsschlüssel-ID und das mit Ihrem Zugriffsschlüssel verknüpfte Secret in das Feld Geheimer Zugriffsschlüssel ein.

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

      • Standard-AWS-Regionen:

        arn:aws:iam::AWS_ACCOUNT:role/AWS_ROLE_NAME

      • AWS GovCloud-Regionen:

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

      Ersetzen Sie Folgendes:

      • AWS_ACCOUNT: Die AWS-Konto-ID ohne Bindestriche.
      • AWS_ROLE_NAME: Der Name der AWS-Rolle. Wenn Ihre Organisation Pfade zum Organisieren von Rollen verwendet, geben Sie den Pfad mit dem Rollennamen an. Beispiel: developers/transfer_user.

      Weitere Informationen zu ARNs finden Sie unter IAM-ARNs.

  10. Wenn es sich um eine ereignisgesteuerte Übertragung handelt, geben Sie den ARN der Amazon SQS-Warteschlange im folgenden Format ein:

    • Standard-AWS-Regionen:

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

    • AWS GovCloud-Regionen:

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

  11. Optional können Sie Objekte nach Präfix, nach dem Datum der letzten Änderung oder nach Speicherklasse filtern. Wenn Sie einen Ordner als Quellspeicherort angegeben haben, sind Präfixfilter relativ zu diesem Ordner. Wenn Ihre Quelle beispielsweise my-test-bucket/path/ ist, enthält ein „Einschließen“-Filter von file alle Dateien, die mit my-test-bucket/path/file beginnen.

  12. Klicken Sie auf Nächster Schritt.

  13. 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. Zum Erstellen eines neuen Buckets klicken Sie auf Bucket-Symbol Neuen Bucket erstellen.

  14. Klicken Sie auf Nächster Schritt.

  15. 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 zu einem von Ihnen ausgewählten Zeitpunkt aus.

      • Täglich ausführen: Führt täglich eine Übertragung aus, beginnend zu einer von Ihnen ausgewählten Zeit.

        Sie können optional ein Enddatum eingeben oder das Enddatum leer lassen, damit die Übertragung kontinuierlich ausgeführt wird.

      • Wöchentlich 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 einer von Ihnen ausgewählten Häufigkeit aus. Sie können die Übertragung in regelmäßigen Abständen von Stunden, Tagen oder Wochen wiederholen.

        Sie können optional ein Enddatum eingeben oder das Enddatum leer lassen, damit die Übertragung kontinuierlich ausgeführt wird.

      • Bei Bedarf ausführen: Es wird keine Ausführung ausgelöst, wenn dieser Übertragungsjob erstellt wird. Sie müssen den Job manuell starten.

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

      • Sofort: Die Übertragung wird gestartet, nachdem Sie auf Erstellen geklickt haben.
      • Ab dem: Startet die Übertragung am ausgewählten Datum und zur ausgewählten Uhrzeit. Klicken Sie auf Kalender, um einen Kalender aufzurufen und das Startdatum auszuwählen.

  16. Klicken Sie auf Nächster Schritt.

  17. 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. Optional können Sie ein Manifest angeben, um die genauen Objekte für die Übertragung festzulegen.

    3. Wählen Sie unter Metadatenoptionen die gewünschte Speicherklasse und das Verhalten für die Erstellungszeit aus. Weitere Informationen finden Sie unter Metadatenaufbewahrung.

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

      • Nie: Eine Zieldatei wird nicht überschrieben, wenn die Quelldatei denselben Namen hat. Die Quelldatei wird übersprungen.
      • 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.

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

      • Nie: Dateien werden weder aus der Quelle noch aus dem Ziel gelöscht.

      • Dateien nach der Übertragung aus der Quelle löschen: Dateien werden nach der Übertragung an das Ziel aus der Quelle gelöscht. Wenn eine Quelldatei nicht übertragen wird, weil sie beispielsweise bereits im Ziel vorhanden ist, wird die Quelldatei nicht gelöscht.

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

      • Dateien aus dem Ziel löschen, wenn sie nicht auch in der Quelle sind: Wenn Dateien im Cloud Storage-Ziel-Bucket nicht auch in der Quelle vorhanden sind, werden die Dateien aus dem Cloud Storage-Bucket gelöscht.

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

    6. Netzwerk-Routingoptionen auswählen:

      • Öffentliches Netzwerk verwenden: Daten werden über standardmäßige öffentliche Internet-Peering-Routen zwischen Amazon S3 und Google Cloud übertragen. Alle API-Befehle, Authentifizierungsheader und Objektdatenstreams werden bei der Übertragung durchgängig mit HTTPS mit Transport Layer Security (TLS 1.3) verschlüsselt.
      • Verwaltetes privates Netzwerk verwenden: Daten werden über ein sicheres privates Routing übertragen, das automatisch von Google bereitgestellt wird. Dadurch werden die AWS-Gebühren für ausgehenden Internet-Traffic reduziert und öffentliche Internetendpunkte umgangen, ohne dass eine physische Interconnect-Verbindung eingerichtet werden muss. Diese Option ist nur für ausgewählte AWS-Regionen verfügbar und wird für AWS GovCloud-Regionen nicht unterstützt. Weitere Informationen finden Sie unter Übertragung über ein von Google verwaltetes privates Netzwerk.
      • Eigenes privates Netzwerk verwenden: Daten werden über Ihre eigene vorkonfigurierte Hybrid-Konnektivitätsinfrastruktur (z. B. Cloud Interconnect, Cloud VPN oder AWS Direct Connect) über private IP-Adressen übertragen. Weitere Informationen finden Sie unter Übertragung über ein vom Kunden verwaltetes privates Netzwerk.

    7. Wählen Sie unter Logging-Optionen die Option Logging in Cloud Logging aktivieren aus, wenn Sie einen detaillierten Datensatz der Aktionen generieren möchten, die für jede übertragene Datei ausgeführt wurden. Es fallen Kosten für Cloud Logging an. Weitere Informationen finden Sie unter Aktionen für die Logübertragung.

    8. Optional können Sie Aktualisierungen des Übertragungsstatus über Cloud Pub/Sub-Benachrichtigungen erhalten auswählen, Ihr Pub/Sub-Thema auswählen und festlegen, welche Ereignisse Benachrichtigungen auslösen. Weitere Informationen finden Sie unter Pub/Sub-Benachrichtigungen.

    9. Wählen Sie unter Dienstkontotyp auswählen die Identität aus, die Sie verwenden möchten:

      • Storage Transfer Service-Dienst-Agent: Der standardmäßige, von Google verwaltete Dienst-Agent erhält automatisch Zugriff auf die Quell- und Ziel-Buckets.
      • Nutzerverwalteter Dienst-Agent: Verwenden Sie ein benutzerdefiniertes Dienstkonto, das Sie erstellt haben. Bevor Sie diese Option auswählen, prüfen Sie, ob Ihrem Dienstkonto Zugriff auf den Quell-Bucket, den Ziel-Bucket und Pub/Sub gewährt wurde. Weitere Informationen finden Sie unter Benutzerverwalteten Dienst-Agent verwenden.

  18. Klicken Sie auf Erstellen, um die Übertragung zu 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"

Ersetzen Sie Folgendes:

  • 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 Rechner an, die AWS-Anmeldedaten für die Übertragungsquelle enthält.

    Formatieren Sie die JSON-Datei je nach Authentifizierungsmethode so:

    • AWS-Zugriffsschlüssel:
    {
    "accessKeyId": "AWS_ACCESS_KEY_ID",
    "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
}
    • Föderierte Identität (ARN der AWS-IAM-Rolle):
    {
    "roleArn": "arn:aws:iam::AWS_ACCOUNT_ID:role/AWS_ROLE_NAME"
}

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, --exclude-prefixes, --match-glob, die zeitbasierten Bedingungen in --include-modified-[before | after]-[absolute | relative] und --include-storage-classes. 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 und Quellobjekte nach Speicherklasse 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 für einen Übertragungsjob finden Sie unter Zeitplan.

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

Wenn Sie sich mit einer föderierten Identität anstelle von Zugriffsschlüsseln authentifizieren möchten, geben Sie Folgendes an:

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

statt des awsAccessKey-Objekts. Weitere Informationen finden Sie unter Mit föderierter Identität authentifizieren.

Übertragung ohne Agenten

Im folgenden Beispiel wird ein Übertragungsjob mit der Standardkonfiguration ohne Agent 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"
      }
  }
}

CloudFront-Distribution

Wenn Sie Daten von S3 über eine CloudFront-Distribution übertragen, geben Sie den Domainnamen der Distribution als Wert des Felds 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"
      }
  }
}

Weitere Informationen finden Sie unter Übertragung von S3 über CloudFront.

Verwaltetes privates Netzwerk

Wenn Sie Daten aus S3 über ein von Google verwaltetes privates Netzwerk übertragen 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"
      }
  }
}

Weitere Informationen finden Sie unter Übertragung über ein von Google verwaltetes privates Netzwerk.

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 für einen Übertragungsjob 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 Storage Transfer Service-Clientbibliotheken unterstützen keine Übertragungen über CloudFront oder verwaltete private Netzwerke.

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