Diese Seite wurde von der Cloud Translation API übersetzt.

Ereignisgesteuerte Übertragungen

Storage Transfer Service kann Ereignisbenachrichtigungen in AWS oder Google Cloud überwachen automatisch Daten zu übertragen, die in der Quelle hinzugefügt oder aktualisiert wurden Standort. Ereignisgesteuerte Übertragungen werden von AWS S3 oder Cloud Storage unterstützt zu Cloud Storage hinzufügen.

Ereignisgesteuerte Übertragungen überwachen Amazon S3-Ereignisbenachrichtigungen für AWS S3-Quellen an Amazon SQS gesendet. Cloud Storage-Quellen senden an ein Pub/Sub-Abo gesendet.

Vorteile ereignisgesteuerter Übertragungen

Da ereignisgesteuerte Übertragungen auf Änderungen am Quell-Bucket warten, werden nahezu in Echtzeit an das Ziel kopiert. Storage Transfer Service benötigt Listenvorgang für die Quelle ausführen und so Zeit und Geld sparen.

Dies ist unter anderem in folgenden Fällen hilfreich:

Ereignisgesteuerte Analysen: Replizieren Sie Daten von AWS in Cloud Storage, um Analyse und Verarbeitung durchführen.
Cloud Storage-Replikation: Automatisches, asynchrones Objekt aktivieren Replikation zwischen Cloud Storage-Buckets.

Ereignisgesteuerte Übertragungen mit Storage Transfer Service unterscheiden sich von typische Cloud Storage-Replikation, indem Sie eine Kopie Ihrer Daten in einem anderen Bucket.

Dies bietet unter anderem folgende Vorteile:
- Aufbewahrung von Entwicklungs- und Produktionsdaten in separaten Namespaces.
- Freigabe von Daten ohne Zugriff auf den ursprünglichen Bucket.
- Die Sicherung läuft auf einem anderen Kontinent oder in einem Gebiet, das nicht von Dual- und Multi-Region-Speicher.
DR/HA-Einrichtung: Objekte der Reihe nach von der Quelle zum Sicherungsziel replizieren von Minuten:
- Cloudübergreifende Sicherung: Erstellen Sie eine Kopie der AWS S3-Sicherung in Cloud Storage.
- Regions- oder projektübergreifende Sicherung: Kopie von Cloud Storage erstellen Bucket in einer anderen Region oder einem anderen Projekt.
Live-Migration: Eine ereignisgesteuerte Übertragung kann eine Migration mit geringen Ausfallzeiten ermöglichen, die Reihenfolge der Ausfallzeit in Minuten, als Folgeschritt für einmalige Batches Migration.

Ereignisgesteuerte Übertragungen aus Cloud Storage einrichten

Ereignisgesteuerte Übertragungen aus Cloud Storage verwenden Pub/Sub-Benachrichtigungen um zu erfahren, wann Objekte im Quell-Bucket geändert wurden hinzugefügt. Objektlöschungen werden nicht erkannt. Löschen eines Objekts an der Quelle wird das zugehörige Objekt im Ziel-Bucket nicht gelöscht.

Berechtigungen konfigurieren

Suchen Sie den Namen des Storage Transfer Service-Dienst-Agents für Ihr Projekt:
1. Rufen Sie die Referenzseite googleServiceAccounts.get auf.
  
  Es wird ein interaktives Steuerfeld mit dem Titel Diese Methode testen geöffnet.
2. Geben Sie im Steuerfeld unter Anfrageparameter Projekt-ID. Das hier angegebene Projekt muss das Projekt sein, zur Verwaltung des Storage Transfer Service verwenden, der sich von der Quelle unterscheiden kann. des Buckets.
3. Klicken Sie auf Ausführen.
Die E-Mail-Adresse des Dienst-Agents wird als Wert von accountEmail zurückgegeben. Kopieren Sie diesen Wert.

Die E-Mail des Dienst-Agents hat das Format project-PROJECT_NUMBER@storage-transfer-service.iam.gserviceaccount.com.
Gewähren Sie dem Storage Transfer Service-Dienst-Agent die Rolle Pub/Sub Subscriber.
Cloud Console
Folgen Sie dazu der Anleitung unter Zugriff über die Google Cloud Console steuern um dem Storage Transfer Service-Dienst die Rolle Pub/Sub Subscriber zuzuweisen. Die Rolle kann auf Themen-, Abo- oder Projektebene gewährt werden.
gcloud CLI
Folgen Sie dazu der Anleitung unter Festlegen einer Richtlinie auf fügen Sie die folgende Bindung hinzu:
```
{
  "role": "roles/pubsub.subscriber",
  "members": [
    "serviceAccount:project-PROJECT_NUMBER@storage-transfer-service.iam.gserviceaccount.com"
}
```

Pub/Sub konfigurieren

Stellen Sie sicher, dass Sie mit dem Voraussetzungen für die Verwendung Pub/Sub mit Cloud Storage.

Konfigurieren Sie die Pub/Sub-Benachrichtigung für Cloud Storage:

gcloud storage buckets notifications create gs://BUCKET_NAME --topic=TOPIC_NAME

Erstellen Sie ein Pull-Abo für das Thema:

gcloud pubsub subscriptions create SUBSCRIPTION_ID --topic=TOPIC_NAME --ack-deadline=300

Übertragungsjob erstellen

Sie können die REST API oder die Google Cloud Console verwenden, um eine ereignisbasierte Übertragungsjob.

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

Cloud Console

Rufen Sie in der Google Cloud Console die Seite Übertragungsjob erstellen auf.

Zur Seite Übertragungsjob erstellen
Wählen Sie Cloud Storage sowohl als Quelle als auch als Ziel aus.
Wählen Sie als Planungsmodus die Option Ereignisgesteuert aus und klicken Sie auf Nächster Schritt.
Wählen Sie den Quell-Bucket für diese Übertragung aus.
Geben Sie im Abschnitt Ereignisstream den Namen des Abos ein:

projects/PROJECT_NAME/subscriptions/SUBSCRIPTION_ID
Legen Sie optional Filter fest und klicken Sie dann auf Nächster Schritt.
Wählen Sie den Ziel-Bucket für diese Übertragung aus.
Geben Sie optional eine Start- und Endzeit für die Übertragung ein. Wenn Sie keine geben Sie eine Uhrzeit an, beginnt die Übertragung sofort und läuft bis manuell beendet wurden.
Geben Sie etwaige Übertragungsoptionen an. Weitere Informationen finden Sie in der Seite Übertragungen erstellen
Klicken Sie auf Erstellen.

Nach der Erstellung wird der Übertragungsjob ausgeführt und ein Event-Listener wartet auf Benachrichtigungen für das Pub/Sub-Abo. Auf der Seite mit den Jobdetails einen Vorgang pro Stunde und enthält Details zu den für jeden Job übertragenen Daten.

REST

Senden Sie Folgendes, um eine ereignisgesteuerte Übertragung mit der REST API zu erstellen: JSON-Objekt zum Endpunkt transferJobs.create an:

transfer_job {
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "transferSpec" {
    "gcsDataSource" {
      "bucketName": "GCS_SOURCE_NAME"
    },
    "gcsDataSink": {
        "bucketName": "GCS_SINK_NAME"
    }
  }
  "eventStream" {
    "name": "projects/PROJECT_NAME/subscriptions/SUBSCRIPTION_ID",
    "eventStreamStartTime": "2022-12-02T01:00:00+00:00",
    "eventStreamExpirationTime": "2023-01-31T01:00:00+00:00"
  }
}

eventStreamStartTime und eventStreamExpirationTime sind optional. Wenn keine Startzeit angegeben wird, wird die Übertragung sofort gestartet. wenn das Ende angegeben ist, wird die Übertragung fortgesetzt, bis sie manuell gestoppt wird.

Clientbibliotheken

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 Storage Transfer Service Go API Referenzdokumentation.

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.


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

	// The name of the source GCS bucket.
	// gcsSourceBucket := "my-source-bucket"

	// The name of the GCS bucket to transfer objects to.
	// gcsSinkBucket := "my-sink-bucket"

	// The Pub/Sub topic to subscribe the event driven transfer to.
	// pubSubID := "projects/PROJECT_NAME/subscriptions/SUBSCRIPTION_ID"

	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{
				DataSource: &storagetransferpb.TransferSpec_GcsDataSource{
					GcsDataSource: &storagetransferpb.GcsData{BucketName: gcsSourceBucket}},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsSinkBucket}},
			},
			EventStream: &storagetransferpb.EventStream{Name: pubSubId},
			Status:      storagetransferpb.TransferJob_ENABLED,
		},
	}
	resp, err := client.CreateTransferJob(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("failed to create transfer job: %w", err)
	}

	fmt.Fprintf(w, "Created an event driven transfer job from %v to %v subscribed to %v with name %v", gcsSourceBucket, gcsSinkBucket, pubSubId, 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;

public class CreateEventDrivenGcsTransfer {
  public static void main(String[] args) throws Exception {
    // Your Google Cloud Project ID
    String projectId = "your-project-id";

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

    // The name of the GCS bucket to transfer data to
    String gcsSinkBucket = "your-gcs-sink-bucket";

    // The ARN of the PubSub queue to subscribe to
    String sqsQueueArn = "projects/PROJECT_NAME/subscriptions/SUBSCRIPTION_ID";

    createEventDrivenGcsTransfer(projectId, gcsSourceBucket, gcsSinkBucket, sqsQueueArn);
  }

  public static void createEventDrivenGcsTransfer(
      String projectId, String gcsSourceBucket, String gcsSinkBucket, String pubSubId)
      throws Exception {
    // 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()) {

      TransferTypes.TransferJob transferJob =
          TransferTypes.TransferJob.newBuilder()
              .setProjectId(projectId)
              .setTransferSpec(
                  TransferTypes.TransferSpec.newBuilder()
                      .setGcsDataSource(
                          TransferTypes.GcsData.newBuilder().setBucketName(gcsSourceBucket))
                      .setGcsDataSink(
                          TransferTypes.GcsData.newBuilder().setBucketName(gcsSinkBucket)))
              .setStatus(TransferTypes.TransferJob.Status.ENABLED)
              .setEventStream(TransferTypes.EventStream.newBuilder().setName(pubSubId).build())
              .build();

      TransferTypes.TransferJob response =
          storageTransfer.createTransferJob(
              TransferProto.CreateTransferJobRequest.newBuilder()
                  .setTransferJob(transferJob)
                  .build());

      System.out.println(
          "Created a transfer job between from "
              + gcsSourceBucket
              + " to "
              + gcsSinkBucket
              + " subscribed to "
              + pubSubId
              + " 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.
 */
// The ID of the Google Cloud Platform Project that owns the job
// projectId = 'my-project-id'

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

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

// The subscription ID to a Pubsub queue to track
// pubsubId = 'projects/PROJECT_NAME/subscriptions/SUBSCRIPTION_ID'

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

/**
 * Creates an event driven transfer that tracks a Pubsub subscription.
 */
async function createEventDrivenGcsTransfer() {
  const [transferJob] = await client.createTransferJob({
    transferJob: {
      projectId,
      status: 'ENABLED',
      transferSpec: {
        gcsDataSource: {
          bucketName: gcsSourceBucket,
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
        },
      },
      eventStream: {
        name: pubsubId,
      },
    },
  });

  console.log(
    `Created an event driven transfer from '${gcsSourceBucket}' to '${gcsSinkBucket}' with name ${transferJob.name}`
  );
}

createEventDrivenGcsTransfer();

Python


from google.cloud import storage_transfer


def create_event_driven_gcs_transfer(
    project_id: str,
    description: str,
    source_bucket: str,
    sink_bucket: str,
    pubsub_id: str,
):
    """Create an event driven transfer between two GCS buckets that tracks a PubSub subscription"""

    client = storage_transfer.StorageTransferServiceClient()

    # The ID of the Google Cloud Platform Project that owns the job
    # project_id = 'my-project-id'

    # A description of this job
    # description = 'Creates an event-driven transfer that tracks a pubsub subscription'

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

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

    # The Pubsub Subscription ID to track
    # pubsub_id = 'projects/PROJECT_NAME/subscriptions/SUBSCRIPTION_ID'

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "transfer_spec": {
                    "gcs_data_source": {
                        "bucket_name": source_bucket,
                    },
                    "gcs_data_sink": {
                        "bucket_name": sink_bucket,
                    },
                },
                "event_stream": {
                    "name": pubsub_id,
                },
            },
        }
    )

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

Ereignisgesteuerte Übertragungen von AWS S3 einrichten

Ereignisgesteuerte Übertragungen von AWS S3 verwenden Benachrichtigungen von Amazon Simple Queue Dienst (SQS), der ermittelt, wenn Objekte im Quell-Bucket geändert wurden, oder hinzugefügt. Objektlöschungen werden nicht erkannt. Löschen eines Objekts an der Quelle wird das zugehörige Objekt im Ziel-Bucket nicht gelöscht.

SQS-Warteschlange erstellen

Rufen Sie in der AWS-Konsole die Seite Einfacher Warteschlangendienst auf.
Klicken Sie auf Warteschlange erstellen.
Geben Sie einen Namen für die Warteschlange ein.

Wählen Sie im Bereich Zugriffsrichtlinie die Option Erweitert aus. Ein JSON-Objekt ist angezeigt:

 {
    "Version": "2008-10-17",
    "Id": "__default_policy_ID",
    "Statement": [
      {
        "Sid": "__owner_statement",
        "Effect": "Allow",
        "Principal": {
          "AWS": "01234567890"
        },
        "Action": [
          "SQS:*"
        ],
        "Resource": "arn:aws:sqs:us-west-2:01234567890:test"
      }
    ]
  }

Die Werte für AWS und Resource sind für jedes Projekt eindeutig.

Kopieren Sie Ihre spezifischen Werte für AWS und Resource aus der angezeigten JSON-Datei. in das folgende JSON-Snippet ein:
```
{
  "Version": "2012-10-17",
  "Id": "example-ID",
  "Statement": [
    {
      "Sid": "example-statement-ID",
      "Effect": "Allow",
      "Principal": {
        "Service": "s3.amazonaws.com"
      },
      "Action": "SQS:SendMessage",
      "Resource": "RESOURCE",
      "Condition": {
        "StringEquals": {
          "aws:SourceAccount": "AWS"
        },
        "ArnLike": {
          "aws:SourceArn": "S3_BUCKET_ARN"
        }
      }
    }
  ]
}
```
Die Werte der Platzhalter in der vorherigen JSON-Datei verwenden Folgendes: Format:
- AWS ist ein numerischer Wert, der Ihre Amazon Web Services darstellt. Projekt arbeiten. Beispiel: "aws:SourceAccount": "1234567890".
- RESOURCE ist eine Amazon Resource Number (ARN), die aus dieser Warteschlange. Beispiel: "Resource": "arn:aws:sqs:us-west-2:01234567890:test"
- S3_BUCKET_ARN ist ein ARN, der den Quell-Bucket identifiziert. Beispiel: "aws:SourceArn": "arn:aws:s3:::example-aws-bucket" Sie können Den ARN eines Buckets auf dem Tab Eigenschaften der Bucket-Detailseite finden in der AWS-Konsole.
Ersetzen Sie die JSON-Datei im Abschnitt Zugriffsrichtlinie durch die aktualisierte JSON-Datei. JSON oben.
Klicken Sie auf Warteschlange erstellen.

Notieren Sie sich anschließend den Amazon Resource Name (ARN) der Warteschlange. Der ARN hat die folgendes Format:

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

Benachrichtigungen für Ihren S3-Bucket aktivieren

Rufen Sie in der AWS-Konsole die Seite S3 auf.
Wählen Sie in der Liste Buckets Ihren Quell-Bucket aus.
Wählen Sie den Tab Eigenschaften aus.
Klicken Sie im Abschnitt Terminbenachrichtigungen auf Ereignisbenachrichtigung erstellen.
Geben Sie einen Namen für das Ereignis ein.
Wählen Sie im Bereich Ereignistypen die Option Alle Ereignisse zum Erstellen von Objekten aus.
Wählen Sie als Ziel die Option SQS-Warteschlange und dann die erstellte Warteschlange aus. für diese Übertragung.
Klicken Sie auf Änderungen speichern.

Berechtigungen konfigurieren

Folgen Sie dazu der Anleitung unter Zugriff auf eine Quelle konfigurieren: Amazon S3 um entweder eine Zugriffsschlüssel-ID und einen geheimen Schlüssel oder eine föderierte Identität zu erstellen. Rolle.

Ersetzen Sie die JSON-Datei für die benutzerdefinierten Berechtigungen durch Folgendes:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "sqs:DeleteMessage",
                "sqs:ChangeMessageVisibility",
                "sqs:ReceiveMessage",
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::AWS_BUCKET_NAME",
                "arn:aws:s3:::AWS_BUCKET_NAME/*",
                "AWS_QUEUE_ARN"
            ]
        }
    ]
}

Notieren Sie sich nach der Erstellung die folgenden Informationen:

Notieren Sie sich für den Nutzer die Zugriffsschlüssel-ID und den geheimen Schlüssel.
Notieren Sie sich für eine Federated Identity-Rolle den Amazon Resource Name (ARN), mit dem Format arn:aws:iam::AWS_ACCOUNT:role/ROLE_NAME

Übertragungsjob erstellen

Sie können die REST API oder die Google Cloud Console verwenden, um eine ereignisbasierte Übertragungsjob.

Cloud Console

Rufen Sie in der Google Cloud Console die Seite Übertragungsjob erstellen auf.

Zur Seite Übertragungsjob erstellen
Wählen Sie Amazon S3 als Quelltyp und Cloud Storage als das Ziel.
Wählen Sie als Planungsmodus die Option Ereignisgesteuert aus und klicken Sie auf Nächster Schritt.
Geben Sie den Namen Ihres S3-Buckets ein. Der Bucket-Name ist der Name, der in der AWS Management Console angezeigt wird. Beispiel: my-aws-bucket
Wählen Sie Ihre Authentifizierungsmethode aus und geben Sie die erforderlichen Informationen ein. die Sie im vorherigen Abschnitt erstellt und notiert haben.
Geben Sie den ARN der Amazon SQS-Warteschlange ein, den Sie zuvor erstellt haben. Dabei werden die folgendes Format:
```
arn:aws:sqs:us-east-1:1234567890:event-queue"
```
Legen Sie optional Filter fest und klicken Sie dann auf Nächster Schritt.
Wählen Sie den Cloud Storage-Ziel-Bucket und optional den Pfad aus.
Geben Sie optional eine Start- und Endzeit für die Übertragung ein. Wenn Sie keine geben Sie eine Uhrzeit an, beginnt die Übertragung sofort und läuft bis manuell beendet.
Geben Sie etwaige Übertragungsoptionen an. Weitere Informationen finden Sie in der Seite Übertragungen erstellen
Klicken Sie auf Erstellen.

Nach der Erstellung wird der Übertragungsjob ausgeführt und ein Event-Listener wartet auf in der SQS-Warteschlange. Auf der Seite mit den Jobdetails wird stündlich durchgeführte Vorgänge sowie Details zu den für jeden Auftrag übertragenen Daten.

REST

Senden Sie Folgendes, um eine ereignisgesteuerte Übertragung mit der REST API zu erstellen: JSON-Objekt zum Endpunkt transferJobs.create an:

transfer_job {
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "transferSpec" {
    "awsS3DataSource" {
      "bucketName": "AWS_SOURCE_NAME",
      "roleArn": "arn:aws:iam::1234567891011:role/role_for_federated_auth"
    },
    "gcsDataSink": {
        "bucketName": "GCS_SINK_NAME"
    }
  }
  "eventStream" {
    "name": "arn:aws:sqs:us-east-1:1234567891011:s3-notification-queue",
    "eventStreamStartTime": "2022-12-02T01:00:00+00:00",
    "eventStreamExpirationTime": "2023-01-31T01:00:00+00:00"
  }
}

Clientbibliotheken

Go


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

	// The name of the source AWS S3 bucket.
	// s3SourceBucket := "my-source-bucket"

	// The name of the GCS bucket to transfer objects to.
	// gcsSinkBucket := "my-sink-bucket"

	// The Amazon Resource Name (ARN) of the AWS SNS queue to subscribe the event driven transfer to.
	// sqsQueueARN := "arn:aws:sqs:us-east-1:1234567891011:s3-notification-queue"

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

	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{
				DataSource: &storagetransferpb.TransferSpec_AwsS3DataSource{
					AwsS3DataSource: &storagetransferpb.AwsS3Data{
						BucketName: s3SourceBucket,
						AwsAccessKey: &storagetransferpb.AwsAccessKey{
							AccessKeyId:     awsAccessKeyID,
							SecretAccessKey: awsSecretKey,
						}},
				},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsSinkBucket}},
			},
			EventStream: &storagetransferpb.EventStream{Name: sqsQueueARN},
			Status:      storagetransferpb.TransferJob_ENABLED,
		},
	}
	resp, err := client.CreateTransferJob(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("failed to create transfer job: %w", err)
	}

	fmt.Fprintf(w, "Created an event driven transfer job from %v to %v subscribed to %v with name %v", s3SourceBucket, gcsSinkBucket, sqsQueueARN, 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;

public class CreateEventDrivenAwsTransfer {
  public static void main(String[] args) throws Exception {
    // Your Google Cloud Project ID
    String projectId = "your-project-id";

    // The name of the source AWS bucket to transfer data from
    String s3SourceBucket = "yourS3SourceBucket";

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

    // The ARN of the SQS queue to subscribe to
    String sqsQueueArn = "arn:aws:sqs:us-east-1:1234567891011:s3-notification-queue";

    createEventDrivenAwsTransfer(projectId, s3SourceBucket, gcsSinkBucket, sqsQueueArn);
  }

  public static void createEventDrivenAwsTransfer(
      String projectId, String s3SourceBucket, String gcsSinkBucket, String sqsQueueArn)
      throws Exception {
    // 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()) {

      // 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");

      TransferTypes.TransferJob transferJob =
          TransferTypes.TransferJob.newBuilder()
              .setProjectId(projectId)
              .setTransferSpec(
                  TransferTypes.TransferSpec.newBuilder()
                      .setAwsS3DataSource(
                          TransferTypes.AwsS3Data.newBuilder()
                              .setBucketName(s3SourceBucket)
                              .setAwsAccessKey(
                                  TransferTypes.AwsAccessKey.newBuilder()
                                      .setAccessKeyId(awsAccessKeyId)
                                      .setSecretAccessKey(awsSecretAccessKey))
                              .build())
                      .setGcsDataSink(
                          TransferTypes.GcsData.newBuilder().setBucketName(gcsSinkBucket)))
              .setStatus(TransferTypes.TransferJob.Status.ENABLED)
              .setEventStream(TransferTypes.EventStream.newBuilder().setName(sqsQueueArn).build())
              .build();

      TransferTypes.TransferJob response =
          storageTransfer.createTransferJob(
              TransferProto.CreateTransferJobRequest.newBuilder()
                  .setTransferJob(transferJob)
                  .build());

      System.out.println(
          "Created a transfer job from "
              + s3SourceBucket
              + " to "
              + gcsSinkBucket
              + " subscribed to "
              + sqsQueueArn
              + " 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.
 */
// The ID of the Google Cloud Platform Project that owns the job
// projectId = 'my-project-id'

// AWS S3 source bucket name
// s3SourceBucket = 'my-s3-source-bucket'

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

// The ARN of the SQS queue to subscribe to
// sqsQueueArn = 'arn:aws:sqs:us-east-1:1234567891011:s3-notification-queue'

// AWS Access Key ID. Should be accessed via environment variable for security.
// awsAccessKeyId = 'AKIA...'

// AWS Secret Access Key. Should be accessed via environment variable for security.
// awsSecretAccessKey = 'HEAoMK2.../...ku8'

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

/**
 * Creates an event driven transfer that tracks an SQS queue.
 */
async function createEventDrivenAwsTransfer() {
  const [transferJob] = await client.createTransferJob({
    transferJob: {
      projectId,
      status: 'ENABLED',
      transferSpec: {
        awsS3DataSource: {
          bucketName: s3SourceBucket,
          awsAccessKey: {
            accessKeyId: awsAccessKeyId,
            secretAccessKey: awsSecretAccessKey,
          },
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
        },
      },
      eventStream: {
        name: sqsQueueArn,
      },
    },
  });

  console.log(
    `Created an event driven transfer from '${s3SourceBucket}' to '${gcsSinkBucket}' with name ${transferJob.name}`
  );
}

createEventDrivenAwsTransfer();

Python


from google.cloud import storage_transfer


def create_event_driven_aws_transfer(
    project_id: str,
    description: str,
    source_s3_bucket: str,
    sink_gcs_bucket: str,
    sqs_queue_arn: str,
    aws_access_key_id: str,
    aws_secret_access_key: str,
):
    """Create an event driven transfer between two GCS buckets that tracks an AWS SQS queue"""

    client = storage_transfer.StorageTransferServiceClient()

    # The ID of the Google Cloud Platform Project that owns the job
    # project_id = 'my-project-id'

    # A description of this job
    # description = 'Creates an event-driven transfer that tracks an SQS queue'

    # AWS S3 source bucket name
    # source_s3_bucket = 'my-s3-source-bucket'

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

    # The ARN of the SQS queue to subscribe to
    # pubsub_id = 'arn:aws:sqs:us-east-1:1234567891011:s3-notification-queue'

    # AWS Access Key ID. Should be accessed via environment variable for security purposes.
    # aws_access_key_id = 'AKIA...'

    # AWS Secret Access Key. Should be accessed via environment variable for security purposes.
    # aws_secret_access_key = 'HEAoMK2.../...ku8'

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "transfer_spec": {
                    "aws_s3_data_source": {
                        "bucket_name": source_s3_bucket,
                        "aws_access_key": {
                            "access_key_id": aws_access_key_id,
                            "secret_access_key": aws_secret_access_key,
                        },
                    },
                    "gcs_data_sink": {
                        "bucket_name": sink_gcs_bucket,
                    },
                },
                "event_stream": {
                    "name": sqs_queue_arn,
                },
            },
        }
    )

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

Ereignisgesteuerte Übertragungen

Vorteile ereignisgesteuerter Übertragungen

Ereignisgesteuerte Übertragungen aus Cloud Storage einrichten

Berechtigungen konfigurieren

Cloud Console

gcloud CLI

Pub/Sub konfigurieren

Übertragungsjob erstellen

Cloud Console

REST

Clientbibliotheken

Go

Java

Node.js

Python

Ereignisgesteuerte Übertragungen von AWS S3 einrichten

SQS-Warteschlange erstellen

Benachrichtigungen für Ihren S3-Bucket aktivieren

Berechtigungen konfigurieren

Übertragungsjob erstellen

Cloud Console

REST

Clientbibliotheken

Go

Java

Node.js

Python

`gcloud` CLI