Daten zwischen Dateisystemen übertragen

Auf dieser Seite erfahren Sie, wie Sie Daten zwischen zwei POSIX-Dateisystemen übertragen. Zu den häufigsten Anwendungsfällen gehören:

  • Bursting in die Cloud und Hybrid-HC: Übertragen Sie schnell große Datasets zur lokalen Verarbeitung in die Cloud.
  • Migration und Synchronisierung mit Filestore´: Migrieren oder synchronisieren Sie Daten von einem lokalen Dateisystem zu Filestore.
  • Verwaltete Dateiübertragung: Sichere und zuverlässige Übertragung von Daten zwischen Rechenzentren oder zwischen zwei Dateisystemen in der Cloud.

Richtlinien zur Übertragungsleistung

Mit den folgenden Richtlinien lässt sich die Leistung bei Übertragungen zwischen Dateisystemen maximieren.

Agent-Bereitstellung

Im Allgemeinen empfehlen wir, jeweils drei Kundenservicemitarbeiter in den Quell- und Ziel-Kundenservicemitarbeiterpools zu verwenden. Beobachten Sie die Übertragung und fügen Sie bei Bedarf weitere Kundenservicemitarbeiter hinzu. Jeder Agent benötigt 4 vCPUs und 8 GiB RAM.

Wenn Sie zu einer Filestore-Instanz migrieren, empfiehlt Filestore, für jeden Kundenservicemitarbeiter den Instanztyp n2-standard-8 zu verwenden. Geben Sie nconnect=2 an, wenn Sie die Instanz auf einer Compute Engine-VM bereitstellen. Weitere Informationen zum Optimieren und Testen der Instanzleistung finden Sie in den Leistungsrichtlinien für Filestore.

Übertragung einer großen Anzahl kleiner Dateien

Für eine bessere Leistung bei der Übertragung einer großen Anzahl kleiner Dateien empfehlen wir, die Dateien in mehrere Verzeichnisse aufzuteilen und ein einzelnes Verzeichnis mit Millionen von Dateien zu vermeiden.

Hinweise

Bevor Sie die auf dieser Seite beschriebenen Aufgaben ausführen können, müssen Sie die Voraussetzungsschritte ausführen.

Agent-Pools erstellen und Agents installieren

Damit Übertragungen von Dateisystem auf Dateisysteme möglich sind, müssen Sie Agent-Pools und Agents für die Quell- und Zieldateisysteme erstellen. Agents für den Quell-Agent-Pool müssen auf Rechnern oder VMs installiert werden, die Zugriff auf das Quelldateisystem haben. Agents für den Ziel-Agent-Pool müssen auf Rechnern oder VMs installiert werden, die Zugriff auf das Zieldateisystem haben.

Das Präfix der Kundenservicemitarbeiter-ID oder der Name des Kundenservicemitarbeiterpools darf keine vertraulichen Informationen wie personenidentifizierbare Informationen oder Sicherheitsdaten enthalten. Ressourcennamen können an die Namen anderer Google Cloud-Ressourcen weitergegeben und für interne Google-Systeme außerhalb Ihres Projekts freigegeben werden.

Quell-Agent-Pool erstellen

Erstellen Sie einen Quell-Agent-Pool mit einer der folgenden Methoden:

gcloud-CLI

Erstellen Sie mit folgendem Befehl einen Quell-Agent-Pool:

gcloud transfer agent-pools create SOURCE_AGENT_POOL

Ersetzen Sie SOURCE_AGENT_POOL durch den Namen, den Sie dem Quell-Agent-Pool geben möchten.

Google Cloud Console

  1. Rufen Sie in der Google Cloud Console die Seite Agent-Pools auf.

    Zu „Agent-Pools“

    Die Seite Agent-Pools wird angezeigt, auf der die vorhandenen Agent-Pools aufgeführt sind.

  2. Klicken Sie auf Weiteren Pool erstellen.

  3. Geben Sie einen Namen für den Pool ein.

  4. Klicken Sie auf Erstellen.

Agents für den Quell-Agent-Pool installieren

Installieren Sie Agents für den Quell-Agent-Pool auf einem Rechner oder einer VM, die Zugriff auf das Quelldateisystem hat:

gcloud-CLI

Installieren Sie die Agents für den Quell-Agent-Pool, indem Sie Folgendes ausführen:

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

Ersetzen Sie Folgendes:

  • SOURCE_AGENT_POOL durch den Namen des Quell-Agent-Pools.
  • NUMBER_OF_AGENTS durch die Anzahl der Agents, die Sie für den Quell-Agent-Pool installieren möchten. Informationen zum Ermitteln der optimalen Anzahl von Agents für Ihre Umgebung finden Sie unter Agent-Anforderungen und Best Practices.
  • MOUNT_DIRECTORIES durch eine durch Kommas getrennte Liste von Verzeichnissen im Quelldateisystem, aus denen kopiert werden soll. Wenn Sie dieses Flag weglassen, wird das gesamte Dateisystem bereitgestellt, was ein Sicherheitsrisiko darstellen kann.

Google Cloud Console

  1. Rufen Sie in der Google Cloud Console die Seite Agent-Pools auf.

    Zu „Agent-Pools“

    Die Seite Agent-Pools wird angezeigt, auf der die vorhandenen Agent-Pools aufgeführt sind.

  2. Klicken Sie auf den Namen des Quell-Agent-Pools, den Sie gerade erstellt haben.

  3. Klicken Sie auf dem Tab Agents auf Agent installieren.

  4. Folgen Sie der Anleitung in der Google Cloud Console, um Docker zu installieren und den Agent zu starten.

Ziel-Agent-Pool erstellen und Agents installieren

Wiederholen Sie die vorherigen Schritte, um einen Ziel-Agent-Pool zu erstellen und Agents zu installieren.

Cloud Storage-Bucket als Vermittler erstellen

Für Übertragungen zwischen zwei Dateisystemen ist ein Cloud Storage-Bucket als Vermittler für die Datenübertragung erforderlich.

  1. Erstellen Sie einen Cloud Storage-Bucket der Standardklasse mit den folgenden Einstellungen:

    • Verschlüsselung: Sie können einen vom Kunden verwalteten Verschlüsselungsschlüssel (Customer-Managed Encryption Key, CMEK) angeben. Andernfalls wird ein Google-eigener und von Google verwalteter Schlüssel verwendet.
    • Objektversionierung, Bucket-Sperre und Standard-Objekt-Holds: Lassen Sie diese Features deaktiviert.

  2. Mit der folgenden Methode können Sie Berechtigungen und Rollen erteilen:

    • Gewähren Sie dem Storage Transfer Service-Dienstkonto die Rolle „Storage-Administrator“ (roles/storage.admin) für den Bucket.

    • Verwenden Sie gcloud transfer authorize, um Ihr Konto für alle Funktionen des Storage Transfer Service zu autorisieren. Mit diesem Befehl werden projektweite Berechtigungen für Storage Admin gewährt:

      gcloud transfer authorize --add-missing

Übertragungsjob erstellen

gcloud-CLI

Führen Sie Folgendes aus, um eine Übertragung vom Quelldateisystem in das Zieldateisystem zu erstellen:

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/

Ersetzen Sie die folgenden Variablen:

  • SOURCE_DIRECTORY durch den Pfad des Quellverzeichnisses.
  • DESTINATION_DIRECTORY durch den Pfad des Zielverzeichnisses.
  • SOURCE_AGENT_POOL durch den Namen des Quell-Agent-Pools.
  • DESTINATION_AGENT_POOL durch den Namen des Ziel-Agent-Pools.
  • STORAGE_BUCKET durch den Namen des Cloud Storage-Buckets.
  • FOLDER durch den Namen des Ordners, in den die Daten übertragen werden sollen.

Wenn Sie einen Übertragungsjob starten, berechnet das System zuerst die Daten in der Quelle und dem Ziel, um die Quelldaten zu ermitteln, die seit der vorherigen Übertragung neu oder aktualisiert sind. Nur die neuen Daten werden übertragen.

Clientbibliotheken

Go


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}")

Vermittler-Buckets verwalten

Nach Abschluss eines Übertragungsjobs speichert Storage Transfer Service Übertragungsprotokolle mit den übertragenen und nicht übertragenen Daten im Bucket. Nach der Übertragung werden automatisch Bereinigungsaufgaben gestartet, um die Zwischendaten zu löschen. In einigen Fällen werden bei der Bereinigung nicht alle Daten im Bucket gelöscht. Wenn Sie Daten löschen möchten, die bei der Bereinigung nicht gelöscht wurden, können Sie sie entweder manuell löschen oder eine Lebenszyklusregel festlegen, um sie automatisch zu löschen. Folgen Sie dazu der Anleitung unten.

Manuelle Bereinigung

Löschen Sie Daten aus dem Zwischen-Bucket, indem Sie je nach Datentyp die folgenden Befehle ausführen.

  • Führen Sie den folgenden Befehl aus, um Daten im Zwischen-Bucket zu löschen, die bei der Bereinigung nicht gelöscht wurden:

    gcloud storage rm gs://STORAGE_BUCKET/PREFIX**

  • Wenn Sie alle Daten einschließlich der Übertragungsprotokolle löschen möchten, geben Sie den Stamm des Bucket mit dem Wildcard-Zeichen „*“ an.

    gcloud storage rm gs://STORAGE_BUCKET/*

  • Führen Sie den folgenden Befehl aus, um den Bucket zu löschen:

    gcloud storage rm gs://STORAGE_BUCKET

Ersetzen Sie die folgenden Variablen:

  • STORAGE_BUCKET durch den Namen des Zwischen-Buckets.

  • PREFIX durch den Namen des Ordners ersetzen, in den die Daten im Zwischen-Bucket übertragen wurden.

Lebenszyklusregel festlegen

Wenn Sie Daten löschen möchten, die nicht durch den automatischen Bereinigungszyklus gelöscht werden, legen Sie eine Lebenszyklusregel für den Cloud Storage-Bucket fest. Verwenden Sie die Bedingung age, um Zwischendaten im Bucket zu löschen. Geben Sie dazu einen Zeitraum an, der länger ist als der längste Übertragungsjob, der den Bucket als Vermittler verwendet. Wenn die angegebene Altersbedingung kürzer als die Zeit ist, die zum Herunterladen der Datei aus dem Vermittler-Bucket an das Ziel erforderlich ist, schlägt die Dateiübertragung fehl.

Optional können Sie die matchesPrefix-Bedingung verwenden, um Daten im Ordner zu löschen, den Sie für den Zwischen-Bucket angegeben haben. Wenn Sie die Übertragungsprotokolle zusammen mit den Daten im Bucket löschen möchten, ist die Bedingung matchesPrefix nicht erforderlich.

Dateimetadaten beibehalten

So behalten Sie Dateimetadaten wie numerische UID-, GID-, MODE- und symbolische Links bei:

gcloud-CLI

Verwenden Sie das Feld --preserve-metadata, um das Verhalten bei der Aufbewahrung für diese Übertragung anzugeben. Für die Übertragung von Dateisystemen sind folgende Optionen verfügbar: gid, mode, symlink, uid.

REST API

Geben Sie die entsprechenden Optionen in einem metadataOptions-Objekt an.

Weitere Informationen finden Sie unter Optionale POSIX-Attribute beibehalten.

Beispielübertragung mit der gcloud-CLI

In diesem Beispiel übertragen wir Daten aus dem Verzeichnis /tmp/datasource auf VM1 in das Verzeichnis /tmp/destination auf VM2.

  1. Richten Sie die Quelle der Übertragung ein.

    1. Erstellen Sie den Quell-Agent-Pool:

      gcloud transfer agent-pools create source_agent_pool

    2. Installieren Sie auf VM1 Agents für source_agent_pool, indem Sie Folgendes ausführen:

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

  2. Richten Sie das Ziel der Übertragung ein.

    1. Erstellen Sie den Ziel-Agent-Pool:

      gcloud transfer agent-pools create destination_agent_pool

    2. Installieren Sie auf VM2 Agents für destination_agent_pool, indem Sie Folgendes ausführen:

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

  3. Erstellen Sie einen Cloud Storage-Vermittler-Bucket.

    1. Erstellen Sie einen Bucket mit dem Namen my-intermediary-bucket.

      gcloud storage buckets create gs://my-intermediary-bucket

    2. Autorisieren Sie Ihr Konto für alle Features des Storage Transfer Service, indem Sie Folgendes ausführen:

      gcloud transfer authorize --add-missing

  4. Erstellen Sie einen Übertragungsjob mit folgendem Befehl:

    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

Nächste Schritte