Bucket-Informationen abrufen

Auf dieser Seite wird beschrieben, wie Sie Informationen über die Größe und Metadaten von Cloud Storage-Buckets abrufen können. Eine Übersicht über Buckets ist in der Liste der wichtigen Begriffe enthalten. Weitere Informationen zu bestimmten Bucket-Eigenschaften finden Sie unter Speicherklassen und Bucket-Standorte.

Größe eines Buckets ermitteln

So bestimmen Sie die Größe eines Buckets:

Stackdriver

  1. Öffnen Sie Stackdriver Metrics Explorer.

    Zu Metrics Explorer

    Wenn Sie Stackdriver noch nicht verwendet haben, klicken Sie auf die Schaltfläche Arbeitsbereich erstellen und erstellen Sie einen Arbeitsbereich für das Projekt, das Ihren Bucket enthält.

  2. Geben Sie im Textfeld Ressourcentyp und Messwert finden den Wert storage.googleapis.com/storage/total_bytes ein.

    Das zugehörige Diagramm zeigt die Größe der einzelnen Buckets im ausgewählten Projekt an.

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. In der Dokumentation zu Stackdriver-Messwerten finden Sie eine vollständige Liste der verfügbaren Messwerte und unter Messwerte, Zeitachsen und Ressourcen finden Sie weitere Informationen zur Verwendung von Metrics Explorer.

gsutil

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://[BUCKET_NAME]

In diesem Beispiel beträgt die Größe des Buckets 134.620 Byte.

Speicherort und Standardspeicherklasse eines Buckets abrufen

So rufen Sie den geografischen Standort und die Standardspeicherklasse eines Buckets ab:

Console

  1. Öffnen Sie in der Google Cloud Platform Console den Cloud Storage-Browser.
    Cloud Storage-Browser öffnen
  2. Suchen Sie in der Bucket-Liste den Bucket aus, den Sie überprüfen möchten, und prüfen Sie dessen Standort und die Standardspeicherklasse.

    Standardspeicherklasse eines Buckets überprüfen

gsutil

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://[BUCKET_NAME]/ :
  Storage class:         STANDARD
  Location constraint:   US
  ...

Codebeispiele

C++

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

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string 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.

private void GetBucketMetadata(string bucketName)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName);
    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}");
}

Go

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

import (
	"context"
	"fmt"
	"io"
	"log"

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

func getBucketMetadata(w io.Writer, client *storage.Client, bucketName string) (*storage.BucketAttrs, error) {
	// bucketName := "bucket-name"
	ctx := context.Background()

	// Initialize client.
	client, err := storage.NewClient(ctx)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close() // Closing the client safely cleans up background resources.

	attrs, err := client.Bucket(bucketName).Attrs(ctx)
	if err != nil {
		return nil, 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, "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.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.

Storage storage = StorageOptions.getDefaultInstance().getService();

// The name of a bucket, e.g. "my-bucket"
// String bucketName = "my-bucket";

// Select all fields
// Fields can be selected individually e.g. Storage.BucketField.NAME
Bucket bucket = storage.get(bucketName, 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());
  }
}

Node.js

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

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

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

async function getBucketMetadata() {
  // Get bucket metadata.
  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const bucketName = 'Name of a bucket, e.g. my-bucket';

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

  for (const [key, value] of Object.entries(metadata)) {
    console.log(`${key}: ${value}`);
  }
}

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * Get bucket metadata.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 *
 * @return void
 */
function get_bucket_metadata($bucketName)
{
    $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.

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

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

Ruby

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

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage bucket name"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new project_id: project_id
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

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.
  2. Verwenden Sie cURL, um die JSON API mit einer GET-Bucket-Anfrage aufzurufen, die die gewünschten fields enthält:

    curl -X GET \
      -H "Authorization: Bearer [OAUTH2_TOKEN]" \
      "https://www.googleapis.com/storage/v1/b/[BUCKET_NAME]?fields=location%2CstorageClass"

    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.

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.
  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]"

    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.
    • [QUERY_PARAMETER] ist:

      • location zum Abrufen des Bucket-Standorts. Die Antwort sieht in etwa so aus: <LocationConstraint>US</LocationConstraint>.
      • storageClass zum Abrufen der Standardspeicherklasse des Buckets. Die Antwort sieht in etwa so aus: <StorageClass>NEARLINE</StorageClass>.

      Mit der XML API können Sie jeweils nur einen Abfrageparameter verwenden.

Nächste Schritte