Bestimmte Dateien oder Objekte mithilfe eines Manifests übertragen

Storage Transfer Service unterstützt die Übertragung bestimmter Dateien oder Objekte, die mithilfe eines Manifests angegeben werden. Ein Manifest ist eine in Cloud Storage hochgeladene CSV-Datei, die eine Liste von Dateien oder Objekten enthält, auf die der Storage Transfer Service reagieren kann.

Ein Manifest kann für die folgenden Übertragungen verwendet werden:

  • Von AWS S3, Azure vCPM oder Cloud Storage in einen Cloud Storage-Bucket.

  • Von einem Dateisystem in einen Cloud Storage-Bucket.

  • Von S3-kompatiblem Speicher in einen Cloud Storage-Bucket.

  • Von einem Cloud Storage-Bucket in ein Dateisystem.

  • Zwischen zwei Dateisystemen.

  • Von einer öffentlich zugänglichen HTTP/HTTPS-Quelle zu einem Cloud Storage-Bucket. Folge der Anleitung unter URL-Liste erstellen, da das Manifestformat für URL-Listen eindeutig ist.

Manifest erstellen

Manifeste müssen das Format CSV haben und können beliebige UTF-8-Zeichen enthalten. Die erste Spalte muss ein Dateipfad oder ein Objektname sein, der als String angegeben ist.

Die maximale Manifestdateigröße beträgt 1 GiB. Das entspricht etwa 1 Million Zeilen. Wenn Sie eine Manifestdatei übertragen möchten, die größer als 1 GiB ist, können Sie sie in mehrere Dateien aufteilen und mehrere Übertragungsjobs ausführen.

Wenn ein Datei- oder Objektname Kommas enthält, muss der Name gemäß CSV-Standards in doppelte Anführungszeichen gesetzt werden. Beispiel: "object1,a.txt".

Wir empfehlen, die Übertragung mit einer kleinen Teilmenge von Dateien oder Objekten zu testen, um unnötige API-Aufrufe aufgrund von Konfigurationsfehlern zu vermeiden.

Sie können den Status von Dateiübertragungen auf der Seite „Übertragungsjobs“ überwachen. Dateien oder Objekte, die nicht übertragen werden sollen, werden in den Übertragungslogs aufgeführt.

Dateisystemübertragungen

Erstellen Sie ein Manifest der Dateien in einem Dateisystem und erstellen Sie eine CSV-Datei mit einer einzelnen Spalte, die die Dateipfade im Verhältnis zum in der Übertragungsjob angegebenen Stammverzeichnis enthält.

Angenommen, Sie möchten die folgenden Dateisystemdateien übertragen:

Dateipfad
rootdir/dir1/subdir1/file1.txt
rootdir/file2.txt
rootdir/dir2/subdir1/file3.txt

Das Manifest sollte so aussehen:

dir1/subdir1/file1.txt
file2.txt
dir2/subdir1/file3.txt

Objektspeicher-Übertragungen

Erstellen Sie zum Erstellen eines Manifests von Objekten eine CSV-Datei, deren erste Spalte die Objektnamen in Bezug auf den Bucket-Namen und den Pfad enthält, die bei der Erstellung des Übertragungsjobs angegeben wurden. Alle Objekte müssen sich im selben Bucket befinden.

Sie können auch eine optionale zweite Spalte mit der Cloud Storage-Generierungsnummer der bestimmten Version angeben, die übertragen werden soll.

Angenommen, Sie möchten die folgenden Objekte übertragen:

Objektpfad Generierungsnummer für Cloud Storage
SOURCE_PATH/object1.pdf 1664826685911832
SOURCE_PATH/object2.pdf
SOURCE_PATH/object3.pdf 1664826610699837

Das Manifest sollte so aussehen:

object1.pdf,1664826685911832
object2.pdf
object3.pdf,1664826610699837

Speichern Sie die Manifestdatei mit einem beliebigen Dateinamen und die Erweiterung .csv.

HTTP/HTTPS-Übertragungen

Wie Sie bestimmte Dateien aus einer HTTP- oder HTTPS-Quelle übertragen, erfahren Sie unter URL-Liste erstellen.

Manifest veröffentlichen

Nachdem Sie das Manifest erstellt haben, müssen Sie es dem Storage Transfer Service zur Verfügung stellen. Storage Transfer Service kann auf die Datei in einem Cloud Storage-Bucket oder in Ihrem Dateisystem zugreifen.

Manifest in Cloud Storage hochladen

Sie können die Manifestdatei in einem beliebigen Cloud Storage-Bucket speichern.

Der Dienst-Agent, der die Übertragung ausführt, muss die Berechtigung storage.objects.get für den Bucket haben, der das Manifest enthält. Unter Erforderliche Berechtigungen erteilen wird beschrieben, wie Sie die Dienst-Agent-ID ermitteln und diesem Agent Berechtigungen für einen Bucket gewähren.

Eine Anleitung zum Hochladen des Manifests in einen Bucket finden Sie in der Cloud Storage-Dokumentation unter Objekte hochladen.

Wenn Sie beispielsweise die Datei gcloud über die Befehlszeile in Cloud Storage hochladen möchten, verwenden Sie den Befehl gcloud storage cp:

gcloud storage cp MANIFEST.CSV gs://DESTINATION_BUCKET_NAME/

Wobei:

  • MANIFEST.CSV ist der lokale Pfad zu Ihrer Manifestdatei. Beispiel: Desktop/manifest01.csv.

  • DESTINATION_BUCKET_NAME ist der Name des Buckets, in den Sie das Objekt hochladen. Beispiel: my-bucket

Wenn der Vorgang erfolgreich ausgeführt wurde, sieht die Antwort in etwa so aus:

Completed files 1/1 | 164.3kiB/164.3kiB

Sie können ein Manifest mit vom Kunden verwalteten Cloud KMS-Verschlüsselungsschlüsseln verschlüsseln. Sorgen Sie in diesem Fall dafür, dass allen Dienstkonten, die auf das Manifest zugreifen, die entsprechenden Verschlüsselungsschlüssel zugewiesen werden. Vom Kunden bereitgestellte Schlüssel werden nicht unterstützt.

Manifest in einem Dateisystem speichern

Sie können die Manifestdatei in Ihrem Quell- oder Zieldateisystem speichern.

Der Speicherort der Datei muss für die Übertragungs-Agents zugänglich sein. Wenn Sie den Verzeichniszugriff für Ihre Agents einschränken, muss sich die Manifestdatei in einem bereitgestellten Verzeichnis befinden.

Übertragung starten

Ändern Sie die Manifestdatei erst, wenn ein Übertragungsvorgang abgeschlossen ist. Wir empfehlen, die Manifestdatei während einer Übertragung zu sperren.

Cloud Console

So starten Sie eine Übertragung mit einem Manifest aus der Cloud Console:

  1. Folgen Sie der Anleitung unter Übertragungen erstellen, um die Quelle, das Ziel und die Optionen auszuwählen.

  2. Klicken Sie im letzten Schritt, unter Einstellungen auswählen, das Kästchen Liste der Dateien bereitstellen, die per Manifestdatei übertragen werden sollen an.

  3. Geben Sie den Speicherort der Manifestdatei ein.

gcloud

Fügen Sie das --manifest-file=MANIFEST_FILE-Flag mit dem gcloud transfer jobs create-Befehl hinzu, um die im Manifest aufgeführten Dateien oder Objekte zu übertragen.

gcloud transfer jobs create SOURCE DESTINATION \
  --manifest-file=MANIFEST_FILE

MANIFEST_FILE kann einen der folgenden Werte haben:

  • Der Pfad zur CSV-Datei in einem Cloud Storage-Bucket:

    --manifest-file=gs://my_bucket/sample_manifest.csv

    Informationen zu den erforderlichen Berechtigungen, wenn der Bucket oder die Datei nicht öffentlich ist, finden Sie unter Manifest in Cloud Storage hochladen.

  • Der relative Pfad aus dem Dateisystem SOURCE, einschließlich aller angegebenen Pfade:

    --manifest-file=source://relative_path/sample_manifest.csv

  • Der relative Pfad aus dem Dateisystem DESTINATION, einschließlich aller angegebenen Pfade:

    --manifest-file=destination://relative_path/sample_manifest.csv

REST + Clientbibliotheken

REST

Zum Übertragen der im Manifest aufgeführten Dateien oder Objekte führen Sie einen createTransferJob-API-Aufruf aus, der ein transferSpec mit dem hinzugefügten Feld transferManifest angibt. Beispiel:

POST https://storagetransfer.googleapis.com/v1/transferJobs

...
  "transferSpec": {
      "posixDataSource": {
          "rootDirectory": "/home/",
      },
      "gcsDataSink": {
          "bucketName": "GCS_NEARLINE_SINK_NAME",
          "path": "GCS_SINK_PATH",
      },
      "transferManifest": {
          "location": "gs://my_bucket/sample_manifest.csv"
      }
  }

Die Manifestdatei kann in einem Cloud Storage-Bucket oder im Quell- oder Zieldateisystem gespeichert werden. Cloud Storage-Buckets müssen das Präfix gs:// verwenden und den vollständigen Pfad einschließlich des Bucket-Namens enthalten. Speicherorte von Dateisystemen müssen das Präfix source:// oder destination:// haben und sich auf die Quelle oder das Ziel des Dateisystems und ein optionales Stammverzeichnis beziehen.

Einfach loslegen (Go)

storagetransfer/transfer_using_manifest.go 

import (
	"context"
	"fmt"
	"io"

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

func transferUsingManifest(w io.Writer, projectID string, sourceAgentPoolName string, rootDirectory string, gcsSinkBucket string, manifestBucket string, manifestObjectName 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"

	// The ID of the GCS bucket that contains the manifest file
	// manifestBucket := "my-manifest-bucket"

	// The name of the manifest file in manifestBucket that specifies which objects to transfer
	// manifestObjectName := "path/to/manifest.csv"

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

	manifestLocation := "gs://" + manifestBucket + "/" + manifestObjectName
	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},
				},
				TransferManifest: &storagetransferpb.TransferManifest{Location: manifestLocation},
			},
			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 using manifest file %v with name %v", rootDirectory, gcsSinkBucket, manifestLocation, resp.Name)
	return resp, nil
}

Java

storage-transfer/src/main/java/com/google/cloud/storage/storagetransfer/samples/TransferUsingManifest.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.TransferManifest;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferSpec;
import java.io.IOException;

public class TransferUsingManifest {

  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 root directory path on the source filesystem
    String rootDirectory = "/directory/to/transfer/source";

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

    // The ID of the GCS bucket which has your manifest file
    String manifestBucket = "my-bucket";

    // The ID of the object in manifestBucket that specifies which files to transfer
    String manifestObjectName = "path/to/manifest.csv";

    transferUsingManifest(
        projectId,
        sourceAgentPoolName,
        rootDirectory,
        gcsSinkBucket,
        manifestBucket,
        manifestObjectName);
  }

  public static void transferUsingManifest(
      String projectId,
      String sourceAgentPoolName,
      String rootDirectory,
      String gcsSinkBucket,
      String manifestBucket,
      String manifestObjectName)
      throws IOException {
    String manifestLocation = "gs://" + manifestBucket + "/" + manifestObjectName;
    TransferJob transferJob =
        TransferJob.newBuilder()
            .setProjectId(projectId)
            .setTransferSpec(
                TransferSpec.newBuilder()
                    .setSourceAgentPoolName(sourceAgentPoolName)
                    .setPosixDataSource(
                        PosixFilesystem.newBuilder().setRootDirectory(rootDirectory).build())
                    .setGcsDataSink((GcsData.newBuilder().setBucketName(gcsSinkBucket)).build())
                    .setTransferManifest(
                        TransferManifest.newBuilder().setLocation(manifestLocation).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 "
              + gcsSinkBucket
              + " using "
              + "manifest file "
              + manifestLocation
              + " with name "
              + response.getName());
    }
  }
}

Node.js

storagetransfer/manifest-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 root directory path on the source filesystem
// const rootDirectory = '/directory/to/transfer/source'

// The ID of the GCS bucket to transfer data to
// const gcsSinkBucket = 'my-sink-bucket'

// Transfer manifest location. Must be a `gs:` URL
// const manifestLocation = 'gs://my-bucket/sample_manifest.csv'

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

/**
 * Creates a request to transfer from the local file system to the sink bucket
 */
async function transferViaManifest() {
  const createRequest = {
    transferJob: {
      projectId,
      transferSpec: {
        sourceAgentPoolName,
        posixDataSource: {
          rootDirectory,
        },
        gcsDataSink: {bucketName: gcsSinkBucket},
        transferManifest: {
          location: manifestLocation,
        },
      },
      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 '${gcsSinkBucket}' using manifest \`${manifestLocation}\` with name ${transferJob.name}`
  );
}

transferViaManifest();

Python

storagetransfer/manifest_request.py 
from google.cloud import storage_transfer

def create_transfer_with_manifest(
        project_id: str, description: str, source_agent_pool_name: str,
        root_directory: str, sink_bucket: str, manifest_location: str):
    """Create a transfer from a POSIX file system to a GCS bucket using
    a manifest file."""

    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 root directory path on the source filesystem
    # root_directory = '/directory/to/transfer/source'

    # Google Cloud Storage destination bucket name
    # sink_bucket = 'my-gcs-destination-bucket'

    # Transfer manifest location. Must be a `gs:` URL
    # manifest_location = 'gs://my-bucket/sample_manifest.csv'

    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,
                'posix_data_source': {
                    'root_directory': root_directory,
                },
                'gcs_data_sink': {
                    'bucket_name': sink_bucket,
                },
                'transfer_manifest': {
                    'location': manifest_location
                }
            }
        }
    })

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

Die Objekte oder Dateien im Manifest werden nicht unbedingt in der aufgeführten Reihenfolge übertragen.

Wenn das Manifest Dateien enthält, die bereits im Ziel vorhanden sind, werden diese Dateien übersprungen, sofern keine Option für die Überschreibung von Objekten, die bereits in Senke vorhanden sind angegeben ist.

Wenn das Manifest Objekte enthält, die in einer anderen Version am Ziel vorhanden sind, wird das Objekt am Ziel mit der Quellversion des Objekts überschrieben. Wenn das Ziel ein versionierter Bucket ist, wird eine neue Version des Objekts erstellt.

Nächste Schritte