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 dabei helfen, die Leistung während der Übertragung von Dateisystem zu Dateisystem zu maximieren.

Agent-Bereitstellung

Im Allgemeinen empfehlen wir, in jedem Quell- und Ziel-Agent-Pool 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 die Verwendung des Instanztyps n2-standard-8 für jeden Agent. 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 von Filestore.

Große Anzahl kleiner Dateien übertragen

Für eine bessere Leistung bei der Übertragung vieler kleiner Dateien 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.

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

Dabei gilt:

  • 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 Anforderungen und Best Practices für Agents.
  • MOUNT_DIRECTORIES ist eine durch Kommas getrennte Liste von Verzeichnissen im Quelldateisystem, aus denen kopiert werden soll. Bei Auslassen dieses Flags wird das gesamte Dateisystem bereitgestellt. Dies könnte ein Sicherheitsrisiko darstellen.

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 die Pub/Sub-Ressource zu erstellen, 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 von Google verwalteter Verschlüsselungsschlü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 Storage Transfer Service-Funktionen zu autorisieren. Dieser Befehl gewährt projektweite Berechtigungen für Storage-Administratoren:

      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

Einfach loslegen (Go)

storagetransfer/transfer_from_posix.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

storage-transfer/src/main/java/com/google/cloud/storage/storagetransfer/samples/TransferBetweenPosix.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

storagetransfer/posix-to-posix-request.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

storagetransfer/posix_to_posix_request.py 
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 Übertragungslogs, in denen übertragene und fehlgeschlagene Daten im Bucket aufgelistet sind. Nach der Übertragung werden Bereinigungsaufgaben automatisch gestartet, um die Zwischendaten zu löschen. In einigen Fällen können Bereinigungsdaten nicht alle Daten im Bucket löschen. Wenn Sie Daten löschen möchten, die bei der Bereinigung nicht gelöscht wurden, verwenden Sie die folgende Anleitung, um die Daten entweder manuell zu löschen oder eine Lebenszyklusregel festzulegen, um die Daten automatisch zu löschen.

Manuelle Bereinigung

Löschen Sie Daten aus dem Zwischen-Bucket. Führen Sie dazu die folgenden gsutil-Befehle mit dem Datentyp aus, den Sie löschen möchten.

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

    gsutil -m rm gs://STORAGE_BUCKET/PREFIX**

  • Wenn Sie alle Daten einschließlich Übertragungslogs löschen möchten, geben Sie das Stammverzeichnis des Buckets mit dem Platzhalter „match-all“ (*) an.

    gsutil -m rm gs://STORAGE_BUCKET/*

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

    gsutil -m rm gs://STORAGE_BUCKET

Ersetzen Sie die folgenden Variablen:

  • STORAGE_BUCKET durch den Namen des Zwischen-Buckets.

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

Lebenszyklusregel festlegen

Legen Sie eine Lebenszyklusregel für den Cloud Storage-Bucket fest, um Daten zu löschen, die nicht durch den automatischen Bereinigungszyklus gelöscht werden. Verwenden Sie die age-Bedingung, 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 ist als die Zeit, die zum Herunterladen der Datei aus dem Zwischen-Bucket in das Ziel benötigt wird, schlägt die Dateiübertragung fehl.

Optional können Sie mit der matchesPrefix-Bedingung Daten in dem Ordner löschen, den Sie für den Zwischen-Bucket angegeben haben. Zum Löschen von Übertragungslogs zusammen mit Daten im Bucket 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 Beibehaltungsverhalten für diese Übertragung an. Optionen für Dateisystemübertragungen 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 an /tmp/destination zu 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.

      gsutil mb 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