Bucket-Informationen abrufen

Zu den Konzepten

Auf dieser Seite wird beschrieben, wie Sie Informationen über die Größe und Metadaten von Cloud Storage-Buckets abrufen können.

Vorbereitung

Die Voraussetzungen können je nach verwendetem Tool variieren:

Console

Sie benötigen die entsprechenden IAM-Berechtigungen, um diesen Leitfaden mit der Google Cloud Console abzuschließen. Wenn Sie den Bucket, auf den Sie zugreifen möchten, nicht erstellt haben, muss Ihnen der Projektinhaber möglicherweise eine Rolle zuweisen, die die erforderlichen Berechtigungen enthält.

Eine Liste der erforderlichen Berechtigungen für bestimmte Aktionen finden Sie unter IAM-Berechtigungen für die Google Cloud Console.

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

Befehlszeile

Damit Sie diese Anleitung mit einem Befehlszeilen-Dienstprogramm ausführen können, benötigen Sie die entsprechenden IAM-Berechtigungen. Wenn Sie den Bucket, auf den Sie zugreifen möchten, nicht erstellt haben, muss Ihnen der Projektinhaber möglicherweise eine Rolle zuweisen, die die erforderlichen Berechtigungen enthält.

Eine Liste der erforderlichen Berechtigungen für bestimmte Aktionen finden Sie unter IAM-Berechtigungen für gsutil-Befehle.

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

Codebeispiele

Sie benötigen die entsprechenden IAM-Berechtigungen, um diesen Leitfaden mit den Cloud Storage-Clientbibliotheken abzuschließen. Wenn Sie den Bucket, auf den Sie zugreifen möchten, nicht erstellt haben, muss Ihnen der Projektinhaber möglicherweise eine Rolle zuweisen, die die erforderlichen Berechtigungen enthält. Sofern nicht anders angegeben, werden Clientbibliotheksanfragen über die JSON API gestellt.

Eine Liste der für bestimmte Aktionen erforderlichen Berechtigungen finden Sie unter IAM-Berechtigungen für JSON-Methoden.

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

REST APIs

JSON API

Sie benötigen die entsprechenden IAM-Berechtigungen, um diese Anleitung mit der JSON API abzuschließen. Wenn Sie den Bucket, auf den Sie zugreifen möchten, nicht erstellt haben, muss Ihnen der Projektinhaber möglicherweise eine Rolle zuweisen, die die erforderlichen Berechtigungen enthält.

Eine Liste der für bestimmte Aktionen erforderlichen Berechtigungen finden Sie unter IAM-Berechtigungen für JSON-Methoden.

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

Größe eines Buckets ermitteln

Console

Hinweis: Monitoring ermittelt die Bucket-Größe einmal pro Tag und meldet keine leeren Buckets. Wenn Sie stattdessen gsutil verwenden, können Sie die Bucket-Größe jederzeit zu einem bestimmten Zeitpunkt messen.

So rufen Sie mit dem Metrics Explorer die Messwerte für eine überwachte Ressource auf:

1. Rufen Sie in der Google Cloud Console unter „Monitoring“ die Seite „Metrics Explorer” auf.

Zum Metrics Explorer

2. Wählen Sie in der Symbolleiste den Tab Explorer aus.
3. Wählen Sie den Tab Konfiguration aus.
4. Maximieren Sie das Menü Messwert auswählen, geben Sie Total bytes in die Filterleiste ein und wählen Sie dann über die Untermenüs einen bestimmten Ressourcentyp und Messwert aus:
   1. Wählen Sie im Menü Aktive Ressourcen die Option GCS-Bucket aus.
   2. Wählen Sie im Menü Aktive Messwertkategorien die Option Speicher aus.
   3. Wählen Sie im Menü Aktive Messwerte die Option Bytes insgesamt aus.
   4. Klicken Sie auf Anwenden.
   Der voll qualifizierte Name für diesen Messwert lautet storage.googleapis.com/storage/total_bytes.
5. Optional: Konfigurieren Sie die Daten, fügen Sie Filter hinzu und verwenden Sie die Menüs Gruppieren nach, Aggregator und Diagrammtyp. Sie können beispielsweise nach Ressourcen- oder Messwertlabels gruppieren. Weitere Informationen finden Sie unter Messwerte bei Verwendung von Metrics Explorer auswählen.
6. Optional: Ändern Sie die Diagrammeinstellungen:
   • Legen Sie für Kontingente und andere Messwerte, die eine Stichprobe pro Tag melden, den Zeitraum auf mindestens eine Woche fest und geben Sie als Darstellungstyp Übereinander angeordnetes Balkendiagramm an.
   • Stellen Sie für Verteilungsmesswerte die Darstellung auf Heatmap-Diagramm ein.

Sie können Metrics Explorer auch verwenden, um andere Bucket-Messwerte zu ermitteln, z. B. storage.googleapis.com/storage/object_count und storage.googleapis.com/storage/total_byte_seconds, die die tägliche Anzahl der genutzten Objekte bzw. den täglich genutzten Speicher messen. Eine vollständige Liste der verfügbaren Messwerte finden Sie in der Dokumentation zu Google Cloud-Messwerten. Weitere Informationen zur Verwendung von Metrics Explorer finden Sie unter Messwerte, Zeitachsen und Ressourcen.

Befehlszeile

Achtung: Der Befehl gsutil du berechnet die aktuelle Speicherplatznutzung durch eine Reihe von Objektauflistungsanfragen, deren Verarbeitung bei einem großen Bucket lange dauern kann. Wenn in einem Bucket Hunderttausende oder mehr Objekte enthalten sind oder Sie die Bucket-Größe im Zeitverlauf beobachten möchten, verwenden Sie stattdessen Monitoring, wie im Tab "Console" beschrieben.

Verwenden Sie den Befehl gsutil du mit dem Flag -s:

gsutil du -s gs://BUCKET_NAME

Dabei ist BUCKET_NAME der Name des entsprechenden Buckets.

Die Antwort sieht in etwa so aus:

134620      gs://my-bucket

In diesem Beispiel beträgt die Größe des Buckets mit dem Namen my-bucket 134.620 Byte.

Metadaten eines Buckets aufrufen

Console

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

   Buckets aufrufen

2. (Optional): Sie können die in der Bucket-Liste der Google Cloud Console angezeigten Spalten durch Klicken auf das Menü der Spaltenanzeigeoptionen einschränken ().

3. Suchen Sie den gewünschten Bucket in der Bucket-Liste und prüfen Sie die Spaltenüberschriften auf die Metadaten, die Sie darstellen möchten.

Befehlszeile

Verwenden Sie den folgenden gsutil ls-Befehl:

gsutil ls -L -b gs://BUCKET_NAME

Dabei ist BUCKET_NAME der Name des entsprechenden Buckets.

Die Antwort sieht in etwa so aus:

gs://my-bucket/ :
  Storage class:         STANDARD
  Location constraint:   US
  ...

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& bucket_name) {
  StatusOr<gcs::BucketMetadata> bucket_metadata =
      client.GetBucketMetadata(bucket_name);

  if (!bucket_metadata) {
    throw std::runtime_error(bucket_metadata.status().message());
  }

  std::cout << "The metadata for bucket " << bucket_metadata->name() << " is "
            << *bucket_metadata << "\n";
}

C#

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

Auf GitHub ansehen Feedback

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

public class GetBucketMetadataSample
{
    public Bucket GetBucketMetadata(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });
        Console.WriteLine($"Bucket:\t{bucket.Name}");
        Console.WriteLine($"Acl:\t{bucket.Acl}");
        Console.WriteLine($"Billing:\t{bucket.Billing}");
        Console.WriteLine($"Cors:\t{bucket.Cors}");
        Console.WriteLine($"DefaultEventBasedHold:\t{bucket.DefaultEventBasedHold}");
        Console.WriteLine($"DefaultObjectAcl:\t{bucket.DefaultObjectAcl}");
        Console.WriteLine($"Encryption:\t{bucket.Encryption}");
        if (bucket.Encryption != null)
        {
            Console.WriteLine($"KmsKeyName:\t{bucket.Encryption.DefaultKmsKeyName}");
        }
        Console.WriteLine($"Id:\t{bucket.Id}");
        Console.WriteLine($"Kind:\t{bucket.Kind}");
        Console.WriteLine($"Lifecycle:\t{bucket.Lifecycle}");
        Console.WriteLine($"Location:\t{bucket.Location}");
        Console.WriteLine($"LocationType:\t{bucket.LocationType}");
        Console.WriteLine($"Logging:\t{bucket.Logging}");
        Console.WriteLine($"Metageneration:\t{bucket.Metageneration}");
        Console.WriteLine($"Owner:\t{bucket.Owner}");
        Console.WriteLine($"ProjectNumber:\t{bucket.ProjectNumber}");
        Console.WriteLine($"RetentionPolicy:\t{bucket.RetentionPolicy}");
        Console.WriteLine($"SelfLink:\t{bucket.SelfLink}");
        Console.WriteLine($"StorageClass:\t{bucket.StorageClass}");
        Console.WriteLine($"TimeCreated:\t{bucket.TimeCreated}");
        Console.WriteLine($"Updated:\t{bucket.Updated}");
        Console.WriteLine($"Versioning:\t{bucket.Versioning}");
        Console.WriteLine($"Website:\t{bucket.Website}");
        Console.WriteLine($"TurboReplication:\t{bucket.Rpo}");
        if (bucket.Labels != null)
        {
            Console.WriteLine("Labels:");
            foreach (var label in bucket.Labels)
            {
                Console.WriteLine($"{label.Key}:\t{label.Value}");
            }
        }
        return bucket;
    }
}

Go

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

Auf GitHub ansehen Feedback

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

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

// getBucketMetadata gets the bucket metadata.
func getBucketMetadata(w io.Writer, bucketName string) (*storage.BucketAttrs, error) {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()
	attrs, err := client.Bucket(bucketName).Attrs(ctx)
	if err != nil {
		return nil, fmt.Errorf("Bucket(%q).Attrs: %v", bucketName, err)
	}
	fmt.Fprintf(w, "BucketName: %v\n", attrs.Name)
	fmt.Fprintf(w, "Location: %v\n", attrs.Location)
	fmt.Fprintf(w, "LocationType: %v\n", attrs.LocationType)
	fmt.Fprintf(w, "StorageClass: %v\n", attrs.StorageClass)
	fmt.Fprintf(w, "Turbo replication (RPO): %v\n", attrs.RPO)
	fmt.Fprintf(w, "TimeCreated: %v\n", attrs.Created)
	fmt.Fprintf(w, "Metageneration: %v\n", attrs.MetaGeneration)
	fmt.Fprintf(w, "PredefinedACL: %v\n", attrs.PredefinedACL)
	if attrs.Encryption != nil {
		fmt.Fprintf(w, "DefaultKmsKeyName: %v\n", attrs.Encryption.DefaultKMSKeyName)
	}
	if attrs.Website != nil {
		fmt.Fprintf(w, "IndexPage: %v\n", attrs.Website.MainPageSuffix)
		fmt.Fprintf(w, "NotFoundPage: %v\n", attrs.Website.NotFoundPage)
	}
	fmt.Fprintf(w, "DefaultEventBasedHold: %v\n", attrs.DefaultEventBasedHold)
	if attrs.RetentionPolicy != nil {
		fmt.Fprintf(w, "RetentionEffectiveTime: %v\n", attrs.RetentionPolicy.EffectiveTime)
		fmt.Fprintf(w, "RetentionPeriod: %v\n", attrs.RetentionPolicy.RetentionPeriod)
		fmt.Fprintf(w, "RetentionPolicyIsLocked: %v\n", attrs.RetentionPolicy.IsLocked)
	}
	fmt.Fprintf(w, "RequesterPays: %v\n", attrs.RequesterPays)
	fmt.Fprintf(w, "VersioningEnabled: %v\n", attrs.VersioningEnabled)
	if attrs.Logging != nil {
		fmt.Fprintf(w, "LogBucket: %v\n", attrs.Logging.LogBucket)
		fmt.Fprintf(w, "LogObjectPrefix: %v\n", attrs.Logging.LogObjectPrefix)
	}
	if attrs.CORS != nil {
		fmt.Fprintln(w, "CORS:")
		for _, v := range attrs.CORS {
			fmt.Fprintf(w, "\tMaxAge: %v\n", v.MaxAge)
			fmt.Fprintf(w, "\tMethods: %v\n", v.Methods)
			fmt.Fprintf(w, "\tOrigins: %v\n", v.Origins)
			fmt.Fprintf(w, "\tResponseHeaders: %v\n", v.ResponseHeaders)
		}
	}
	if attrs.Labels != nil {
		fmt.Fprintf(w, "\n\n\nLabels:")
		for key, value := range attrs.Labels {
			fmt.Fprintf(w, "\t%v = %v\n", key, value)
		}
	}
	return attrs, nil
}

Java

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

Auf GitHub ansehen Feedback

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.util.Map;

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

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

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

    // Select all fields. Fields can be selected individually e.g. Storage.BucketField.NAME
    Bucket bucket =
        storage.get(bucketName, Storage.BucketGetOption.fields(Storage.BucketField.values()));

    // Print bucket metadata
    System.out.println("BucketName: " + bucket.getName());
    System.out.println("DefaultEventBasedHold: " + bucket.getDefaultEventBasedHold());
    System.out.println("DefaultKmsKeyName: " + bucket.getDefaultKmsKeyName());
    System.out.println("Id: " + bucket.getGeneratedId());
    System.out.println("IndexPage: " + bucket.getIndexPage());
    System.out.println("Location: " + bucket.getLocation());
    System.out.println("LocationType: " + bucket.getLocationType());
    System.out.println("Metageneration: " + bucket.getMetageneration());
    System.out.println("NotFoundPage: " + bucket.getNotFoundPage());
    System.out.println("RetentionEffectiveTime: " + bucket.getRetentionEffectiveTime());
    System.out.println("RetentionPeriod: " + bucket.getRetentionPeriod());
    System.out.println("RetentionPolicyIsLocked: " + bucket.retentionPolicyIsLocked());
    System.out.println("RequesterPays: " + bucket.requesterPays());
    System.out.println("SelfLink: " + bucket.getSelfLink());
    System.out.println("StorageClass: " + bucket.getStorageClass().name());
    System.out.println("TimeCreated: " + bucket.getCreateTime());
    System.out.println("VersioningEnabled: " + bucket.versioningEnabled());
    if (bucket.getLabels() != null) {
      System.out.println("\n\n\nLabels:");
      for (Map.Entry<String, String> label : bucket.getLabels().entrySet()) {
        System.out.println(label.getKey() + "=" + label.getValue());
      }
    }
    if (bucket.getLifecycleRules() != null) {
      System.out.println("\n\n\nLifecycle Rules:");
      for (BucketInfo.LifecycleRule rule : bucket.getLifecycleRules()) {
        System.out.println(rule);
      }
    }
  }
}

Node.js

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

Auf GitHub ansehen Feedback

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

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

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

  // Get Bucket Metadata
  const [metadata] = await storage.bucket(bucketName).getMetadata();

  console.log(JSON.stringify(metadata, null, 2));
}

PHP

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

Auf GitHub ansehen Feedback

use Google\Cloud\Storage\StorageClient;

/**
 * Get bucket metadata.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function get_bucket_metadata(string $bucketName): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $info = $bucket->info();

    printf('Bucket Metadata: %s' . PHP_EOL, print_r($info));
}

Python

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

Auf GitHub ansehen Feedback

from google.cloud import storage

def bucket_metadata(bucket_name):
    """Prints out a bucket's metadata."""
    # bucket_name = 'your-bucket-name'

    storage_client = storage.Client()
    bucket = storage_client.get_bucket(bucket_name)

    print(f"ID: {bucket.id}")
    print(f"Name: {bucket.name}")
    print(f"Storage Class: {bucket.storage_class}")
    print(f"Location: {bucket.location}")
    print(f"Location Type: {bucket.location_type}")
    print(f"Cors: {bucket.cors}")
    print(f"Default Event Based Hold: {bucket.default_event_based_hold}")
    print(f"Default KMS Key Name: {bucket.default_kms_key_name}")
    print(f"Metageneration: {bucket.metageneration}")
    print(
        f"Public Access Prevention: {bucket.iam_configuration.public_access_prevention}"
    )
    print(f"Retention Effective Time: {bucket.retention_policy_effective_time}")
    print(f"Retention Period: {bucket.retention_period}")
    print(f"Retention Policy Locked: {bucket.retention_policy_locked}")
    print(f"Requester Pays: {bucket.requester_pays}")
    print(f"Self Link: {bucket.self_link}")
    print(f"Time Created: {bucket.time_created}")
    print(f"Versioning Enabled: {bucket.versioning_enabled}")
    print(f"Labels: {bucket.labels}")

Ruby

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

Auf GitHub ansehen Feedback

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

  require "google/cloud/storage"

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

  puts "ID:                       #{bucket.id}"
  puts "Name:                     #{bucket.name}"
  puts "Storage Class:            #{bucket.storage_class}"
  puts "Location:                 #{bucket.location}"
  puts "Location Type:            #{bucket.location_type}"
  puts "Cors:                     #{bucket.cors}"
  puts "Default Event Based Hold: #{bucket.default_event_based_hold?}"
  puts "Default KMS Key Name:     #{bucket.default_kms_key}"
  puts "Logging Bucket:           #{bucket.logging_bucket}"
  puts "Logging Prefix:           #{bucket.logging_prefix}"
  puts "Metageneration:           #{bucket.metageneration}"
  puts "Retention Effective Time: #{bucket.retention_effective_at}"
  puts "Retention Period:         #{bucket.retention_period}"
  puts "Retention Policy Locked:  #{bucket.retention_policy_locked?}"
  puts "Requester Pays:           #{bucket.requester_pays}"
  puts "Self Link:                #{bucket.api_url}"
  puts "Time Created:             #{bucket.created_at}"
  puts "Versioning Enabled:       #{bucket.versioning?}"
  puts "Index Page:               #{bucket.website_main}"
  puts "Not Found Page:           #{bucket.website_404}"
  puts "Labels:"
  bucket.labels.each do |key, value|
    puts " - #{key} = #{value}"
  end
  puts "Lifecycle Rules:"
  bucket.lifecycle.each do |rule|
    puts "#{rule.action} - #{rule.storage_class} - #{rule.age} - #{rule.matches_storage_class}"
  end
end

Terraform

Sie können die Metadaten eines Buckets mit einer Terraform-Ressource aufrufen.

Auf GitHub ansehen Feedback

# Get bucket metadata
data "google_storage_bucket" "default" {
  name = google_storage_bucket.static.id
}

output "bucket_metadata" {
  value = data.google_storage_bucket.default
}

REST APIs

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

2. Rufen Sie mithilfe von cURL die JSON API mit einer GET-Bucket-Anfrage auf:

   curl -X GET \
     -H "Authorization: Bearer OAUTH2_TOKEN" \
     "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME"

   Dabei gilt:

   • OAUTH2_TOKEN ist der Name des Zugriffstokens, das Sie in Schritt 1 generiert haben.
   • BUCKET_NAME ist der Name des entsprechenden Buckets. Beispiel: my-bucket

3. Grenzen Sie die Ergebnisse mithilfe von Abfrageparametern auf die gewünschten Felder ein:

   curl -X GET \
   -H "Authorization: Bearer OAUTH2_TOKEN" \
   "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=FIELD1%2CFIELD2"

   Dabei ist FIELD# ein Bucket-Attribut, das Sie in das Ergebnis aufnehmen möchten. Beispiel: location und storageClass

Die Antwort sieht in etwa so aus:

{
  "location": "US",
  "storageClass": "STANDARD"
}

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

2. Verwenden Sie cURL, um die XML API mit einer GET-Bucket-Anfrage aufzurufen:

   curl -X GET \
   -H "Authorization: Bearer OAUTH2_TOKEN" \
   "https://storage.googleapis.com/BUCKET_NAME?QUERY_PARAMETER"

   Wobei:

   • OAUTH2_TOKEN ist der Name des Zugriffstokens, das Sie in Schritt 1 generiert haben.
   • BUCKET_NAME ist der Name des entsprechenden Buckets. Beispiel: my-bucket
   • QUERY_PARAMETER ist das Metadatenfeld, das Sie zurückgeben möchten. Beispiel: location zum Abrufen des Bucket-Standorts. Sie können jeweils immer nur einen Abfrageparameter mit der XML API verwenden.

   Die Antwort sieht in etwa so aus: <LocationConstraint>US</LocationConstraint>.

Nächste Schritte

• Übersicht über Bucket-Metadaten
• Objekte in Ihrem Bucket auflisten
• Standardspeicherklasse von Buckets ändern
• Bucket-Labels hinzufügen, entfernen und anzeigen
• Ressourcen in Monitoring überwachen

Jetzt testen

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