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 soll.

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

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

  • Von einem Dateisystem in einen Cloud Storage-Bucket.

  • Vom S3-kompatiblen Speicher zu einem 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. Folgen Sie der Anleitung unter URL-Liste erstellen, da das Manifestformat für URL-Listen eindeutig ist.

Manifest erstellen

Manifeste müssen als CSV-Dateien formatiert sein und können beliebige UTF-8-Zeichen enthalten. Die erste Spalte muss ein Datei- oder Objektname sein, der als String angegeben wird.

Manifestdateien unterstützen keine Platzhalter. Der Wert muss ein bestimmter Datei- oder Objektname sein. Ordnernamen ohne Datei- oder Objektnamen werden nicht unterstützt.

Die maximale Größe der Manifestdatei beträgt 1 GiB, was ungefähr 1 Million Zeilen entspricht. Wenn Sie eine Manifestdatei übertragen müssen, 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äß den 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

Wenn Sie ein Manifest der Dateien in einem Dateisystem erstellen möchten, erstellen Sie eine CSV-Datei mit nur einer Spalte, die die Dateipfade relativ zum Stammverzeichnis enthält, das beim Erstellen des Übertragungsjobs angegeben wurde.

So können Sie beispielsweise die folgenden Dateisystemdateien übertragen:

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

Ihr Manifest sollte in etwa so aussehen:

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

Objektspeicherübertragungen

Zum Erstellen eines Manifests mit Objekten erstellen Sie eine CSV-Datei, deren erste Spalte die Objektnamen enthält, die sich auf den Bucket-Namen und den Pfad beziehen, der beim Erstellen des Übertragungsjobs angegeben wurde. Alle Objekte müssen sich im selben Bucket befinden.

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

Sie können beispielsweise die folgenden Objekte übertragen:

Objektpfad Cloud Storage-Generierungsnummer
SOURCE_PATH/object1.pdf 1664826685911832
SOURCE_PATH/object2.pdf
SOURCE_PATH/object3.pdf 1664826610699837

Ihr Manifest sollte in etwa so aussehen:

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

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

HTTP-/HTTPS-Übertragungen

Informationen zum Übertragen bestimmter Dateien aus einer HTTP- oder HTTPS-Quelle finden Sie unter URL-Liste erstellen.

Manifest veröffentlichen

Nachdem Sie das Manifest erstellt haben, müssen Sie es für Storage Transfer Service verfügbar machen. 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 mit dem Manifest haben. Unter Erforderliche Berechtigungen gewähren erfahren Sie, wie Sie die Dienst-Agent-ID ermitteln und diesem Dienst-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 gcloud-Befehlszeile verwenden möchten, um eine Datei in Cloud Storage hochzuladen, 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 im Quell- oder Zieldateisystem speichern.

Der Speicherort der Datei muss für die Übertragungs-Agents zugänglich sein. Wenn Sie für Ihre Agents den Verzeichniszugriff 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 über die Cloud Console eine Übertragung mit einem Manifest:

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

  2. Klicken Sie im letzten Schritt Einstellungen auswählen auf das Kästchen Liste der Dateien angeben, die über Manifestdatei übertragen werden sollen.

  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 einer der folgenden Werte sein:

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

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

    Weitere Informationen zu den erforderlichen Berechtigungen für den Fall, dass 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

Wenn Sie die im Manifest aufgeführten Dateien oder Objekte übertragen möchten, führen Sie einen createTransferJob-API-Aufruf aus, der eine 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 des Dateisystems müssen das Präfix source:// oder destination:// verwenden und relativ zur Quelle oder Ziel des Dateisystems und dem optionalen Stammverzeichnis sein.

Einfach loslegen (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


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


// 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

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 am Ziel vorhanden sind, werden diese Dateien übersprungen, sofern nicht die Option Objekte überschreiben, die bereits in der 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