Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Cómo agregar usuarios a un servidor SFTP

En este documento, se muestra cómo agregar usuarios a un servidor de Cloud FTP. Los usuarios, como los socios externos y las partes interesadas internas, pueden usar el servidor para transferir archivos de forma segura hacia y desde Cloud Storage.

En general, estos son los pasos para agregar un usuario a un servidor SFTP:

Configura los permisos para el usuario.
Crea un usuario de SFTP y asigna sus directorios a buckets de Cloud Storage.

Si quieres conocer los pasos para crear un servidor, consulta Cómo crear un servidor SFTP externo y Cómo crear un servidor SFTP interno.

Consideraciones

Puedes otorgar acceso a un usuario a un máximo de 10 buckets.
Un usuario puede tener un máximo de 10 claves públicas.

Antes de comenzar

Crea uno o más buckets de Cloud Storage para almacenar los datos con los que trabajará el usuario, si los buckets aún no existen.
Obtén la clave pública del usuario de cada par de claves SSH que usará para conectarse al servidor.

Si el usuario no tiene un par de claves SSH, sigue estos pasos para generar uno.
Genera un par de llaves SSH

¿Qué formato de clave necesitas?

El formato de clave que necesitas depende del cliente que uses para conectarte al servidor SFTP. Para obtener más información, consulta Clientes de SFTP compatibles.
Formato PEM

Para crear un par de claves de OpenSSH (formato PEM), usa la utilidad ssh-keygen.

En la máquina cliente que se conectará al servidor SFTP, ejecuta el siguiente comando:

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

Reemplaza KEY_PAIR_NAME por un nombre para el par de claves, como sftp_user_key.

Extrae la clave pública:

cat ~/.ssh/KEY_PAIR_NAME.pub
Formato PPK

Para crear un par de claves de PuTTY (formato PPK), usa la herramienta PuTTYgen.

En la máquina cliente que se conectará al servidor SFTP, ejecuta el siguiente comando:

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

Reemplaza KEY_PAIR_NAME por un nombre para el par de claves, como sftp_user_key.

Extrae la clave pública:

puttygen -L KEY_PAIR_NAME.ppk

Roles obligatorios

Para obtener el permiso que necesitas para agregar usuarios de SFTP, pídele a tu administrador que te otorgue el rol de IAM de administrador de FTP (roles/ftp.admin) en tu proyecto. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene el permiso ftp.users.create, que se requiere para agregar usuarios de SFTP.

También puedes obtener este permiso con roles personalizados o con otros roles predefinidos.

Cómo configurar los permisos de un usuario

Instala Google Cloud CLI y, luego, accede a gcloud CLI con tu identidad federada. Después de acceder, inicializa Google Cloud CLI con el siguiente comando:
```
gcloud init
```
Configura el proyecto:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el ID del proyecto que contiene el servidor SFTP.
Crea una cuenta de servicio para el usuario si aún no existe. La cuenta de servicio accede a los recursos de Cloud Storage en nombre del usuario.
```
gcloud iam service-accounts create USERNAME-sa \
    --description="USERNAME SFTP Service Account" \
    --display-name="USERNAME SFTP Service Account"
```
Reemplaza USERNAME por un nombre de usuario único para el usuario de SFTP. El nombre de usuario debe comenzar con una letra minúscula y puede incluir letras minúsculas, números o guiones. La longitud máxima es de 32 caracteres.

Si la operación se realiza de forma correcta, se muestra un mensaje como Created service account [example-userid-sa].
Otorga roles de IAM al administrador que crea el usuario de SFTP:
1. Otórgate el rol de usuario de cuenta de servicio (roles/iam.serviceAccountUser):
```
gcloud iam service-accounts add-iam-policy-binding USERNAME-sa@PROJECT_ID. \
    --member="user:ADMINISTRATOR_EMAIL" \
    --role="roles/iam.serviceAccountUser"
```
  Reemplaza ADMINISTRATOR_EMAIL por la dirección de correo electrónico del principal que crea el usuario de SFTP. Si creas el usuario (en lugar de una aplicación), este valor es la dirección de correo electrónico que usas para acceder a Google Cloud.
  
  Si la operación se realiza correctamente, se mostrará un mensaje como el siguiente:
```
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. Otórgate el rol de visualizador de buckets de almacenamiento (roles/storage.bucketViewer) en el bucket:
```
gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="user:ADMINISTRATOR_EMAIL" \
    --role="roles/storage.bucketViewer"
```
  Reemplaza BUCKET_NAME por el nombre del depósito:
  
  Repite este paso para cada bucket al que el usuario deba acceder.
3. Otórgate el rol de Visualizador de objetos de Storage (roles/storage.objectViewer) en el bucket:
```
gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="user:ADMINISTRATOR_EMAIL" \
    --role="roles/storage.objectViewer"
```
  Repite este paso para cada bucket al que el usuario necesite acceder.
Otorga a la cuenta de servicio del usuario el rol de IAM necesario para acceder al bucket:
```
gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="serviceAccount:USERNAME-sa@PROJECT_ID." \
    --role="ROLE"
```
Reemplaza ROLE por uno de los siguientes roles de IAM:
- Para el acceso de solo lectura, usa el rol roles/storage.objectViewer.
- Para obtener acceso de lectura y escritura, usa el rol roles/storage.objectAdmin.
Repite este paso para cada bucket al que el usuario deba acceder.
Autoriza al agente de servicio de Cloud FTP a generar tokens para la cuenta de servicio del usuario:
1. Obtén la dirección de correo electrónico del agente de servicio del servidor. Para conocer los pasos, consulta Obtén detalles sobre un servidor.
2. Autoriza al agente de servicio de Cloud FTP:
```
gcloud iam service-accounts add-iam-policy-binding USERNAME-sa@PROJECT_ID. \
    --member="serviceAccount:SERVICE_AGENT_EMAIL" \
    --role="roles/iam.serviceAccountTokenCreator"
```
  Reemplaza SERVICE_AGENT_EMAIL por la dirección de correo electrónico del agente de servicio.

A continuación, crea un usuario.

Crea un usuario del servidor SFTP

Después de configurar los permisos para un usuario, crea el usuario y asigna sus directorios a uno o más buckets de Cloud Storage.

gcloud

Para crear un usuario para un servidor SFTP, ejecuta el comando gcloud alpha storage ftp users create.

Antes de usar cualquiera de los datos de comando a continuación, haz los siguientes reemplazos:
- CREDENTIAL_NAME: Es un nombre único para identificar las credenciales del usuario.
- SSH_PUBLIC_KEY: Es el cuerpo de la clave pública SSH del usuario, en formato OpenSSH. Por ejemplo: ssh-rsa AAAAB3NzaC1ycRexample...
- USERNAME: Es el nombre de usuario del usuario de SFTP.
- SERVICE_ACCOUNT: La cuenta de servicio del usuario. Por ejemplo, username-sa@example-project..
- LOCATION_ID: Es la ubicación del servidor, como us-west1.
- SERVER_ID: Es el ID del servidor.
- BUCKET_NAME: Es el nombre de un bucket al que se le otorga acceso al usuario de SFTP, como example-bucket. Omite el gs://.
- (Opcional) BUCKET_PREFIX: Es la ruta de acceso a una carpeta dentro del bucket que se establecerá como el directorio raíz para esta asignación de directorio. Si omites la propiedad bucket_prefix, Cloud FTP usa la raíz del bucket.
- DIRECTORY: Es la ruta de acceso lógica del directorio de destino que se presenta al usuario de SFTP. Por ejemplo, /home/uploads
  
  Si asignas varios buckets o carpetas, proporciona una ruta de acceso de directorio única para cada asignación.
  
  No se admiten los directorios lógicos anidados. Si proporcionas varias asignaciones para un directorio, proporciona los directorios en una estructura plana en lugar de una estructura anidada. Por ejemplo, usa /dir1 y /dir2 en lugar de /dir1 y /dir1/dir2.
- SFTP_PERMISSION: Es el nivel de acceso del directorio. Para el acceso de solo lectura, establece este valor en READ_ONLY. Para obtener acceso de lectura y escritura, establece este valor en READ_WRITE.
Ten en cuenta lo siguiente:
- Para otorgar acceso a un usuario a varios buckets, proporciona la marca --storage-directory-mapping varias veces, con una asignación de directorio para cada bucket.
- Para configurar varias claves públicas para un usuario, proporciona varias credenciales en el archivo credentials.json.
Guarda el siguiente código en un archivo llamado credentials.json.
```
[
  {
    "credentialName": "CREDENTIAL_NAME",
    "credentialType": "PUBLIC_KEY",
    "sshPublicKeyBody": "SSH_PUBLIC_KEY"
  }
]
```
Ejecuta el siguiente comando:
Linux, macOS o Cloud Shell

Nota: Asegúrate de haber inicializado Google Cloud CLI con autenticación y un proyecto mediante la ejecución de gcloud init o gcloud auth login y gcloud config set project.
```
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)

Nota: Asegúrate de haber inicializado Google Cloud CLI con autenticación y un proyecto mediante la ejecución de gcloud init o gcloud auth login y gcloud config set project.
```
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)

Nota: Asegúrate de haber inicializado Google Cloud CLI con autenticación y un proyecto mediante la ejecución de gcloud init, o gcloud auth login y gcloud config set project.
```
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 creación del usuario tarda unos segundos.
Proporciona al usuario la siguiente información, que necesita para conectarse al servidor:
- Es el nombre de usuario de SFTP del usuario.
- La configuración de acceso del servidor, que depende del tipo de servidor:
  - En el caso de un servidor externo, es la dirección IP del servidor.
  - Para un servidor interno, el URI del adjunto de servicio del servidor.
  Para conocer los pasos para obtener la configuración de acceso del servidor, consulta Obtén detalles sobre un servidor.
- Es la huella digital de la clave del servidor (opcional).

REST

Para crear un usuario para un servidor SFTP, usa el método servers.users.create.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:
- PROJECT_ID: Es el ID del proyecto de Google Cloud del servidor.
- LOCATION_ID: La ubicación del servidor, como us-west1.
- SERVER_ID: Es el ID del servidor.
- USERNAME: Es el nombre de usuario del usuario de SFTP.
- BUCKET_NAME: Es el nombre de un bucket al que se le otorga acceso al usuario de SFTP, como example-bucket. Omite el gs://.
- BUCKET_PREFIX (opcional): Es la ruta de acceso de una carpeta dentro del bucket que se establecerá como el directorio raíz para esta asignación de directorio. Si omites este valor, Cloud FTP usa la raíz del bucket.
- DIRECTORY: Es la ruta de acceso lógica al directorio de destino que se presenta al usuario de SFTP. Por ejemplo, /home/uploads Si omites este valor, Cloud FTP establece el directorio de destino en /.
  
  Si asignas varios buckets o carpetas, proporciona una ruta de acceso de directorio única para cada asignación.
  
  No se admiten los directorios lógicos anidados. Si proporcionas varias asignaciones para un directorio, proporciona los directorios en una estructura plana en lugar de una estructura anidada. Por ejemplo, usa /dir1 y /dir2 en lugar de /dir1 y /dir1/dir2.
- SFTP_PERMISSION: Es el nivel de acceso del directorio. Para el acceso de solo lectura, establece este valor en READ_ONLY. Para obtener acceso de lectura y escritura, establece este valor en READ_WRITE.
- SERVICE_ACCOUNT: Es la cuenta de servicio del usuario. Por ejemplo, username-sa@example-project..
- CREDENTIAL_NAME: Es un nombre único para identificar las credenciales del usuario.
- SSH_PUBLIC_KEY: Es el cuerpo de la clave pública SSH del usuario, en formato OpenSSH. Por ejemplo: ssh-rsa AAAAB3NzaC1ycRexample...
Ten en cuenta lo siguiente:
- Para otorgar acceso a un usuario a varios buckets, proporciona varias asignaciones de bucket en la lista storageDirectoryMappings.
- Para configurar varias claves públicas para un usuario, proporciona varias credenciales en la lista userCredentials.
Método HTTP y URL:
```
POST https://ftp.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/servers/SERVER_ID/users?userId=USERNAME
```
Cuerpo JSON de la solicitud:
```
{
  "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 tu solicitud, expande una de estas opciones:
curl (Linux, macOS o Cloud Shell)

Nota: Con el siguiente comando, se supone que accediste a gcloud CLI con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login , o a través del uso de Cloud Shell, que accede de forma automática a gcloud CLI . Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://ftp.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/servers/SERVER_ID/users?userId=USERNAME"
```
PowerShell (Windows)

Nota: El siguiente comando supone que accediste a gcloud CLI con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login . Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://ftp.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/servers/SERVER_ID/users?userId=USERNAME" | Select-Object -Expand Content
```
La respuesta identifica una operación de larga duración. La creación del usuario tarda unos segundos.
Proporciona al usuario la siguiente información, que necesita para conectarse al servidor:
- Es el nombre de usuario de SFTP del usuario.
- La configuración de acceso del servidor, que depende del tipo de servidor:
  - En el caso de un servidor externo, es la dirección IP del servidor.
  - Para un servidor interno, el URI del adjunto de servicio del servidor.
  Para conocer los pasos para obtener la configuración de acceso del servidor, consulta Obtén detalles sobre un servidor.
- Es la huella digital de la clave del servidor (opcional).

Bibliotecas cliente

C#

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Cloud FTP, consulta las bibliotecas cliente de Cloud FTP. Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud FTP para C#.

Para autenticarte en Cloud FTP, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 obtener información sobre cómo instalar y usar la biblioteca cliente de Cloud FTP, consulta las bibliotecas cliente de Cloud FTP. Para obtener más información, consulta la documentación de referencia de la API de Cloud FTP para Go.

Para autenticarte en Cloud FTP, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 autenticarte en Cloud FTP, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 autenticarte en Cloud FTP, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 autenticarte en Cloud FTP, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 autenticarte en Cloud FTP, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 autenticarte en Cloud FTP, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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

¿Qué sigue?

Conéctate a un servidor SFTP externo.
Conéctate a un servidor SFTP interno.
Transfiere datos con comandos de SFTP.
Obtén información sobre las opciones de protección, copia de seguridad y recuperación de datos para los buckets de Cloud Storage.

Cómo agregar usuarios a un servidor SFTP Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Consideraciones

Antes de comenzar

Genera un par de llaves SSH

¿Qué formato de clave necesitas?

Formato PEM

Formato PPK

Roles obligatorios

Cómo configurar los permisos de un usuario

Crea un usuario del servidor SFTP

gcloud

Linux, macOS o Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Bibliotecas cliente

C#

Go

Java

Node.js

PHP

Python

Ruby

¿Qué sigue?

Cómo agregar usuarios a un servidor SFTP