Objekte hochladen

Auf dieser Seite wird beschrieben, wie Sie Objekte in Ihren Cloud Storage-Bucket hochladen. Ein hochgeladenes Objekt besteht aus den Daten, die Sie zusammen mit den zugehörigen Metadaten speichern möchten. Eine konzeptionelle Übersicht finden Sie unter Uploads und Downloads.

Vorbereitung

Zum Hochladen eines Objekts in einen Bucket in einem Projekt benötigen Sie die IAM-Berechtigung storage.objects.create für das Projekt. Wenn Sie an einem Projekt arbeiten, das nicht Sie erstellt haben, muss Ihnen der Projektinhaber möglicherweise erst eine Rolle zuweisen, die eine entsprechende Berechtigung – zum Beispiel Storage-Objektersteller.

Eine vollständige Liste der Rollen finden Sie unter Cloud Storage-Rollen. Weitere Informationen zu Rollen mit eingeschränkter Berechtigung finden Sie unter Benutzerdefinierte Rollen erstellen und verwalten.

Objekt in einen Bucket hochladen

So laden Sie ein Objekt in einen Bucket hoch:

Console

1. Wechseln Sie in der Cloud Console zum Cloud Storage-Browser.
   

   Browser aufrufen

2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, in den Sie ein Objekt hochladen möchten.

3. Führen Sie im Tab "Objekte" für den Bucket eine der beiden Aktionen aus:

   • Fügen Sie die gewünschten Dateien per Drag-and-drop von Ihrem Desktop oder Dateimanager in den Hauptbereich der Cloud Console.

   • Klicken Sie auf die Schaltfläche Dateien hochladen, wählen Sie im angezeigten Dialogfeld die Dateien aus, die Sie hochladen möchten, und klicken Sie auf Öffnen.

   Hinweis: Wenn Sie den Chrome-Browser verwenden, werden auch Ordneruploads unterstützt.

Informationen zum Abrufen detaillierter Fehlerinformationen zu fehlgeschlagenen Vorgängen im Cloud Storage-Browser finden Sie unter Fehlerbehebung.

gsutil

Führen Sie den Befehl gsutil cp aus:

gsutil cp OBJECT_LOCATION gs://DESTINATION_BUCKET_NAME/

Dabei gilt:

• OBJECT_LOCATION ist der lokale Pfad zu Ihrem Objekt. Beispiel: Desktop/dog.png

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

Wenn der Vorgang erfolgreich war, sieht die Antwort so aus:

Operation completed over 1 objects/58.8 KiB.

Hinweis: Verwenden Sie das Flag -r, um Verzeichnisse rekursiv hochzuladen.

Sie können Objektmetadaten mit festem Schlüssel und benutzerdefinierte Objektmetadaten als Teil des Objektuploads in den Headern der Anfrage mit der Option -h der obersten Ebene festlegen.

Codebeispiele

C++

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C++ API.

Auf GitHub ansehen Feedback

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& file_name,
   std::string const& bucket_name, std::string const& object_name) {
  // Note that the client library automatically computes a hash on the
  // client-side to verify data integrity during transmission.
  StatusOr<gcs::ObjectMetadata> metadata = client.UploadFile(
      file_name, bucket_name, object_name, gcs::IfGenerationMatch(0));
  if (!metadata) throw std::runtime_error(metadata.status().message());

  std::cout << "Uploaded " << file_name << " to object " << metadata->name()
            << " in bucket " << metadata->bucket()
            << "\nFull metadata: " << *metadata << "\n";
}

C#

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C# API.

Auf GitHub ansehen Feedback

using Google.Cloud.Storage.V1;
using System;
using System.IO;

public class UploadFileSample
{
    public void UploadFile(
        string bucketName = "your-unique-bucket-name",
        string localPath = "my-local-path/my-file-name",
        string objectName = "my-file-name")
    {
        var storage = StorageClient.Create();
        using var fileStream = File.OpenRead(localPath);
        storage.UploadObject(bucketName, objectName, null, fileStream);
        Console.WriteLine($"Uploaded {objectName}.");
    }
}

Go

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Go API.

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"
	"os"
	"time"

	"cloud.google.com/go/storage"
)

// uploadFile uploads an object.
func uploadFile(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	// Open local file.
	f, err := os.Open("notes.txt")
	if err != nil {
		return fmt.Errorf("os.Open: %v", err)
	}
	defer f.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*50)
	defer cancel()

	// Upload an object with storage.Writer.
	wc := client.Bucket(bucket).Object(object).NewWriter(ctx)
	if _, err = io.Copy(wc, f); err != nil {
		return fmt.Errorf("io.Copy: %v", err)
	}
	if err := wc.Close(); err != nil {
		return fmt.Errorf("Writer.Close: %v", err)
	}
	fmt.Fprintf(w, "Blob %v uploaded.\n", object)
	return nil
}

Java

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Java API.

Auf GitHub ansehen Feedback

import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.BlobInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class UploadObject {
  public static void uploadObject(
      String projectId, String bucketName, String objectName, String filePath) throws IOException {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The ID of your GCS object
    // String objectName = "your-object-name";

    // The path to your file to upload
    // String filePath = "path/to/your/file"

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    BlobId blobId = BlobId.of(bucketName, objectName);
    BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();
    storage.create(blobInfo, Files.readAllBytes(Paths.get(filePath)));

    System.out.println(
        "File " + filePath + " uploaded to bucket " + bucketName + " as " + objectName);
  }
}

Node.js

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Node.js API.

Weitere Informationen zum Hochladen eines Streams, eines Strings oder eines Zwischenspeichers finden Sie unter File.save().

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The path to your file to upload
// const filePath = 'path/to/your/file';

// The new ID for your GCS file
// const destFileName = 'your-new-file-name';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function uploadFile() {
  await storage.bucket(bucketName).upload(filePath, {
    destination: destFileName,
  });

  console.log(`${filePath} uploaded to ${bucketName}`);
}

uploadFile().catch(console.error);

PHP

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage PHP API.

Auf GitHub ansehen Feedback

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file.
 *
 * @param string $bucketName the name of your Google Cloud bucket.
 * @param string $objectName the name of the object.
 * @param string $source the path to the file to upload.
 *
 * @return Psr\Http\Message\StreamInterface
 */
function upload_object($bucketName, $objectName, $source)
{
    $storage = new StorageClient();
    $file = fopen($source, 'r');
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->upload($file, [
        'name' => $objectName
    ]);
    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, basename($source), $bucketName, $objectName);
}

Python

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Python API.

Verwenden Sie die Methode Blob.upload_from_file(), Blob.upload_from_filename() oder Blob.upload_from_string(), um ein Objekt hochzuladen.

Auf GitHub ansehen Feedback

from google.cloud import storage

def upload_blob(bucket_name, source_file_name, destination_blob_name):
    """Uploads a file to the bucket."""
    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"
    # The path to your file to upload
    # source_file_name = "local/path/to/file"
    # The ID of your GCS object
    # destination_blob_name = "storage-object-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(destination_blob_name)

    blob.upload_from_filename(source_file_name)

    print(
        "File {} uploaded to {}.".format(
            source_file_name, destination_blob_name
        )
    )

Ruby

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Ruby API.

Auf GitHub ansehen Feedback

def upload_file bucket_name:, local_file_path:, file_name: nil
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The path to your file to upload
  # local_file_path = "/local/path/to/file.txt"

  # The ID of your GCS object
  # file_name = "your-file-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name

  file = bucket.create_file local_file_path, file_name

  puts "Uploaded #{local_file_path} as #{file.name} in bucket #{bucket_name}"
end

REST APIs

JSON API

Einzelanfrage ohne Objektmetadaten hochladen

1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.

2. Verwenden Sie cURL, um die JSON API mit einer POST-Objektanfrage aufzurufen:

   curl -X POST --data-binary @OBJECT_LOCATION \
       -H "Authorization: Bearer OAUTH2_TOKEN" \
       -H "Content-Type: OBJECT_CONTENT_TYPE" \
       "https://storage.googleapis.com/upload/storage/v1/b/BUCKET_NAME/o?uploadType=media&name=OBJECT_NAME"

   Dabei gilt:

   • OBJECT_LOCATION ist der lokale Pfad zu Ihrem Objekt. Beispiel: Desktop/dog.png
   • OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
   • OBJECT_CONTENT_TYPE ist der Inhaltstyp des Objekts. Beispiel: image/png
   • BUCKET_NAME ist der Name des Buckets, in den Sie das Objekt hochladen. Beispiel: my-bucket
   • OBJECT_NAME ist der Name, den Sie dem Objekt geben möchten. Beispiel: pets/dog.png.

Einzelanfrage mit Objektmetadaten hochladen

Hinweis: Informationen zum Hinzufügen oder Ändern von Metadaten für ein vorhandenes Objekt in Cloud Storage finden Sie unter Objektmetadaten ansehen und bearbeiten.

1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.

2. Erstellen Sie eine Datei multipart/related, die folgende Informationen enthält:

   --BOUNDARY_STRING
   Content-Type: application/json; charset=UTF-8
   
   OBJECT_METADATA
   
   --BOUNDARY_STRING
   Content-Type: OBJECT_CONTENT_TYPE
   
   OBJECT_DATA
   --BOUNDARY_STRING--

   Dabei gilt:

   • BOUNDARY_STRING ist ein String, den Sie definieren, um die verschiedenen Teile der mehrteiligen Datei zu identifizieren. Beispiel: my-boundary
   • OBJECT_METADATA sind Metadaten, die Sie im JSON-Format in die Datei einschließen möchten. Dieser Bereich sollte mindestens ein name-Attribut für das Objekt enthalten, z. B. {"name": "myObject"}.
   • OBJECT_CONTENT_TYPE ist der Inhaltstyp des Objekts. Beispiel: image/png
   • OBJECT_DATA sind die Daten für das Objekt.

3. Verwenden Sie cURL, um die JSON API mit einer POST-Objektanfrage aufzurufen:

   curl -X POST --data-binary @MULTIPART_FILE_LOCATION \
       -H "Authorization: Bearer OAUTH2_TOKEN" \
       -H "Content-Type: multipart/related; boundary=BOUNDARY_STRING" \
       -H "Content-Length: MULTIPART_FILE_SIZE" \
       "https://storage.googleapis.com/upload/storage/v1/b/BUCKET_NAME/o?uploadType=multipart"

   Dabei gilt:

   • MULTIPART_FILE_LOCATION ist der lokale Pfad zu der mehrteiligen Datei, die Sie in Schritt 2 erstellt haben. Beispiel: Desktop/my-upload.multipart
   • OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
   • BOUNDARY_STRING ist der Grenzstring, den Sie in Schritt 2 definiert haben. Beispiel: my-boundary
   • MULTIPART_FILE_SIZE ist die Gesamtgröße der mehrteiligen Datei in Byte, die Sie in Schritt 2 erstellt haben. Beispiel: 2000000
   • BUCKET_NAME ist der Name des Buckets, in den Sie das Objekt hochladen. Beispiel: my-bucket

Ist die Anfrage erfolgreich, gibt der Server den Statuscode HTTP 200 OK zusammen mit den Metadaten der Datei zurück.

XML API

1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.

2. Verwenden Sie cURL, um die XML API mit einer PUT-Objektanfrage aufzurufen:

   curl -X PUT --data-binary @OBJECT_LOCATION \
       -H "Authorization: Bearer OAUTH2_TOKEN" \
       -H "Content-Type: OBJECT_CONTENT_TYPE" \
       "https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME"

   Dabei gilt:

   • OBJECT_LOCATION ist der lokale Pfad zu Ihrem Objekt. Beispiel: Desktop/dog.png
   • OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
   • OBJECT_CONTENT_TYPE ist der Inhaltstyp des Objekts. Beispiel: image/png
   • BUCKET_NAME ist der Name des Buckets, in den Sie das Objekt hochladen. Beispiel: my-bucket
   • OBJECT_NAME ist der Name, den Sie dem Objekt geben möchten. Beispiel: pets/dog.png.

Sie können zusätzliche Objektmetadaten im Rahmen des Objektuploads in den Headern der Anfrage auf die gleiche Weise festlegen, wie im obigen Beispiel Content-Type festgelegt wird. Mit der XML API können Metadaten nur beim Schreiben eines Objekts, also beim Hochladen, Verschieben oder Ersetzen, festgelegt werden. Weitere Informationen zu Metadaten mit festen Schlüsseln und benutzerdefinierten Metadaten finden Sie unter Objektmetadaten und Objektmetadaten bearbeiten.

Nächste Schritte

• Hochladen und Herunterladen – Konzeptüberblick
• Vorgaben für die Benennung von Objekten
• Objekte von Ihrer Compute Engine-Instanz übertragen
• Daten von Cloud-Anbietern oder anderen Onlinequellen übertragen (z. B. mit URL-Listen)
• Daten öffentlich zugänglich machen.
• Zugriff auf Objekte und Buckets steuern

Jetzt testen

Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie einfach ein Konto, um die Leistungsfähigkeit von Cloud Storage in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Cloud Storage kostenlos testen