Adicionar usuários a um servidor SFTP

Neste documento, mostramos como adicionar usuários a um servidor do Cloud FTP. Usuários como parceiros externos e partes interessadas internas podem usar o servidor para transferir arquivos com segurança de e para o Cloud Storage.

Basicamente, estas são as etapas para adicionar um usuário a um servidor SFTP:

  1. Configure as permissões do usuário.
  2. Crie um usuário do SFTP e mapeie os diretórios dele para buckets do Cloud Storage.

Para saber como criar um servidor, consulte Criar um servidor SFTP externo e Criar um servidor SFTP interno.

Considerações

  • É possível conceder a um usuário acesso a no máximo 10 buckets.

  • Um usuário pode ter no máximo 10 chaves públicas.

Antes de começar

  1. Crie um ou mais buckets do Cloud Storage para armazenar os dados com que o usuário vai trabalhar, se os buckets ainda não existirem.

  2. Consiga a chave pública do usuário de cada par de chaves SSH que ele usará para se conectar ao servidor.

    Se o usuário não tiver um par de chaves SSH, siga as etapas abaixo para gerar um.

    Gerar um par de chaves SSH

    Qual formato de chave você precisa?

    O formato de chave necessário depende do cliente usado para se conectar ao servidor SFTP. Para mais informações, consulte Clientes SFTP compatíveis.

    Formato PEM

    1. Para criar um par de chaves OpenSSH (formato PEM), use o utilitário ssh-keygen.

      Na máquina cliente que vai se conectar ao servidor SFTP, execute o seguinte comando:

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

      Substitua KEY_PAIR_NAME por um nome para o par de chaves, como sftp_user_key.

    2. Extraia a chave pública:

      cat ~/.ssh/KEY_PAIR_NAME.pub

    Formato PPK

    1. Para criar um par de chaves do PuTTY (formato PPK), use a ferramenta PuTTYgen.

      Na máquina cliente que vai se conectar ao servidor SFTP, execute o seguinte comando:

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

      Substitua KEY_PAIR_NAME por um nome para o par de chaves, como sftp_user_key.

    2. Extraia a chave pública:

      puttygen -L KEY_PAIR_NAME.ppk

Funções exigidas

Para receber a permissão necessária para adicionar usuários do SFTP, peça ao administrador para conceder a você o papel do IAM de Administrador de FTP (roles/ftp.admin) no projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém a permissão ftp.users.create, que é necessária para adicionar usuários do SFTP.

Também é possível receber essa permissão com papéis personalizados ou outros papéis predefinidos.

Configurar permissões para um usuário

  1. Instale a Google Cloud CLI e faça login na CLI gcloud com sua identidade federada. Depois de fazer login, inicialize a Google Cloud CLI executando o seguinte comando: 

    gcloud init

  2. Defina o projeto:

    gcloud config set project PROJECT_ID

    Substitua PROJECT_ID pelo ID do projeto que contém o servidor SFTP.

  3. Crie uma conta de serviço para o usuário, se ainda não houver uma. A conta de serviço acessa os recursos do Cloud Storage em nome do usuário.

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

    Substitua USERNAME por um nome de usuário exclusivo para o usuário do SFTP. O nome de usuário precisa começar com uma letra minúscula e pode incluir letras minúsculas, números ou hifens. O tamanho máximo é de 32 caracteres.

    Se tudo der certo, uma mensagem como Created service account [example-userid-sa] será exibida.

  4. Conceda papéis do IAM ao administrador que cria o usuário do SFTP:

    1. Conceda a si mesmo o papel de Usuário da conta de serviço (roles/iam.serviceAccountUser):

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

      Substitua ADMINISTRATOR_EMAIL pelo endereço de e-mail do principal que está criando o usuário do SFTP. Se você estiver criando o usuário (em vez de um aplicativo), esse valor será o endereço de e-mail usado para acessar o Google Cloud.

      Se a operação for bem-sucedida, uma mensagem como esta vai aparecer:

      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. Conceda a si mesmo o papel de Leitor de buckets do Storage (roles/storage.bucketViewer) no bucket: 

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

      Substitua BUCKET_NAME pelo nome do bucket.

      Repita essa etapa para cada bucket que o usuário precisa acessar.

    3. Conceda a si mesmo o papel de Leitor de objetos do Storage (roles/storage.objectViewer) no bucket:

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

      Repita essa etapa para cada bucket que o usuário precisa acessar.

  5. Conceda à conta de serviço do usuário o papel do IAM necessário para acessar o bucket:

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

    Substitua ROLE por um dos seguintes papéis do IAM:

    • Para acesso somente leitura, use o papel roles/storage.objectViewer.
    • Para acesso de leitura e gravação, use o papel roles/storage.objectAdmin.

    Repita essa etapa para cada bucket que o usuário precisa acessar.

  6. Autorize o agente de serviço do Cloud FTP a gerar tokens para a conta de serviço do usuário:

    1. Encontre o endereço de e-mail do agente de serviço do servidor. Para conferir as etapas, consulte Receber detalhes sobre um servidor.

    2. Autorize o agente de serviço do Cloud FTP:

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

      Substitua SERVICE_AGENT_EMAIL pelo endereço de e-mail do agente de serviço.

Em seguida, crie um usuário.

Criar um usuário do servidor SFTP

Depois de configurar as permissões para um usuário, crie o usuário e mapeie os diretórios dele para um ou mais buckets do Cloud Storage.

gcloud

  1. Para criar um usuário para um servidor SFTP, execute o comando gcloud alpha storage ftp users create.

    Antes de usar os dados do comando abaixo, faça estas substituições:

    • CREDENTIAL_NAME: um nome exclusivo para identificar as credenciais do usuário.
    • SSH_PUBLIC_KEY: o corpo da chave pública SSH do usuário, no formato OpenSSH. Por exemplo, ssh-rsa AAAAB3NzaC1ycRexample....
    • USERNAME: o nome de usuário do SFTP.
    • SERVICE_ACCOUNT: a conta de serviço do usuário. Por exemplo, username-sa@example-project..
    • LOCATION_ID: o local do servidor, como us-west1.
    • SERVER_ID: o ID do servidor.
    • BUCKET_NAME: o nome de um bucket a que o usuário do SFTP tem acesso, como example-bucket. Omita o gs://.
    • (Opcional) BUCKET_PREFIX: o caminho de uma pasta no bucket a ser definida como o diretório raiz para esse mapeamento de diretório. Se você omitir a propriedade bucket_prefix, o Cloud FTP vai usar a raiz do bucket.

    • DIRECTORY: o caminho do diretório de destino lógico que é apresentado ao usuário do SFTP. Por exemplo, /home/uploads.

      Se você mapear vários buckets ou pastas, forneça um caminho de diretório exclusivo para cada mapeamento.

      Não há suporte para diretórios lógicos aninhados. Se você fornecer vários mapeamentos para um diretório, forneça os diretórios em uma estrutura simples em vez de aninhada. Por exemplo, use /dir1 e /dir2 em vez de /dir1 e /dir1/dir2.

    • SFTP_PERMISSION: o nível de acesso do diretório. Para acesso somente leitura, defina esse valor como READ_ONLY. Para acesso de leitura e gravação, defina esse valor como READ_WRITE.

    Observe o seguinte:

    • Para conceder a um usuário acesso a vários buckets, forneça a flag --storage-directory-mapping várias vezes, com um mapeamento de diretório para cada bucket.
    • Para configurar várias chaves públicas para um usuário, forneça várias credenciais no arquivo credentials.json.

    Salve o conteúdo a seguir em um arquivo chamado credentials.json: 

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

    Execute o seguinte comando:

    Linux, macOS ou 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
         A criação do usuário leva alguns segundos.

  2. Informe ao usuário os seguintes dados, que são necessários para se conectar ao servidor:

    • O nome de usuário do SFTP.

    • A configuração de acesso do servidor, que depende do tipo de servidor:

      • Para um servidor externo, o endereço IP do servidor.

      • Para um servidor interno, o URI do anexo de serviço do servidor.

      Para saber como acessar a configuração de acesso do servidor, consulte Receber detalhes sobre um servidor.

    • (Opcional) A impressão digital da chave do servidor.

REST

  1. Para criar um usuário para um servidor SFTP, use o método servers.users.create.

    Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

    • PROJECT_ID: o ID do projeto Google Cloud do servidor.
    • LOCATION_ID: o local do servidor, como us-west1.
    • SERVER_ID: o ID do servidor.
    • USERNAME: o nome de usuário do SFTP.
    • BUCKET_NAME: o nome de um bucket ao qual o usuário do SFTP tem acesso, como example-bucket. Omita o gs://.
    • (Opcional) BUCKET_PREFIX: o caminho de uma pasta no bucket para definir como o diretório raiz desse mapeamento de diretório. Se você omitir esse valor, o Cloud FTP usará a raiz do bucket.

    • DIRECTORY: o caminho lógico do diretório de destino apresentado ao usuário do SFTP. Por exemplo, /home/uploads. Se você omitir esse valor, o Cloud FTP vai definir o diretório de destino como /.

      Se você mapear vários buckets ou pastas, forneça um caminho de diretório exclusivo para cada mapeamento.

      Não há suporte para diretórios lógicos aninhados. Se você fornecer vários mapeamentos para um diretório, forneça os diretórios em uma estrutura simples em vez de aninhada. Por exemplo, use /dir1 e /dir2 em vez de /dir1 e /dir1/dir2.

    • SFTP_PERMISSION: o nível de acesso do diretório. Para acesso somente leitura, defina esse valor como READ_ONLY. Para acesso de leitura e gravação, defina esse valor como READ_WRITE.
    • SERVICE_ACCOUNT: a conta de serviço do usuário. Por exemplo, username-sa@example-project..
    • CREDENTIAL_NAME: um nome exclusivo para identificar as credenciais do usuário.
    • SSH_PUBLIC_KEY: o corpo da chave pública SSH do usuário, no formato OpenSSH. Por exemplo, ssh-rsa AAAAB3NzaC1ycRexample....

    Observe o seguinte:

    • Para conceder a um usuário acesso a vários buckets, forneça vários mapeamentos de bucket na lista storageDirectoryMappings.
    • Para configurar várias chaves públicas para um usuário, forneça várias credenciais na lista userCredentials.

    Método HTTP e URL: 

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

    Corpo JSON da solicitação:

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

    Para enviar a solicitação, expanda uma destas opções:

    A resposta identifica uma operação de longa duração. A criação do usuário leva alguns segundos.

  2. Informe ao usuário os seguintes dados, que são necessários para se conectar ao servidor:

    • O nome de usuário do SFTP.

    • A configuração de acesso do servidor, que depende do tipo de servidor:

      • Para um servidor externo, o endereço IP do servidor.

      • Para um servidor interno, o URI do anexo de serviço do servidor.

      Para saber como acessar a configuração de acesso do servidor, consulte Receber detalhes sobre um servidor.

    • (Opcional) A impressão digital da chave do servidor.

Bibliotecas de cliente

C#

Para saber como instalar e usar a biblioteca de cliente do Cloud FTP, consulte Bibliotecas de cliente do Cloud FTP. Para mais informações, consulte a documentação de referência da API Cloud FTP C#.

Para se autenticar no Cloud FTP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

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

Para saber como instalar e usar a biblioteca de cliente do Cloud FTP, consulte Bibliotecas de cliente do Cloud FTP. Para mais informações, consulte a documentação de referência da API Cloud FTP Go.

Para autenticar no Cloud FTP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


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

Para saber como instalar e usar a biblioteca de cliente do Cloud FTP, consulte Bibliotecas de cliente do Cloud FTP. Para mais informações, consulte a documentação de referência da API Cloud FTP Java.

Para autenticar no Cloud FTP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

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

Para saber como instalar e usar a biblioteca de cliente do Cloud FTP, consulte Bibliotecas de cliente do Cloud FTP. Para mais informações, consulte a documentação de referência da API Cloud FTP Node.js.

Para se autenticar no Cloud FTP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

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

Para saber como instalar e usar a biblioteca de cliente do Cloud FTP, consulte Bibliotecas de cliente do Cloud FTP. Para mais informações, consulte a documentação de referência da API Cloud FTP PHP.

Para autenticar no Cloud FTP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

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

Para saber como instalar e usar a biblioteca de cliente do Cloud FTP, consulte Bibliotecas de cliente do Cloud FTP. Para mais informações, consulte a documentação de referência da API Cloud FTP Python.

Para autenticar no Cloud FTP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

# 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

Para saber como instalar e usar a biblioteca de cliente do Cloud FTP, consulte Bibliotecas de cliente do Cloud FTP. Para mais informações, consulte a documentação de referência da API Cloud FTP Ruby.

Para se autenticar no Cloud FTP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

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

A seguir