Übertragungen erstellen

Auf dieser Seite erfahren Sie, wie Sie Übertragungsjobs erstellen und starten.

Informationen, ob Ihre Quelle und Ihr Ziel (auch als Senke bezeichnet) von Storage Transfer Service unterstützt werden, finden Sie unter Unterstützte Quellen und Senken.

Agents und Agent-Pools

Je nach Quelle und Ziel müssen Sie möglicherweise einen Agent-Pool erstellen und konfigurieren und Agents auf einem Computer mit Zugriff auf Ihre Quelle oder Ziel installieren.

  • Für Übertragungen von Amazon S3, Microsoft Azure, URL-Listen oder Cloud Storage zu Cloud Storage sind Agents und Agent-Pools nicht erforderlich.

  • Für Übertragungen, deren Quelle und/oder Ziel ein Dateisystem oder ein S3-kompatibler Speicher ist, sind Agents und Agent-Pools erforderlich. Eine Anleitung finden Sie unter Agent-Pools verwalten.

Hinweise

Bevor Sie die Übertragungen konfigurieren, müssen Sie den Zugriff konfiguriert haben:

Wenn Sie gcloud-Befehle verwenden, installieren Sie die gcloud CLI.

Übertragung erstellen

Der Name des Übertragungsjobs darf keine vertraulichen Informationen wie personenidentifizierbare Informationen oder Sicherheitsdaten enthalten. Ressourcennamen können an die Namen anderer Google Cloud-Ressourcen weitergegeben und für Google-interne Systeme außerhalb Ihres Projekts bereitgestellt 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 eine Quelle aus:

    Cloud Storage

    Ihr Nutzerkonto muss die Berechtigung storage.buckets.get haben, um Quell- und Ziel-Buckets auszuwählen. Alternativ können Sie den Namen des Buckets direkt eingeben. Weitere Informationen finden Sie unter Zugriff auf die Fehlerbehebung.

    1. Wählen Sie unter Quelltyp die Option Cloud Storage aus.

    2. Wählen Sie den Zieltyp aus.

    3. Wenn Ihr Ziel Cloud Storage ist, wählen Sie den Planungsmodus aus. Batchübertragungen werden einmalig oder geplant ausgeführt. Bei ereignisgesteuerten Übertragungen wird die Quelle kontinuierlich überwacht und Daten übertragen, wenn sie hinzugefügt oder geändert werden.

      Eine Anleitung zum Konfigurieren einer ereignisgesteuerten Übertragung finden Sie unter Ereignisgesteuerte Übertragungen.

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

    5. Wählen Sie einen Bucket und optional einen Ordner in diesem Bucket aus, indem Sie einen der folgenden Schritte ausführen:

      • Geben Sie im Feld Bucket oder Ordner einen vorhandenen Cloud Storage-Bucket-Namen und -Pfad ohne das Präfix gs:// ein. Beispiel: my-test-bucket/path/to/files Geben Sie den Namen in der exakten Schreibweise in das Feld Bucket-Name ein, wenn Sie einen Cloud Storage-Bucket aus einem anderen Projekt festlegen möchten.

      • Wählen Sie eine Liste der vorhandenen Buckets in Ihren Projekten aus. Klicken Sie dazu auf Durchsuchen und wählen Sie einen Bucket aus.

        Wenn Sie auf Durchsuchen klicken, können Sie Buckets in anderen Projekten auswählen. Klicken Sie dazu auf Projekt-ID, dann wählen Sie die neue Projekt-ID und den Bucket aus.

      • Zum Erstellen eines neuen Buckets klicken Sie auf  Neuen Bucket erstellen.

    6. Für eine ereignisgesteuerte Übertragung geben Sie den Namen des Pub/Sub-Abos im folgenden Format ein:

      projects/PROJECT_NAME/subscriptions/SUBSCRIPTION_ID
      
    7. Optional können Sie Objekte nach Präfix oder nach dem Datum der letzten Änderung filtern. Wenn Sie einen Ordner als Quellspeicherort angegeben haben, beziehen sich Präfixfilter auf diesen Ordner. Wenn die Quelle beispielsweise my-test-bucket/path/ ist, umfasst der Einschließen-Filter file alle Dateien, die mit my-test-bucket/path/file beginnen.
    8. Klicken Sie auf Next step (Nächster Schritt).

    Amazon S3

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

    2. Wählen Sie als Zieltyp die Option Google Cloud Storage aus.

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

      Eine Anleitung zum Konfigurieren einer ereignisgesteuerten Übertragung finden Sie unter Ereignisgesteuerte Übertragungen.

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

    5. 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.

    6. 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.

    7. Wählen Sie Ihre AWS-Authentifizierungsmethode (Amazon Web Services) aus. Sie können einen AWS-Zugriffsschlüssel oder einen Amazon-Ressourcennamen (ARN) für die Identitätsföderation angeben:

      • 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.

      • ARN: Geben Sie Ihren ARN in das Feld ARN der AWS-IAM-Rolle mit der folgenden Syntax ein:

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

        Wobei:

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

        Weitere Informationen zu ARNs finden Sie unter IAM-ARNs.

    8. Bei einer ereignisgesteuerten Übertragung geben Sie den ARN der Amazon SQS-Warteschlange ein. Dieser hat das folgende Format:

      arn:aws:sqs:us-east-1:1234567890:event-queue
      
    9. Optional können Sie Objekte nach Präfix oder nach dem Datum der letzten Änderung filtern. Wenn Sie einen Ordner als Quellspeicherort angegeben haben, beziehen sich Präfixfilter auf diesen Ordner. Wenn die Quelle beispielsweise my-test-bucket/path/ ist, umfasst der Einschließen-Filter file alle Dateien, die mit my-test-bucket/path/file beginnen.
    10. Klicken Sie auf Next step (Nächster Schritt).

    S3-kompatibler Speicher

    1. Wählen Sie unter Quelltyp die Option S3-kompatibler Objektspeicher aus.

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

    3. Geben Sie die erforderlichen Informationen für diese Übertragung an:

      1. Wählen Sie den Agent-Pool aus, den Sie für diese Übertragung konfiguriert haben.

      2. Geben Sie den Bucket-Namen relativ zum Endpunkt ein. Ihre Daten befinden sich beispielsweise unter:

        https://us-east-1.example.com/folder1/bucket_a

        Eingeben: folder1/bucket_a

      3. Geben Sie den Endpunkt ein. Lassen Sie dabei das Protokoll (http:// oder https://) weg. Im Beispiel aus dem vorherigen Schritt geben Sie Folgendes ein:

        us-east-1.example.com

    4. Geben Sie optionale Attribute für diese Übertragung an:

      1. Geben Sie die Signaturregion für das Signieren von Anfragen ein. Lassen Sie dieses Feld leer, wenn Ihre Quelle keine Signaturregion benötigt.

      2. Wählen Sie den Signaturprozess für diese Anfrage aus.

      3. Wählen Sie den Adressierungsstil aus. Dadurch wird bestimmt, ob der Bucket-Name im Pfadstil angegeben wird (z. B. https://s3.region.example.com/bucket-name/key-name) oder im virtuellen gehosteten Stil (z. B. https://bucket-name.s3.region.example.com/key-name). Weitere Informationen finden Sie in der Amazon-Dokumentation unter [Virtuelles Hosting von Buckets].

      4. Wählen Sie das Netzwerkprotokoll aus.

      5. Wählen Sie die zu verwendende API-Eintragsversion aus. Weitere Informationen finden Sie in der Dokumentation zu ListObjectsV2 und ListObjects.

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

    Microsoft Azure Blob Storage

    1. Wählen Sie unter Quelltyp die Option Azure Blob Storage oder Data Lake Storage Gen2 aus.

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

    3. Geben Sie Folgendes an:

      1. Storage-Kontoname: der Name des Microsoft Azure Storage-Quellkontos.

        Der Name des Storage-Kontos wird im Microsoft Azure Storage-Portal unter Alle Dienste > Speicher > Speicherkonten angezeigt.

      2. Containername: der Name des Microsoft Azure Storage-Containers.

        Der Containername wird im Microsoft Azure Storage-Portal unter Speicher Explorer > Blob-Container angezeigt.

      3. Shared Access Signature (SAS): Das Microsoft Azure Storage-SAS-Token, das aus einer gespeicherten Zugriffsrichtlinie erstellt wurde. Weitere Informationen finden Sie unter Gewähren von eingeschränktem Zugriff auf Azure Storage-Ressourcen mithilfe von SAS (Shared Access Signature).

        Die Standardablaufzeit für SAS-Tokens beträgt 8 Stunden. Achten Sie bei der Erstellung des SAS-Tokens darauf, eine angemessene Ablaufzeit festzulegen, damit Sie die Übertragung erfolgreich abschließen können.
    4. Optional können Sie Objekte nach Präfix oder nach dem Datum der letzten Änderung filtern. Wenn Sie einen Ordner als Quellspeicherort angegeben haben, beziehen sich Präfixfilter auf diesen Ordner. Wenn die Quelle beispielsweise my-test-bucket/path/ ist, umfasst der Einschließen-Filter file alle Dateien, die mit my-test-bucket/path/file beginnen.
    5. Klicken Sie auf Next step (Nächster Schritt).

    Dateisystem

    1. Wählen Sie unter Quelltyp die Option POSIX-Dateisystem aus.

    2. Wählen Sie Ihren Zieltyp aus und klicken Sie auf Nächster Schritt.

    3. Wählen Sie einen vorhandenen Agent-Pool aus oder wählen Sie Agent-Pool erstellen aus und folgen Sie der Anleitung zum Erstellen eines neuen Pools.

    4. Geben Sie den vollständig qualifizierten Pfad des Dateisystemverzeichnisses an.

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

    HDFS

    Weitere Informationen finden Sie unter Von HDFS zu Cloud Storage übertragen.

    URL-Liste

    1. Wählen Sie unter Quelltyp die Option URL-Liste aus und klicken Sie auf Nächster Schritt.

    2. Geben Sie unter URL der TSV-Datei die URL zu einer TSV-Datei (tabulatorgetrennte Werte) ein. Details zum Erstellen der TSV-Datei finden Sie unter URL-Liste erstellen.

    3. Optional können Sie Objekte nach Präfix oder nach dem Datum der letzten Änderung filtern. Wenn Sie einen Ordner als Quellspeicherort angegeben haben, beziehen sich Präfixfilter auf diesen Ordner. Wenn die Quelle beispielsweise my-test-bucket/path/ ist, umfasst der Einschließen-Filter file alle Dateien, die mit my-test-bucket/path/file beginnen.
    4. Klicken Sie auf Next step (Nächster Schritt).

  4. Ziel auswählen:

    Cloud Storage

    1. 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.

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

    3. Wählen Sie die Einstellungen für den Übertragungsjob aus. Einige Optionen sind nur für bestimmte Kombinationen aus Quelle und Senke verfügbar.

      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.

        • 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.

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

    Dateisystem

    1. Wählen Sie einen vorhandenen Agent-Pool oder Agent-Pool erstellen aus und folgen Sie der Anleitung zum Erstellen eines neuen Pools.

    2. Geben Sie den vollständig qualifizierten Zielverzeichnispfad an.

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

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

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

      • Jede Woche ausführen: Die Übertragung wird wöchentlich zu einem von Ihnen festgelegten Zeitpunkt ausgeführt.

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

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

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

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

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

gcloud-CLI

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

gcloud transfer jobs create \
  SOURCE DESTINATION

Wobei:

  • SOURCE ist die Datenquelle für diese Übertragung. Das Format für jede Quelle lautet:

    • Cloud Storage: gs://BUCKET_NAME. Geben Sie für die Übertragung aus einem bestimmten Ordner gs://BUCKET_NAME/FOLDER_PATH/ an, einschließlich des abschließenden Schrägstrichs.
    • Amazon S3: s3://BUCKET_NAME/FOLDER_PATH
    • S3-kompatibler Speicher: s3://BUCKET_NAME. Der Bucket-Name bezieht sich auf den Endpunkt. Wenn sich Ihre Daten beispielsweise bei https://us-east-1.example.com/folder1/bucket_a befinden, geben Sie s3://folder1/bucket_a ein.
    • Microsoft Azure Storage: https://myaccount.blob.core.windows.net/CONTAINER_NAME
    • URL-Liste: https://PATH_TO_URL_LIST oder http://PATH_TO_URL_LIST
    • POSIX-Dateisystem: posix:///PATH Dies muss ein absoluter Pfad vom Stammverzeichnis des Agent-Hostcomputers sein.
    • HDFS: hdfs:///PATH
  • Der DESTINATION ist einer der folgenden:

    • Cloud Storage: gs://BUCKET_NAME. Geben Sie zum Übertragen in ein bestimmtes Verzeichnis gs://BUCKET_NAME/FOLDER_PATH/ an, einschließlich des abschließenden Schrägstrichs.
    • POSIX-Dateisystem: posix:///PATH Dies muss ein absoluter Pfad vom Stammverzeichnis des Agent-Hostcomputers sein.

Wenn für die Übertragung Übertragungs-Agents erforderlich sind, sind die folgenden Optionen verfügbar:

  • --source-agent-pool gibt den für diese Übertragung zu verwendenden Quell-Agent-Pool an. Erforderlich für Übertragungen, die von einem Dateisystem stammen.

  • --destination-agent-pool gibt den Ziel-Agent-Pool an, der für diese Übertragung verwendet werden soll. Erforderlich für Übertragungen an ein Dateisystem.

  • --intermediate-storage-path ist der Pfad zu einem Cloud Storage-Bucket im Format gs://my-intermediary-bucket. Erforderlich für Übertragungen zwischen zwei Dateisystemen. Weitere Informationen zum Zwischen-Bucket finden Sie unter Cloud Storage-Bucket als zwischengelagerten Bucket erstellen.

Weitere Optionen:

  • --source-creds-file gibt den relativen Pfad zu einer lokalen Datei auf Ihrem Rechner an, die AWS- oder Azure-Anmeldedaten für die Übertragungsquelle enthält. Informationen zur Formatierung von Anmeldedatendateien finden Sie in der Referenz zu TransferSpec.

  • --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, --description und --source-creds-file 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 der Quelle angegeben haben, beziehen sich die Präfixfilter auf diesen Ordner. Weitere Informationen finden Sie unter Quellobjekte nach Präfix filtern.

    Objektbedingungen werden für Übertragungen mit Dateisystemen nicht unterstützt.

  • Ü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 für agentenlose Übertragungen oder Übertragungen aus S3-kompatiblen Quellen mit --log-actions und --log-action-states. Weitere Informationen finden Sie unter Cloud Logging für Storage Transfer Service.

Für Übertragungen aus S3-kompatiblen Quellen werden auch die folgenden Optionen verwendet:

  • --source-endpoint (erforderlich): Gibt den Endpunkt Ihres Speichersystems an. Beispiel: s3.example.com. Erkundigen Sie sich bei Ihrem Anbieter nach der korrekten Formatierung. Geben Sie nicht das Protokoll an (http:// oder https://).
  • --source-signing-region gibt eine Region für Signieranfragen an. Lassen Sie dieses Flag weg, wenn Ihr Speicheranbieter keine Signaturregion benötigt.
  • --source-auth-method gibt die zu verwendende Authentifizierungsmethode an. Gültige Werte sind AWS_SIGNATURE_V2 oder AWS_SIGNATURE_V4. Weitere Informationen finden Sie in der Dokumentation zu SigV4 und SigV2 von Amazon.
  • --source-request-model gibt den zu verwendenden Adressierungsstil an. Gültige Werte sind PATH_STYLE oder VIRTUAL_HOSTED_STYLE. Der Pfadstil hat das Format https://s3.example.com/BUCKET_NAME/KEY_NAME. Für den Stil „Virtuell gehostet“ wird das Format „https://BUCKET_NAME.s3.beispiel.de/KEY_NAME“ verwendet.
  • --source-network-protocol gibt das Netzwerkprotokoll an, das Agents für diesen Job verwenden sollen. Gültige Werte sind HTTP und HTTPS.
  • --source-list-api gibt die Version der S3 Listing API für die Rückgabe von Objekten aus dem Bucket an. Gültige Werte sind LIST_OBJECTS oder LIST_OBJECTS_V2. Weitere Informationen finden Sie in der Amazon-Dokumentation zu ListObjectsV2 und ListObjects.

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

Beispiele

Amazon S3 für Cloud Storage

Führen Sie den folgenden Befehl aus, um einen täglichen Übertragungsjob zu erstellen, um am letzten Tag geänderte Daten von s3://my-s3-bucket in einen Cloud Storage-Bucket mit dem Namen my-storage-bucket zu verschieben:

gcloud transfer jobs create \
  s3://my-s3-bucket gs://my-storage-bucket \
  --source-creds-file=/examplefolder/creds.txt \
  --include-modified-after-relative=1d \
  --schedule-repeats-every=1d

S3-kompatibler Speicher zu Cloud Storage

So übertragen Sie von einer S3-kompatiblen Quelle in einen Cloud Storage-Bucket:

gcloud transfer jobs create s3://my-s3-compat-bucket gs://my-storage-bucket \
  --source-agent-pool=my-source-agent-pool
  --source-endpoint=us-east-1.example.com/ \
  --source-auth-method=AWS_SIGNATURE_V2 \
  --source-request-model=PATH_STYLE \
  --source-network-protocol=HTTPS \
  --source-list-api=LIST_OBJECTS_V2

Dateisystem in Cloud Storage

Geben Sie Folgendes an, um von einem Dateisystem in einen Cloud Storage-Bucket zu übertragen:

gcloud transfer jobs create \
  posix:///tmp/source gs://my-storage-bucket \
  --source-agent-pool=my-source-agent-pool

Cloud Storage zum Dateisystem

Geben Sie Folgendes an, um von einem Cloud Storage-Bucket in ein Dateisystem zu übertragen:

gcloud transfer jobs create \
  gs://my-storage-bucket posix:///tmp/destination \
  --destination-agent-pool=my-destination-agent-pool

Dateisystem zum Dateisystem

Für die Übertragung zwischen zwei Dateisystemen müssen Sie einen Quell-Agent-Pool, einen Ziel-Agent-Pool und einen Cloud Storage-Zwischen-Bucket angeben, über den die Daten übertragen werden.

Weitere Informationen zum Zwischen-Bucket finden Sie unter Cloud Storage-Bucket als Vermittler erstellen.

Geben Sie dann beim Aufrufen von transfer jobs create die folgenden drei Ressourcen an:

gcloud transfer jobs create \
  posix:///tmp/source/on/systemA posix:///tmp/destination/on/systemB \
  --source-agent-pool=source_agent_pool \
  --destination-agent-pool=destination_agent_pool \
  --intermediate-storage-path=gs://my-intermediary-bucket

REST

Die folgenden Beispiele zeigen, 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 für einen Übertragungsjob finden Sie unter Zeitplan.

Übertragung zwischen Cloud Storage-Buckets

In diesem Beispiel erfahren Sie, wie Sie Dateien von einem Cloud Storage-Bucket in einen anderen verschieben. Sie können beispielsweise Daten in einen Bucket an einem anderen Speicherort bewegen.

Anfrage mit transferJobs create:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "schedule": {
      "scheduleStartDate": {
          "day": 1,
          "month": 1,
          "year": 2015
      },
      "startTimeOfDay": {
          "hours": 1,
          "minutes": 1
      }
  },
  "transferSpec": {
      "gcsDataSource": {
          "bucketName": "GCS_SOURCE_NAME"
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      },
      "transferOptions": {
          "deleteObjectsFromSourceAfterTransfer": true
      }
  }
}
Lösung:
200 OK
{
  "transferJob": [
      {
          "creationTime": "2015-01-01T01:01:00.000000000Z",
          "description": "YOUR DESCRIPTION",
          "name": "transferJobs/JOB_ID",
          "status": "ENABLED",
          "lastModificationTime": "2015-01-01T01:01:00.000000000Z",
          "projectId": "PROJECT_ID",
          "schedule": {
              "scheduleStartDate": {
                  "day": 1,
                  "month": 1,
                  "year": 2015
              },
              "startTimeOfDay": {
                  "hours": 1,
                  "minutes": 1
              }
          },
          "transferSpec": {
              "gcsDataSource": {
                  "bucketName": "GCS_SOURCE_NAME",
              },
              "gcsDataSink": {
                  "bucketName": "GCS_NEARLINE_SINK_NAME"
              },
              "objectConditions": {
                  "minTimeElapsedSinceLastModification": "2592000.000s"
              },
              "transferOptions": {
                  "deleteObjectsFromSourceAfterTransfer": true
              }
          }
      }
  ]
}

Übertragung von Amazon S3 zu Cloud Storage

In diesem Beispiel erfahren Sie, wie Sie Dateien von Amazon S3 in einen Cloud Storage-Bucket verschieben. Informieren Sie sich unbedingt unter Zugriff auf Amazon S3 konfigurieren und unter Preise über die Auswirkungen einer Datenverschiebung von Amazon S3 zu Cloud Storage.

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

Anfrage mit transferJobs create:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "schedule": {
      "scheduleStartDate": {
          "day": 1,
          "month": 1,
          "year": 2015
      },
      "scheduleEndDate": {
          "day": 1,
          "month": 1,
          "year": 2015
      },
      "startTimeOfDay": {
          "hours": 1,
          "minutes": 1
      }
  },
  "transferSpec": {
      "awsS3DataSource": {
          "bucketName": "AWS_SOURCE_NAME",
          "awsAccessKey": {
              "accessKeyId": "AWS_ACCESS_KEY_ID",
              "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
          }
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}
Lösung:
200 OK
{
  "transferJob": [
      {
          "creationTime": "2015-01-01T01:01:00.000000000Z",
          "description": "YOUR DESCRIPTION",
          "name": "transferJobs/JOB_ID",
          "status": "ENABLED",
          "lastModificationTime": "2015-01-01T01:01:00.000000000Z",
          "projectId": "PROJECT_ID",
          "schedule": {
              "scheduleStartDate": {
                  "day": 1,
                  "month": 1,
                  "year": 2015
              },
              "scheduleEndDate": {
                  "day": 1,
                  "month": 1,
                  "year": 2015
              },
              "startTimeOfDay": {
                  "hours": 1,
                  "minutes": 1
              }
          },
          "transferSpec": {
              "awsS3DataSource": {
                  "bucketName": "AWS_SOURCE_NAME"
              },
              "gcsDataSink": {
                  "bucketName": "GCS_SINK_NAME"
              },
              "objectConditions": {},
              "transferOptions": {}
          }
      }
  ]
}

Wenn Sie Daten von S3 über eine CloudFront-Distribution übertragen, geben Sie den Domainnamen der Distribution als Wert des Felds transferSpec.awsS3DataSource.cloudfrontDomain an:

"transferSpec": {
  "awsS3DataSource": {
    "bucketName": "AWS_SOURCE_NAME",
    "cloudfrontDomain": "https://dy1h2n3l4ob56.cloudfront.net",
    "awsAccessKey": {
      "accessKeyId": "AWS_ACCESS_KEY_ID",
      "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
    }
  },
  ...
}

Übertragung zwischen Microsoft Azure Blob Storage und Cloud Storage

In diesem Beispiel erfahren Sie, wie Sie Dateien von Microsoft Azure Storage in ein Cloud Storage-Bucket verschieben und dabei ein Microsoft Azure Storage Shared Access Signature-Token (SAS) verwenden.

Weitere Informationen zu Microsoft Azure Storage SAS finden Sie unter Zugriff auf Azure Storage-Ressourcen mit SAS (Shared Access Signature) gewähren.

Lesen Sie zuerst die Abschnitte Zugriff auf Microsoft Azure Storage konfigurieren und Preise, um sich über die Auswirkungen einer Datenverschiebung von Microsoft Azure Storage zu Cloud Storage zu informieren.

Anfrage mit transferJobs create:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "schedule": {
      "scheduleStartDate": {
          "day": 14,
          "month": 2,
          "year": 2020
      },
      "scheduleEndDate": {
          "day": 14
          "month": 2,
          "year": 2020
      },
      "startTimeOfDay": {
          "hours": 1,
          "minutes": 1
      }
  },
  "transferSpec": {
      "azureBlobStorageDataSource": {
          "storageAccount": "AZURE_SOURCE_NAME",
          "azureCredentials": {
              "sasToken": "AZURE_SAS_TOKEN",
          },
          "container": "AZURE_CONTAINER",
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}
Antwort:
200 OK
{
  "transferJob": [
      {
          "creationTime": "2020-02-14T01:01:00.000000000Z",
          "description": "YOUR DESCRIPTION",
          "name": "transferJobs/JOB_ID",
          "status": "ENABLED",
          "lastModificationTime": "2020-02-14T01:01:00.000000000Z",
          "projectId": "PROJECT_ID",
          "schedule": {
              "scheduleStartDate": {
                  "day": 14
                  "month": 2,
                  "year": 2020
              },
              "scheduleEndDate": {
                  "day": 14,
                  "month": 2,
                  "year": 2020
              },
              "startTimeOfDay": {
                  "hours": 1,
                  "minutes": 1
              }
          },
          "transferSpec": {
              "azureBlobStorageDataSource": {
                  "storageAccount": "AZURE_SOURCE_NAME",
                  "azureCredentials": {
                      "sasToken": "AZURE_SAS_TOKEN",
                  },
                  "container": "AZURE_CONTAINER",
              },
              "objectConditions": {},
              "transferOptions": {}
          }
      }
  ]
}

Übertragung aus einem Dateisystem

In diesem Beispiel erfahren Sie, wie Sie Dateien aus einem POSIX-Dateisystem in einen Cloud Storage-Bucket verschieben.

Verwenden Sie transferJobs.create mit einem posixDataSource:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
 "name":"transferJobs/sample_transfer",
 "description": "My First Transfer",
 "status": "ENABLED",
 "projectId": "my_transfer_project_id",
 "schedule": {
     "scheduleStartDate": {
         "year": 2022,
         "month": 5,
         "day": 2
     },
     "startTimeOfDay": {
         "hours": 22,
         "minutes": 30,
         "seconds": 0,
         "nanos": 0
     }
     "scheduleEndDate": {
         "year": 2022,
         "month": 12,
         "day": 31
     },
     "repeatInterval": {
         "259200s"
     },
 },
 "transferSpec": {
     "posixDataSource": {
          "rootDirectory": "/bar/",
     },
     "sourceAgentPoolName": "my_example_pool",
     "gcsDataSink": {
          "bucketName": "destination_bucket"
          "path": "foo/bar/"
     },
  }
}

Das Feld schedule ist optional. Ist dies nicht der Fall, muss der Übertragungsjob mit einer transferJobs.run-Anfrage gestartet werden.

Mit transferJobs.get können Sie den Status Ihrer Übertragung nach dem Erstellen eines Jobs prüfen:

GET https://storagetransfer.googleapis.com/v1/transferJobs/sample_transfer?project_id=my_transfer_project_id

Quell- und Zielpfade angeben

Mit Quell- und Zielpfaden können Sie Quell- und Zielverzeichnisse angeben, wenn Sie Daten in Ihren Cloud Storage-Bucket übertragen. Beispiel: Sie haben die Dateien file1.txt und file2.txt und einen Cloud Storage-Bucket namens B. Wenn Sie einen Zielpfad mit dem Namen my-stuff festlegen, befinden sich Ihre Dateien nach der Übertragung in gs://B/my-stuff/file1.txt und gs://B/my-stuff/file2.txt.

Quellpfad angeben

Zum Festlegen eines Quellpfads beim Erstellen eines Übertragungsjobs fügen Sie dem Feld gcsDataSource in der Spezifikation TransferSpec das Feld path hinzu:

{
gcsDataSource: {
  bucketName: "SOURCE_BUCKET",
  path: "SOURCE_PATH/",
},
}

In diesem Beispiel:

  • SOURCE_BUCKET: Der Cloud Storage-Quell-Bucket.
  • SOURCE_PATH: Der Cloud Storage-Quellpfad.

Zielpfad angeben

Zum Festlegen eines Zielordners beim Erstellen eines Übertragungsjobs fügen Sie dem Feld gcsDataSink in der Spezifikation TransferSpec das Feld path hinzu:

{
gcsDataSink: {
  bucketName: "DESTINATION_BUCKET",
  path: "DESTINATION_PATH/",
},
}

In diesem Beispiel:

  • DESTINATION_BUCKET: Cloud Storage-Ziel-Bucket
  • DESTINATION_PATH: Der Cloud Storage-Zielpfad.

Beispiel für eine vollständige Anfrage

Das folgende Beispiel zeigt eine vollständige Anfrage:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "schedule": {
      "scheduleStartDate": {
          "day": 1,
          "month": 1,
          "year": 2015
      },
      "startTimeOfDay": {
          "hours": 1,
          "minutes": 1
      }
  },
  "transferSpec": {
      "gcsDataSource": {
          "bucketName": "GCS_SOURCE_NAME",
          "path": "GCS_SOURCE_PATH",
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME",
          "path": "GCS_SINK_PATH",
      },
      "objectConditions": {
          "minTimeElapsedSinceLastModification": "2592000s"
      },
      "transferOptions": {
          "deleteObjectsFromSourceAfterTransfer": true
      }
  }

}

Clientbibliotheken

In den folgenden Beispielen wird gezeigt, wie Sie 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 Angeben 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 zwischen Cloud Storage-Buckets

In diesem Beispiel erfahren Sie, wie Sie Dateien von einem Cloud Storage-Bucket in einen anderen verschieben. Sie können beispielsweise Daten in einen Bucket an einem anderen Speicherort bewegen.

Einfach loslegen (Go)

import (
	"context"
	"fmt"
	"io"
	"time"

	"google.golang.org/genproto/googleapis/type/date"
	"google.golang.org/genproto/googleapis/type/timeofday"
	"google.golang.org/protobuf/types/known/durationpb"

	storagetransfer "cloud.google.com/go/storagetransfer/apiv1"
	"cloud.google.com/go/storagetransfer/apiv1/storagetransferpb"
)

func transferToNearline(w io.Writer, projectID string, gcsSourceBucket string, gcsNearlineSinkBucket string) (*storagetransferpb.TransferJob, error) {
	// Your Google Cloud Project ID
	// projectID := "my-project-id"

	// The name of the GCS bucket to transfer objects from
	// gcsSourceBucket := "my-source-bucket"

	// The name of the Nearline GCS bucket to transfer objects to
	// gcsNearlineSinkBucket := "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 that haven't been modified in 30 days to a Nearline bucket"

	// The time to start the transfer
	startTime := time.Now().UTC()

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId:   projectID,
			Description: jobDescription,
			TransferSpec: &storagetransferpb.TransferSpec{
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsNearlineSinkBucket}},
				DataSource: &storagetransferpb.TransferSpec_GcsDataSource{
					GcsDataSource: &storagetransferpb.GcsData{BucketName: gcsSourceBucket},
				},
				ObjectConditions: &storagetransferpb.ObjectConditions{
					MinTimeElapsedSinceLastModification: &durationpb.Duration{Seconds: 2592000 /*30 days */},
				},
				TransferOptions: &storagetransferpb.TransferOptions{DeleteObjectsFromSourceAfterTransfer: true},
			},
			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", gcsSourceBucket, gcsNearlineSinkBucket, resp.Name)
	return resp, nil
}

Java

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

import com.google.protobuf.Duration;
import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto.CreateTransferJobRequest;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
import com.google.storagetransfer.v1.proto.TransferTypes.ObjectConditions;
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.TransferOptions;
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 TransferToNearline {
  /**
   * Creates a one-off transfer job that transfers objects in a standard GCS bucket that are more
   * than 30 days old to a Nearline GCS bucket.
   */
  public static void transferToNearline(
      String projectId,
      String jobDescription,
      String gcsSourceBucket,
      String gcsNearlineSinkBucket,
      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 of old objects to a Nearline GCS bucket.";

    // The name of the source GCS bucket to transfer data from
    // String gcsSourceBucket = "your-gcs-source-bucket";

    // The name of the Nearline GCS bucket to transfer old objects to
    // String gcsSinkBucket = "your-nearline-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();

    // 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 date =
        Date.newBuilder()
            .setYear(startCalendar.get(Calendar.YEAR))
            .setMonth(startCalendar.get(Calendar.MONTH) + 1)
            .setDay(startCalendar.get(Calendar.DAY_OF_MONTH))
            .build();
    TimeOfDay time =
        TimeOfDay.newBuilder()
            .setHours(startCalendar.get(Calendar.HOUR_OF_DAY))
            .setMinutes(startCalendar.get(Calendar.MINUTE))
            .setSeconds(startCalendar.get(Calendar.SECOND))
            .build();

    TransferJob transferJob =
        TransferJob.newBuilder()
            .setDescription(jobDescription)
            .setProjectId(projectId)
            .setTransferSpec(
                TransferSpec.newBuilder()
                    .setGcsDataSource(GcsData.newBuilder().setBucketName(gcsSourceBucket))
                    .setGcsDataSink(GcsData.newBuilder().setBucketName(gcsNearlineSinkBucket))
                    .setObjectConditions(
                        ObjectConditions.newBuilder()
                            .setMinTimeElapsedSinceLastModification(
                                Duration.newBuilder().setSeconds(2592000 /* 30 days */)))
                    .setTransferOptions(
                        TransferOptions.newBuilder().setDeleteObjectsFromSourceAfterTransfer(true)))
            .setSchedule(Schedule.newBuilder().setScheduleStartDate(date).setStartTimeOfDay(time))
            .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 standard bucket to Nearline bucket:");
    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'

// Google Cloud Storage source bucket name
// gcsSourceBucket = 'my-gcs-source-bucket'

// Google Cloud Storage destination bucket name
// gcsSinkBucket = 'my-gcs-destination-bucket'

// Date to start daily migration
// startDate = new Date()

// Creates a client
const client = new StorageTransferServiceClient();

/**
 * Create a daily migration from a GCS bucket to another GCS bucket for
 * objects untouched for 30+ days.
 */
async function createDailyNearline30DayMigration() {
  // Runs the request and creates the job
  const [transferJob] = await client.createTransferJob({
    transferJob: {
      projectId,
      description,
      status: 'ENABLED',
      schedule: {
        scheduleStartDate: {
          day: startDate.getDate(),
          month: startDate.getMonth() + 1,
          year: startDate.getFullYear(),
        },
      },
      transferSpec: {
        gcsDataSource: {
          bucketName: gcsSourceBucket,
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
        },
        objectConditions: {
          minTimeElapsedSinceLastModification: {
            seconds: 2592000, // 30 days
          },
        },
        transferOptions: {
          deleteObjectsFromSourceAfterTransfer: true,
        },
      },
    },
  });

  console.log(`Created transferJob: ${transferJob.name}`);
}

createDailyNearline30DayMigration();

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
from google.protobuf.duration_pb2 import Duration

def create_daily_nearline_30_day_migration(
    project_id: str,
    description: str,
    source_bucket: str,
    sink_bucket: str,
    start_date: datetime,
):
    """Create a daily migration from a GCS bucket to a Nearline GCS bucket
    for objects untouched for 30 days."""

    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'

    # Google Cloud Storage source bucket name
    # source_bucket = 'my-gcs-source-bucket'

    # Google Cloud Storage destination bucket name
    # sink_bucket = 'my-gcs-destination-bucket'

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "schedule": {
                    "schedule_start_date": {
                        "day": start_date.day,
                        "month": start_date.month,
                        "year": start_date.year,
                    }
                },
                "transfer_spec": {
                    "gcs_data_source": {
                        "bucket_name": source_bucket,
                    },
                    "gcs_data_sink": {
                        "bucket_name": sink_bucket,
                    },
                    "object_conditions": {
                        "min_time_elapsed_since_last_modification": Duration(
                            seconds=2592000  # 30 days
                        )
                    },
                    "transfer_options": {
                        "delete_objects_from_source_after_transfer": True
                    },
                },
            }
        }
    )

    result = client.create_transfer_job(transfer_job_request)
    print(f"Created transferJob: {result.name}")

Übertragung von Amazon S3 zu Cloud Storage

In diesem Beispiel erfahren Sie, wie Sie Dateien von Amazon S3 in einen Cloud Storage-Bucket verschieben. Informieren Sie sich unbedingt unter Zugriff auf Amazon S3 konfigurieren und unter Preise über die Auswirkungen einer Datenverschiebung von Amazon S3 zu Cloud Storage.

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

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

Übertragung zwischen Microsoft Azure Blob Storage und Cloud Storage

In diesem Beispiel erfahren Sie, wie Sie Dateien von Microsoft Azure Storage in ein Cloud Storage-Bucket verschieben und dabei ein Microsoft Azure Storage Shared Access Signature-Token (SAS) verwenden.

Weitere Informationen zu Microsoft Azure Storage SAS finden Sie unter Zugriff auf Azure Storage-Ressourcen mit SAS (Shared Access Signature) gewähren.

Lesen Sie zuerst die Abschnitte Zugriff auf Microsoft Azure Storage konfigurieren und Preise, um sich über die Auswirkungen einer Datenverschiebung von Microsoft Azure Storage zu Cloud Storage zu informieren.

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Storage Transfer Service finden Sie unter Storage Transfer Service-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Storage Transfer Service Go API.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Storage Transfer Service zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import (
	"context"
	"fmt"
	"io"
	"os"

	storagetransfer "cloud.google.com/go/storagetransfer/apiv1"
	"cloud.google.com/go/storagetransfer/apiv1/storagetransferpb"
)

func transferFromAzure(w io.Writer, projectID string, azureStorageAccountName string, azureSourceContainer string, gcsSinkBucket string) (*storagetransferpb.TransferJob, error) {
	// Your Google Cloud Project ID.
	// projectID := "my-project-id"

	// The name of your Azure Storage account.
	// azureStorageAccountName := "my-azure-storage-acc"

	// The name of the Azure container to transfer objects from.
	// azureSourceContainer := "my-source-container"

	// 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()

	// The Azure SAS token, should be accessed via environment variable for security
	azureSasToken := os.Getenv("AZURE_SAS_TOKEN")

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId: projectID,
			TransferSpec: &storagetransferpb.TransferSpec{
				DataSource: &storagetransferpb.TransferSpec_AzureBlobStorageDataSource{
					AzureBlobStorageDataSource: &storagetransferpb.AzureBlobStorageData{
						StorageAccount: azureStorageAccountName,
						AzureCredentials: &storagetransferpb.AzureCredentials{
							SasToken: azureSasToken,
						},
						Container: azureSourceContainer,
					},
				},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsSinkBucket}},
			},
			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", azureSourceContainer, gcsSinkBucket, resp.Name)
	return resp, nil
}

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Storage Transfer Service finden Sie unter Storage Transfer Service-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Storage Transfer Service Java API.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Storage Transfer Service zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto;
import com.google.storagetransfer.v1.proto.TransferProto.RunTransferJobRequest;
import com.google.storagetransfer.v1.proto.TransferTypes.AzureBlobStorageData;
import com.google.storagetransfer.v1.proto.TransferTypes.AzureCredentials;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
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 java.io.IOException;
import java.util.concurrent.ExecutionException;

public class TransferFromAzure {
  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    // Your Google Cloud Project ID
    String projectId = "my-project-id";

    // Your Azure Storage Account name
    String azureStorageAccount = "my-azure-account";

    // The Azure source container to transfer data from
    String azureSourceContainer = "my-source-container";

    // The GCS bucket to transfer data to
    String gcsSinkBucket = "my-sink-bucket";

    transferFromAzureBlobStorage(
        projectId, azureStorageAccount, azureSourceContainer, gcsSinkBucket);
  }

  /**
   * Creates and runs a transfer job to transfer all data from an Azure container to a GCS bucket.
   */
  public static void transferFromAzureBlobStorage(
      String projectId,
      String azureStorageAccount,
      String azureSourceContainer,
      String gcsSinkBucket)
      throws IOException, ExecutionException, InterruptedException {

    // Your Azure SAS token, should be accessed via environment variable
    String azureSasToken = System.getenv("AZURE_SAS_TOKEN");

    TransferSpec transferSpec =
        TransferSpec.newBuilder()
            .setAzureBlobStorageDataSource(
                AzureBlobStorageData.newBuilder()
                    .setAzureCredentials(
                        AzureCredentials.newBuilder().setSasToken(azureSasToken).build())
                    .setContainer(azureSourceContainer)
                    .setStorageAccount(azureStorageAccount))
            .setGcsDataSink(GcsData.newBuilder().setBucketName(gcsSinkBucket).build())
            .build();

    TransferJob transferJob =
        TransferJob.newBuilder()
            .setProjectId(projectId)
            .setStatus(Status.ENABLED)
            .setTransferSpec(transferSpec)
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources,
    // or use "try-with-close" statement to do this automatically.
    try (StorageTransferServiceClient storageTransfer = StorageTransferServiceClient.create()) {
      // Create the transfer job
      TransferJob response =
          storageTransfer.createTransferJob(
              TransferProto.CreateTransferJobRequest.newBuilder()
                  .setTransferJob(transferJob)
                  .build());

      // Run the created job
      storageTransfer
          .runTransferJobAsync(
              RunTransferJobRequest.newBuilder()
                  .setProjectId(projectId)
                  .setJobName(response.getName())
                  .build())
          .get();

      System.out.println(
          "Created and ran a transfer job from "
              + azureSourceContainer
              + " to "
              + gcsSinkBucket
              + " with "
              + "name "
              + response.getName());
    }
  }
}

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Storage Transfer Service finden Sie unter Storage Transfer Service-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Storage Transfer Service Node.js API.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Storage Transfer Service zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.


// 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'

// Azure Storage Account name
// azureStorageAccount = 'accountname'

// Azure Storage Account name
// azureSourceContainer = 'my-azure-source-bucket'

// Azure Shared Access Signature token
// azureSASToken = '?sv=...'

// 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 Azure Blob Storage to Google Cloud Storage.
 */
async function transferFromBlobStorage() {
  // 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: {
        azureBlobStorageDataSource: {
          azureCredentials: {
            sasToken: azureSASToken,
          },
          container: azureSourceContainer,
          storageAccount: azureStorageAccount,
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
        },
      },
    },
  });

  console.log(
    `Created and ran a transfer job from '${azureSourceContainer}' to '${gcsSinkBucket}' with name ${transferJob.name}`
  );
}

transferFromBlobStorage();

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Storage Transfer Service finden Sie unter Storage Transfer Service-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Storage Transfer Service Python API.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Storage Transfer Service zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

from datetime import datetime

from google.cloud import storage_transfer

def create_one_time_azure_transfer(
    project_id: str,
    description: str,
    azure_storage_account: str,
    azure_sas_token: str,
    source_container: str,
    sink_bucket: str,
):
    """Creates a one-time transfer job from Azure Blob Storage to Google Cloud
    Storage."""

    # Initialize client that will be used to create storage transfer requests.
    # This client only needs to be created once, and can be reused for
    # multiple requests.
    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'

    # Azure Storage Account name
    # azure_storage_account = 'accountname'

    # Azure Shared Access Signature token
    # azure_sas_token = '?sv=...'

    # Azure Blob source container name
    # source_container = 'my-azure-source-bucket'

    # 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": {
                    "azure_blob_storage_data_source": {
                        "storage_account": azure_storage_account,
                        "azure_credentials": {"sas_token": azure_sas_token},
                        "container": source_container,
                    },
                    "gcs_data_sink": {
                        "bucket_name": sink_bucket,
                    },
                },
            }
        }
    )

    result = client.create_transfer_job(transfer_job_request)
    print(f"Created transferJob: {result.name}")

Übertragung aus einem Dateisystem

In diesem Beispiel erfahren Sie, wie Sie Dateien aus einem POSIX-Dateisystem in einen Cloud Storage-Bucket verschieben.

Einfach loslegen (Go)


import (
	"context"
	"fmt"
	"io"

	storagetransfer "cloud.google.com/go/storagetransfer/apiv1"
	"cloud.google.com/go/storagetransfer/apiv1/storagetransferpb"
)

func transferFromPosix(w io.Writer, projectID string, sourceAgentPoolName string, rootDirectory string, gcsSinkBucket string) (*storagetransferpb.TransferJob, error) {
	// Your project id
	// projectId := "myproject-id"

	// The agent pool associated with the POSIX data source. If not provided, defaults to the default agent
	// sourceAgentPoolName := "projects/my-project/agentPools/transfer_service_default"

	// The root directory path on the source filesystem
	// rootDirectory := "/directory/to/transfer/source"

	// The ID of the GCS bucket to transfer data 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()

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId: projectID,
			TransferSpec: &storagetransferpb.TransferSpec{
				SourceAgentPoolName: sourceAgentPoolName,
				DataSource: &storagetransferpb.TransferSpec_PosixDataSource{
					PosixDataSource: &storagetransferpb.PosixFilesystem{RootDirectory: rootDirectory},
				},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsSinkBucket},
				},
			},
			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", rootDirectory, gcsSinkBucket, resp.Name)
	return resp, nil
}

Java

import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
import com.google.storagetransfer.v1.proto.TransferTypes.PosixFilesystem;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferSpec;
import java.io.IOException;

public class TransferFromPosix {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Your project id
    String projectId = "my-project-id";

    // The agent pool associated with the POSIX data source. If not provided, defaults to the
    // default agent
    String sourceAgentPoolName = "projects/my-project-id/agentPools/transfer_service_default";

    // The root directory path on the source filesystem
    String rootDirectory = "/directory/to/transfer/source";

    // The ID of the GCS bucket to transfer data to
    String gcsSinkBucket = "my-sink-bucket";

    transferFromPosix(projectId, sourceAgentPoolName, rootDirectory, gcsSinkBucket);
  }

  public static void transferFromPosix(
      String projectId, String sourceAgentPoolName, String rootDirectory, String gcsSinkBucket)
      throws IOException {
    TransferJob transferJob =
        TransferJob.newBuilder()
            .setProjectId(projectId)
            .setTransferSpec(
                TransferSpec.newBuilder()
                    .setSourceAgentPoolName(sourceAgentPoolName)
                    .setPosixDataSource(
                        PosixFilesystem.newBuilder().setRootDirectory(rootDirectory).build())
                    .setGcsDataSink(GcsData.newBuilder().setBucketName(gcsSinkBucket).build()))
            .setStatus(TransferJob.Status.ENABLED)
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources,
    // or use "try-with-close" statement to do this automatically.
    try (StorageTransferServiceClient storageTransfer = StorageTransferServiceClient.create()) {

      // Create the transfer job
      TransferJob response =
          storageTransfer.createTransferJob(
              TransferProto.CreateTransferJobRequest.newBuilder()
                  .setTransferJob(transferJob)
                  .build());

      System.out.println(
          "Created a transfer job from "
              + rootDirectory
              + " to "
              + gcsSinkBucket
              + " with "
              + "name "
              + response.getName());
    }
  }
}

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.
 */
// Your project id
// const projectId = 'my-project'

// The agent pool associated with the POSIX data source. Defaults to the default agent
// const sourceAgentPoolName = 'projects/my-project/agentPools/transfer_service_default'

// The root directory path on the source filesystem
// const rootDirectory = '/directory/to/transfer/source'

// The ID of the GCS bucket to transfer data to
// const gcsSinkBucket = 'my-sink-bucket'

// Creates a client
const client = new StorageTransferServiceClient();

/**
 * Creates a request to transfer from the local file system to the sink bucket
 */
async function transferDirectory() {
  const createRequest = {
    transferJob: {
      projectId,
      transferSpec: {
        sourceAgentPoolName,
        posixDataSource: {
          rootDirectory,
        },
        gcsDataSink: {bucketName: gcsSinkBucket},
      },
      status: 'ENABLED',
    },
  };

  // Runs the request and creates the job
  const [transferJob] = await client.createTransferJob(createRequest);

  const runRequest = {
    jobName: transferJob.name,
    projectId: projectId,
  };

  await client.runTransferJob(runRequest);

  console.log(
    `Created and ran a transfer job from '${rootDirectory}' to '${gcsSinkBucket}' with name ${transferJob.name}`
  );
}

transferDirectory();

Python

from google.cloud import storage_transfer

def transfer_from_posix_to_gcs(
    project_id: str,
    description: str,
    source_agent_pool_name: str,
    root_directory: str,
    sink_bucket: str,
):
    """Create a transfer from a POSIX file system to a GCS bucket."""

    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'

    # The agent pool associated with the POSIX data source.
    # Defaults to 'projects/{project_id}/agentPools/transfer_service_default'
    # source_agent_pool_name = 'projects/my-project/agentPools/my-agent'

    # The root directory path on the source filesystem
    # root_directory = '/directory/to/transfer/source'

    # Google Cloud Storage sink bucket name
    # sink_bucket = 'my-gcs-sink-bucket'

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "transfer_spec": {
                    "source_agent_pool_name": source_agent_pool_name,
                    "posix_data_source": {
                        "root_directory": root_directory,
                    },
                    "gcs_data_sink": {"bucket_name": sink_bucket},
                },
            }
        }
    )

    result = client.create_transfer_job(transfer_job_request)
    print(f"Created transferJob: {result.name}")