Aggiungere utenti a un server SFTP

Questo documento mostra come aggiungere utenti a un server Cloud FTP. Utenti come partner esterni e stakeholder interni possono utilizzare il server per trasferire in modo sicuro i file da e verso Cloud Storage.

In linea generale, i passaggi per aggiungere un utente a un server SFTP sono i seguenti:

  1. Configura le autorizzazioni per l'utente.
  2. Crea un utente SFTP e mappa le sue directory ai bucket Cloud Storage.

Per i passaggi per creare un server, consulta Crea un server SFTP esterno e Crea un server SFTP interno.

Considerazioni

  • Puoi concedere a un utente l'accesso a un massimo di 10 bucket.

  • Un utente può avere un massimo di 10 chiavi pubbliche.

Prima di iniziare

  1. Crea uno o più bucket Cloud Storage per archiviare i dati con cui l'utente lavorerà, se i bucket non esistono già.

  2. Recupera la chiave pubblica dell'utente da ogni coppia di chiavi SSH che utilizzerà per connettersi al server.

    Se l'utente non dispone di una coppia di chiavi SSH, segui questi passaggi per generarne una.

    Genera una coppia di chiavi SSH

    Di quale formato della chiave hai bisogno?

    Il formato della chiave necessario dipende dal client che utilizzi per connetterti al server SFTP. Per maggiori informazioni, consulta Client SFTP supportati.

    Formato PEM

    1. Per creare una coppia di chiavi OpenSSH (formato PEM), utilizza l'utilità ssh-keygen.

      Sul computer client che si connetterà al server SFTP, esegui questo comando:

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

      Sostituisci KEY_PAIR_NAME con un nome per la coppia di chiavi, ad esempio sftp_user_key.

    2. Estrai la chiave pubblica:

      cat ~/.ssh/KEY_PAIR_NAME.pub

    Formato PPK

    1. Per creare una coppia di chiavi PuTTY (formato PPK), utilizza lo strumento PuTTYgen.

      Sulla macchina client che si connetterà al server SFTP, esegui questo comando:

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

      Sostituisci KEY_PAIR_NAME con un nome per la coppia di chiavi, ad esempio sftp_user_key.

    2. Estrai la chiave pubblica:

      puttygen -L KEY_PAIR_NAME.ppk

Ruoli obbligatori

Per ottenere l'autorizzazione necessaria per aggiungere utenti SFTP, chiedi all'amministratore di concederti il ruolo IAM FTP Admin (roles/ftp.admin) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene l'autorizzazione ftp.users.create necessaria per aggiungere utenti SFTP.

Potresti anche ottenere questa autorizzazione con ruoli personalizzati o altri ruoli predefiniti.

Configurare le autorizzazioni per un utente

  1. Installa Google Cloud CLI, quindi accedi a gcloud CLI con la tua identità federata. Dopo aver eseguito l'accesso, inizializza Google Cloud CLI eseguendo il comando seguente: 

    gcloud init

  2. Imposta il progetto:

    gcloud config set project PROJECT_ID

    Sostituisci PROJECT_ID con l'ID del progetto che contiene il server SFTP.

  3. Crea un account di servizio per l'utente, se non esiste già. Il account di servizio accede alle risorse Cloud Storage per conto dell'utente.

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

    Sostituisci USERNAME con un nome utente univoco per l'utente SFTP. Il nome utente deve iniziare con una lettera minuscola e può includere lettere minuscole, numeri o trattini. La lunghezza massima è di 32 caratteri.

    In caso di esito positivo, viene visualizzato un messaggio come Created service account [example-userid-sa].

  4. Concedi i ruoli IAM all'amministratore che crea l'utente SFTP:

    1. Concedi a te stesso il ruolo Service Account User (roles/iam.serviceAccountUser):

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

      Sostituisci ADMINISTRATOR_EMAIL con l'indirizzo email dell'entità che sta creando l'utente SFTP. Se stai creando l'utente (anziché un'applicazione), questo valore è l'indirizzo email che utilizzi per accedere a Google Cloud.

      In caso di esito positivo, viene visualizzato un messaggio simile al seguente:

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

    2. Concediti il ruolo Storage Bucket Viewer (roles/storage.bucketViewer) sul bucket: 

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

      Sostituisci BUCKET_NAME con il nome del bucket.

      Ripeti questo passaggio per ogni bucket a cui l'utente deve accedere.

    3. Concediti il ruolo Visualizzatore oggetti Storage (roles/storage.objectViewer) nel bucket:

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

      Ripeti questo passaggio per ogni bucket a cui l'utente deve accedere.

  5. Concedi al account di servizio dell'utente il ruolo IAM necessario per accedere al bucket:

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

    Sostituisci ROLE con uno dei seguenti ruoli IAM:

    • Per l'accesso di sola lettura, utilizza il ruolo roles/storage.objectViewer.
    • Per l'accesso in lettura e scrittura, utilizza il ruolo roles/storage.objectAdmin.

    Ripeti questo passaggio per ogni bucket a cui l'utente deve accedere.

  6. Autorizza l'agente di servizio Cloud FTP a generare token per il account di servizio dell'utente:

    1. Recupera l'indirizzo email del service agent del server. Per i passaggi, consulta Visualizza i dettagli di un server.

    2. Autorizza il service agent Cloud FTP:

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

      Sostituisci SERVICE_AGENT_EMAIL con l'indirizzo email del service agent.

A questo punto, crea un utente.

Creare un utente del server SFTP

Dopo aver configurato le autorizzazioni per un utente, crei l'utente e mappi le sue directory a uno o più bucket Cloud Storage.

gcloud

  1. Per creare un utente per un server SFTP, esegui il comando gcloud alpha storage ftp users create.

    Prima di utilizzare i dati dei comandi riportati di seguito, effettua le seguenti sostituzioni:

    • CREDENTIAL_NAME: un nome univoco per identificare le credenziali utente.
    • SSH_PUBLIC_KEY: il corpo della chiave pubblica SSH dell'utente, in formato OpenSSH. Ad esempio: ssh-rsa AAAAB3NzaC1ycRexample....
    • USERNAME: il nome utente dell'utente SFTP.
    • SERVICE_ACCOUNT: il account di servizio dell'utente. Ad esempio, username-sa@example-project..
    • LOCATION_ID: la località del server, ad esempio us-west1.
    • SERVER_ID: l'ID server.
    • BUCKET_NAME: il nome di un bucket a cui l'utente SFTP ha accesso, ad esempio example-bucket. Ometti gs://.
    • (Facoltativo) BUCKET_PREFIX: il percorso di una cartella all'interno del bucket da impostare come directory principale per questa mappatura delle directory. Se ometti la proprietà bucket_prefix, Cloud FTP utilizza la radice del bucket.

    • DIRECTORY: il percorso della directory di destinazione logica presentato all'utente SFTP. Ad esempio, /home/uploads.

      Se mappi più bucket o cartelle, fornisci un percorso di directory univoco per ogni mappatura.

      Le directory logiche nidificate non sono supportate. Se fornisci più mappature per una directory, fornisci le directory in una struttura piatta anziché in una struttura nidificata. Ad esempio, utilizza /dir1 e /dir2 anziché /dir1 e /dir1/dir2.

    • SFTP_PERMISSION: il livello di accesso per la directory. Per l'accesso di sola lettura, imposta questo valore su READ_ONLY. Per l'accesso in lettura e scrittura, imposta questo valore su READ_WRITE.

    Tieni presente quanto segue:

    • Per concedere a un utente l'accesso a più bucket, fornisci il flag --storage-directory-mapping più volte, con una mappatura della directory per ogni bucket.
    • Per configurare più chiavi pubbliche per un utente, fornisci più credenziali nel file credentials.json.

    Salva i seguenti contenuti in un file denominato credentials.json: 

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

    Esegui questo comando:

    Linux, macOS o 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
         La creazione dell'utente richiede alcuni secondi.

  2. Fornisci all'utente le seguenti informazioni, di cui ha bisogno per connettersi al server:

    • Il nome utente SFTP dell'utente.

    • La configurazione di accesso del server, che dipende dal tipo di server:

      • Per un server esterno, l'indirizzo IP del server.

      • Per un server interno, l'URI dell'allegato del servizio del server.

      Per i passaggi per ottenere la configurazione di accesso del server, vedi Visualizzare i dettagli di un server.

    • (Facoltativo) L'impronta della chiave del server.

REST

  1. Per creare un utente per un server SFTP, utilizza il metodo servers.users.create.

    Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

    • PROJECT_ID: l' Google Cloud ID progetto del server.
    • LOCATION_ID: la località del server, ad esempio us-west1.
    • SERVER_ID: l'ID server.
    • USERNAME: il nome utente dell'utente SFTP.
    • BUCKET_NAME: il nome di un bucket a cui l'utente SFTP ha accesso, ad esempio example-bucket. Ometti gs://.
    • (Facoltativo) BUCKET_PREFIX: il percorso di una cartella all'interno del bucket da impostare come directory root per questa mappatura delle directory. Se ometti questo valore, Cloud FTP utilizza la radice del bucket.

    • DIRECTORY: il percorso della directory di destinazione logica presentato all'utente SFTP. Ad esempio, /home/uploads. Se ometti questo valore, Cloud FTP imposta la directory di destinazione su /.

      Se mappi più bucket o cartelle, fornisci un percorso di directory univoco per ogni mappatura.

      Le directory logiche nidificate non sono supportate. Se fornisci più mappature per una directory, fornisci le directory in una struttura piatta anziché in una struttura nidificata. Ad esempio, utilizza /dir1 e /dir2 anziché /dir1 e /dir1/dir2.

    • SFTP_PERMISSION: il livello di accesso per la directory. Per l'accesso di sola lettura, imposta questo valore su READ_ONLY. Per l'accesso in lettura e scrittura, imposta questo valore su READ_WRITE.
    • SERVICE_ACCOUNT: il account di servizio dell'utente. Ad esempio, username-sa@example-project..
    • CREDENTIAL_NAME: un nome univoco per identificare le credenziali utente.
    • SSH_PUBLIC_KEY: il corpo della chiave pubblica SSH dell'utente, in formato OpenSSH. Ad esempio: ssh-rsa AAAAB3NzaC1ycRexample....

    Tieni presente quanto segue:

    • Per concedere a un utente l'accesso a più bucket, fornisci più mappature dei bucket nell'elenco storageDirectoryMappings.
    • Per configurare più chiavi pubbliche per un utente, fornisci più credenziali nell'elenco userCredentials.

    Metodo HTTP e URL: 

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

    Corpo JSON della richiesta: 

    {
  "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"
    }
  ]
}

    Per inviare la richiesta, espandi una di queste opzioni:

    La risposta identifica un'operazione a lunga esecuzione. La creazione dell'utente richiede alcuni secondi.

  2. Fornisci all'utente le seguenti informazioni, necessarie per connettersi al server:

    • Il nome utente SFTP dell'utente.

    • La configurazione di accesso del server, che dipende dal tipo di server:

      • Per un server esterno, l'indirizzo IP del server.

      • Per un server interno, l'URI del collegamento al servizio del server.

      Per i passaggi per ottenere la configurazione di accesso del server, vedi Visualizzare i dettagli di un server.

    • (Facoltativo) L'impronta della chiave del server.

Librerie client

C#

Per scoprire come installare e utilizzare la libreria client per Cloud FTP, consulta la sezione Librerie client di Cloud FTP. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud FTP C#.

Per eseguire l'autenticazione in Cloud FTP, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

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

Per scoprire come installare e utilizzare la libreria client per Cloud FTP, consulta Librerie client di Cloud FTP. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud FTP Go.

Per eseguire l'autenticazione in Cloud FTP, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 


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

Per scoprire come installare e utilizzare la libreria client per Cloud FTP, consulta la sezione Librerie client di Cloud FTP. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud FTP Java.

Per eseguire l'autenticazione in Cloud FTP, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

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

Per scoprire come installare e utilizzare la libreria client per Cloud FTP, consulta la sezione Librerie client di Cloud FTP. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud FTP Node.js.

Per eseguire l'autenticazione in Cloud FTP, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

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

Per scoprire come installare e utilizzare la libreria client per Cloud FTP, consulta Librerie client di Cloud FTP. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud FTP PHP.

Per eseguire l'autenticazione in Cloud FTP, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

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

Per scoprire come installare e utilizzare la libreria client per Cloud FTP, consulta Librerie client di Cloud FTP. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud FTP Python.

Per eseguire l'autenticazione in Cloud FTP, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

# 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

Per scoprire come installare e utilizzare la libreria client per Cloud FTP, consulta Librerie client di Cloud FTP. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud FTP Ruby.

Per eseguire l'autenticazione in Cloud FTP, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

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

Passaggi successivi