Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Trasferire dati tra file system

Questa pagina mostra come trasferire dati tra due file system POSIX. I casi d'uso comuni includono:

Burst to cloud e HPC ibrido: trasferisci rapidamente set di dati di grandi dimensioni da on-premise al cloud per l'elaborazione.
Migrazione e sincronizzazione con Filestore: esegui la migrazione o la sincronizzazione dei dati da un file system on-premise a Filestore.
Trasferimento di file gestito: trasferisci dati in modo sicuro e affidabile tra data center o tra due file system nel cloud.

Linee guida per le prestazioni di trasferimento

Le seguenti linee guida possono aiutarti a massimizzare le prestazioni durante i trasferimenti da file system a file system.

Deployment dell'agente

In generale, ti consigliamo di utilizzare tre agenti in ciascuno dei pool di agenti di origine e di destinazione. Monitora il trasferimento e aggiungi altri agenti, se necessario. Ogni agente richiede 4 vCPU e 8 GiB di RAM.

Se esegui la migrazione a un'istanza Filestore, Filestore consiglia di utilizzare il tipo di istanza n2-standard-8 per ogni agente. Specifica nconnect=2 quando monti l'istanza su una VM Compute Engine. Per ulteriori informazioni su come ottimizzare e testare le prestazioni dell'istanza, consulta le linee guida per le prestazioni di Filestore.

Trasferimento di un numero elevato di file di piccole dimensioni

Per prestazioni migliori durante il trasferimento di un numero elevato di file di piccole dimensioni, ti consigliamo di suddividere i file in più directory ed evitare una singola directory con milioni di file.

Prima di iniziare

Prima di poter eseguire le attività descritte in questa pagina, completa i passaggi dei prerequisiti.

Crea pool di agenti e installa agenti

Per i trasferimenti da file system a file system, devi creare pool di agenti e agenti per i file system di origine e di destinazione. Gli agenti per il pool di agenti di origine devono essere installati su macchine o VM che hanno accesso al file system di origine. Gli agenti per il pool di agenti di destinazione devono essere installati su macchine o VM che hanno accesso al file system di destinazione.

Non includere informazioni sensibili come quelle che consentono l'identificazione personale (PII) oppure dati di sicurezza nel prefisso dell'ID agente o nel nome del pool di agenti. I nomi delle risorse potrebbero essere propagati ai nomi di altre risorse Google Cloud e potrebbero essere esposti a sistemi interni di Google al di fuori del tuo progetto.

Crea un pool di agenti di origine

Crea un pool di agenti di origine utilizzando uno dei seguenti metodi:

gcloud CLI

Crea un pool di agenti di origine eseguendo:

gcloud transfer agent-pools create SOURCE_AGENT_POOL

Sostituisci SOURCE_AGENT_POOL con il nome che vuoi assegnare a l pool di agenti di origine.

Google Cloud Console

Nella Google Cloud console, vai alla pagina Pool di agenti.

Vai a Pool di agenti

Viene visualizzata la pagina Pool di agenti, che elenca i pool di agenti esistenti.
Fai clic su Crea un altro pool.
Inserisci un nome per il pool.
Fai clic su Crea.

Installa agenti per il pool di agenti di origine

Installa gli agenti per il pool di agenti di origine su una macchina o una VM che ha accesso al file system di origine:

gcloud CLI

Installa gli agenti per il pool di agenti di origine eseguendo:

gcloud transfer agents install --pool=SOURCE_AGENT_POOL --count=NUMBER_OF_AGENTS \
  --mount-directories=MOUNT_DIRECTORIES

Sostituisci quanto segue:

SOURCE_AGENT_POOL con il nome del pool di agenti di origine.
NUMBER_OF_AGENTS con il numero di agenti che vuoi installare per il pool di agenti di origine. Per determinare il numero ottimale di agenti per il tuo ambiente, consulta Requisiti e best practice per gli agenti.
MOUNT_DIRECTORIES con un elenco di directory separate da virgole nel file system di origine da cui copiare. Se ometti questo flag, viene montato l' intero file system, il che potrebbe comportare un rischio per la sicurezza.

Google Cloud Console

Nella Google Cloud console, vai alla pagina Pool di agenti.

Vai a Pool di agenti

Viene visualizzata la pagina Pool di agenti, che elenca i pool di agenti esistenti.
Fai clic sul nome del pool di agenti di origine che hai appena creato.
Nella scheda Agenti, fai clic su Installa agente.
Segui le istruzioni nella Google Cloud console per installare Docker e avviare l'agente.

Crea un pool di agenti di destinazione e installa agenti

Ripeti i passaggi precedenti per creare un pool di agenti di destinazione e installare gli agenti.

Crea un bucket Cloud Storage come intermediario

I trasferimenti da file system a file system richiedono un bucket Cloud Storage come intermediario per il trasferimento dei dati.

Crea un bucket di classe Cloud Storage Standard con le seguenti impostazioni:
- Crittografia: puoi specificare una chiave di crittografia gestita dal cliente (CMEK). In caso contrario, viene utilizzata una Google-owned and Google-managed encryption key .
- Controllo delle versioni degli oggetti, Blocco bucket e conservazione predefinita degli oggetti: mantieni queste funzionalità disattivate.
Concedi autorizzazioni e ruoli utilizzando uno dei seguenti metodi:
- Concedi all'account di servizio Storage Transfer Service il ruolo Amministratore Storage (roles/storage.admin) per il bucket.
- Utilizza gcloud transfer authorize per autorizzare il tuo account per tutte le funzionalità di Storage Transfer Service. Questo comando concede le autorizzazioni di Amministratore Storage a livello di progetto:
```
gcloud transfer authorize --add-missing
```

Crea un job di trasferimento

gcloud CLI

Per creare un trasferimento dal file system di origine al file system di destinazione, esegui

gcloud transfer jobs create SOURCE_DIRECTORY DESTINATION_DIRECTORY \
    --source-agent-pool=SOURCE_AGENT_POOL \
    --destination-agent-pool=DESTINATION_AGENT_POOL \
    --intermediate-storage-path= gs://STORAGE_BUCKET/FOLDER/

Sostituisci le seguenti variabili:

SOURCE_DIRECTORY con il percorso della directory di origine.
DESTINATION_DIRECTORY con il percorso della directory di destinazione.
SOURCE_AGENT_POOL con il nome del pool di agenti di origine.
DESTINATION_AGENT_POOL con il nome del pool di agenti di destinazione.
STORAGE_BUCKET con il nome del bucket Cloud Storage.
FOLDER con il nome della cartella in cui vuoi trasferire i dati.

Quando avvii un job di trasferimento, il sistema calcola innanzitutto i dati di origine e di destinazione per determinare i dati di origine nuovi o aggiornati dall'ultimo trasferimento. Vengono trasferiti solo i nuovi dati.

Librerie client

Vai


import (
	"context"
	"fmt"
	"io"

	storagetransfer "cloud.google.com/go/storagetransfer/apiv1"
	"cloud.google.com/go/storagetransfer/apiv1/storagetransferpb"
)

func transferFromPosix(w io.Writer, projectID string, sourceAgentPoolName string, rootDirectory string, gcsSinkBucket string) (*storagetransferpb.TransferJob, error) {
	// Your project id
	// projectId := "myproject-id"

	// The agent pool associated with the POSIX data source. If not provided, defaults to the default agent
	// sourceAgentPoolName := "projects/my-project/agentPools/transfer_service_default"

	// The root directory path on the source filesystem
	// rootDirectory := "/directory/to/transfer/source"

	// The ID of the GCS bucket to transfer data to
	// gcsSinkBucket := "my-sink-bucket"

	ctx := context.Background()
	client, err := storagetransfer.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("storagetransfer.NewClient: %w", err)
	}
	defer client.Close()

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId: projectID,
			TransferSpec: &storagetransferpb.TransferSpec{
				SourceAgentPoolName: sourceAgentPoolName,
				DataSource: &storagetransferpb.TransferSpec_PosixDataSource{
					PosixDataSource: &storagetransferpb.PosixFilesystem{RootDirectory: rootDirectory},
				},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsSinkBucket},
				},
			},
			Status: storagetransferpb.TransferJob_ENABLED,
		},
	}

	resp, err := client.CreateTransferJob(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("failed to create transfer job: %w", err)
	}
	if _, err = client.RunTransferJob(ctx, &storagetransferpb.RunTransferJobRequest{
		ProjectId: projectID,
		JobName:   resp.Name,
	}); err != nil {
		return nil, fmt.Errorf("failed to run transfer job: %w", err)
	}
	fmt.Fprintf(w, "Created and ran transfer job from %v to %v with name %v", rootDirectory, gcsSinkBucket, resp.Name)
	return resp, nil
}

Java

import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
import com.google.storagetransfer.v1.proto.TransferTypes.PosixFilesystem;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferSpec;
import java.io.IOException;

public class TransferBetweenPosix {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Your project id
    String projectId = "my-project-id";

    // The agent pool associated with the POSIX data source. If not provided, defaults to the
    // default agent
    String sourceAgentPoolName = "projects/my-project-id/agentPools/transfer_service_default";

    // The agent pool associated with the POSIX data sink. If not provided, defaults to the default
    // agent
    String sinkAgentPoolName = "projects/my-project-id/agentPools/transfer_service_default";

    // The root directory path on the source filesystem
    String rootDirectory = "/directory/to/transfer/source";

    // The root directory path on the sink filesystem
    String destinationDirectory = "/directory/to/transfer/sink";

    // The ID of the GCS bucket for intermediate storage
    String bucketName = "my-intermediate-bucket";

    transferBetweenPosix(
        projectId,
        sourceAgentPoolName,
        sinkAgentPoolName,
        rootDirectory,
        destinationDirectory,
        bucketName);
  }

  public static void transferBetweenPosix(
      String projectId,
      String sourceAgentPoolName,
      String sinkAgentPoolName,
      String rootDirectory,
      String destinationDirectory,
      String bucketName)
      throws IOException {

    TransferJob transferJob =
        TransferJob.newBuilder()
            .setProjectId(projectId)
            .setTransferSpec(
                TransferSpec.newBuilder()
                    .setSinkAgentPoolName(sinkAgentPoolName)
                    .setSourceAgentPoolName(sourceAgentPoolName)
                    .setPosixDataSource(
                        PosixFilesystem.newBuilder().setRootDirectory(rootDirectory).build())
                    .setPosixDataSink(
                        PosixFilesystem.newBuilder().setRootDirectory(destinationDirectory).build())
                    .setGcsIntermediateDataLocation(
                        GcsData.newBuilder().setBucketName(bucketName).build())
                    .build())
            .setStatus(TransferJob.Status.ENABLED)
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources,
    // or use "try-with-close" statement to do this automatically.
    try (StorageTransferServiceClient storageTransfer = StorageTransferServiceClient.create()) {

      // Create the transfer job
      TransferJob response =
          storageTransfer.createTransferJob(
              TransferProto.CreateTransferJobRequest.newBuilder()
                  .setTransferJob(transferJob)
                  .build());

      System.out.println(
          "Created and ran a transfer job from "
              + rootDirectory
              + " to "
              + destinationDirectory
              + " with name "
              + response.getName());
    }
  }
}

Node.js


// Imports the Google Cloud client library
const {
  StorageTransferServiceClient,
} = require('@google-cloud/storage-transfer');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// Your project id
// const projectId = 'my-project'

// The agent pool associated with the POSIX data source. Defaults to the default agent
// const sourceAgentPoolName = 'projects/my-project/agentPools/transfer_service_default'

// The agent pool associated with the POSIX data sink. Defaults to the default agent
// const sinkAgentPoolName = 'projects/my-project/agentPools/transfer_service_default'

// The root directory path on the source filesystem
// const rootDirectory = '/directory/to/transfer/source'

// The root directory path on the sink filesystem
// const destinationDirectory = '/directory/to/transfer/sink'

// The ID of the GCS bucket for intermediate storage
// const bucketName = 'my-intermediate-bucket'

// Creates a client
const client = new StorageTransferServiceClient();

/**
 * Creates a request to transfer from the local file system to the sink bucket
 */
async function transferDirectory() {
  const createRequest = {
    transferJob: {
      projectId,
      transferSpec: {
        sourceAgentPoolName,
        sinkAgentPoolName,
        posixDataSource: {
          rootDirectory,
        },
        posixDataSink: {
          rootDirectory: destinationDirectory,
        },
        gcsIntermediateDataLocation: {
          bucketName,
        },
      },
      status: 'ENABLED',
    },
  };

  // Runs the request and creates the job
  const [transferJob] = await client.createTransferJob(createRequest);

  const runRequest = {
    jobName: transferJob.name,
    projectId: projectId,
  };

  await client.runTransferJob(runRequest);

  console.log(
    `Created and ran a transfer job from '${rootDirectory}' to '${destinationDirectory}' with name ${transferJob.name}`
  );
}

transferDirectory();

Python

from google.cloud import storage_transfer


def transfer_between_posix(
    project_id: str,
    description: str,
    source_agent_pool_name: str,
    sink_agent_pool_name: str,
    root_directory: str,
    destination_directory: str,
    intermediate_bucket: str,
):
    """Creates a transfer between POSIX file systems."""

    client = storage_transfer.StorageTransferServiceClient()

    # The ID of the Google Cloud Platform Project that owns the job
    # project_id = 'my-project-id'

    # A useful description for your transfer job
    # description = 'My transfer job'

    # The agent pool associated with the POSIX data source.
    # Defaults to 'projects/{project_id}/agentPools/transfer_service_default'
    # source_agent_pool_name = 'projects/my-project/agentPools/my-agent'

    # The agent pool associated with the POSIX data sink.
    # Defaults to 'projects/{project_id}/agentPools/transfer_service_default'
    # sink_agent_pool_name = 'projects/my-project/agentPools/my-agent'

    # The root directory path on the source filesystem
    # root_directory = '/directory/to/transfer/source'

    # The root directory path on the destination filesystem
    # destination_directory = '/directory/to/transfer/sink'

    # The Google Cloud Storage bucket for intermediate storage
    # intermediate_bucket = 'my-intermediate-bucket'

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "transfer_spec": {
                    "source_agent_pool_name": source_agent_pool_name,
                    "sink_agent_pool_name": sink_agent_pool_name,
                    "posix_data_source": {
                        "root_directory": root_directory,
                    },
                    "posix_data_sink": {
                        "root_directory": destination_directory,
                    },
                    "gcs_intermediate_data_location": {
                        "bucket_name": intermediate_bucket
                    },
                },
            }
        }
    )

    result = client.create_transfer_job(transfer_job_request)
    print(f"Created transferJob: {result.name}")

Gestisci i bucket intermedi

Al termine di un job di trasferimento, Storage Transfer Service salva i log di trasferimento che elencano i dati trasferiti e quelli non trasferiti nel bucket. Al termine del trasferimento, le attività di pulizia vengono avviate automaticamente per eliminare i dati intermedi. In alcuni casi, le attività di pulizia non riescono a eliminare tutti i dati nel bucket. Per eliminare i dati non cancellati durante la pulizia, segui le istruzioni riportate di seguito per eliminare i dati manualmente o per impostare una regola del ciclo di vita per eliminare i dati automaticamente.

Pulizia manuale

Elimina i dati dal bucket intermedio eseguendo i seguenti comandi in base al tipo di dati che vuoi eliminare.

Per cancellare i dati nel bucket intermedio che non sono stati eliminati durante la pulizia, esegui il seguente comando:
```
gcloud storage rm gs://STORAGE_BUCKET/PREFIX**
```
Per eliminare tutti i dati, inclusi i log di trasferimento, specifica la radice del bucket utilizzando il carattere jolly (*) che corrisponde a tutti i dati.
```
gcloud storage rm gs://STORAGE_BUCKET/*
```
Per eliminare il bucket, esegui il seguente comando:
```
gcloud storage rm gs://STORAGE_BUCKET
```

Sostituisci le seguenti variabili:

STORAGE_BUCKET con il nome del bucket intermedio.
PREFIX con il nome della cartella in cui sono stati trasferiti i dati all'interno del bucket intermedio.

Imposta una regola del ciclo di vita

Per eliminare i dati non cancellati dal ciclo di pulizia automatico, imposta una regola del ciclo di vita per il bucket Cloud Storage. Utilizza la age condizione per cancellare i dati intermedi in the bucket specificando un periodo più lungo del job di trasferimento più lungo che utilizza il bucket come intermediario. Se la condizione di età specificata è inferiore al tempo necessario per scaricare il file dal bucket intermedio alla destinazione, il trasferimento del file non riesce.

Facoltativamente, utilizza la matchesPrefix condizione per cancellare i dati nella cartella specificata per il bucket intermedio. Per eliminare i log di trasferimento insieme ai dati nel bucket, la condizione matchesPrefix non è obbligatoria.

Conservazione dei metadati dei file

Per conservare i metadati dei file, inclusi UID, GID, MODE e link simbolici numerici:

gcloud CLI

Utilizza il campo --preserve-metadata per specificare il comportamento di conservazione per questo trasferimento. Le opzioni che si applicano ai trasferimenti di file system sono: gid, mode, symlink, uid.

API REST

Specifica le opzioni appropriate in un metadataOptions oggetto.

Per ulteriori informazioni, consulta Conservazione degli attributi POSIX facoltativi.

Esempio di trasferimento utilizzando gcloud CLI

In questo esempio, trasferiamo i dati dalla directory /tmp/datasource nella VM1 a /tmp/destination nella VM2.

Configura l'origine del trasferimento.

Crea il pool di agenti di origine:

gcloud transfer agent-pools create source_agent_pool

Nella VM1, installa gli agenti per source_agent_pool eseguendo:

gcloud transfer agents install --pool=source_agent_pool \
    --count=1 \
    --mount-directories="/tmp/datasource"

Configura la destinazione del trasferimento.

Crea il pool di agenti di destinazione:

gcloud transfer agent-pools create destination_agent_pool

Nella VM2, installa gli agenti per destination_agent_pool eseguendo:

gcloud transfer agents install --pool=destination_agent_pool \
    --count=3 \
    --mount-directories="/tmp/destination"

Crea un bucket Cloud Storage intermedio.
1. Crea un bucket denominato my-intermediary-bucket:
```
gcloud storage buckets create gs://my-intermediary-bucket
```
2. Autorizza il tuo account per tutte le funzionalità di Storage Transfer Service eseguendo:
```
gcloud transfer authorize --add-missing
```

Crea un job di trasferimento eseguendo:

gcloud transfer jobs create posix:///tmp/datasource posix:///tmp/destination \
    --source-agent-pool=source_agent_pool \
    --destination-agent-pool=destination_agent_pool \
    --intermediate-storage-path=gs://my-intermediary-bucket

Passaggi successivi

Scopri di più sulla gestione dei job.

Trasferire dati tra file system Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Linee guida per le prestazioni di trasferimento

Deployment dell'agente

Trasferimento di un numero elevato di file di piccole dimensioni

Prima di iniziare

Crea pool di agenti e installa agenti

Crea un pool di agenti di origine

gcloud CLI

Google Cloud Console

Installa agenti per il pool di agenti di origine

gcloud CLI

Google Cloud Console

Crea un pool di agenti di destinazione e installa agenti

Crea un bucket Cloud Storage come intermediario

Crea un job di trasferimento

gcloud CLI

Librerie client

Vai

Java

Node.js

Python

Gestisci i bucket intermedi

Pulizia manuale

Imposta una regola del ciclo di vita

Conservazione dei metadati dei file

gcloud CLI

API REST

Esempio di trasferimento utilizzando gcloud CLI

Passaggi successivi

Trasferire dati tra file system