Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Mettre à jour les buckets pour un utilisateur SFTP

Ce document explique comment mettre à jour les buckets Cloud Storage pour un utilisateur Cloud FTP, y compris les buckets auxquels un utilisateur peut accéder et les autorisations dont il dispose.

Voici les étapes à suivre pour mettre à jour les buckets d'un utilisateur :

Mettez à jour les rôles IAM du compte de service de l'utilisateur.
Mappez les répertoires de l'utilisateur aux buckets mis à jour.

Avant de commencer

Créez un ou plusieurs buckets Cloud Storage pour stocker les données avec lesquelles l'utilisateur travaillera, s'ils n'existent pas déjà. Vous pouvez accorder à un utilisateur l'accès à un maximum de 10 buckets.

Rôles requis

Pour obtenir l'autorisation dont vous avez besoin pour mettre à jour les utilisateurs SFTP, demandez à votre administrateur de vous attribuer le rôle IAM Administrateur FTP (roles/ftp.admin) sur votre projet. Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Ce rôle prédéfini contient l' ftp.users.update autorisation, qui est requise pour mettre à jour les utilisateurs SFTP.

Vous pouvez également obtenir cette autorisation avec des rôles personnalisés ou d'autres rôles prédéfinis.

Mettre à jour les rôles IAM pour le compte de service d'un utilisateur

Si vous modifiez les buckets auxquels un utilisateur peut accéder ou l'autorisation dont il dispose pour un mappage de répertoire existant, vous devez mettre à jour le compte de service de l'utilisateur avec les rôles IAM appropriés. Procédez comme suit :

Récupérez l'adresse e-mail du compte de service de l'utilisateur. Pour connaître la procédure à suivre, consultez Obtenir des informations sur un utilisateur.
Si vous ajoutez des buckets au mappage de répertoire ou si vous augmentez l'accès aux buckets existants, procédez comme suit :
1. Attribuez-vous le rôle Lecteur de buckets Storage (roles/storage.bucketViewer) sur le bucket, si vous ne l'avez pas déjà :
```
gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="user:ADMINISTRATOR_EMAIL" \
    --role="roles/storage.bucketViewer"
```
  Remplacez les éléments suivants :
  - ADMINISTRATOR_EMAIL: adresse e-mail du compte principal qui crée l'utilisateur SFTP. Si vous créez l' utilisateur (par opposition à une application), cette valeur correspond à l'adresse e-mail que vous utilisez pour accéder à Google Cloud.
  - BUCKET_NAME : nom du bucket.
2. Attribuez-vous le rôle Lecteur d'objets Storage (roles/storage.objectViewer) sur le bucket, si vous ne l'avez pas déjà :
```
gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="user:ADMINISTRATOR_EMAIL" \
    --role="roles/storage.objectViewer"
```
3. Attribuez au compte de service de l'utilisateur les rôles IAM nécessaires pour accéder aux buckets :
```
gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
  --member="serviceAccount:SERVICE_ACCOUNT" \
  --role="ROLE_TO_GRANT"
```
  Remplacez les éléments suivants :
  - SERVICE_ACCOUNT: adresse e-mail du compte de service de l'utilisateur.
  - ROLE_TO_GRANT: rôle IAM à attribuer. Spécifiez l'un des rôles suivants :
    - Pour un accès en lecture seule, utilisez le rôle roles/storage.objectViewer.
    - Pour un accès en lecture et en écriture, utilisez le rôle roles/storage.objectAdmin.
4. Répétez les étapes précédentes pour chaque bucket auquel l'utilisateur doit accéder.
Si vous supprimez des buckets du mappage de répertoire ou si vous réduisez l'accès aux buckets existants, révoquez l'accès du compte de service de l'utilisateur :
```
gcloud storage buckets remove-iam-policy-binding gs://BUCKET_NAME \
  --member="serviceAccount:SERVICE_ACCOUNT" \
  --role="ROLE_TO_REVOKE"
```
Remplacez ROLE_TO_REVOKE par le rôle IAM que vous souhaitez révoquer.

Répétez cette étape pour chaque bucket et rôle IAM auxquels l'utilisateur ne doit plus avoir accès.

Mettre à jour les buckets d'un utilisateur

gcloud

Pour mettre à jour les buckets d'un utilisateur SFTP, exécutez la gcloud alpha storage ftp users update commande.

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

USERNAME : nom d'utilisateur SFTP.
LOCATION_ID : emplacement du serveur, tel que us-west1.
SERVER_ID : ID du serveur.
BUCKET_NAME : nom d'un bucket auquel l'utilisateur SFTP a accès, tel que example-bucket. Omettez gs://.
(Facultatif) BUCKET_PREFIX : chemin d'accès d'un dossier dans le bucket à définir comme le répertoire racine pour ce mappage de répertoire. Si vous omettez la propriété bucket_prefix, Cloud FTP utilise la racine du bucket.
DIRECTORY : chemin d'accès logique du répertoire de destination présenté à l'utilisateur SFTP. Par exemple, /home/uploads.

Si vous mappez plusieurs buckets ou dossiers, fournissez un chemin d'accès de répertoire unique pour chaque mappage.

Les répertoires logiques imbriqués ne sont pas compatibles. Si vous fournissez plusieurs mappages pour un répertoire, fournissez les répertoires dans une structure plate plutôt qu'imbriquée. Par exemple, utilisez /dir1 et /dir2 au lieu de /dir1 et /dir1/dir2.
SFTP_PERMISSION : niveau d'accès au répertoire. Pour un accès en lecture seule, définissez cette valeur sur READ_ONLY. Pour un accès en lecture et en écriture, définissez cette valeur sur READ_WRITE.

Pour accorder à un utilisateur l'accès à plusieurs buckets, fournissez l'option --storage-directory-mapping plusieurs fois, avec un mappage de répertoire pour chaque bucket.

Exécutez la commande suivante :

Linux, macOS ou Cloud Shell

gcloud alpha storage ftp users update USERNAME --location=LOCATION_ID \
    --server=SERVER_ID \
    --storage-directory-mapping=bucket=BUCKET_NAME,bucket_prefix=BUCKET_PREFIX,directory=DIRECTORY,permission=SFTP_PERMISSION

Windows (PowerShell)

gcloud alpha storage ftp users update USERNAME --location=LOCATION_ID `
    --server=SERVER_ID `
    --storage-directory-mapping=bucket=BUCKET_NAME,bucket_prefix=BUCKET_PREFIX,directory=DIRECTORY,permission=SFTP_PERMISSION

Windows (cmd.exe)

gcloud alpha storage ftp users update USERNAME --location=LOCATION_ID ^
    --server=SERVER_ID ^
    --storage-directory-mapping=bucket=BUCKET_NAME,bucket_prefix=BUCKET_PREFIX,directory=DIRECTORY,permission=SFTP_PERMISSION

La mise à jour de l'utilisateur prend quelques secondes.

Si un utilisateur dispose d'une connexion SFTP active, il devra peut-être se déconnecter, puis se reconnecter pour que les paramètres de bucket mis à jour prennent effet.

REST

Pour mettre à jour les buckets d'un utilisateur SFTP, utilisez la servers.users.patch méthode. Dans le paramètre de requête updateMask, fournissez le champ storageDirectoryMappings.

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

PROJECT_ID : ID du Google Cloud projet du serveur.
LOCATION_ID : emplacement du serveur, tel que us-west1.
SERVER_ID : ID du serveur.
USERNAME : nom d'utilisateur SFTP.
BUCKET_NAME : nom d'un bucket auquel l'utilisateur SFTP a accès, tel que example-bucket. Omettez gs://.
(Facultatif) BUCKET_PREFIX : chemin d'accès d'un dossier dans le bucket à définir comme le répertoire racine pour ce mappage de répertoire. Si vous omettez cette valeur, Cloud FTP utilise la racine du bucket root.
DIRECTORY : chemin d'accès logique du répertoire de destination présenté à l'utilisateur SFTP. Par exemple, /home/uploads. Si vous omettez cette valeur, Cloud FTP définit le répertoire de destination sur /.

Si vous mappez plusieurs buckets ou dossiers, fournissez un chemin d'accès de répertoire unique pour chaque mappage.

Les répertoires logiques imbriqués ne sont pas compatibles. Si vous fournissez plusieurs mappages pour un répertoire, fournissez les répertoires dans une structure plate plutôt qu'imbriquée. Par exemple, utilisez /dir1 et /dir2 au lieu de /dir1 et /dir1/dir2.
SFTP_PERMISSION : niveau d'accès au répertoire. Pour un accès en lecture seule, définissez cette valeur sur READ_ONLY. Pour un accès en lecture et en écriture, définissez cette valeur sur READ_WRITE.

Pour accorder à un utilisateur l'accès à plusieurs buckets, fournissez plusieurs mappages de buckets dans la storageDirectoryMappings liste.

Méthode HTTP et URL :

PATCH https://ftp.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/servers/SERVER_ID/users/USERNAME?updateMask=storageDirectoryMappings

Corps JSON de la requête :

{
  "storageDirectoryMappings": [
    {
      "bucket": "BUCKET_NAME",
      "bucketPrefix": "BUCKET_PREFIX",
      "directory": "DIRECTORY",
      "permission": "SFTP_PERMISSION"
    }
  ]
}

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, et exécutez la commande suivante :

curl -X PATCH \
     -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/USERNAME?updateMask=storageDirectoryMappings"

PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, et exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method PATCH `
    -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/USERNAME?updateMask=storageDirectoryMappings" | Select-Object -Expand Content

La réponse identifie une opération de longue durée. La mise à jour de l'utilisateur prend quelques secondes.

Si un utilisateur dispose d'une connexion SFTP active, il devra peut-être se déconnecter, puis se reconnecter pour que les paramètres de bucket mis à jour prennent effet.

Bibliothèques clientes

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour Cloud FTP, consultez Bibliothèques clientes Cloud FTP. Pour en savoir plus, consultez la documentation de référence de l' API Cloud FTP C#.

Pour vous authentifier auprès de Cloud FTP, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

public sealed partial class GeneratedCloudFtpClientSnippets
{
    /// <summary>Snippet for UpdateUserAsync</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 UpdateUserAsync()
    {
        // Create client
        CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
        // Initialize request argument(s)
        User user = new User();
        FieldMask updateMask = new FieldMask();
        // Make the request
        Operation<User, OperationMetadata> response = await cloudFtpClient.UpdateUserAsync(user, updateMask);

        // 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.PollOnceUpdateUserAsync(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


//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.UpdateUserRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/ftp/apiv1/ftppb#UpdateUserRequest.
	}
	op, err := c.UpdateUser(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Java

import com.google.api.core.ApiFuture;
import com.google.cloud.ftp.v1.CloudFtpClient;
import com.google.cloud.ftp.v1.UpdateUserRequest;
import com.google.cloud.ftp.v1.User;
import com.google.longrunning.Operation;
import com.google.protobuf.FieldMask;

public class AsyncUpdateUser {

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

  public static void asyncUpdateUser() 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()) {
      UpdateUserRequest request =
          UpdateUserRequest.newBuilder()
              .setUpdateMask(FieldMask.newBuilder().build())
              .setUser(User.newBuilder().build())
              .build();
      ApiFuture<Operation> future = cloudFtpClient.updateUserCallable().futureCall(request);
      // Do something.
      Operation response = future.get();
    }
  }
}

Node.js

/**
 * 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.
 */
/**
 *  Optional. Field mask is used to specify the fields to be overwritten in the
 *  User resource by the update.
 *  The fields specified in the update_mask are relative to the resource, not
 *  the full request. A field will be overwritten if it is in the mask. If the
 *  user does not provide a mask then all fields present in the request will be
 *  overwritten.
 */
// const updateMask = {}
/**
 *  Required. The resource being updated
 */
// const user = {}

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

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

async function callUpdateUser() {
  // Construct request
  const request = {
    user,
  };

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

callUpdateUser();

PHP

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

/**
 * Updates the parameters of a single User.
 *
 * @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 update_user_sample(
    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 UpdateUserRequest())
        ->setUser($user);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $cloudFtpClient->updateUser($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
{
    $userCustomerServiceAccount = '[CUSTOMER_SERVICE_ACCOUNT]';
    $userUserCredentialsCredentialName = '[CREDENTIAL_NAME]';
    $userUserCredentialsCredentialType = Type::TYPE_UNSPECIFIED;
    $userStorageDirectoryMappingsBucket = '[BUCKET]';
    $userStorageDirectoryMappingsDirectory = '[DIRECTORY]';
    $userStorageDirectoryMappingsPermission = Permission::PERMISSION_UNSPECIFIED;

    update_user_sample(
        $userCustomerServiceAccount,
        $userUserCredentialsCredentialName,
        $userUserCredentialsCredentialType,
        $userStorageDirectoryMappingsBucket,
        $userStorageDirectoryMappingsDirectory,
        $userStorageDirectoryMappingsPermission
    );
}

Python

# 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_update_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.UpdateUserRequest(
        user=user,
    )

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

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

    response = operation.result()

    # Handle the response
    print(response)

Ruby

require "google/cloud/ftp/v1"

##
# Snippet for the update_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#update_user.
#
def update_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::UpdateUserRequest.new

  # Call the update_user method.
  result = client.update_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

Mettre à jour les buckets pour un utilisateur SFTP Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avant de commencer

Rôles requis

Mettre à jour les rôles IAM pour le compte de service d'un utilisateur

Mettre à jour les buckets d'un utilisateur

gcloud

Linux, macOS ou Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

REST

curl (Linux, macOS ou Cloud Shell)

PowerShell (Windows)

Bibliothèques clientes

C#

Go

Java

Node.js

PHP

Python

Ruby

Mettre à jour les buckets pour un utilisateur SFTP