Objekte aus dem Speicher hochladen

Auf dieser Seite erfahren Sie, wie Sie mithilfe von Clientbibliotheken Objekte aus dem Speicher in Ihren Cloud Storage-Bucket hochladen. Das Hochladen aus dem Arbeitsspeicher ist nützlich, wenn Sie unnötige Schreibvorgänge aus dem Arbeitsspeicher in Ihr lokales Dateisystem vermeiden möchten.

Ein hochgeladenes Objekt besteht aus den Daten, die Sie zusammen mit den zugehörigen Metadaten speichern möchten. Eine konzeptionelle Übersicht, einschließlich der Auswahl der optimalen Uploadmethode, basierend auf der Dateigröße, finden Sie unter Uploads und Downloads.

Rollen und Berechtigungen

Clientbibliotheken

Sie benötigen die entsprechenden IAM-Berechtigungen, um diesen Leitfaden mit den Cloud Storage-Clientbibliotheken abzuschließen. Wenn der Bucket in ein Projekt hochladen möchten, dass nicht Sie erstellt haben, muss Ihnen der Projektinhaber möglicherweise erst eine Rolle zuweisen, die die erforderlichen Berechtigungen enthält.

Sofern nicht anders angegeben, werden Clientbibliotheksanfragen über die JSON API gestellt und benötigen die unter IAM-Berechtigungen für JSON-Methoden aufgeführten Berechtigungen. Um zu erfahren, welche JSON API-Methoden aufgerufen werden, wenn Sie Anfragen über eine Clientbibliothek stellen, können Sie die Rohanfragen protokollieren.

Eine Liste der relevanten IAM-Rollen finden Sie unter Cloud Storage-Rollen. Alternativ können Sie eine benutzerdefinierte Rolle erstellen, die spezifische, eingeschränkte Berechtigungen hat.

Objekt aus Arbeitsspeicher hochladen

Clientbibliotheken

C++

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name) {
  std::string const text = "Lorem ipsum dolor sit amet";
  // For small uploads where the data is contiguous in memory use
  // `InsertObject()`. For more specific size recommendations see
  //     https://cloud.google.com/storage/docs/uploads-downloads#size
  auto metadata = client.InsertObject(bucket_name, object_name, text);
  if (!metadata) throw std::move(metadata).status();
  std::cout << "Successfully wrote to object " << metadata->name()
            << " its size is: " << metadata->size() << "\n";

  // For larger uploads, or uploads where the data is not contiguous in
  // memory, use `WriteObject()`. Consider using `std::ostream::write()` for
  // best performance.
  std::vector<std::string> v(100, text);
  gcs::ObjectWriteStream stream =
      client.WriteObject(bucket_name, object_name);
  std::copy(v.begin(), v.end(), std::ostream_iterator<std::string>(stream));
  stream.Close();

  metadata = std::move(stream).metadata();
  if (!metadata) throw std::move(metadata).status();
  std::cout << "Successfully wrote to object " << metadata->name()
            << " its size is: " << metadata->size()
            << "\nFull metadata: " << *metadata << "\n";
}

C#

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


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

public class UploadObjectFromMemorySample
{
    public void UploadObjectFromMemory(
        string bucketName = "unique-bucket-name",
        string objectName = "file-name",
        string contents = "Hello world!")
    {
        var storage = StorageClient.Create();
        byte[] byteArray = Encoding.UTF8.GetBytes(contents);
        MemoryStream stream = new MemoryStream(byteArray);
        storage.UploadObject(bucketName, objectName, "application/octet-stream" , stream);

        Console.WriteLine($" {objectName} uploaded to bucket {bucketName} with contents: {contents}");
    }
}

Go

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

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"time"

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

// streamFileUpload uploads an object via a stream.
func streamFileUpload(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: %w", err)
	}
	defer client.Close()

	b := []byte("Hello world.")
	buf := bytes.NewBuffer(b)

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

	// Upload an object with storage.Writer.
	wc := client.Bucket(bucket).Object(object).NewWriter(ctx)
	wc.ChunkSize = 0 // note retries are not supported for chunk size 0.

	if _, err = io.Copy(wc, buf); err != nil {
		return fmt.Errorf("io.Copy: %w", err)
	}
	// Data can continue to be added to the file until the writer is closed.
	if err := wc.Close(); err != nil {
		return fmt.Errorf("Writer.Close: %w", err)
	}
	fmt.Fprintf(w, "%v uploaded to %v.\n", object, bucket)

	return nil
}

Java

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


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.ByteArrayInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class UploadObjectFromMemory {
  public static void uploadObjectFromMemory(
      String projectId, String bucketName, String objectName, String contents) 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 string of contents you wish to upload
    // String contents = "Hello world!";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    BlobId blobId = BlobId.of(bucketName, objectName);
    BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();
    byte[] content = contents.getBytes(StandardCharsets.UTF_8);
    storage.createFrom(blobInfo, new ByteArrayInputStream(content));

    System.out.println(
        "Object "
            + objectName
            + " uploaded to bucket "
            + bucketName
            + " with contents "
            + contents);
  }
}

Node.js

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

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

// The contents that you want to upload
// const contents = 'these are my contents';

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

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

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

async function uploadFromMemory() {
  await storage.bucket(bucketName).file(destFileName).save(contents);

  console.log(
    `${destFileName} with contents ${contents} uploaded to ${bucketName}.`
  );
}

uploadFromMemory().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * Upload an object from memory buffer.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 * @param string $contents The contents to upload to the file.
 *        (e.g. 'these are my contents')
 */
function upload_object_from_memory(
    string $bucketName,
    string $objectName,
    string $contents
): void {
    $storage = new StorageClient();
    if (!$stream = fopen('data://text/plain,' . $contents, 'r')) {
        throw new \InvalidArgumentException('Unable to open file for reading');
    }
    $bucket = $storage->bucket($bucketName);
    $bucket->upload($stream, [
        'name' => $objectName,
    ]);
    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, $contents, $bucketName, $objectName);
}

Python

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

from google.cloud import storage


def upload_blob_from_memory(bucket_name, contents, destination_blob_name):
    """Uploads a file to the bucket."""

    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"

    # The contents to upload to the file
    # contents = "these are my contents"

    # 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_string(contents)

    print(
        f"{destination_blob_name} with contents {contents} uploaded to {bucket_name}."
    )

Ruby

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

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"

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

# The contents to upload to your file
# file_content = "Hello, world!"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name, skip_lookup: true

file = bucket.create_file StringIO.new(file_content), file_name

puts "Uploaded file #{file.name} to bucket #{bucket_name} with content: #{file_content}"

Objekte aus dem Speicher hochladen

Rollen und Berechtigungen

Clientbibliotheken

Objekt aus Arbeitsspeicher hochladen

Clientbibliotheken

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

Nächste Schritte