Creare un server SFTP interno

Questo documento mostra come creare un server SFTP interno utilizzando Cloud FTP. Un server SFTP interno è accessibile solo all'interno della tua rete Virtual Private Cloud (VPC) utilizzando Private Service Connect. I dipendenti e gli stakeholder interni che fanno parte della tua rete possono utilizzare il server per trasferire in sicurezza i file da e verso Cloud Storage.

Specifica i progetti autorizzati a connettersi al server. Se vuoi, puoi specificare i progetti per i quali rifiutare la connessione.

Per informazioni di base sul VPC, consulta la panoramica di VPC.

Per i passaggi per creare un server esterno, accessibile tramite internet, consulta Crea un server SFTP esterno. Non puoi modificare la natura esterna o interna di un server dopo averlo creato.

Prima di iniziare

Console

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  2. If you're using an existing project for this guide, verify that you have the permissions required to complete this guide. If you created a new project, then you already have the required permissions.

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Cloud FTP API, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the API

  5. Raccogli le seguenti informazioni sugli utenti del tuo server:

    • Un elenco di ID progetto o numeri di progetto autorizzati ad accedere al server.
    • (Facoltativo) Un elenco di ID progetto o numeri di progetto a cui è stato rifiutato l'accesso al server.

gcloud

  1. Installa Google Cloud CLI.

  2. Configura gcloud CLI per utilizzare la tua identità federata.

    Per saperne di più, consulta Accedi a gcloud CLI con la tua identità federata.

  3. Per inizializzare gcloud CLI, esegui questo comando: 

    gcloud init

  4. Crea o seleziona un progetto Google Cloud .

    Ruoli richiesti per selezionare o creare un progetto

    • Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per cui ti è stato concesso un ruolo.
    • Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.

    • Crea un progetto Google Cloud :

      gcloud projects create PROJECT_ID

      Sostituisci PROJECT_ID con un nome per il progetto Google Cloud che stai creando.

    • Seleziona il progetto Google Cloud che hai creato:

      gcloud config set project PROJECT_ID

      Sostituisci PROJECT_ID con il nome del progetto Google Cloud .

  5. Se utilizzi un progetto esistente per questa guida, verifica di disporre delle autorizzazioni necessarie per completare la guida. Se hai creato un nuovo progetto, disponi già delle autorizzazioni necessarie.

  6. Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .

  7. Abilita l'API Cloud FTP, se non è già abilitata:

    Ruoli richiesti per abilitare le API

    Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente hai già questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli. 

    gcloud services enable ftp.googleapis.com

  8. Raccogli le seguenti informazioni sugli utenti del tuo server:

    • Un elenco di ID progetto o numeri di progetto autorizzati ad accedere al server.
    • (Facoltativo) Un elenco di ID progetto o numeri di progetto a cui è stato rifiutato l'accesso al server.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per creare un server SFTP, chiedi all'amministratore di concederti il ruolo IAM Cloud FTP Admin (roles/ftp.admin) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per creare un server SFTP. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare un server SFTP sono necessarie le seguenti autorizzazioni:

  • ftp.servers.create
  • Se utilizzi la console Google Cloud per eseguire questa attività:
    • ftp.servers.list
    • ftp.locations.list

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Crea un server interno

Console

  1. Nella console Google Cloud , vai alla pagina Cloud FTP.

    Vai a Cloud FTP

  2. Fai clic su Crea server.

  3. Nella scheda Configurazione server, inserisci i dettagli di base del server:

    1. Nel campo ID server, inserisci un ID univoco per il server.

    2. Nell'elenco Regione, seleziona la Google Cloud località per il server.

      Per velocità di trasferimento di dati più elevate, crea il server nella stessa località del bucket Cloud Storage in cui sono archiviati i tuoi dati. Se la località del bucket non è supportata da Cloud FTP, seleziona la località disponibile più vicina.

    3. (Facoltativo) Inserisci un nome visualizzato per il server.

    4. Fai clic su Continua.

  4. Nella scheda Networking e sicurezza, configura la connettività per il server:

    1. Seleziona Interno (solo VPC).

    2. Nella sezione Progetti accettati, specifica i progetti consumer che possono connettersi al server utilizzando Private Service Connect. Segui questi passaggi:

      1. Nel campo ID progetto o numero, inserisci l'ID progetto o il numero di un progetto autorizzato a connettersi. Ad esempio, example-allowed-project.

      2. Nel campo Limite di connessioni, inserisci il numero massimo di endpoint Private Service Connect che possono essere creati nel progetto consumer. Il valore deve essere compreso tra 1 e 250 endpoint.

      3. Per aggiungere altri progetti, fai clic su Aggiungi progetto accettato, quindi ripeti i passaggi precedenti.

    3. (Facoltativo) Per impedire ai progetti di connettersi al server, nella sezione Progetti rifiutati, fai clic su Aggiungi progetto rifiutato. Inserisci l'ID progetto o il numero di un progetto consumer a cui è vietato connettersi al server.

      Ai progetti in questo elenco viene rifiutato l'accesso al server anche se sono inclusi nell'elenco dei progetti consentiti.

  5. Fai clic su Crea.

    La creazione del server richiede circa 10 minuti.

gcloud

Per creare un server interno, esegui il comando gcloud alpha storage ftp servers create e fornisci il flag --access-type=INTERNAL.

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

  • SERVER_ID: un ID univoco per il server. Deve iniziare con una lettera minuscola e terminare con una lettera minuscola o un numero. Può contenere lettere minuscole, numeri e trattini. Non può iniziare con il prefisso goog o contenere la stringa google, incluse varianti ortografiche simili come g00gle. La lunghezza massima è di 30 caratteri.

  • LOCATION_ID: la Google Cloud località del server, ad esempio us-west1.

    Per velocità di trasferimento dei dati più elevate, crea il server nella stessa località del bucket Cloud Storage in cui sono archiviati i tuoi dati. Se la località del bucket non è supportata da Cloud FTP, seleziona la località disponibile più vicina.

  • PROJECT_TO_ALLOW: l'ID progetto o il numero di un progetto consumer autorizzato a connettersi al server utilizzando Private Service Connect. Ad esempio, example-allowed-project. Devi specificare almeno un progetto.

    Puoi consentire un massimo di 500 progetti. Fornisci più progetti e i relativi limiti di connessione in un elenco separato da virgole. Ad esempio, --consumer-accept-list=projectA=20,projectB=15.

  • CONNECTION_LIMIT: il numero massimo di endpoint Private Service Connect che è possibile creare nel progetto consumer. Il valore deve essere compreso tra 1 e 250 endpoint.

  • (Facoltativo) PROJECT_TO_REJECT: l'ID progetto o il numero di un progetto consumer a cui è vietato connettersi al server. Ad esempio, example-rejected-project. Ai progetti in questo elenco viene negato l'accesso al server anche se sono inclusi nell'elenco dei progetti consentiti.

    Puoi rifiutare un massimo di 64 progetti. Fornisci più progetti in un elenco separato da virgole.

    Se non vuoi rifiutare esplicitamente alcun progetto, ometti il flag --consumer-reject-list.

Esegui questo comando:

Linux, macOS o Cloud Shell

gcloud alpha storage ftp servers create SERVER_ID --access-type=INTERNAL \
    --location=LOCATION_ID \
    --consumer-accept-list=PROJECT_TO_ALLOW=CONNECTION_LIMIT \
    --consumer-reject-list=PROJECT_TO_REJECT

Windows (PowerShell)

gcloud alpha storage ftp servers create SERVER_ID --access-type=INTERNAL `
    --location=LOCATION_ID `
    --consumer-accept-list=PROJECT_TO_ALLOW=CONNECTION_LIMIT `
    --consumer-reject-list=PROJECT_TO_REJECT

Windows (cmd.exe)

gcloud alpha storage ftp servers create SERVER_ID --access-type=INTERNAL ^
    --location=LOCATION_ID ^
    --consumer-accept-list=PROJECT_TO_ALLOW=CONNECTION_LIMIT ^
    --consumer-reject-list=PROJECT_TO_REJECT

La creazione del server richiede circa 10 minuti.

REST

Per creare un server interno, utilizza il metodo servers.create e fornisci una configurazione di accesso internalConfig.

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

  • PROJECT_ID: l'ID progetto Google Cloud del server.

  • LOCATION_ID: la Google Cloud località del server, ad esempio us-west1.

    Per velocità di trasferimento dei dati più elevate, crea il server nella stessa località del bucket Cloud Storage in cui sono archiviati i tuoi dati. Se la località del bucket non è supportata da Cloud FTP, seleziona la località disponibile più vicina.

  • SERVER_ID: un ID univoco per il server. Deve iniziare con una lettera minuscola e terminare con una lettera minuscola o un numero. Può contenere lettere minuscole, numeri e trattini. Non può iniziare con il prefisso goog o contenere la stringa google, incluse varianti ortografiche simili come g00gle. La lunghezza massima è di 30 caratteri.

  • PROJECT_TO_ALLOW: l'ID progetto o il numero di un progetto consumer autorizzato a connettersi al server utilizzando Private Service Connect. Ad esempio, example-allowed-project. Devi specificare almeno un progetto.

    Puoi consentire un massimo di 500 progetti.

  • CONNECTION_LIMIT: il numero massimo di endpoint Private Service Connect che è possibile creare nel progetto consumer. Il valore deve essere compreso tra 1 e 250 endpoint.

  • (Facoltativo) PROJECT_TO_REJECT: l'ID progetto o il numero di un progetto consumer a cui è vietato connettersi al server. Ad esempio, example-rejected-project. Ai progetti in questo elenco viene negato l'accesso al server anche se sono inclusi nell'elenco dei progetti consentiti.

    Puoi rifiutare un massimo di 64 progetti.

    Se non vuoi rifiutare esplicitamente alcun progetto, ometti l'oggetto consumerRejectList.

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

{
  "accessType": "INTERNAL",
  "internalConfig": {
    "consumerAcceptList": [
      {
        "project": "projects/PROJECT_TO_ALLOW",
        "connectionLimit": CONNECTION_LIMIT
      }
    ],
    "consumerRejectList": [
      {
        "project": "projects/PROJECT_TO_REJECT"
      }
    ]
  }
}

Per inviare la richiesta, espandi una di queste opzioni:

La risposta identifica un'operazione a lunga esecuzione.

La creazione del server richiede circa 10 minuti.

Librerie client

Per creare un server interno, imposta il tipo di accesso su interno e fornisci una configurazione di accesso interno.

C#

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

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

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

public sealed partial class GeneratedCloudFtpClientSnippets
{
    /// <summary>Snippet for CreateServerAsync</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 CreateServerAsync()
    {
        // Create client
        CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
        // Initialize request argument(s)
        string parent = "projects/[PROJECT]/locations/[LOCATION]";
        Server server = new Server();
        string serverId = "";
        // Make the request
        Operation<Server, OperationMetadata> response = await cloudFtpClient.CreateServerAsync(parent, server, serverId);

        // Poll until the returned long-running operation is complete
        Operation<Server, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
        // Retrieve the operation result
        Server 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<Server, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceCreateServerAsync(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            Server retrievedResult = retrievedResponse.Result;
        }
    }
}

Go

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

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


//go:build examples

package main

import (
	"context"

	ftp "cloud.google.com/go/ftp/apiv1"
	ftppb "cloud.google.com/go/ftp/apiv1/ftppb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := ftp.NewCloudFtpRESTClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &ftppb.CreateServerRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/ftp/apiv1/ftppb#CreateServerRequest.
	}
	op, err := c.CreateServer(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Java

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

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

import com.google.api.core.ApiFuture;
import com.google.cloud.ftp.v1.CloudFtpClient;
import com.google.cloud.ftp.v1.CreateServerRequest;
import com.google.cloud.ftp.v1.LocationName;
import com.google.cloud.ftp.v1.Server;
import com.google.longrunning.Operation;

public class AsyncCreateServer {

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

  public static void asyncCreateServer() 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()) {
      CreateServerRequest request =
          CreateServerRequest.newBuilder()
              .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
              .setServerId("serverId1379103678")
              .setServer(Server.newBuilder().build())
              .setRequestId("requestId693933066")
              .build();
      ApiFuture<Operation> future = cloudFtpClient.createServerCallable().futureCall(request);
      // Do something.
      Operation response = future.get();
    }
  }
}

Node.js

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

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

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. Value for parent.
 */
// const parent = 'abc123'
/**
 *  Required. A unique ID for the server. Must start with a lowercase letter,
 *  and end with a lowercase letter or number. Can contain lowercase letters,
 *  numbers, and hyphens. Maximum length is 30 characters.
 */
// const serverId = 'abc123'
/**
 *  Required. The resource being created
 */
// const server = {}
/**
 *  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 callCreateServer() {
  // Construct request
  const request = {
    parent,
    serverId,
    server,
  };

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

callCreateServer();

PHP

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

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

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\Ftp\V1\Client\CloudFtpClient;
use Google\Cloud\Ftp\V1\CreateServerRequest;
use Google\Cloud\Ftp\V1\Server;
use Google\Cloud\Ftp\V1\Server\AccessType;
use Google\Rpc\Status;

/**
 * Creates a new Server in a given project and location.
 *
 * @param string $formattedParent  Value for parent. Please see
 *                                 {@see CloudFtpClient::locationName()} for help formatting this field.
 * @param string $serverId         A unique ID for the server. Must start with a lowercase letter,
 *                                 and end with a lowercase letter or number. Can contain lowercase letters,
 *                                 numbers, and hyphens. Maximum length is 30 characters.
 * @param int    $serverAccessType The access type of the Server.
 */
function create_server_sample(
    string $formattedParent,
    string $serverId,
    int $serverAccessType
): void {
    // Create a client.
    $cloudFtpClient = new CloudFtpClient();

    // Prepare the request message.
    $server = (new Server())
        ->setAccessType($serverAccessType);
    $request = (new CreateServerRequest())
        ->setParent($formattedParent)
        ->setServerId($serverId)
        ->setServer($server);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $cloudFtpClient->createServer($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            /** @var Server $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::locationName('[PROJECT]', '[LOCATION]');
    $serverId = '[SERVER_ID]';
    $serverAccessType = AccessType::ACCESS_TYPE_UNSPECIFIED;

    create_server_sample($formattedParent, $serverId, $serverAccessType);
}

Python

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

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

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import ftp_v1


def sample_create_server():
    # Create a client
    client = ftp_v1.CloudFtpClient()

    # Initialize request argument(s)
    server = ftp_v1.Server()
    server.access_type = "INTERNAL"

    request = ftp_v1.CreateServerRequest(
        parent="parent_value",
        server_id="server_id_value",
        server=server,
    )

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

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

    response = operation.result()

    # Handle the response
    print(response)

Ruby

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

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

require "google/cloud/ftp/v1"

##
# Snippet for the create_server 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_server.
#
def create_server
  # 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::CreateServerRequest.new

  # Call the create_server method.
  result = client.create_server request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

Passaggi successivi