הוספת משתמשים לשרת SFTP

במאמר הזה מוסבר איך להוסיף משתמשים לשרת Cloud FTP. משתמשים כמו שותפים חיצוניים ובעלי עניין פנימיים יכולים להשתמש בשרת כדי להעביר קבצים אל Cloud Storage וממנו בצורה מאובטחת.

ככלל, אלה השלבים להוספת משתמש לשרת SFTP:

  1. מגדירים את ההרשאות של המשתמש.
  2. יוצרים משתמש SFTP וממפים את הספריות שלו לקטגוריות של Cloud Storage.

כדי ליצור שרת, קראו את המאמרים יצירת שרת SFTP חיצוני ויצירת שרת SFTP פנימי.

לתשומת ליבכם

  • אפשר לתת למשתמש גישה ל-10 קטגוריות לכל היותר.

  • לכל משתמש יכולים להיות עד 10 מפתחות ציבוריים.

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

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

  2. מקבלים את המפתח הציבורי של המשתמש מכל זוג מפתחות SSH שהוא ישתמש בו כדי להתחבר לשרת.

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

    יצירת זוג מפתחות SSH

    איזה פורמט של מפתח דרוש לך?

    פורמט המפתח שאתם צריכים תלוי בלקוח שבו אתם משתמשים כדי להתחבר לשרת ה-SFTP. מידע נוסף זמין במאמר לקוחות SFTP נתמכים.

    פורמט PEM

    1. כדי ליצור זוג מפתחות OpenSSH (בפורמט PEM), משתמשים בכלי השירות ssh-keygen.

      במכונת הלקוח שתתחבר לשרת ה-SFTP, מריצים את הפקודה הבאה:

      ssh-keygen -t rsa -b 4096 -f ~/.ssh/KEY_PAIR_NAME

      מחליפים את KEY_PAIR_NAME בשם של זוג המפתחות, למשל sftp_user_key.

    2. מחלצים את המפתח הציבורי:

      cat ~/.ssh/KEY_PAIR_NAME.pub

    פורמט PPK

    1. כדי ליצור זוג מפתחות PuTTY (בפורמט PPK), משתמשים בכלי PuTTYgen.

      במכונת הלקוח שתתחבר לשרת ה-SFTP, מריצים את הפקודה הבאה:

      puttygen -t rsa -b 4096 -o KEY_PAIR_NAME.ppk

      מחליפים את KEY_PAIR_NAME בשם של זוג המפתחות, למשל sftp_user_key.

    2. מחילוץ המפתח הציבורי:

      puttygen -L KEY_PAIR_NAME.ppk

התפקידים הנדרשים

כדי לקבל את ההרשאה שנדרשת להוספת משתמשי SFTP, צריך לבקש מהאדמין להקצות לכם ב-IAM את התפקיד אדמין FTP (roles/ftp.admin) בפרויקט. כדי לקרוא הסבר על מתן תפקידים, ראו איך מנהלים את הגישה ברמת הפרויקט, התיקייה והארגון.

התפקיד המוגדר מראש הזה כולל את ההרשאה ftp.users.create, שנדרשת כדי להוסיף משתמשי SFTP.

יכול להיות שתוכלו לקבל את ההרשאה הזו גם בתפקידים בהתאמה אישית או בתפקידים מוגדרים מראש.

הגדרת הרשאות למשתמש

  1. התקינו את ה-CLI של Google Cloud. אחר כך, מאתחלים את ה-CLI של Google Cloud באמצעות הפקודה הבאה: 

    gcloud init

    אם אתם משתמשים בספק זהויות חיצוני (IdP), קודם אתם צריכים להיכנס ל-CLI של gcloud באמצעות המאגר המאוחד לניהול זהויות.

  2. מגדירים את הפרויקט:

    gcloud config set project PROJECT_ID

    מחליפים את PROJECT_ID במזהה הפרויקט שמכיל את שרת ה-SFTP.

  3. אם למשתמש אין חשבון שירות, יוצרים לו חשבון שירות. חשבון השירות ניגש למשאבי Cloud Storage בשם המשתמש.

    gcloud iam service-accounts create USERNAME-sa \
    --description="USERNAME SFTP Service Account" \
    --display-name="USERNAME SFTP Service Account"

    מחליפים את USERNAME בשם משתמש ייחודי למשתמש ב-SFTP. שם המשתמש צריך להתחיל באות קטנה באנגלית, ויכול לכלול אותיות קטנות, מספרים או מקפים. האורך המרבי הוא 32 תווים.

    אם הפעולה בוצעה בהצלחה, תוצג הודעה כמו Created service account [example-userid-sa].

  4. מקצים תפקידי IAM לאדמין שיוצר את משתמש ה-SFTP:

    1. מקצים לעצמכם את התפקיד 'משתמש בחשבון שירות' (roles/iam.serviceAccountUser):

      gcloud iam service-accounts add-iam-policy-binding USERNAME-sa@PROJECT_ID.iam.gserviceaccount.com \
    --member="user:ADMINISTRATOR_EMAIL" \
    --role="roles/iam.serviceAccountUser"

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

      אם הפעולה בוצעה בהצלחה, תוצג הודעה כמו זו:

      Updated IAM policy for serviceAccount [example-userid-sa@example-project.iam.gserviceaccount.com].
bindings:
- members:
- user:admin@example.com
role: roles/iam.serviceAccountUser
etag: BwZJk7OiSzw=
version: 1

    2. מקצים לעצמכם את התפקיד Storage Bucket Viewer‏ (roles/storage.bucketViewer) בקטגוריה: 

      gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="user:ADMINISTRATOR_EMAIL" \
    --role="roles/storage.bucketViewer"

      מחליפים את BUCKET_NAME בשם הקטגוריה.

      חוזרים על השלב הזה לכל קטגוריה שהמשתמש צריך לגשת אליה.

    3. מקצים לעצמכם את התפקיד "צפייה באובייקט אחסון" (roles/storage.objectViewer) בקטגוריה:

      gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="user:ADMINISTRATOR_EMAIL" \
    --role="roles/storage.objectViewer"

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

  5. מקצים לחשבון השירות של המשתמש את תפקיד ה-IAM שנדרש כדי לגשת לדלי:

    gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="serviceAccount:USERNAME-sa@PROJECT_ID.iam.gserviceaccount.com" \
    --role="ROLE"

    מחליפים את ROLE באחד מתפקידי ה-IAM הבאים:

    • כדי לתת גישה לקריאה בלבד, משתמשים בתפקיד roles/storage.objectViewer.
    • כדי לקבל גישת קריאה וכתיבה, צריך להשתמש בתפקיד roles/storage.objectAdmin.

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

  6. נותנים לסוכן השירות של Cloud FTP הרשאה ליצור אסימונים לחשבון השירות של המשתמש:

    1. מוצאים את כתובת האימייל של סוכן השירות של השרת. איך מקבלים פרטים על שרת?

    2. נותנים הרשאה לסוכן השירות של Cloud FTP:

      gcloud iam service-accounts add-iam-policy-binding USERNAME-sa@PROJECT_ID.iam.gserviceaccount.com \
    --member="serviceAccount:SERVICE_AGENT_EMAIL" \
    --role="roles/iam.serviceAccountTokenCreator"

      מחליפים את SERVICE_AGENT_EMAIL בכתובת האימייל של סוכן השירות.

עכשיו יוצרים משתמש.

יצירת משתמש בשרת SFTP

אחרי שמגדירים הרשאות למשתמש, יוצרים את המשתמש וממפים את הספריות שלו לקטגוריה אחת או יותר של Cloud Storage.

gcloud

  1. כדי ליצור משתמש לשרת SFTP, מריצים את הפקודה gcloud alpha storage ftp users create.

    לפני השימוש בנתוני הפקודה הבאים, צריך להחליף את הנתונים הבאים:

    • ‫CREDENTIAL_NAME: שם ייחודי לזיהוי פרטי הכניסה של המשתמש.
    • ‫SSH_PUBLIC_KEY: גוף המפתח הציבורי של ה-SSH של המשתמש, בפורמט OpenSSH. לדוגמה, ssh-rsa AAAAB3NzaC1ycRexample....
    • ‫USERNAME: שם המשתמש של משתמש ה-SFTP.
    • ‫SERVICE_ACCOUNT: חשבון השירות של המשתמש. לדוגמה: username-sa@example-project.iam.gserviceaccount.com.
    • ‫LOCATION_ID: המיקום של השרת, למשל us-west1.
    • ‫SERVER_ID: מזהה השרת.
    • ‫BUCKET_NAME: השם של מאגר (bucket) שלמשתמש ה-SFTP יש גישה אליו, למשל example-bucket. השמיטו את gs://.
    • (אופציונלי) BUCKET_PREFIX: הנתיב של תיקייה בתוך הקטגוריה שרוצים להגדיר כתיקיית השורש של מיפוי התיקיות הזה. אם משמיטים את המאפיין bucket_prefix, אז Cloud FTP משתמש בתיקיית השורש של הקטגוריה.

    • ‫DIRECTORY: הנתיב של ספריית הנחיתה הלוגית שמוצג למשתמש ה-SFTP. לדוגמה, /home/uploads.

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

      אין תמיכה בספריות לוגיות מקוננות. אם אתם מספקים כמה מיפויים לספרייה, צריך לספק את הספריות במבנה שטוח ולא במבנה מקונן. לדוגמה, במקום /dir1 ו-/dir1/dir2, צריך להשתמש ב-/dir1 וב-/dir2.

    • ‫SFTP_PERMISSION: רמת הגישה לספרייה. כדי להגדיר הרשאת קריאה בלבד, צריך להגדיר את הערך הזה ל-READ_ONLY. כדי לקבל גישת קריאה וכתיבה, צריך להגדיר את הערך הזה ל-READ_WRITE.

    שימו לב לנקודות הבאות:

    • כדי לתת למשתמש גישה לכמה קטגוריות, צריך לציין את הדגל --storage-directory-mapping כמה פעמים, עם מיפוי ספרייה לכל קטגוריה.
    • כדי להגדיר כמה מפתחות ציבוריים למשתמש, צריך לספק כמה פרטי כניסה בקובץ credentials.json.

    שומרים את התוכן הבא בקובץ בשם credentials.json: 

    [
  {
    "credentialName": "CREDENTIAL_NAME",
    "credentialType": "PUBLIC_KEY",
    "sshPublicKeyBody": "SSH_PUBLIC_KEY"
  }
]

    מריצים את הפקודה הבאה:

    ‫Linux,‏ macOS או Cloud Shell

    gcloud alpha storage ftp users create USERNAME \
    --customer-service-account=SERVICE_ACCOUNT --location=LOCATION_ID \
    --server=SERVER_ID \
    --storage-directory-mapping=bucket=BUCKET_NAME,bucket_prefix=BUCKET_PREFIX,directory=DIRECTORY,permission=SFTP_PERMISSION \
    --user-credentials-from-file=credentials.json

    ‏Windows (PowerShell)

    gcloud alpha storage ftp users create USERNAME `
    --customer-service-account=SERVICE_ACCOUNT --location=LOCATION_ID `
    --server=SERVER_ID `
    --storage-directory-mapping=bucket=BUCKET_NAME,bucket_prefix=BUCKET_PREFIX,directory=DIRECTORY,permission=SFTP_PERMISSION `
    --user-credentials-from-file=credentials.json

    Windows‏ (cmd.exe)

    gcloud alpha storage ftp users create USERNAME ^
    --customer-service-account=SERVICE_ACCOUNT --location=LOCATION_ID ^
    --server=SERVER_ID ^
    --storage-directory-mapping=bucket=BUCKET_NAME,bucket_prefix=BUCKET_PREFIX,directory=DIRECTORY,permission=SFTP_PERMISSION ^
    --user-credentials-from-file=credentials.json
         יצירת המשתמש אורכת כמה שניות.

  2. מספקים למשתמש את הפרטים הבאים, שנדרשים כדי להתחבר לשרת:

    • שם המשתמש ב-SFTP של המשתמש.

    • הגדרת הגישה של השרת, שמשתנה בהתאם לסוג השרת:

      • לשרת חיצוני, כתובת ה-IP של השרת.

      • בשרת פנימי, ה-URI של קובץ המצורף של השירות בשרת.

      במאמר קבלת פרטים על שרת מוסבר איך לקבל את הגדרת הגישה של השרת.

    • (אופציונלי) טביעת האצבע של מפתח השרת.

REST

  1. כדי ליצור משתמש לשרת SFTP, משתמשים ב-method ‏servers.users.create.

    לפני שמשתמשים בנתוני הבקשה, צריך להחליף את הנתונים הבאים:

    • ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud של השרת.
    • ‫LOCATION_ID: המיקום של השרת, למשל us-west1.
    • ‫SERVER_ID: מזהה השרת.
    • ‫USERNAME: שם המשתמש של משתמש ה-SFTP.
    • ‫BUCKET_NAME: שם הקטגוריה שלמשתמש ה-SFTP יש גישה אליה, למשל example-bucket. לא כוללים את gs://.
    • (אופציונלי) BUCKET_PREFIX: הנתיב של תיקייה בתוך קטגוריית האחסון שרוצים להגדיר כתיקיית השורש למיפוי הזה של הספריות. אם לא מציינים את הערך הזה, Cloud FTP משתמש בתיקיית הבסיס של הקטגוריה.

    • DIRECTORY: הנתיב הלוגי של ספריית הנחיתה שמוצג למשתמש ה-SFTP. לדוגמה, /home/uploads. אם משמיטים את הערך הזה, Cloud FTP מגדיר את ספריית הנחיתה כ-/.

      אם ממפים כמה קטגוריות או תיקיות, צריך לציין נתיב ספרייה ייחודי לכל מיפוי.

      אין תמיכה בספריות לוגיות מקוננות. אם אתם מספקים כמה מיפויים לספרייה, צריך לספק את הספריות במבנה שטוח ולא במבנה מקונן. לדוגמה, במקום /dir1 ו-/dir1/dir2, צריך להשתמש ב-/dir1 וב-/dir2.

    • ‫SFTP_PERMISSION: רמת הגישה לספרייה. כדי להגדיר הרשאת קריאה בלבד, צריך להגדיר את הערך הזה בתור READ_ONLY. כדי להגדיר הרשאת קריאה וכתיבה, צריך להגדיר את הערך הזה בתור READ_WRITE.
    • ‫SERVICE_ACCOUNT: חשבון השירות של המשתמש. לדוגמה: username-sa@example-project.iam.gserviceaccount.com.
    • ‫CREDENTIAL_NAME: שם ייחודי לזיהוי פרטי הכניסה של המשתמש.
    • ‫SSH_PUBLIC_KEY: גוף המפתח הציבורי של ה-SSH של המשתמש, בפורמט OpenSSH. לדוגמה, ssh-rsa AAAAB3NzaC1ycRexample....

    שימו לב לנקודות הבאות:

    • כדי לתת למשתמש גישה לכמה קטגוריות, צריך לספק כמה מיפויים של קטגוריות ברשימה storageDirectoryMappings.
    • כדי להגדיר כמה מפתחות ציבוריים למשתמש, צריך לספק כמה פרטי כניסה ברשימה userCredentials.

    ה-method של ה-HTTP וכתובת ה-URL: 

    POST https://ftp.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/servers/SERVER_ID/users?userId=USERNAME

    תוכן בקשת JSON: 

    {
  "storageDirectoryMappings": [
    {
      "bucket": "BUCKET_NAME",
      "bucketPrefix": "BUCKET_PREFIX",
      "directory": "DIRECTORY",
      "permission": "SFTP_PERMISSION"
    }
  ],
  "customerServiceAccount": "SERVICE_ACCOUNT",
  "userCredentials": [
    {
      "credentialName": "CREDENTIAL_NAME",
      "credentialType": "PUBLIC_KEY",
      "sshPublicKeyBody": "SSH_PUBLIC_KEY"
    }
  ]
}

    כדי לשלוח את הבקשה צריך להרחיב אחת מהאפשרויות הבאות:

    התגובה מזהה פעולה ממושכת. יצירת המשתמש אורכת כמה שניות.

  2. מספקים למשתמש את הפרטים הבאים, שנדרשים כדי להתחבר לשרת:

    • שם המשתמש ב-SFTP של המשתמש.

    • הגדרת הגישה של השרת, שמשתנה בהתאם לסוג השרת:

      • לשרת חיצוני, כתובת ה-IP של השרת.

      • בשרת פנימי, ה-URI של קובץ ה-attachment של השירות בשרת.

      במאמר קבלת פרטים על שרת מוסבר איך לקבל את הגדרת הגישה של השרת.

    • (אופציונלי) טביעת האצבע של המפתח של השרת.

ספריות לקוח

C#

מידע על התקנה ושימוש בספריית הלקוח של Cloud FTP מופיע במאמר ספריות הלקוח של Cloud FTP. מידע נוסף מופיע במאמרי העזרה של Cloud FTP C# API.

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

using Google.Cloud.Ftp.V1;
using Google.LongRunning;
using System.Threading.Tasks;

public sealed partial class GeneratedCloudFtpClientSnippets
{
    /// <summary>Snippet for CreateUserAsync</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public async Task CreateUserAsync()
    {
        // Create client
        CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
        // Initialize request argument(s)
        string parent = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
        User user = new User();
        string userId = "";
        // Make the request
        Operation<User, OperationMetadata> response = await cloudFtpClient.CreateUserAsync(parent, user, userId);

        // Poll until the returned long-running operation is complete
        Operation<User, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
        // Retrieve the operation result
        User result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<User, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceCreateUserAsync(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            User retrievedResult = retrievedResponse.Result;
        }
    }
}

Go

כדי ללמוד איך מתקינים את ספריית הלקוח ואיך משתמשים בה ב-Cloud FTP, ראו: ספריות לקוח של Cloud FTP. למידע נוסף, קראו את מאמרי העזרה של Cloud FTP Go API.

כדי לבצע אימות ב-Cloud FTP, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 


//go:build examples

package main

import (
	"context"

	ftp "cloud.google.com/go/ftp/apiv1"
	ftppb "cloud.google.com/go/ftp/apiv1/ftppb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := ftp.NewCloudFtpRESTClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &ftppb.CreateUserRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/ftp/apiv1/ftppb#CreateUserRequest.
	}
	op, err := c.CreateUser(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

כדי ללמוד איך מתקינים את ספריית הלקוח ואיך משתמשים בה ב-Cloud FTP, ראו: ספריות לקוח של Cloud FTP. למידע נוסף, קראו את מאמרי העזרה של Cloud FTP Java API.

כדי לבצע אימות ב-Cloud FTP, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

import com.google.api.core.ApiFuture;
import com.google.cloud.ftp.v1.CloudFtpClient;
import com.google.cloud.ftp.v1.CreateUserRequest;
import com.google.cloud.ftp.v1.ServerName;
import com.google.cloud.ftp.v1.User;
import com.google.longrunning.Operation;

public class AsyncCreateUser {

  public static void main(String[] args) throws Exception {
    asyncCreateUser();
  }

  public static void asyncCreateUser() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (CloudFtpClient cloudFtpClient = CloudFtpClient.create()) {
      CreateUserRequest request =
          CreateUserRequest.newBuilder()
              .setParent(ServerName.of("[PROJECT]", "[LOCATION]", "[SERVER]").toString())
              .setUserId("userId-836030906")
              .setUser(User.newBuilder().build())
              .setRequestId("requestId693933066")
              .build();
      ApiFuture<Operation> future = cloudFtpClient.createUserCallable().futureCall(request);
      // Do something.
      Operation response = future.get();
    }
  }
}

Node.js

כדי ללמוד איך מתקינים את ספריית הלקוח ואיך משתמשים בה ב-Cloud FTP, ראו: ספריות לקוח של Cloud FTP. למידע נוסף, קראו את מאמרי העזרה של Cloud FTP Node.js API.

כדי לבצע אימות ב-Cloud FTP, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית. 

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. Value for parent.
 */
// const parent = 'abc123'
/**
 *  Required. A unique user ID for the SFTP user. The user ID must start with a
 *  lowercase letter and can include lowercase letters, numbers, or hyphens.
 */
// const userId = 'abc123'
/**
 *  Required. The resource being created
 */
// const user = {}
/**
 *  Optional. An optional request ID to identify requests. Specify a unique
 *  request ID so that if you must retry your request, the server will know to
 *  ignore the request if it has already been completed. The server will
 *  guarantee that for at least 60 minutes since the first request.
 *  For example, consider a situation where you make an initial request and the
 *  request times out. If you make the request again with the same request
 *  ID, the server can check if original operation with the same request ID
 *  was received, and if so, will ignore the second request. This prevents
 *  clients from accidentally creating duplicate commitments.
 *  The request ID must be a valid UUID with the exception that zero UUID is
 *  not supported (00000000-0000-0000-0000-000000000000).
 */
// const requestId = 'abc123'

// Imports the Ftp library
const {CloudFtpClient} = require('@google-cloud/ftp').v1;

// Instantiates a client
const ftpClient = new CloudFtpClient();

async function callCreateUser() {
  // Construct request
  const request = {
    parent,
    userId,
    user,
  };

  // Run request
  const [operation] = await ftpClient.createUser(request);
  const [response] = await operation.promise();
  console.log(response);
}

callCreateUser();

PHP

מידע על התקנה ושימוש בספריית הלקוח של Cloud FTP מופיע במאמר ספריות הלקוח של Cloud FTP. מידע נוסף מופיע במאמרי העזרה של Cloud FTP PHP API.

כדי לבצע אימות ב-Cloud FTP, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית. 

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\Ftp\V1\Client\CloudFtpClient;
use Google\Cloud\Ftp\V1\CreateUserRequest;
use Google\Cloud\Ftp\V1\StorageDirectoryMapping;
use Google\Cloud\Ftp\V1\StorageDirectoryMapping\Permission;
use Google\Cloud\Ftp\V1\User;
use Google\Cloud\Ftp\V1\UserCredential;
use Google\Cloud\Ftp\V1\UserCredential\Type;
use Google\Rpc\Status;

/**
 * Creates a new User in a given project and location and Server.
 *
 * @param string $formattedParent                        Value for parent. Please see
 *                                                       {@see CloudFtpClient::serverName()} for help formatting this field.
 * @param string $userId                                 A unique user ID for the SFTP user. The user ID must start with a
 *                                                       lowercase letter and can include lowercase letters, numbers, or hyphens.
 * @param string $userCustomerServiceAccount             Service account in customer project attached to this SFTP User.
 * @param string $userUserCredentialsCredentialName      Name of the user credential.
 * @param int    $userUserCredentialsCredentialType      Type of credential.
 * @param string $userStorageDirectoryMappingsBucket     Name of the bucket.
 * @param string $userStorageDirectoryMappingsDirectory  Directory where the user lands in the SFTP server.
 * @param int    $userStorageDirectoryMappingsPermission Permission to the bucket.
 */
function create_user_sample(
    string $formattedParent,
    string $userId,
    string $userCustomerServiceAccount,
    string $userUserCredentialsCredentialName,
    int $userUserCredentialsCredentialType,
    string $userStorageDirectoryMappingsBucket,
    string $userStorageDirectoryMappingsDirectory,
    int $userStorageDirectoryMappingsPermission
): void {
    // Create a client.
    $cloudFtpClient = new CloudFtpClient();

    // Prepare the request message.
    $userCredential = (new UserCredential())
        ->setCredentialName($userUserCredentialsCredentialName)
        ->setCredentialType($userUserCredentialsCredentialType);
    $userUserCredentials = [$userCredential];
    $storageDirectoryMapping = (new StorageDirectoryMapping())
        ->setBucket($userStorageDirectoryMappingsBucket)
        ->setDirectory($userStorageDirectoryMappingsDirectory)
        ->setPermission($userStorageDirectoryMappingsPermission);
    $userStorageDirectoryMappings = [$storageDirectoryMapping];
    $user = (new User())
        ->setCustomerServiceAccount($userCustomerServiceAccount)
        ->setUserCredentials($userUserCredentials)
        ->setStorageDirectoryMappings($userStorageDirectoryMappings);
    $request = (new CreateUserRequest())
        ->setParent($formattedParent)
        ->setUserId($userId)
        ->setUser($user);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $cloudFtpClient->createUser($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            /** @var User $result */
            $result = $response->getResult();
            printf('Operation successful with response data: %s' . PHP_EOL, $result->serializeToJsonString());
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = CloudFtpClient::serverName('[PROJECT]', '[LOCATION]', '[SERVER]');
    $userId = '[USER_ID]';
    $userCustomerServiceAccount = '[CUSTOMER_SERVICE_ACCOUNT]';
    $userUserCredentialsCredentialName = '[CREDENTIAL_NAME]';
    $userUserCredentialsCredentialType = Type::TYPE_UNSPECIFIED;
    $userStorageDirectoryMappingsBucket = '[BUCKET]';
    $userStorageDirectoryMappingsDirectory = '[DIRECTORY]';
    $userStorageDirectoryMappingsPermission = Permission::PERMISSION_UNSPECIFIED;

    create_user_sample(
        $formattedParent,
        $userId,
        $userCustomerServiceAccount,
        $userUserCredentialsCredentialName,
        $userUserCredentialsCredentialType,
        $userStorageDirectoryMappingsBucket,
        $userStorageDirectoryMappingsDirectory,
        $userStorageDirectoryMappingsPermission
    );
}

Python

מידע על התקנה ושימוש בספריית הלקוח של Cloud FTP מופיע במאמר ספריות הלקוח של Cloud FTP. מידע נוסף מופיע במאמרי העזרה של Cloud FTP Python API.

כדי לבצע אימות ב-Cloud FTP, צריך להגדיר את Application Default Credentials. למידע נוסף, ראו הגדרת אימות לסביבת פיתוח מקומית. 

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import ftp_v1


def sample_create_user():
    # Create a client
    client = ftp_v1.CloudFtpClient()

    # Initialize request argument(s)
    user = ftp_v1.User()
    user.customer_service_account = "customer_service_account_value"
    user.user_credentials.credential_name = "credential_name_value"
    user.user_credentials.credential_type = "PUBLIC_KEY"
    user.storage_directory_mappings.bucket = "bucket_value"
    user.storage_directory_mappings.directory = "directory_value"
    user.storage_directory_mappings.permission = "READ_WRITE"

    request = ftp_v1.CreateUserRequest(
        parent="parent_value",
        user_id="user_id_value",
        user=user,
    )

    # Make the request
    operation = client.create_user(request=request)

    print("Waiting for operation to complete...")

    response = operation.result()

    # Handle the response
    print(response)

Ruby

כדי ללמוד איך מתקינים את ספריית הלקוח ואיך משתמשים בה ב-Cloud FTP, ראו: ספריות לקוח של Cloud FTP. מידע נוסף מופיע במאמרי העזרה של Cloud FTP Ruby API.

כדי לבצע אימות ב-Cloud FTP, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית. 

require "google/cloud/ftp/v1"

##
# Snippet for the create_user call in the CloudFtp service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Ftp::V1::CloudFtp::Rest::Client#create_user.
#
def create_user
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Ftp::V1::CloudFtp::Rest::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Ftp::V1::CreateUserRequest.new

  # Call the create_user method.
  result = client.create_user request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

המאמרים הבאים