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

Die folgenden Richtlinien können dazu beitragen, die Leistung bei Übertragungen zwischen Dateisystemen zu maximieren.

Agent-Bereitstellung

Im Allgemeinen empfehlen wir, in jedem der Quell- und Ziel-Agent-Pools drei Agents zu verwenden. Überwachen Sie die Übertragung und fügen Sie bei Bedarf weitere Agents hinzu. Jeder Agent benötigt 4 vCPUs und 8 GiB RAM.

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

Übertragen großer Mengen kleiner Dateien

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

Hinweis

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

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.

Die Präfixe der Agent-IDs und die Namen der Agent-Pools dürfen keine vertraulichen Informationen wie personenidentifizierbare Informationen oder Sicherheitsdaten enthalten. Ressourcennamen können an die Namen anderer Google Cloud-Ressourcen weitergegeben werden und für Google-interne Systeme außerhalb Ihres Projekts sichtbar sein.

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 auf dem Quelldateisystem, aus denen kopiert werden soll. Wenn Sie dieses Flag weglassen, wird das gesamte Dateisystem eingebunden, 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 kundenverwalteten Verschlüsselungsschlüssel (CMEK) angeben. Andernfalls wird Google-owned and Google-managed encryption key 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.

    • Autorisieren Sie Ihr Konto mit gcloud transfer authorize für alle Features des Storage Transfer Service. Mit diesem Befehl werden projektweite Berechtigungen als Storage-Administrator erteilt:

      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-Bucket.
  • 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 können mit den Bereinigungsaufgaben nicht alle Daten im Bucket gelöscht werden. Wenn Sie Daten löschen möchten, die bei der Bereinigung nicht gelöscht wurden, folgen Sie der Anleitung unten, um die Daten entweder manuell zu löschen oder eine Lebenszyklusregel festzulegen, mit der die Daten automatisch gelöscht werden.

Manuelle Bereinigung

Löschen Sie Daten aus dem Vermittler-Bucket, indem Sie die folgenden Befehle ausführen. Die Befehle richten sich nach der Art der Daten, die Sie löschen möchten.

  • Führen Sie den folgenden Befehl aus, um Daten im Vermittler-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 das Stammverzeichnis des Buckets mit dem Platzhalter für alle Übereinstimmungen (*) 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 Vermittler-Buckets.

  • PREFIX durch den Namen des Ordners, in den die Daten im Vermittler-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 age Bedingung, um Zwischendaten in dem Bucket zu löschen. Geben Sie dazu einen Zeitraum an, der länger als der längste Übertragungsjob ist, 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 in dem Ordner zu löschen, den Sie für den Vermittler-Bucket angegeben haben. Wenn Sie Übertragungsprotokolle zusammen mit 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

Geben Sie im Feld --preserve-metadata das Verhalten für die Beibehaltung für diese Übertragung an. Optionen, die für Übertragungen zwischen Dateisystemen gelten, sind: 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 nach /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