העברה מאחסון שתואם ל-S3 ל-Cloud Storage

אפשר להשתמש ב-Storage Transfer Service כדי להעביר נתונים ממערכות לאחסון אובייקטים בענן או באתר, שתואמות ל-Amazon S3 API.

‫Storage Transfer Service ניגש לנתונים שלכם באחסון שתואם ל-S3 באמצעות סוכני העברה שפרוסים במכונות וירטואליות קרוב למקור הנתונים. הסוכנים האלה פועלים בקונטיינר של Docker ושייכים למאגר סוכנים, שהוא אוסף של סוכנים שמשתמשים באותה הגדרה ומעבירים את הנתונים במקביל.

התכונה הזו מאפשרת להעביר נתונים ממאגר אובייקטים מקומי או בענן אל Cloud Storage, להעביר נתונים לארכיון כדי לפנות נפח אחסון מקומי, לשכפל נתונים ל-Google Cloud כדי לשמור על המשכיות עסקית או להעביר נתונים ל-Google Cloud לצורך ניתוח ועיבוד. לקוחות שמעבירים נתונים מ-AWS S3 ל-Cloud Storage יכולים להשתמש בתכונה הזו כדי לשלוט בנתיבי הרשת ל-Google Cloud, וכך להפחית באופן משמעותי את החיובים על העברת נתונים יוצאים.

לפני שמתחילים

לפני שמגדירים את ההעברות, צריך לבצע את השלבים הבאים:

דרישות מוקדמות

לפני שמגדירים את ההעברה, צריך לוודא שהגדרתם את הדברים הבאים:

אפשרויות העברה

התכונות הבאות של Storage Transfer Service זמינות להעברות מאחסון תואם-S3 ל-Cloud Storage:

העברת קבצים ספציפיים באמצעות מניפסט
אפשר להעביר רשימה של קבצים כדי ש-Storage Transfer Service יפעל לגביהם. פרטים נוספים זמינים במאמר העברת קבצים או אובייקטים ספציפיים באמצעות מניפסט.
ציון סוג האחסון (storage class)
אתם יכולים לציין את סוג האחסון ב-Cloud Storage שבו אתם רוצים להשתמש בשביל הנתונים בקטגוריית היעד. אפשר לעיין באפשרויות של StorageClass כדי לקבל פרטים על REST, או להשתמש בדגל --custom-storage-class עם Google Cloud CLI.

שימו לב שהמערכת מתעלמת מההגדרות של סוגי האחסון אם בקטגוריית היעד מופעלת התכונה סיווג אוטומטי. אם התכונה "סיווג אוטומטי" מופעלת, האובייקטים שמועברים לקטגוריה מוגדרים בהתחלה כ-Standard Storage.

שימור מטא-נתונים

כשמעבירים קבצים מאחסון שתואם ל-S3, אפשר להשתמש ב-Storage Transfer Service כדי לשמור מאפיינים מסוימים כמטא-נתונים בהתאמה אישית.

בקטע אחסון ב-Amazon S3 או באחסון תואם-S3 ב-Cloud Storage במאמר שמירת מטא-נתונים מוסבר אילו מטא-נתונים אפשר לשמור ואיך מגדירים את ההעברה.

רישום ביומן ומעקב
אפשר לראות העברות מאחסון תואם-S3 ב-Cloud Logging וב-Cloud Monitoring. למידע נוסף, קראו את המאמרים Cloud Logging לשירות Storage Transfer Service ומעקב אחרי משימות העברה. אפשר גם להגדיר התראות Pub/Sub.

יצירת מאגר סוכנים

אל תכללו מידע רגיש כמו פרטים אישיים מזהים (PII) או נתוני אבטחה בשם של מאגר הנציגים או בתחילית של מזהה הנציג. יכול להיות ששמות המשאבים יופצו לשמות של משאבים אחרים ב-Google Cloud, וייחשפו למערכות פנימיות של Google מחוץ לפרויקט שלכם.

כדי ליצור מאגר של סוכנים:

מסוף Google Cloud

  1. נכנסים לדף Agent pools במסוף Google Cloud .

    כניסה לדף Agent pools

    הדף Agent pools מוצג, ומופיעה בו רשימה של מאגרי הסוכנים הקיימים.

  2. לוחצים על יצירת מאגר נוסף.

  3. נותנים שם למאגר, ואפשר גם להוסיף תיאור.

  4. אתם יכולים להגדיר מגבלת רוחב פס שתחול על כל המאגר. רוחב הפס שצוין ב-MB/s יחולק בין כל הנציגים במאגר. מידע נוסף זמין במאמר ניהול רוחב הפס של הרשת.

  5. לוחצים על יצירה.

‫API בארכיטקטורת REST

משתמשים ב-projects.agentPools.create:

POST https://storagetransfer.googleapis.com/v1/projects/PROJECT_ID/agentPools?agent_pool_id=AGENT_POOL_ID

מחליפים את מה שכתוב בשדות הבאים:

  • ‫PROJECT_ID: מזהה הפרויקט שבו יוצרים את מאגר הנציגים.
  • ‫AGENT_POOL_ID: המזהה של מאגר הנציגים שאתם יוצרים.

אם מאגר סוכנים תקוע במצב Creating במשך יותר מ-30 דקות, מומלץ למחוק את מאגר הסוכנים וליצור אותו מחדש.

אם מבטלים את ההרשאות הנדרשות של Storage Transfer Service מפרויקט כשמאגר הנציגים נמצא במצב Creating, השירות לא יפעל כמו שצריך.

‫CLI של gcloud

כדי ליצור מאגר סוכנים באמצעות כלי שורת הפקודה gcloud, מריצים את הפקודה gcloud transfer agent-pools create.

gcloud transfer agent-pools create AGENT_POOL

אלה האפשרויות הזמינות:

  • ‫AGENT_POOL הוא מזהה ייחודי וקבוע של המאגר הזה.

  • הפקודה --no-async חוסמת משימות אחרות במסוף עד ליצירת המאגר. אם לא כוללים אותו, יצירת המאגר תתבצע באופן אסינכרוני.

  • --bandwidth-limit מגדיר את רוחב הפס ב-MB/s שיהיה זמין לסוכנים במאגר הזה. מגבלת רוחב הפס חלה על כל הנציגים במאגר, והיא יכולה לעזור למנוע מצב שבו עומס העבודה של ההעברה במאגר ישבש פעולות אחרות שחולקות את רוחב הפס. לדוגמה, מזינים "50" כדי להגדיר מגבלת רוחב פס של 50MB לשנייה. אם לא מציינים את הדגל הזה, הנציגים במאגר הזה ישתמשו בכל רוחב הפס שזמין להם.

  • --display-name הוא שם שאפשר לשנות כדי לזהות את המאגר הזה. אפשר לכלול פרטים שלא מתאימים לשם המשאב המלא והייחודי של המאגר.

התקנת סוכני העברה

סוכני העברה הם סוכני תוכנה שמתאמים את פעילויות ההעברה מהמקור באמצעות Storage Transfer Service. צריך להתקין אותם במערכת עם גישה לנתוני המקור.

‫CLI של gcloud

כדי להתקין סוכנים לשימוש עם מקור תואם ל-S3 באמצעות ה-CLI של gcloud, משתמשים בפקודה transfer agents install.

אתם צריכים לספק את פרטי הכניסה כמשתני סביבה בתור הערכים של AWS_ACCESS_KEY_ID ו-AWS_SECRET_ACCESS_KEY, או לשמור אותם כפרטי כניסה שמוגדרים כברירת מחדל בקובצי התצורה של המערכת.

export AWS_ACCESS_KEY_ID=ID
export AWS_SECRET_ACCESS_KEY=SECRET
gcloud transfer agents install --pool=POOL_NAME

כדי להריץ סוכנים באמצעות מפתח של חשבון שירות, משתמשים באפשרות --creds-file:

gcloud transfer agents install --pool=POOL_NAME \
  --creds-file=/relative/path/to/service-account-key.json

יצירת משימת העברה

מסוף Google Cloud

כדי ליצור העברה ממקור תואם-S3 לקטגוריה של Cloud Storage:

  1. נכנסים לדף Storage Transfer Service במסוף Google Cloud .

    כניסה ל-Storage Transfer Service

  2. לוחצים על Transfer. נפתח הדף Create a transfer job.

  3. בוחרים באפשרות S3-compatible object storage בתור Source type. היעד חייב להיות Google Cloud Storage.

    לוחצים על השלב הבא.

הגדרת המקור

  1. מציינים את המידע הנדרש להעברה:

    1. בוחרים את מאגר הסוכנים שהגדרתם להעברה הזו.

    2. מזינים את שם הקטגוריה ביחס לנקודת הקצה. לדוגמה, אם הנתונים נמצאים במיקום:

      https://example.com/bucket_a

      מזינים: bucket_a

    3. מזינים את נקודת הקצה. אל תכללו את הפרוטוקול (http:// או https://) או את שם הקטגוריה. לדוגמה:

      example.com

  2. מציינים את המאפיינים האופציונליים של ההעברה:

    1. מזינים את אזור החתימה שבו רוצים להשתמש כדי לחתום על בקשות.

    2. בוחרים את תהליך החתימה לבקשה הזו.

    3. בוחרים את סגנון הפנייה. ההגדרה הזו קובעת אם שם הקטגוריה יופיע בסגנון נתיב (למשל, https://example.com/bucket-name/key-name) או בסגנון אירוח וירטואלי (למשל, https://bucket-name.example.com/key-name). למידע נוסף, קראו את המאמר Virtual hosting of buckets במסמכי התיעוד של Amazon.

    4. בוחרים את פרוטוקול הרשת.

    5. בוחרים את גרסת ה-API של דף האפליקציה שבה רוצים להשתמש. מידע נוסף זמין במסמכי התיעוד של ListObjectsV2 ו-ListObjects.

  3. לוחצים על השלב הבא.

הגדרת הכיור

  1. בשדה Bucket or folder, מזינים את שם קטגוריית היעד ואת שם התיקייה (אופציונלי), או לוחצים על Browse כדי לבחור קטגוריה מרשימת הקטגוריות הקיימות בפרויקט הנוכחי. כדי ליצור קטגוריה חדשה, לוחצים על Create new bucket.

  2. לוחצים על השלב הבא.

בחירת הגדרות העברה

  1. בשדה Description, מזינים תיאור של ההעברה. מומלץ להזין תיאור משמעותי וייחודי כדי שתוכלו להבדיל בין המשימות.

  2. בקטע Metadata options, בוחרים אם להשתמש באפשרויות ברירת המחדל או לוחצים על View and select options כדי לציין ערכים לכל המטא-נתונים הנתמכים. פרטים נוספים זמינים במאמר שמירת מטא-נתונים.

  3. בקטע מתי להחליף, בוחרים אחת מהאפשרויות הבאות:

    • אם שונה: החלפת קובצי היעד אם לקובץ המקור עם אותו שם יש ערכי Etag או סיכום ביקורת (checksum) שונים.

    • תמיד: תמיד מחליף את קובצי היעד כשלמקור יש את אותו שם, גם אם הם זהים.

  4. בקטע מתי למחוק, בוחרים אחת מהאפשרויות הבאות:

    • אף פעם: אף פעם לא למחוק קבצים מהמקור או מהיעד.

    • ‫Delete file from source after they're transferred: מחיקת קבצים מהמקור אחרי שהם מועברים ליעד. אם קובץ מקור לא מועבר, למשל כי הוא כבר קיים ביעד, קובץ המקור לא נמחק.

    • Delete files from destination if they're not also at source: אם הקבצים בקטגוריית היעד של Cloud Storage לא נמצאים גם במקור, הקבצים נמחקים מקטגוריית Cloud Storage.

      האפשרות הזו מבטיחה שקטגוריית היעד של Cloud Storage תהיה זהה למקור.

  5. בקטע Notification options, בוחרים את נושא Pub/Sub ואת האירועים שעליהם רוצים לקבל התראות. למידע נוסף, קראו את המאמר התראות Pub/Sub.

  6. לוחצים על השלב הבא.

תזמון ההעברה

אפשר לתזמן את ההעברה כך שתפעל פעם אחת בלבד, או להגדיר העברה חוזרת.

לוחצים על Create כדי ליצור את משימת ההעברה.

‫CLI של gcloud

לפני שמשתמשים ב-CLI של gcloud כדי ליצור העברה, צריך לפעול לפי ההוראות במאמר הגדרת הגישה לכיור של Cloud Storage.

כדי להשתמש ב-CLI של gcloud ליצירת העברה ממקור תואם-S3 לקטגוריה של Cloud Storage, משתמשים בפקודה הבאה.

gcloud transfer jobs create s3://SOURCE_BUCKET_NAME gs://SINK_BUCKET_NAME \
  --source-agent-pool=POOL_NAME \
  --source-endpoint=ENDPOINT \
  --source-signing-region=REGION \
  --source-auth-method=AWS_SIGNATURE_V2 | AWS_SIGNATURE_V4 \
  --source-request-model=PATH_STYLE | VIRTUAL_HOSTED_STYLE \
  --source-network-protocol=HTTP | HTTPS \
  --source-list-api=LIST_OBJECTS | LIST_OBJECTS_V2

צריך להשתמש בדגלים הבאים:

  • ‫--source-agent-pool הוא השם של מאגר הנציגים שבו משתמשים בהעברה הזו.

  • ‫--source-endpoint מציין את נקודת הקצה של מערכת האחסון. לדוגמה, s3.us-east.example.com. כדאי לבדוק עם הספק מהו הפורמט הנכון. אל תכללו את הפרוטוקול (למשל, https://) או את שם הקטגוריה.

שאר הדגלים הם אופציונליים:

  • ‫--source-signing-region מציין אזור לבקשות חתומות. אם ספק האחסון לא דורש אזור חתימה, אפשר להשמיט את הדגל הזה.
  • ‫--source-auth-method מציין את שיטת האימות שבה צריך להשתמש. הערכים התקינים הם AWS_SIGNATURE_V2 או AWS_SIGNATURE_V4. מידע נוסף זמין במסמכי התיעוד של אמזון בנושא SigV4 ו-SigV2.
  • --source-request-model מציין את סגנון הפנייה שבו צריך להשתמש. הערכים המותרים הם PATH_STYLE או VIRTUAL_HOSTED_STYLE. סגנון הנתיב משתמש בפורמט https://s3.REGION.example.com/BUCKET_NAME/KEY_NAME. בסגנון של אירוח וירטואלי משתמשים בפורמט `https://BUCKET_NAME.s3.REGION.example.com/KEY_NAME.
  • ‫--source-network-protocol מציין את פרוטוקול הרשת שבו הסוכנים צריכים להשתמש במשימה הזו. הערכים התקינים הם HTTP או HTTPS.
  • ‫--source-list-api מציין את הגרסה של S3 listing API להחזרת אובייקטים מהקטגוריה. הערכים התקינים הם LIST_OBJECTS או LIST_OBJECTS_V2. מידע נוסף זמין במסמכי התיעוד של אמזון בנושא ListObjectsV2 ו-ListObjects.

כדי לראות אפשרויות נוספות של משימות העברה, מריצים את הפקודה gcloud transfer jobs create --help או קוראים את מאמרי העזרה של gcloud.

‫API בארכיטקטורת REST

לפני שמשתמשים ב-API בארכיטקטורת REST כדי ליצור העברה, צריך לפעול לפי ההוראות במאמר הגדרת הגישה לכיור של Cloud Storage.

כדי ליצור העברה ממקור תואם ל-S3 באמצעות API בארכיטקטורת REST, יוצרים אובייקט JSON כמו בדוגמה הבאה.

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  ...
  "transferSpec": {
    "source_agent_pool_name":"POOL_NAME",
    "awsS3CompatibleData": {
      "region":"us-east-1",
      "s3Metadata":{
        "protocol": "NETWORK_PROTOCOL_HTTPS",
        "requestModel": "REQUEST_MODEL_VIRTUAL_HOSTED_STYLE",
        "authMethod": "AUTH_METHOD_AWS_SIGNATURE_V4"
      },
      "endpoint": "example.com",
      "bucketName": "BUCKET_NAME",
      "path": "PATH",
    },
    "gcsDataSink": {
      "bucketName": "SINK_NAME",
      "path": "SINK_PATH"
    },
    "transferOptions": {
      "deleteObjectsFromSourceAfterTransfer": false
    }
  }
}

תיאורי השדות מפורטים במאמרי העזרה של ה-API של AwsS3CompatibleData.

ספריות לקוח

לפני שמשתמשים בספריות הלקוח כדי ליצור העברה, צריך לפעול לפי ההוראות במאמר הגדרת גישה לכיור של Cloud Storage.

Go

במאמר ספריות הלקוח של Storage Transfer Service מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Storage Transfer Service. למידע נוסף, קראו את מאמרי העזרה של Storage Transfer Service Go API.

כדי לבצע אימות ב-Storage Transfer Service, עליכם להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 


import (
	"context"
	"fmt"
	"io"

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

func transferFromS3CompatibleSource(w io.Writer, projectID string, sourceAgentPoolName string, sourceBucketName string, sourcePath string, gcsSinkBucket string, gcsPath string) (*storagetransferpb.TransferJob, error) {
	// Your project id.
	// projectId := "my-project-id"

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

	// The S3 compatible bucket name to transfer data from.
	//sourceBucketName = "my-bucket-name"

	// The S3 compatible path (object prefix) to transfer data from.
	//sourcePath = "path/to/data"

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

	// The GCS path (object prefix) to transfer data to.
	//gcsPath = "path/to/data"

	// The S3 region of the source bucket.
	region := "us-east-1"

	// The S3 compatible endpoint.
	endpoint := "us-east-1.example.com"

	// The S3 compatible network protocol.
	protocol := storagetransferpb.S3CompatibleMetadata_NETWORK_PROTOCOL_HTTPS

	// The S3 compatible request model.
	requestModel := storagetransferpb.S3CompatibleMetadata_REQUEST_MODEL_VIRTUAL_HOSTED_STYLE

	// The S3 Compatible auth method.
	authMethod := storagetransferpb.S3CompatibleMetadata_AUTH_METHOD_AWS_SIGNATURE_V4

	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_AwsS3CompatibleDataSource{
					AwsS3CompatibleDataSource: &storagetransferpb.AwsS3CompatibleData{
						BucketName: sourceBucketName,
						Path:       sourcePath,
						Endpoint:   endpoint,
						Region:     region,
						DataProvider: &storagetransferpb.AwsS3CompatibleData_S3Metadata{
							S3Metadata: &storagetransferpb.S3CompatibleMetadata{
								AuthMethod:   authMethod,
								RequestModel: requestModel,
								Protocol:     protocol,
							},
						},
					}},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{
						BucketName: gcsSinkBucket,
						Path:       gcsPath,
					},
				},
			},
			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", sourceBucketName, gcsSinkBucket, resp.Name)
	return resp, nil
}

Java

במאמר ספריות הלקוח של Storage Transfer Service מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Storage Transfer Service. למידע נוסף, קראו את מאמרי העזרה של Storage Transfer Service Java API.

כדי לבצע אימות ב-Storage Transfer Service, עליכם להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

import static com.google.storagetransfer.v1.proto.TransferTypes.S3CompatibleMetadata.AuthMethod;
import static com.google.storagetransfer.v1.proto.TransferTypes.S3CompatibleMetadata.NetworkProtocol;
import static com.google.storagetransfer.v1.proto.TransferTypes.S3CompatibleMetadata.RequestModel;

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

public class TransferFromS3CompatibleSource {

  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 S3 compatible data source. If not provided, defaults to
    // the default agent
    String sourceAgentPoolName = "projects/my-project-id/agentPools/transfer_service_default";

    // The S3 compatible bucket name to transfer data from
    String sourceBucketName = "my-bucket-name";

    // The S3 compatible path (object prefix) to transfer data from
    String sourcePath = "path/to/data";

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

    // The GCS path (object prefix) to transfer data to
    String gcsPath = "path/to/data";

    // The S3 region of the source bucket
    String region = "us-east-1";

    // The S3 compatible endpoint
    String endpoint = "us-east-1.example.com";

    // The S3 compatible network protocol
    NetworkProtocol protocol = NetworkProtocol.NETWORK_PROTOCOL_HTTPS;

    // The S3 compatible request model
    RequestModel requestModel = RequestModel.REQUEST_MODEL_VIRTUAL_HOSTED_STYLE;

    // The S3 Compatible auth method
    AuthMethod authMethod = AuthMethod.AUTH_METHOD_AWS_SIGNATURE_V4;

    transferFromS3CompatibleSource(
        projectId,
        sourceAgentPoolName,
        sourceBucketName,
        sourcePath,
        region,
        endpoint,
        protocol,
        requestModel,
        authMethod,
        gcsSinkBucket,
        gcsPath);
  }

  public static void transferFromS3CompatibleSource(
      String projectId,
      String sourceAgentPoolName,
      String sourceBucketName,
      String sourcePath,
      String region,
      String endpoint,
      NetworkProtocol protocol,
      RequestModel requestModel,
      AuthMethod authMethod,
      String gcsSinkBucket,
      String gcsPath)
      throws IOException {
    TransferJob transferJob =
        TransferJob.newBuilder()
            .setProjectId(projectId)
            .setTransferSpec(
                TransferSpec.newBuilder()
                    .setSourceAgentPoolName(sourceAgentPoolName)
                    .setAwsS3CompatibleDataSource(
                        TransferTypes.AwsS3CompatibleData.newBuilder()
                            .setRegion(region)
                            .setEndpoint(endpoint)
                            .setBucketName(sourceBucketName)
                            .setPath(sourcePath)
                            .setS3Metadata(
                                TransferTypes.S3CompatibleMetadata.newBuilder()
                                    .setProtocol(protocol)
                                    .setRequestModel(requestModel)
                                    .setAuthMethod(authMethod)
                                    .build())
                            .build())
                    .setGcsDataSink(
                        GcsData.newBuilder().setBucketName(gcsSinkBucket).setPath(gcsPath).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 "
              + sourceBucketName
              + " to "
              + gcsSinkBucket
              + " with "
              + "name "
              + response.getName());
    }
  }
}

Node.js

במאמר ספריות הלקוח של Storage Transfer Service מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Storage Transfer Service. למידע נוסף, קראו את מאמרי העזרה של Storage Transfer Service Node.js API.

כדי לבצע אימות ב-Storage Transfer Service, עליכם להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 


// Imports the Google Cloud client library
const storageTransfer = require('@google-cloud/storage-transfer');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// Useful enums for AWS S3-Compatible Transfers
// const {AuthMethod, NetworkProtocol, RequestModel} = storageTransfer.protos.google.storagetransfer.v1.S3CompatibleMetadata;

// Your project id
// const projectId = 'my-project';

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

// The S3-compatible bucket name to transfer data from
// const sourceBucketName = "my-bucket-name";

// The S3-compatible path (object prefix) to transfer data from
// const sourcePath = "path/to/data/";

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

// The GCS path (object prefix) to transfer data to
// const gcsPath = "path/to/data/";

// The S3 region of the source bucket
// const region = 'us-east-1';

// The S3-compatible endpoint
// const endpoint = "us-east-1.example.com";

// The S3-compatible network protocol
// const protocol = NetworkProtocol.NETWORK_PROTOCOL_HTTPS;

// The S3-compatible request model
// const requestModel = RequestModel.REQUEST_MODEL_VIRTUAL_HOSTED_STYLE;

// The S3-compatible auth method
// const authMethod = AuthMethod.AUTH_METHOD_AWS_SIGNATURE_V4;

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

/**
 * Creates a transfer from an AWS S3-compatible source to GCS
 */
async function transferFromS3CompatibleSource() {
  // Runs the request and creates the job
  const [transferJob] = await client.createTransferJob({
    transferJob: {
      projectId,
      transferSpec: {
        sourceAgentPoolName,
        awsS3CompatibleDataSource: {
          region,
          s3Metadata: {
            authMethod,
            protocol,
            requestModel,
          },
          endpoint,
          bucketName: sourceBucketName,
          path: sourcePath,
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
          path: gcsPath,
        },
      },
      status: 'ENABLED',
    },
  });

  await client.runTransferJob({
    jobName: transferJob.name,
    projectId,
  });

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

transferFromS3CompatibleSource();

Python

במאמר ספריות הלקוח של Storage Transfer Service מוסבר איך להתקין את ספריית הלקוח ולהשתמש בה ב-Storage Transfer Service. למידע נוסף, קראו את מאמרי העזרה של Storage Transfer Service Python API.

כדי לבצע אימות ב-Storage Transfer Service, עליכם להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

from google.cloud import storage_transfer

AuthMethod = storage_transfer.S3CompatibleMetadata.AuthMethod
NetworkProtocol = storage_transfer.S3CompatibleMetadata.NetworkProtocol
RequestModel = storage_transfer.S3CompatibleMetadata.RequestModel


def transfer_from_S3_compat_to_gcs(
    project_id: str,
    description: str,
    source_agent_pool_name: str,
    source_bucket_name: str,
    source_path: str,
    gcs_sink_bucket: str,
    gcs_path: str,
    region: str,
    endpoint: str,
    protocol: NetworkProtocol,
    request_model: RequestModel,
    auth_method: AuthMethod,
) -> None:
    """Creates a transfer from an AWS S3-compatible source to GCS"""

    client = storage_transfer.StorageTransferServiceClient()

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

    # A useful description for your transfer job
    # description = 'My transfer job'

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

    # The S3 compatible bucket name to transfer data from
    # source_bucket_name = "my-bucket-name"

    # The S3 compatible path (object prefix) to transfer data from
    # source_path = "path/to/data/"

    # The ID of the GCS bucket to transfer data to
    # gcs_sink_bucket = "my-sink-bucket"

    # The GCS path (object prefix) to transfer data to
    # gcs_path = "path/to/data/"

    # The S3 region of the source bucket
    # region = 'us-east-1'

    # The S3-compatible endpoint
    # endpoint = "us-east-1.example.com"

    # The S3-compatible network protocol
    # protocol = NetworkProtocol.NETWORK_PROTOCOL_HTTPS

    # The S3-compatible request model
    # request_model = RequestModel.REQUEST_MODEL_VIRTUAL_HOSTED_STYLE

    # The S3-compatible auth method
    # auth_method = AuthMethod.AUTH_METHOD_AWS_SIGNATURE_V4

    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,
                    "aws_s3_compatible_data_source": {
                        "region": region,
                        "s3_metadata": {
                            "auth_method": auth_method,
                            "protocol": protocol,
                            "request_model": request_model,
                        },
                        "endpoint": endpoint,
                        "bucket_name": source_bucket_name,
                        "path": source_path,
                    },
                    "gcs_data_sink": {
                        "bucket_name": gcs_sink_bucket,
                        "path": gcs_path,
                    },
                },
            }
        }
    )

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

שאלות נפוצות

מה קורה אם הספק התואם ל-S3 משתמש באישור SSL בהתאמה אישית?

אם הספק שתואם ל-S3 משתמש באישור SSL שלא הונפק על ידי רשות אישורים ציבורית, יכול להיות שההעברות ייכשלו עם שגיאת TLS. כדי לפתור את הבעיה, צריך לטעון את אישור הבסיס של הספק לקונטיינר של נציג ההעברה ב-/etc/ssl/certs/CERT_FILE באמצעות הדגל -v של Docker.

לדוגמה:

sudo docker run --ulimit memlock=64000000 -d --rm \
-v HOST_DIRECTORY:CONTAINER_DIRECTORY \
-v PATH/TO/KEY.JSON:/etc/gcloud/key.json:ro \
-v /path/to/your/CERT_FILE:/etc/ssl/certs/CERT_FILE \
-e AWS_ACCESS_KEY_ID=AWS_ACCESS_KEY_ID \
-e AWS_SECRET_ACCESS_KEY=AWS_SECRET_ACCESS_KEY \
gcr.io/cloud-ingest/tsop-agent:latest \
--project-id=PROJECT_ID \
--creds-file=/etc/gcloud/key.json \
--hostname=$(hostname) \
--agent-pool=POOL_NAME

האם יש עלות להעברה מאחסון תואם ל-S3?

העברות מאחסון שתואם ל-S3 לא מחויבות בעמלה "העברות של Storage Transfer Service שדורשות סוכנים". בקטע תמחור מפורטות עמלות נוספות שעשויות לחול. יכול להיות שתחויבו גם על העברת נתונים יוצאים ועל דמי תפעול על ידי ספק שירותי הענן של המקור.

האם יש תמיכה ב-Cloud Logging בהעברות של אחסון תואם-S3?

כן, אפשר להפעיל את Cloud Logging להעברות שלכם לפי ההוראות במאמר Cloud Logging ל-Storage Transfer Service.

האם אפשר להעביר נתונים באמצעות מניפסט?

כן, יש תמיכה בקובצי מניפסט בהעברות שתואמות ל-S3.

אם מוסיפים אובייקט לקטגוריית המקור אחרי שהמשימה התחילה, האם האובייקט הזה יועבר?

השירות Storage Transfer Service מבצע פעולת רשימה בקטגוריית המקור כדי לחשב את ההבדל מהיעד. אם פעולת הרישום כבר הושלמה כשהאובייקט החדש נוסף, המערכת תדלג על האובייקט הזה עד להעברה הבאה.

האם Storage Transfer Service מבצע התאמה של סיכום ביקורת (checksum) במקורות שתואמים ל-S3?

השירות Storage Transfer Service מסתמך על נתוני סיכום ביקורת (checksum) שמוחזרים מהמקור. באחסון שתואם ל-S3, ‏ Storage Transfer Service מצפה שה-ETag של האובייקט יהיה גיבוב (hash) ה-MD5 של האובייקט.

עם זאת, לאובייקטים שהועברו לאחסון תואם S3 באמצעות העלאה מרובת חלקים של S3 אין תגי ETag של MD5. במקרה כזה, השירות Storage Transfer Service משתמש בגודל הקובץ כדי לאמת את האובייקט שהועבר.

מהו קצב העברת הנתונים שאפשר להשיג בהעברות מאחסון תואם ל-S3?

כדי להגדיל את קצב ההעברה, אפשר להוסיף עוד סוכני העברה. מומלץ להשתמש ב-3 סוכנים כדי להבטיח עמידות בפני תקלות ולמלא צינור של פחות מ-10Gbps. כדי להרחיב את הפעילות, אפשר להוסיף עוד סוכנים. אפשר להוסיף ולהסיר נציגים בזמן שההעברה מתבצעת.

איפה צריך לפרוס את סוכני ההעברה כדי להעביר נתונים מ-Amazon S3 ל-Cloud Storage?

אתם יכולים להתקין סוכנים ב-Amazon EC2 או ב-EKS באותו אזור שבו נמצא הקטגוריה. אפשר גם להריץ סוכנים ב-Google Cloud באזור הקרוב ביותר.