Diese Seite wurde von der Cloud Translation API übersetzt.

Bestimmte Dateien oder Objekte mithilfe eines Manifests übertragen

Der Storage Transfer Service unterstützt die Übertragung bestimmter Dateien oder Objekte, die mit einem manifest angegeben werden. Ein Manifest ist eine CSV-Datei, die in Cloud Storage hochgeladen wird und eine Liste von Dateien oder Objekten enthält, auf denen Storage Transfer Service Aktionen ausführen kann.

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

Von AWS S3, Azure Blob Storage oder Cloud Storage in einen Cloud Storage-Bucket.
Von einem Dateisystem in einen Cloud Storage-Bucket
Von einem 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 einzigartig ist.

Manifest erstellen

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

Manifestdateien unterstützen keine Platzhalter. Der Wert muss der Name einer bestimmten Datei oder eines bestimmten Objekts sein. Ordnernamen ohne Datei- oder Objektnamen werden nicht unterstützt.

Die maximale Manifestdateigröße beträgt 1 GiB, was etwa 1 Million Zeilen entspricht. 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 er gemäß den CSV-Standards in 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 von Dateien in einem Dateisystem erstellen möchten, erstellen Sie eine CSV-Datei mit einer einzelnen Spalte, die die Dateipfade relativ zum Stammverzeichnis enthält, das bei der Erstellung des Übertragungsjobs angegeben wurde.

Sie können beispielsweise die folgenden Dateien des Dateisystems ü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

Um ein Manifest von Objekten zu erstellen, erstellen Sie eine CSV-Datei, deren erste Spalte die Objektnamen relativ zum Bucket-Namen und Pfad enthält, die beim Erstellen 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 zu übertragenden Version angeben.

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

Wenn Sie bestimmte Dateien von einer HTTP- oder HTTPS-Quelle übertragen möchten, folgen Sie der Anleitung unter URL-Liste erstellen.

Manifest veröffentlichen

Nachdem Sie das Manifest erstellt haben, müssen Sie es für den 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 haben, der das Manifest enthält. Eine Anleitung zum Ermitteln der Dienst-Agent-ID und zum Erteilen von Berechtigungen für diesen Dienst-Agent für einen Bucket finden Sie unter Erforderliche Berechtigungen erteilen.

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

Wenn Sie beispielsweise mit der gcloud CLI eine Datei 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 im Quell- oder Zieldateisystem speichern.

Auf den Speicherort der Datei muss für die Übertragungs-Agenten zugegriffen werden können. Wenn Sie den Verzeichniszugriff für Ihre Kundenservicemitarbeiter 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 über die Cloud Console:

Folgen Sie der Anleitung unter Wechselstellen erstellen, um Quell- und Zielort sowie Optionen auszuwählen.
Klicken Sie im letzten Schritt Einstellungen auswählen auf das Kästchen Liste der zu übertragenden Dateien über Manifestdatei angeben.
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
```
Unter Manifest in Cloud Storage hochladen finden Sie Informationen zu den erforderlichen Berechtigungen, wenn der Bucket oder die Datei nicht öffentlich ist.
Der relative Pfad vom Dateisystem SOURCE, einschließlich aller angegebenen Pfade:
```
--manifest-file=source://relative_path/sample_manifest.csv
```
Der relative Pfad vom Dateisystem DESTINATION, einschließlich aller angegebenen Pfade:
```
--manifest-file=destination://relative_path/sample_manifest.csv
```

REST + Clientbibliotheken

REST

Um die im Manifest aufgeführten Dateien oder Objekte zu übertragen, 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:// und den vollständigen Pfad einschließlich des Bucket-Namens enthalten. Dateisystemspeicherorte müssen das Präfix source:// oder destination:// verwenden und sind relativ zum Dateisystem-Quell- oder Zielverzeichnis und optional zum Stammverzeichnis.

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 im Ziel vorhanden sind, werden diese Dateien übersprungen, es sei denn, die Option Überschreiben von Objekten, die bereits im Ziel vorhanden sind ist angegeben.

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.