Obtenir la taille et les métadonnées d'un bucket

Cette page explique comment obtenir des informations sur la taille et les métadonnées de vos buckets Cloud Storage.

Autorisations requises

Console

Pour suivre ce guide à l'aide de Google Cloud Console, vous devez disposer des autorisations IAM appropriées. Si vous n'avez pas créé le bucket auquel vous souhaitez accéder, vous devrez peut-être demander au propriétaire du projet de vous attribuer un rôle contenant les autorisations nécessaires.

Pour obtenir la liste des autorisations requises pour des actions spécifiques, consultez la page Autorisations IAM pour Google Cloud Console.

Pour obtenir la liste des rôles pertinents, consultez la page Rôles Cloud Storage. Vous pouvez également créer un rôle personnalisé disposant d'autorisations limitées spécifiques.

Command line

Pour suivre ce guide à l'aide d'un utilitaire de ligne de commande, vous devez disposer des autorisations IAM appropriées. Si vous n'avez pas créé le bucket auquel vous souhaitez accéder, vous devrez peut-être demander au propriétaire du projet de vous attribuer un rôle contenant les autorisations nécessaires.

Pour obtenir la liste des autorisations requises pour des actions spécifiques, consultez la page Autorisations IAM pour les commandes gsutil.

Pour obtenir la liste des rôles pertinents, consultez la page Rôles Cloud Storage. Vous pouvez également créer un rôle personnalisé disposant d'autorisations limitées spécifiques.

Bibliothèques clientes

Pour suivre ce guide à l'aide des bibliothèques clientes Cloud Storage, vous devez disposer des autorisations IAM appropriées. Si vous n'avez pas créé le bucket auquel vous souhaitez accéder, vous devrez peut-être demander au propriétaire du projet de vous attribuer un rôle contenant les autorisations nécessaires.

Sauf indication contraire, les requêtes de bibliothèque cliente sont effectuées via l'API JSON et nécessitent des autorisations, comme indiqué dans la section Autorisations IAM pour les méthodes JSON. Pour savoir quelles méthodes d'API JSON sont appelées lorsque vous envoyez des requêtes à l'aide d'une bibliothèque cliente, consignez les requêtes brutes.

Pour obtenir la liste des rôles IAM pertinents, consultez la page Rôles Cloud Storage. Vous pouvez également créer un rôle personnalisé disposant d'autorisations limitées spécifiques.

API REST

API JSON

Pour suivre ce guide à l'aide de l'API JSON, vous devez disposer des autorisations IAM appropriées. Si vous n'avez pas créé le bucket auquel vous souhaitez accéder, vous devrez peut-être demander au propriétaire du projet de vous attribuer un rôle contenant les autorisations nécessaires.

Pour obtenir la liste des autorisations requises pour des actions spécifiques, consultez la page Autorisations IAM pour les méthodes JSON.

Pour obtenir la liste des rôles pertinents, consultez la page Rôles Cloud Storage. Vous pouvez également créer un rôle personnalisé disposant d'autorisations limitées spécifiques.

Déterminer la taille d'un bucket

Console

Pour afficher les métriques d'une ressource surveillée à l'aide de l'explorateur de métriques, procédez comme suit :

Dans Google Cloud Console, accédez à la page Explorateur de métriques de Monitoring.

Accéder à l'explorateur de métriques

Dans le volet Sélectionner une métrique, développez le menu Métrique, saisissez Total bytes dans la barre de filtre, puis utilisez les sous-menus pour sélectionner un type de ressource et une métrique spécifiques :
1. Dans le menu Ressources actives, sélectionnez Bucket GCS.
2. Dans le menu Catégories de métriques actives, sélectionnez Stockage.
3. Dans le menu Métriques actives, sélectionnez Nombre total d'octets.
4. Cliquez sur Appliquer.
Le nom complet de cette métrique est storage.googleapis.com/storage/total_bytes.
Facultatif : Pour configurer l'affichage des données, ajoutez des filtres et des regroupements, et configurez les champs d'alignement. Par défaut, l'Explorateur de métriques ajoute un regroupement qui calcule la moyenne de toutes les séries temporelles :
- Pour regrouper des séries temporelles par étiquette de ressource ou de métrique, développez le menu Étiquettes dans la section Grouper par, puis effectuez vos sélections. Vous pouvez également modifier la fonction de regroupement.
- Pour afficher toutes les séries temporelles, cliquez sur Supprimer dans l'entrée Grouper par.
- Pour accéder aux champs d'alignement, cliquez sur Plus d'options.
Pour plus d'informations, consultez la page Sélectionner des métriques lors de l'utilisation de l'Explorateur de métriques.
Facultatif : Modifiez les paramètres dans le volet Afficher :
- Pour le quota et les autres métriques qui indiquent un échantillon par jour, définissez le type de widget sur Graphique à barres empilées.
- Pour les métriques à valeur de distribution, définissez le type de widget sur Carte de densité.
Facultatif : Pour le quota et les autres métriques qui indiquent un échantillon par jour, définissez la période sur au moins une semaine.

Vous pouvez également utiliser l'explorateur de métriques pour mesurer d'autres métriques de bucket, telles que storage.googleapis.com/storage/object_count et storage.googleapis.com/storage/total_byte_seconds, qui mesurent le nombre quotidien d'objets et la consommation quotidienne de stockage respectivement. Consultez la documentation sur les métriques Google Cloud pour obtenir la liste complète des métriques disponibles et la page Métriques, séries temporelles et ressources pour plus d'informations sur l'utilisation de l'explorateur de métriques.

Command line

Exécutez la commande gsutil du avec une option -s :

gsutil du -s gs://BUCKET_NAME

où BUCKET_NAME est le nom du bucket concerné.

La réponse est semblable à ceci :

134620      gs://my-bucket

Dans cet exemple, la taille du bucket my-bucket est de 134 620 octets.

Afficher les métadonnées d'un bucket

Console

Dans la console Google Cloud, accédez à la page Buckets Cloud Storage.
Accéder à la page "Buckets"
Dans la liste des buckets, cliquez sur le nom du bucket dont vous souhaitez afficher les métadonnées.
Cliquez sur l'onglet Configuration pour afficher les détails du bucket, tels que les régions incluses, la classe de stockage, les autorisations et le type de réplication.

Ligne de commande

Exécutez la commande gsutil ls suivante :

gsutil ls -L -b gs://BUCKET_NAME

où BUCKET_NAME est le nom du bucket concerné.

La réponse est semblable à ceci :

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

Bibliothèques clientes

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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::move(bucket_metadata).status();

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

C#

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C#.

Afficher sur GitHub Commentaires


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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Go.

Afficher sur GitHub Commentaires

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: %w", 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: %w", 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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

Afficher sur GitHub Commentaires


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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Node.js.

Afficher sur GitHub Commentaires

// 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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage PHP.

Afficher sur GitHub Commentaires

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

Afficher sur GitHub Commentaires


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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Ruby.

Afficher sur GitHub Commentaires

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

Les ressources Terraform vous permettent d'afficher les métadonnées d'un bucket.

Afficher sur GitHub Commentaires

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

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

API REST

API JSON

Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth. Pour obtenir des instructions, consultez la page Authentification des API.
Exécutez cURL pour appeler l'API JSON avec une requête de bucket GET :
```
curl -X GET \
  -H "Authorization: Bearer OAUTH2_TOKEN" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME"
```
Où :
- OAUTH2_TOKEN correspond au nom du jeton d'accès que vous avez généré à l'étape 1 ;
- BUCKET_NAME correspond au nom du bucket concerné. Par exemple, my-bucket.
Vous pouvez éventuellement affiner les résultats des métadonnées à l'aide du paramètre de chaîne de requête fields. Exemple :
```
curl -X GET \
-H "Authorization: Bearer OAUTH2_TOKEN" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=FIELD1%2CFIELD2"
```
Où FIELD# est une propriété de bucket que vous souhaitez inclure dans le résultat. Par exemple, location et storageClass.

La réponse est semblable à ceci :

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

API XML

Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth. Pour obtenir des instructions, consultez la page Authentification des API.
Utilisez cURL pour appeler l'API XML avec une requête de bucket GET :
```
curl -X GET \
-H "Authorization: Bearer OAUTH2_TOKEN" \
"https://storage.googleapis.com/BUCKET_NAME?QUERY_PARAMETER"
```
Où :
- OAUTH2_TOKEN correspond au nom du jeton d'accès que vous avez généré à l'étape 1 ;
- BUCKET_NAME correspond au nom du bucket concerné. Exemple :my-bucket
- QUERY_PARAMETER est le champ de métadonnées que vous souhaitez afficher. Par exemple, vous pouvez indiquer location pour obtenir l'emplacement du bucket. Vous ne pouvez utiliser qu'un seul paramètre de requête à la fois avec l'API XML. Pour obtenir la liste des champs de métadonnées compatibles avec l'API XML, consultez la page de référence concernant la requête GET sur un bucket.
La réponse est semblable à ceci : <LocationConstraint>US</LocationConstraint>.

Étape suivante

Faites l'essai

Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de Cloud Storage en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits offerts pour exécuter, tester et déployer des charges de travail.

Profiter d'un essai gratuit de Cloud Storage