Buckets erstellen

Auf dieser Seite wird gezeigt, wie Sie Cloud Storage-Buckets erstellen. Wenn in der Anfrage nichts anderes angegeben ist, werden Buckets in der US-Multiregion mit der Standardspeicherklasse Standard Storage erstellt und haben eine Vorläufig löschen-Aufbewahrungsdauer von sieben Tagen.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle "Storage Admin" (roles/storage.admin) für das Projekt zuzuweisen, um die erforderlichen Berechtigungen zum Erstellen eines Cloud Storage-Buckets zu erhalten.

Diese vordefinierte Rolle enthält die Berechtigung, die zum Erstellen eines Buckets erforderlich ist. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

storage.buckets.create
storage.buckets.enableObjectRetention (nur erforderlich, wenn Objektaufbewahrungskonfigurationen für den Bucket aktiviert werden)
storage.buckets.list (nur erforderlich, wenn Sie einen Bucket mit der Google Cloud Console erstellen)
resourcemanager.projects.get (nur erforderlich, wenn Sie einen Bucket mit der Google Cloud Console erstellen)

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten. Informationen dazu, welche Rollen mit welchen Berechtigungen verknüpft sind, finden Sie unter IAM-Rollen für Cloud Storage.

Eine Anleitung zum Zuweisen von Rollen für Projekte finden Sie unter Zugriff auf Projekte verwalten.

Neuen Bucket erstellen

Wenn Sie zum ersten Mal einen Bucket erstellen, lesen Sie den Hilfeartikel Objektspeicher mit der Google Cloud Console entdecken oder Objektspeicher mit der Google Cloud CLI entdecken.

So erstellen Sie Bucket mit bestimmten Einstellungen oder erweiterten Konfigurationen:

Console

Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.

Buckets aufrufen
Klicken Sie auf Erstellen.
Geben Sie auf der Seite Bucket erstellen die Bucket-Informationen ein. Klicken Sie nach jedem der folgenden Schritte auf Weiter, um mit dem nächsten Schritt fortzufahren:
1. Führen Sie im Abschnitt Einstieg die folgenden Schritte aus:
  - Geben Sie einen global eindeutigen Namen ein, der den Anforderungen für Bucket-Namen entspricht.
  - Wenn Sie den hierarchischen Namespace (Vorabversion) aktivieren möchten, klicken Sie auf den Maximierungspfeil , um den Bereich Für dateiorientierte und datenintensive Arbeitslasten optimieren zu maximieren, und wählen Sie dann Hierarchischen Namespace für diesen Bucket aktivieren aus.
    
    Hinweis: Sie können den hierarchischen Namespace nicht in einem vorhandenen Bucket aktivieren.
  - So fügen Sie ein Bucket-Label hinzu: Klicken Sie auf den Erweiterungspfeil, um den Abschnitt Label zu maximieren, klicken Sie auf Label hinzufügen und geben Sie key und value für Ihr Label an.
2. Gehen Sie im Bereich Speicherort für Daten auswählen so vor:
  1. Standorttyp auswählen.
  2. Wählen Sie im Drop-down-Menü für den Standorttyp einen Speicherort aus, an dem die Objektdaten in Ihrem Bucket dauerhaft gespeichert werden sollen.
    - Wenn Sie den Standorttyp Dual-Region auswählen, können Sie auch die Turboreplikation aktivieren, indem Sie das entsprechende Kästchen anklicken.
  3. Wenn Sie die Bucket-übergreifende Replikation einrichten möchten, maximieren Sie den Bereich Bucket-übergreifende Replikation einrichten und führen Sie die folgenden Schritte aus:
    Bucket-übergreifende Replikation einrichten
    
    Klicken Sie das Kästchen neben Bucket-übergreifende Replikation über Storage Transfer Service hinzufügen an.
    
    Wählen Sie im Menü Ziel-Bucket einen Ziel-Bucket aus.
    
    Optional: Klicken Sie im Bereich Replikationseinstellungen auf Konfigurieren, um die Einstellungen für den Replikationsjob zu konfigurieren.
    
    Der Bereich Bucket-übergreifende Replikation konfigurieren wird angezeigt.
    
    Wenn Sie die zu replizierenden Objekte nach dem Objektnamenspräfix filtern möchten, geben Sie ein Präfix ein, mit dem Sie Objekte ein- oder ausschließen möchten, und klicken Sie dann auf Präfix hinzufügen.
    
    Wenn Sie eine Speicherklasse für die replizierten Objekte festlegen möchten, wählen Sie im Menü Speicherklasse eine Speicherklasse aus. Wenn Sie diesen Schritt überspringen, verwenden die replizierten Objekte standardmäßig die Speicherklasse des Ziel-Buckets.
    
    Klicken Sie auf Fertig.
3. Im Abschnitt Speicherklasse für Ihre Daten auswählen wählen Sie entweder Standardspeicherklasse für den Bucket oder wählen Sie Autoclass zur automatischen Verwaltung der Speicherklassen Ihrer Bucket-Daten.
4. Im Abschnitt Zugriff auf Objekte steuern wählen Sie aus, ob der Bucket Verhinderung des öffentlichen Zugriffs durchsetzt, und wählen Sie ein Zugriffssteuerungsmodell für die Objekte Ihres Buckets.
  
  Hinweis: Wenn die Verhinderung des öffentlichen Zugriff bereits durch die Organisationsrichtlinie Ihres Projekts erzwungen wird, ist das Kästchen Öffentlichen Zugriff verhindern gesperrt.
5. Führen Sie im Bereich Festlegen, wie Objektdaten geschützt werden sollen die folgenden Schritte aus:
  - Wählen Sie unter Datenschutz die Optionen aus, die Sie für Ihren Bucket festlegen möchten.
  - Um auszuwählen, wie Ihre Objektdaten verschlüsselt werden, klicken Sie auf den Erweiterungspfeil mit Label Datenverschlüsselung und wählen Sie eine Methode für die Datenverschlüsselung “
Klicken Sie auf Erstellen.

Unter Fehlerbehebung erfahren Sie, wie Sie detaillierte Fehlerinformationen zu fehlgeschlagenen Cloud Storage-Vorgängen in der Google Cloud Console abrufen.

Befehlszeile

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Führen Sie in Ihrer Entwicklungsumgebung den Befehl gcloud storage buckets create aus:
```
gcloud storage buckets create gs://BUCKET_NAME --location=BUCKET_LOCATION
```
Dabei gilt:
- BUCKET_NAME ist der Name, den Sie dem Bucket gemäß den Benennungsanforderungen geben möchten. Beispiel: my-bucket.
- BUCKET_LOCATION ist der Standort des Buckets. Beispiel: us-east1
  
  Hinweis: Wenn Sie eine konfigurierbare Dual-Region erstellen, müssen Sie das Flag --location auf den Standortcode festlegen, der mit den zugrunde liegenden Regionen verknüpft ist. Außerdem müssen Sie das Flag --placement mit einem gültigen Regionspaar verwenden. Beispiel: --location=ASIA --placement=ASIA-EAST1,ASIA-SOUTHEAST1
Wenn die Anfrage erfolgreich ist, gibt der Befehl die folgende Meldung zurück:
```
Creating gs://BUCKET_NAME/...
```
Mit den folgenden optionalen Flags können Sie das Erstellen des Buckets noch genauer steuern:
- --project: Geben Sie die Projekt-ID oder Nummer des Projekts an, mit dem der Bucket verknüpft wird. Beispiel: my-project.
- --default-storage-class: Geben Sie die Standardspeicherklasse des Buckets an. Beispiel: STANDARD
- --uniform-bucket-level-access: Aktivieren Sie den einheitlichen Zugriff auf Bucket-Ebene für Ihren Bucket.
Beispiel:
```
gcloud storage buckets create gs://BUCKET_NAME --project=PROJECT_ID --default-storage-class=STORAGE_CLASS --location=BUCKET_LOCATION --uniform-bucket-level-access
```
Eine vollständige Liste der Optionen zum Erstellen von Buckets mit der gcloud CLI finden Sie unter buckets create-Optionen.

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& storage_class, std::string const& location) {
  StatusOr<gcs::BucketMetadata> bucket_metadata =
      client.CreateBucket(bucket_name, gcs::BucketMetadata()
                                           .set_storage_class(storage_class)
                                           .set_location(location));
  if (!bucket_metadata) throw std::move(bucket_metadata).status();

  std::cout << "Bucket " << bucket_metadata->name() << " created."
            << "\nFull Metadata: " << *bucket_metadata << "\n";
}

C#

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


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class CreateRegionalBucketSample
{
    /// <summary>
    /// Creates a storage bucket with region.
    /// </summary>
    /// <param name="projectId">The ID of the project to create the buckets in.</param>
    /// <param name="location">The location of the bucket. Object data for objects in the bucket resides in 
    /// physical storage within this region. Defaults to US.</param>
    /// <param name="bucketName">The name of the bucket to create.</param>
    /// <param name="storageClass">The bucket's default storage class, used whenever no storageClass is specified
    /// for a newly-created object. This defines how objects in the bucket are stored
    /// and determines the SLA and the cost of storage. Values include MULTI_REGIONAL,
    /// REGIONAL, STANDARD, NEARLINE, COLDLINE, ARCHIVE, and DURABLE_REDUCED_AVAILABILITY.
    /// If this value is not specified when the bucket is created, it will default to
    /// STANDARD.</param>
    public Bucket CreateRegionalBucket(
        string projectId = "your-project-id",
        string bucketName = "your-unique-bucket-name",
        string location = "us-west1",
        string storageClass = "REGIONAL")
    {
        var storage = StorageClient.Create();
        Bucket bucket = new Bucket
        {
            Location = location,
            Name = bucketName,
            StorageClass = storageClass
        };
        var newlyCreatedBucket = storage.CreateBucket(projectId, bucket);
        Console.WriteLine($"Created {bucketName}.");
        return newlyCreatedBucket;
    }
}

Go

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

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

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

// createBucketClassLocation creates a new bucket in the project with Storage class and
// location.
func createBucketClassLocation(w io.Writer, projectID, bucketName string) error {
	// projectID := "my-project-id"
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

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

	storageClassAndLocation := &storage.BucketAttrs{
		StorageClass: "COLDLINE",
		Location:     "asia",
	}
	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, storageClassAndLocation); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Created bucket %v in %v with storage class %v\n", bucketName, storageClassAndLocation.Location, storageClassAndLocation.StorageClass)
	return nil
}

Java

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

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageClass;
import com.google.cloud.storage.StorageOptions;

public class CreateBucketWithStorageClassAndLocation {
  public static void createBucketWithStorageClassAndLocation(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

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

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();

    // See the StorageClass documentation for other valid storage classes:
    // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
    StorageClass storageClass = StorageClass.COLDLINE;

    // See this documentation for other valid locations:
    // http://g.co/cloud/storage/docs/bucket-locations#location-mr
    String location = "ASIA";

    Bucket bucket =
        storage.create(
            BucketInfo.newBuilder(bucketName)
                .setStorageClass(storageClass)
                .setLocation(location)
                .build());

    System.out.println(
        "Created bucket "
            + bucket.getName()
            + " in "
            + bucket.getLocation()
            + " with storage class "
            + bucket.getStorageClass());
  }
}

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 name of a storage class
// See the StorageClass documentation for other valid storage classes:
// https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
// const storageClass = 'coldline';

// The name of a location
// See this documentation for other valid locations:
// http://g.co/cloud/storage/docs/locations#location-mr
// const location = 'ASIA';

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

// Creates a client
// The bucket in the sample below will be created in the project associated with this client.
// For more information, please see https://cloud.google.com/docs/authentication/production or https://googleapis.dev/nodejs/storage/latest/Storage.html
const storage = new Storage();

async function createBucketWithStorageClassAndLocation() {
  // For default values see: https://cloud.google.com/storage/docs/locations and
  // https://cloud.google.com/storage/docs/storage-classes
  const [bucket] = await storage.createBucket(bucketName, {
    location,
    [storageClass]: true,
  });

  console.log(
    `${bucket.name} created with ${storageClass} class in ${location}`
  );
}

createBucketWithStorageClassAndLocation().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * Create a new bucket with a custom default storage class and location.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function create_bucket_class_location(string $bucketName): void
{
    $storage = new StorageClient();
    $storageClass = 'COLDLINE';
    $location = 'ASIA';
    $bucket = $storage->createBucket($bucketName, [
        'storageClass' => $storageClass,
        'location' => $location,
    ]);

    $objects = $bucket->objects([
        'encryption' => [
            'defaultKmsKeyName' => null,
        ]
    ]);

    printf('Created bucket %s in %s with storage class %s', $bucketName, $storageClass, $location);
}

Python

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

from google.cloud import storage


def create_bucket_class_location(bucket_name):
    """
    Create a new bucket in the US region with the coldline storage
    class
    """
    # bucket_name = "your-new-bucket-name"

    storage_client = storage.Client()

    bucket = storage_client.bucket(bucket_name)
    bucket.storage_class = "COLDLINE"
    new_bucket = storage_client.create_bucket(bucket, location="us")

    print(
        "Created bucket {} in {} with storage class {}".format(
            new_bucket.name, new_bucket.location, new_bucket.storage_class
        )
    )
    return new_bucket

Ruby

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

def create_bucket_class_location bucket_name:
  # The ID to give your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.create_bucket bucket_name,
                                  location:      "ASIA",
                                  storage_class: "COLDLINE"

  puts "Created bucket #{bucket.name} in #{bucket.location} with #{bucket.storage_class} class"
end

Terraform

Sie können eine Terraform-Ressource zum Erstellen eines Storage-Buckets verwenden.

# Create new storage bucket in the US multi-region
# with coldline storage
resource "random_id" "bucket_prefix" {
  byte_length = 8
}

resource "google_storage_bucket" "static" {
  name          = "${random_id.bucket_prefix.hex}-new-bucket"
  location      = "US"
  storage_class = "COLDLINE"

  uniform_bucket_level_access = true
}

REST APIs

JSON API

Installieren und initialisieren Sie die dcloud CLI, um ein Zugriffstoken für den Header Authorization zu generieren.

Alternativ können Sie mit dem OAuth 2.0 Playground ein Zugriffstoken erstellen und in den Header Authorization einfügen.
Erstellen Sie eine JSON-Datei mit den Einstellungen für den Bucket, darunter auch ein name für den Bucket. Eine vollständige Liste der Einstellungen finden Sie in der Dokumentation zu Buckets:Insert. Folgende Einstellungen können verwendet werden:
```
{
  "name": "BUCKET_NAME",
  "location": "BUCKET_LOCATION",
  "storageClass": "STORAGE_CLASS",
  "iamConfiguration": {
    "uniformBucketLevelAccess": {
      "enabled": true
    },
  }
}
```
Dabei gilt:
- BUCKET_NAME ist der Name, den Sie Ihrem Bucket zuweisen möchten. Beachten Sie dabei die Anforderungen für Bucket-Namen. Beispiel: my-bucket.
- BUCKET_LOCATION ist der Standort, an dem Sie die Objektdaten Ihres Buckets speichern möchten. Beispiel: US-EAST1.
  
  Hinweis: Wenn Sie eine konfigurierbare Dual-Region erstellen, müssen Sie den Parameter location auf den Standortcode festlegen, der den zugrunde liegenden Regionen zugeordnet ist. Außerdem müssen Sie den Parameter customPlacementConfig angeben.
- STORAGE_CLASS ist die Standardspeicherklasse Ihres Buckets. Beispiel: STANDARD
Verwenden Sie cURL zum Aufrufen der JSON API:
```
curl -X POST --data-binary @JSON_FILE_NAME \
 -H "Authorization: Bearer $(gcloud auth print-access-token)" \
 -H "Content-Type: application/json" \
 "https://storage.googleapis.com/storage/v1/b?project=PROJECT_IDENTIFIER"
```
Dabei gilt:
- JSON_FILE_NAME ist der Name der JSON-Datei, die Sie in Schritt 2 erstellt haben.
- PROJECT_IDENTIFIER ist die ID oder Nummer des Projekts, mit dem Ihr Bucket verknüpft wird. Beispiel: my-project

XML API

Die gcloud CLI installieren und initialisieren, um ein Zugriffstoken für den Header Authorization zu generieren.

Alternativ können Sie mit dem OAuth 2.0 Playground ein Zugriffstoken erstellen und in den Header Authorization einfügen.
Erstellen Sie eine XML-Datei, die Einstellungen für den Bucket enthält. Eine vollständige Liste der Einstellungen finden Sie in der Dokumentation XML: Bucket erstellen. Folgende Einstellungen können verwendet werden:
```
<CreateBucketConfiguration>
  <StorageClass>STORAGE_CLASS</StorageClass>
  <LocationConstraint>BUCKET_LOCATION</LocationConstraint>
</CreateBucketConfiguration>
```
Dabei gilt:
- STORAGE_CLASS ist die Standardspeicherklasse Ihres Buckets. Beispiel: STANDARD.
- BUCKET_LOCATION ist der Standort, an dem Sie die Objektdaten Ihres Buckets speichern möchten. Beispiel: US-EAST1.
  
  Hinweis: Wenn Sie eine konfigurierbare Dual-Region erstellen, müssen Sie das Element <LocationConstraint> auf den Standortcode festlegen, der mit den zugrunde liegenden Regionen verknüpft ist. Außerdem muss ein Element <CustomPlacementConfig> enthalten sein.
Verwenden Sie cURL zum Aufrufen der XML API:
```
curl -X PUT --data-binary @XML_FILE_NAME \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "x-goog-project-id: PROJECT_ID" \
  "https://storage.googleapis.com/BUCKET_NAME"
```
Dabei gilt:
- XML_FILE_NAME ist der Name der XML-Datei, die Sie in Schritt 2 erstellt haben.
- PROJECT_ID ist die ID des Projekts, mit dem Ihr Bucket verknüpft wird. Beispiel: my-project.
- BUCKET_NAME ist der Name, den Sie Ihrem Bucket zuweisen möchten. Beachten Sie dabei die Anforderungen für Bucket-Namen. Beispiel: my-bucket.
Wenn die Anfrage erfolgreich war, wird keine Antwort zurückgegeben.

Nächste Schritte

Buckets in einem Projekt auflisten
Mehr über die mit einem Bucket verknüpften Metadaten erfahren.
Buckets verschieben und umbenennen
Buckets löschen
Objekte in Ihren Bucket hochladen.
Mit dem Kubernetes Config Connector können Sie das Erstellen und Konfigurieren von Buckets verwalten.

Überzeugen Sie sich selbst

Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie 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