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

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 auf Weiter, um mit dem nächsten Schritt fortzufahren.
- Geben Sie unter Bucket benennen einen Namen ein, der den Anforderungen für Bucket-Namen entspricht.
- Wählen Sie unter Speicherort für Daten auswählen einen Standorttyp und die Option Standort aus, unter dem die Bucket-Daten dauerhaft gespeichert werden.
- Wählen Sie unter Speicherklasse für Daten auswählen eine Standardspeicherklasse für den Bucket oder Autoclass für die automatische Speicherklassenverwaltung der Daten Ihres Buckets aus.
  Hinweis: Im Feld Schätzung monatliche Kosten im rechten Bereich finden Sie eine Schätzung der monatlichen Kosten für den Bucket auf der Grundlage der ausgewählten Speicherklasse und des ausgewählten Standorts sowie der erwarteten Datengröße und der erwarteten Vorgänge.
- Für Wählen Sie aus, wie der Zugriff auf Objekte gesteuert werden soll wählen Sie aus, ob Ihr Bucket Verhinderung des öffentlichen Zugriffs erzwingen soll und wählen Sie ein Modell für die Zugriffssteuerung für die Objekte Ihres Buckets aus.
  Hinweis: Wenn die Verhinderung des öffentlichen Zugriff bereits durch die Organisationsrichtlinie Ihres Projekts erzwungen wird, ist die Schaltfläche Öffentlichen Zugriff verhindern gesperrt.
- Konfigurieren Sie für Festlegen, wie Objektdaten geschützt werden sollen bei Bedarf Schutztools und wählen Sie eine Methode für die Datenverschlüsselung aus.
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

Aktivieren Sie Cloud Shell in der Google Cloud Console.

Cloud Shell aktivieren

Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.
Führen Sie in Ihrer Entwicklungsumgebung den Befehl gcloud storage buckets create aus:
```
gcloud storage buckets create gs://BUCKET_NAME --location=BUCKET_LOCATION
```
Wobei:
- 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 des Buckets. Beispiel: us-east1
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 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
- --soft-delete-duration: Geben Sie die Aufbewahrungsdauer Vorläufiges Löschen des Buckets an. Beispiel: 2w1d
- --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
```

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

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. Eine Anleitung finden Sie unter API-Authentifizierung.
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
    },
  }
}

Wobei:

BUCKET_NAME ist der Name, den Sie dem Bucket gemäß den Benennungsanforderungen geben möchten. Beispiel: my-bucket
BUCKET_LOCATION ist der Standort, an dem Sie die Objektdaten Ihres Buckets speichern möchten. Beispiel: US-EAST1
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 OAUTH2_TOKEN" \
     -H "Content-Type: application/json" \
     "https://storage.googleapis.com/storage/v1/b?project=PROJECT_IDENTIFIER"
```
Wobei:
- JSON_FILE_NAME ist der Name der JSON-Datei, die Sie in Schritt 2 erstellt haben.
- OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
- PROJECT_IDENTIFIER ist die ID oder Nummer des Projekts, mit dem Ihr Bucket verknüpft wird. Beispiel: my-project

XML API

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. Eine Anleitung finden Sie unter API-Authentifizierung.
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>
   <LocationConstraint>BUCKET_LOCATION</LocationConstraint>
   <StorageClass>STORAGE_CLASS</StorageClass>
</CreateBucketConfiguration>

Wobei:

BUCKET_LOCATION ist der Standort, an dem Sie die Objektdaten Ihres Buckets speichern möchten. Beispiel: US-EAST1
STORAGE_CLASS ist die Standardspeicherklasse Ihres Buckets. Beispiel: STANDARD

Verwenden Sie cURL zum Aufrufen der XML API:
```
curl -X PUT --data-binary @XML_FILE_NAME \
     -H "Authorization: Bearer OAUTH2_TOKEN" \
     -H "x-goog-project-id: PROJECT_ID" \
     "https://storage.googleapis.com/BUCKET_NAME"
```
Wobei:
- XML_FILE_NAME ist der Name der XML-Datei, die Sie in Schritt 2 erstellt haben.
- OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 generiert 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 gemäß den Benennungsanforderungen zuweisen möchten. Beispiel: my-bucket

Weitere Informationen

Ü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