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.

Leistungsrichtlinien für Übertragungen

Die folgenden Richtlinien können dabei helfen, die Leistung bei Übertragungen von Dateisystem zu Dateisystem 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 auf einer Compute Engine-VM bereitstellen. Weitere Informationen zum Optimieren und Testen der Instanzleistung finden Sie in den Leistungsrichtlinien von Filestore.

Große Mengen kleiner Dateien übertragen

Für eine bessere Leistung bei der Übertragung einer großen Anzahl kleiner Dateien wird empfohlen, 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 erforderlichen Schritte 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.

Fügen Sie keine vertraulichen Informationen wie personenidentifizierbare Informationen oder Sicherheitsdaten in das Agent-ID-Präfix oder den Agent-Pool-Namen ein. Ressourcennamen können an die Namen anderer Google Cloud-Ressourcen weitergegeben und für Google-interne Systeme außerhalb Ihres Projekts bereitgestellt 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 Anforderungen und Best Practices für Agents.
• MOUNT_DIRECTORIES durch eine durch Kommas getrennte Liste von Verzeichnissen im Quelldateisystem, aus dem kopiert werden soll. Durch Weglassen dieses Flags wird das gesamte Dateisystem bereitgestellt, was ein Sicherheitsrisiko darstellen könnte.

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 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 Features von Storage Transfer Service zu autorisieren. Dieser Befehl gewährt projektweite Storage-Administratorberechtigungen:

     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)

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

Nachdem ein Übertragungsjob abgeschlossen wurde, speichert Storage Transfer Service Übertragungslogs mit den übertragenen und fehlgeschlagenen Daten im Bucket. Nach der Übertragung werden Bereinigungsaufgaben automatisch gestartet, um die Zwischendaten zu löschen. In einigen Fällen werden durch Bereinigungsaufgaben nicht alle Daten im Bucket gelöscht. Wenn Sie Daten löschen möchten, die bei der Bereinigung nicht gelöscht werden, folgen Sie der nachstehenden Anleitung, um die Daten entweder manuell zu löschen oder eine Lebenszyklusregel zum automatischen Löschen der Daten festzulegen.

Manuelle Bereinigung

Führen Sie je nach Typ der zu löschenden Daten die folgenden gsutil-Befehle aus, um Daten aus dem Zwischen-Bucket zu löschen.

• Führen Sie den folgenden Befehl aus, um Daten im Zwischen-Bucket zu löschen, die bei 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 „stimmt mit allen Übereinstimmungen“ (*) 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

Zum Löschen von Daten, die durch den automatischen Bereinigungszyklus nicht 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 als der längste Übertragungsjob ist, der den Bucket als Vermittler verwendet. Wenn die angegebene Altersbedingung kürzer als die zum Herunterladen der Datei aus dem Zwischen-Bucket zum Ziel erforderliche Zeit ist, schlägt die Dateiübertragung fehl.

Verwenden Sie optional die Bedingung matchesPrefix, um Daten in dem Ordner zu 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

Verwenden Sie das Feld --preserve-metadata, um das Beibehaltungsverhalten für diese Übertragung anzugeben. Für die Übertragung von Dateisystemen gelten folgende Optionen: 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.

      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

• Weitere Informationen zum Verwalten von Jobs.