Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Nutzer einem SFTP-Server hinzufügen

In diesem Dokument wird beschrieben, wie Sie einem Cloud FTP-Server Nutzer hinzufügen. Nutzer wie externe Partner und interne Stakeholder können den Server verwenden, um Dateien sicher in Cloud Storage zu übertragen und aus Cloud Storage herunterzuladen.

Auf übergeordneter Ebene sind folgende Schritte erforderlich, um einem SFTP-Server einen Nutzer hinzuzufügen:

Konfigurieren Sie die Berechtigungen für den Nutzer.
Erstellen Sie einen SFTP-Nutzer und ordnen Sie seine Verzeichnisse Cloud Storage-Buckets zu.

Eine Anleitung zum Erstellen eines Servers finden Sie unter Externen SFTP-Server erstellen und Internen SFTP-Server erstellen.

Hinweise

Sie können einem Nutzer Zugriff auf maximal 10 Buckets gewähren.
Ein Nutzer kann maximal 10 öffentliche Schlüssel haben.

Hinweis

Erstellen Sie einen oder mehrere Cloud Storage-Buckets zum Speichern der Daten, mit denen der Nutzer arbeiten wird, falls die Buckets noch nicht vorhanden sind.
Rufen Sie den öffentlichen Schlüssel des Nutzers aus jedem SSH-Schlüsselpaar ab, das er für die Verbindung zum Server verwenden wird.

Wenn der Nutzer kein SSH-Schlüsselpaar hat, können Sie mit den folgenden Schritten eines generieren.
SSH-Schlüsselpaar generieren

Welches Schlüsselformat benötigen Sie?

Das erforderliche Schlüsselformat hängt davon ab, welchen Client Sie für die Verbindung zum SFTP-Server verwenden. Weitere Informationen finden Sie unter Unterstützte SFTP-Clients.
PEM-Format

Verwenden Sie zum Erstellen eines OpenSSH-Schlüsselpaars (PEM-Format) das Dienstprogramm ssh-keygen.

Führen Sie auf dem Clientcomputer, der eine Verbindung zum SFTP-Server herstellen soll, den folgenden Befehl aus:

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

Ersetzen Sie KEY_PAIR_NAME durch einen Namen für das Schlüsselpaar, z. B. sftp_user_key.

Extrahieren Sie den öffentlichen Schlüssel:

cat ~/.ssh/KEY_PAIR_NAME.pub
PPK-Format

Verwenden Sie zum Erstellen eines PuTTY-Schlüsselpaars (PPK-Format) das Tool PuTTYgen.

Führen Sie auf dem Clientcomputer, der eine Verbindung zum SFTP-Server herstellen soll, den folgenden Befehl aus:

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

Ersetzen Sie KEY_PAIR_NAME durch einen Namen für das Schlüsselpaar, z. B. sftp_user_key.

Extrahieren Sie den öffentlichen Schlüssel:

puttygen -L KEY_PAIR_NAME.ppk

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle FTP-Administrator (roles/ftp.admin) für Ihr Projekt zuzuweisen, um die Berechtigung zu erhalten, die Sie zum Hinzufügen von SFTP-Nutzern benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierte Rolle enthält die Berechtigung ftp.users.create, die zum Hinzufügen von SFTP-Nutzern erforderlich ist.

Sie können diese Berechtigung auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Berechtigungen für einen Nutzer konfigurieren

Installieren Sie die Google Cloud CLI. Initialisieren Sie die Google Cloud CLI nach der Installation mit dem folgenden Befehl:
```
gcloud init
```
Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

Hinweis: Sie können die gcloud CLI in der Google Cloud Console ausführen, ohne die Google Cloud CLI zu installieren. Wenn Sie die gcloud CLI in der Google Cloud Console ausführen möchten, verwenden Sie Cloud Shell.
Projekt festlegen:
```
gcloud config set project PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch die ID des Projekts, das den SFTP-Server enthält.
Erstellen Sie ein Dienstkonto für den Nutzer, falls noch keines vorhanden ist. Das Dienstkonto greift im Namen des Nutzers auf Cloud Storage-Ressourcen zu.
```
gcloud iam service-accounts create USERNAME-sa \
    --description="USERNAME SFTP Service Account" \
    --display-name="USERNAME SFTP Service Account"
```
Ersetzen Sie USERNAME durch einen eindeutigen Nutzernamen für den SFTP-Nutzer. Der Nutzername muss mit einem Kleinbuchstaben beginnen und darf Kleinbuchstaben, Ziffern oder Bindestriche enthalten. Die maximale Länge beträgt 32 Zeichen.

Bei Erfolg wird eine Meldung wie Created service account [example-userid-sa] angezeigt.
Weisen Sie dem Administrator, der den SFTP-Nutzer erstellt, IAM-Rollen zu:
1. Weisen Sie sich selbst die Rolle „Dienstkontonutzer“ (roles/iam.serviceAccountUser) zu:
```
gcloud iam service-accounts add-iam-policy-binding USERNAME-sa@PROJECT_ID.iam.gserviceaccount.com \
    --member="user:ADMINISTRATOR_EMAIL" \
    --role="roles/iam.serviceAccountUser"
```
  Ersetzen Sie ADMINISTRATOR_EMAIL durch die E-Mail-Adresse des Hauptkontos, das den SFTP-Nutzer erstellt. Wenn Sie den Nutzer erstellen (im Gegensatz zu einer Anwendung), ist dieser Wert die E-Mail-Adresse, die Sie für den Zugriff auf Google Cloudverwenden.
  
  Bei Erfolg wird eine Meldung wie die folgende angezeigt:
```
Updated IAM policy for serviceAccount [example-userid-sa@example-project.iam.gserviceaccount.com].
bindings:
- members:
- user:admin@example.com
role: roles/iam.serviceAccountUser
etag: BwZJk7OiSzw=
version: 1
```
2. Weisen Sie sich selbst die Rolle „Storage Bucket Viewer“ (roles/storage.bucketViewer) für den Bucket zu:
```
gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="user:ADMINISTRATOR_EMAIL" \
    --role="roles/storage.bucketViewer"
```
  Ersetzen Sie BUCKET_NAME durch den Namen des Buckets:
  
  Wiederholen Sie diesen Schritt für jeden Bucket, auf den der Nutzer zugreifen muss.
3. Weisen Sie sich selbst die Rolle „Storage-Objekt-Betrachter“ (roles/storage.objectViewer) für den Bucket zu:
```
gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="user:ADMINISTRATOR_EMAIL" \
    --role="roles/storage.objectViewer"
```
  Wiederholen Sie diesen Schritt für jeden Bucket, auf den der Nutzer zugreifen muss.
Weisen Sie dem Dienstkonto des Nutzers die IAM-Rolle zu, die für den Zugriff auf den Bucket erforderlich ist:
```
gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="serviceAccount:USERNAME-sa@PROJECT_ID.iam.gserviceaccount.com" \
    --role="ROLE"
```
Ersetzen Sie ROLE durch eine der folgenden IAM-Rollen:
- Verwenden Sie für den Lesezugriff die Rolle roles/storage.objectViewer.
- Verwenden Sie für Lese- und Schreibzugriff die Rolle roles/storage.objectAdmin.
Wiederholen Sie diesen Schritt für jeden Bucket, auf den der Nutzer zugreifen muss.
Autorisieren Sie den Cloud FTP-Dienst-Agent, Tokens für das Dienstkonto des Nutzers zu generieren:
1. Rufen Sie die E‑Mail-Adresse des Dienst-Agents des Servers ab. Eine Anleitung finden Sie unter Details zu einem Server abrufen.
2. Autorisieren Sie den Cloud FTP-Dienst-Agent:
```
gcloud iam service-accounts add-iam-policy-binding USERNAME-sa@PROJECT_ID.iam.gserviceaccount.com \
    --member="serviceAccount:SERVICE_AGENT_EMAIL" \
    --role="roles/iam.serviceAccountTokenCreator"
```
  Ersetzen Sie SERVICE_AGENT_EMAIL durch die E-Mail-Adresse des Dienst-Agents.

Erstellen Sie als Nächstes einen Nutzer.

SFTP-Servernutzer erstellen

Nachdem Sie die Berechtigungen für einen Nutzer konfiguriert haben, erstellen Sie den Nutzer und ordnen seine Verzeichnisse einem oder mehreren Cloud Storage-Buckets zu.

gcloud

Führen Sie den Befehl gcloud alpha storage ftp users create aus, um einen Nutzer für einen SFTP-Server zu erstellen.

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:
- CREDENTIAL_NAME: Ein eindeutiger Name zur Identifizierung der Nutzeranmeldedaten.
- SSH_PUBLIC_KEY: der Text des öffentlichen SSH-Schlüssels des Nutzers im OpenSSH-Format. Beispiel: ssh-rsa AAAAB3NzaC1ycRexample....
- USERNAME: Der Nutzername des SFTP-Nutzers.
- SERVICE_ACCOUNT: das Dienstkonto des Nutzers. Beispiel: username-sa@example-project.iam.gserviceaccount.com.
- LOCATION_ID: der Standort des Servers, z. B. us-west1.
- SERVER_ID: die Server-ID.
- BUCKET_NAME: Der Name eines Buckets, auf den der SFTP-Nutzer Zugriff hat, z. B. example-bucket. Lassen Sie die gs:// weg.
- (Optional) BUCKET_PREFIX: Der Pfad eines Ordners im Bucket, der als Stammverzeichnis für diese Verzeichniszuordnung festgelegt werden soll. Wenn Sie das Attribut bucket_prefix weglassen, verwendet Cloud FTP das Bucket-Stammverzeichnis.
- DIRECTORY: der logische Pfad des Landing-Verzeichnisses, der dem SFTP-Nutzer angezeigt wird. Beispiel: /home/uploads.
  
  Wenn Sie mehrere Buckets oder Ordner zuordnen, geben Sie für jede Zuordnung einen eindeutigen Verzeichnispfad an.
  
  Verschachtelte logische Verzeichnisse werden nicht unterstützt. Wenn Sie mehrere Zuordnungen für ein Verzeichnis angeben, sollten Sie die Verzeichnisse in einer flachen Struktur anstelle einer verschachtelten Struktur angeben. Verwenden Sie beispielsweise /dir1 und /dir2 anstelle von /dir1 und /dir1/dir2.
- SFTP_PERMISSION: die Zugriffsebene für das Verzeichnis. Legen Sie für den Lesezugriff den Wert READ_ONLY fest. Legen Sie diesen Wert für Lese- und Schreibzugriff auf READ_WRITE fest.
Wichtige Hinweise:
- Wenn Sie einem Nutzer Zugriff auf mehrere Buckets gewähren möchten, geben Sie das Flag --storage-directory-mapping mehrmals an, mit einer Verzeichniszuordnung für jeden Bucket.
- Wenn Sie mehrere öffentliche Schlüssel für einen Nutzer konfigurieren möchten, geben Sie mehrere Anmeldedaten in der Datei credentials.json an.
Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen credentials.json:
```
[
  {
    "credentialName": "CREDENTIAL_NAME",
    "credentialType": "PUBLIC_KEY",
    "sshPublicKeyBody": "SSH_PUBLIC_KEY"
  }
]
```
Führen Sie folgenden Befehl aus:
Linux, macOS oder Cloud Shell

Hinweis: Prüfen Sie, ob die Google Cloud CLI mit Authentifizierung und einem Projekt initialisiert wurde. Führen Sie dazu gcloud init oder gcloud auth login und gcloud config set project aus.
```
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)

Hinweis: Prüfen Sie, ob die Google Cloud CLI mit Authentifizierung und einem Projekt initialisiert wurde. Führen Sie dazu gcloud init oder gcloud auth login und gcloud config set project aus.
```
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)

Hinweis: Prüfen Sie, ob die Google Cloud CLI mit Authentifizierung und einem Projekt initialisiert wurde. Führen Sie dazu gcloud init oder gcloud auth login und gcloud config set project aus.
```
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
```
Es dauert einige Sekunden, bis der Nutzer erstellt ist.
Geben Sie dem Nutzer die folgenden Informationen, die er für die Verbindung zum Server benötigt:
- Der SFTP-Nutzername des Nutzers.
- Die Zugriffskonfiguration des Servers, die vom Servertyp abhängt:
  - Bei einem externen Server die IP-Adresse des Servers.
  - Für einen internen Server der URI des Dienstanhangs des Servers.
  Eine Anleitung zum Abrufen der Zugriffskonfiguration des Servers finden Sie unter Details zu einem Server abrufen.
- (Optional) Der Schlüssel-Fingerabdruck des Servers.

REST

Verwenden Sie die Methode servers.users.create, um einen Nutzer für einen SFTP-Server zu erstellen.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:
- PROJECT_ID: die Google Cloud -Projekt-ID des Servers.
- LOCATION_ID: der Standort des Servers, z. B. us-west1.
- SERVER_ID: die Server-ID.
- USERNAME: Der Nutzername des SFTP-Nutzers.
- BUCKET_NAME: Der Name eines Buckets, auf den der SFTP-Nutzer Zugriff hat, z. B. example-bucket. Lassen Sie gs:// weg.
- (Optional) BUCKET_PREFIX: der Pfad eines Ordners im Bucket, der als Stammverzeichnis für diese Verzeichniszuordnung festgelegt werden soll. Wenn Sie diesen Wert weglassen, verwendet Cloud FTP das Bucket-Stammverzeichnis.
- DIRECTORY: der logische Pfad des Landing-Verzeichnisses, der dem SFTP-Nutzer angezeigt wird. Beispiel: /home/uploads. Wenn Sie diesen Wert weglassen, legt Cloud FTP das Landing Directory auf / fest.
  
  Wenn Sie mehrere Buckets oder Ordner zuordnen, geben Sie für jede Zuordnung einen eindeutigen Verzeichnispfad an.
  
  Verschachtelte logische Verzeichnisse werden nicht unterstützt. Wenn Sie mehrere Zuordnungen für ein Verzeichnis angeben, sollten Sie die Verzeichnisse in einer flachen Struktur anstelle einer verschachtelten Struktur angeben. Verwenden Sie beispielsweise /dir1 und /dir2 anstelle von /dir1 und /dir1/dir2.
- SFTP_PERMISSION: die Zugriffsebene für das Verzeichnis. Legen Sie für den Lesezugriff den Wert READ_ONLY fest. Für Lese- und Schreibzugriff legen Sie diesen Wert auf READ_WRITE fest.
- SERVICE_ACCOUNT: das Dienstkonto des Nutzers. Beispiel: username-sa@example-project.iam.gserviceaccount.com.
- CREDENTIAL_NAME: Ein eindeutiger Name zur Identifizierung der Nutzeranmeldedaten.
- SSH_PUBLIC_KEY: der Text des öffentlichen SSH-Schlüssels des Nutzers im OpenSSH-Format. Beispiel: ssh-rsa AAAAB3NzaC1ycRexample....
Wichtige Hinweise:
- Wenn Sie einem Nutzer Zugriff auf mehrere Buckets gewähren möchten, geben Sie mehrere Bucket-Zuordnungen in der Liste storageDirectoryMappings an.
- Wenn du mehrere öffentliche Schlüssel für einen Nutzer konfigurieren möchtest, gib mehrere Anmeldedaten in der Liste userCredentials an.
HTTP-Methode und URL:
```
POST https://ftp.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/servers/SERVER_ID/users?userId=USERNAME
```
JSON-Text anfordern:
```
{
  "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"
    }
  ]
}
```
Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:
curl (Linux, macOS oder Cloud Shell)

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto in der gcloud-Befehlszeile angemeldet haben, indem Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt haben, die Sie automatisch in der gcloud-Befehlszeile anmeldet. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:
```
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)

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto in der gcloud-Befehlszeile angemeldet haben, indem Sie gcloud init oder gcloud auth login ausgeführt haben. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:
```
$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
```
Die Antwort identifiziert einen Vorgang mit langer Ausführungszeit. Es dauert einige Sekunden, bis der Nutzer erstellt ist.
Geben Sie dem Nutzer die folgenden Informationen, die er für die Verbindung zum Server benötigt:
- Der SFTP-Nutzername des Nutzers.
- Die Zugriffskonfiguration des Servers, die vom Servertyp abhängt:
  - Bei einem externen Server die IP-Adresse des Servers.
  - Für einen internen Server der URI des Dienstanhangs des Servers.
  Eine Anleitung zum Abrufen der Zugriffskonfiguration des Servers finden Sie unter Details zu einem Server abrufen.
- (Optional) Der Schlüsselfingerabdruck des Servers.

Clientbibliotheken

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud FTP finden Sie unter Cloud FTP-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud FTP C# API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud FTP zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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


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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud FTP finden Sie unter Cloud FTP-Clientbibliotheken. Weitere Informationen finden Sie in der API-Referenzdokumentation zu Cloud FTP Java.

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

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

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

# 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

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

Nutzer einem SFTP-Server hinzufügen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Hinweise

Hinweis

SSH-Schlüsselpaar generieren

Welches Schlüsselformat benötigen Sie?

PEM-Format

PPK-Format

Erforderliche Rollen

Berechtigungen für einen Nutzer konfigurieren

SFTP-Servernutzer erstellen

gcloud

Linux, macOS oder Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)