Bucket-Informationen abrufen

Auf dieser Seite wird gezeigt, wie Sie Informationen über die Größe und die 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

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

  1. Wählen Sie in der Google Cloud Console Monitoring aus oder klicken Sie auf die folgende Schaltfläche:
    Weiter zu Monitoring
  2. Wenn der Metrics Explorer im Navigationsbereich angezeigt wird, klicken Sie auf  Metrics Explorer. Wählen Sie andernfalls Resources (Ressourcen) und dann Metrics Explorer aus.
  3. Prüfen Sie, ob der Tab Metric (Messwert) ausgewählt ist.
  4. Klicken Sie in das Feld mit der Bezeichnung Find resource type and metric (Ressourcentyp und Messwert suchen) und treffen Sie Ihre Auswahl über das Menü oder geben Sie den Namen für die Ressource und den Messwert ein. Verwenden Sie die folgenden Informationen, um die Felder für dieses Textfeld auszufüllen:
    1. Wählen Sie für Ressource den Wert gcs_bucket aus oder geben Sie ihn ein.
    2. Wählen Sie für Messwert die Gesamtanzahl der Bytes aus oder geben Sie sie ein.
    Der voll qualifizierte Name für diese überwachte Ressource lautet storage.googleapis.com/storage/total_bytes.
  5. Mit den Menüs Filter, Group By (Gruppieren nach) und Aggregation können Sie die Darstellung der Daten ändern. Sie können beispielsweise nach Ressourcen- oder Messwertlabels gruppieren. Weitere Informationen finden Sie unter Messwerte auswählen – Zusätzliche Konfiguration.

Sie können mit Metrics Explorer auch andere Bucket-Messwerte ermitteln, z. B. storage.googleapis.com/storage/object_count und storage.googleapis.com/storage/total_byte_seconds. Damit wird die Anzahl der täglich genutzten Objekte bzw. der Umfang des täglich genutzten Speichers festgestellt. Die Dokumentation zu Stackdriver-Messwerten enthält eine vollständige Liste der verfügbaren Messwerte. 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.

Metadaten eines Buckets aufrufen

So rufen Sie die mit einem Bucket verknüpften Metadaten auf:

Console

  1. Öffnen Sie in der Google Cloud Console den Cloud Storage-Browser.
    Zum Cloud Storage-Browser
  2. (Optional): Sie können die in der Bucket-Liste der Cloud Console angezeigten Spalten durch Klicken auf das Menü der Spaltenanzeigeoptionen einschränken (Symbol für Spaltenoptionen).

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

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"
    	"time"

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

    	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
    	defer cancel()
    	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.

from google.cloud import storage
    import pprint

    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("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:

    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]%2C[FIELD2]"

    Dabei ist [FIELD#] ein Bucket-Attribut, das Sie in das Ergebnis aufnehmen möchten. Beispiele: 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.
  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 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>.

Weitere Informationen