Obtén información del depósito

En esta página, se muestra cómo obtener información sobre el tamaño y los metadatos de tus depósitos de Cloud Storage. Para obtener una descripción general de los depósitos, consulta Depósitos. Para obtener más información sobre las propiedades específicas de los depósitos, consulta Clases de almacenamiento y Ubicaciones de depósitos.

Determina el tamaño de un depósito

Para determinar el tamaño de un depósito, haz lo siguiente:

Stackdriver

  1. En Google Cloud Console, selecciona Monitoring o usa el siguiente botón:

    Ir a Monitoring

  2. Selecciona Recursos > Explorador de métricas.

  3. En el cuadro de texto Buscar tipo de recurso y métrica, ingresa storage.googleapis.com/storage/total_bytes.

    El grafo asociado muestra el tamaño de cada depósito en el proyecto seleccionado.

También puedes usar el Explorador de métricas para medir otras métricas del depósito, como storage.googleapis.com/storage/object_count y storage.googleapis.com/storage/total_byte_seconds, que miden la cantidad diaria de objetos y el almacenamiento diario que se usó, respectivamente. Consulta la documentación de métricas de Stackdriver para obtener una lista completa de las métricas disponibles, y la página sobre métricas, series temporales y recursos a fin de obtener más información sobre el uso del Explorador de métricas.

gsutil

Usa el comando gsutil du con una marca -s:

gsutil du -s gs://[BUCKET_NAME]/

En el que [BUCKET_NAME] es el nombre del depósito relevante.

La respuesta se ve como el siguiente ejemplo:

134620      gs://[BUCKET_NAME]

En este ejemplo, el tamaño del depósito es de 134,620 bytes.

Muestra los metadatos de un depósito

Para mostrar los metadatos asociados con un depósito, haz lo siguiente:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud Console.
    Abrir el navegador de Cloud Storage
  2. (Opcional) Puedes limitar las columnas que aparecen en la lista de depósitos de Cloud Console. Para ello, haz clic en el ícono Opciones de visualización de columnas (Ícono de opciones de columna.).

  3. En la lista de depósitos, busca el depósito que deseas verificar y revisa los encabezados de columna para ver los metadatos que deseas.

gsutil

Usa el siguiente comando gsutil ls:

gsutil ls -L -b gs://[BUCKET_NAME]/

En el que [BUCKET_NAME] es el nombre del depósito relevante.

La respuesta se ve como el siguiente ejemplo:

gs://[BUCKET_NAME]/ :
  Storage class:         STANDARD
  Location constraint:   US
  ...

Ejemplos de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

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#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C#.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Java.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

# 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

API de REST

API de JSON

  1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus propias credenciales de OAuth.
  2. Usa cURL para llamar a la API de JSON con una solicitud de depósito GET:

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

    En el que:

    • [OAUTH2_TOKEN] es el nombre del token de acceso que generaste en el paso 1.
    • [BUCKET_NAME] es el nombre del depósito correspondiente. Por ejemplo, my-bucket.
  3. Limita los resultados a los campos que desees mediante los parámetros de búsqueda:

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

    En el ejemplo anterior, [FIELD#] es una propiedad de depósito que deseas incluir en el resultado. Por ejemplo, location y storageClass.

La respuesta se ve como el siguiente ejemplo:

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

API de XML

  1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus propias credenciales de OAuth.
  2. Usa cURL para llamar a la API de XML con una solicitud de depósito GET:

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

    donde:

    • [OAUTH2_TOKEN] es el nombre del token de acceso que generaste en el paso 1.
    • [BUCKET_NAME] es el nombre del depósito correspondiente. Por ejemplo, my-bucket.
    • [QUERY_PARAMETER] es el campo de metadatos que deseas mostrar. Por ejemplo, location para obtener la ubicación del depósito. Solo puedes usar un parámetro de búsqueda a la vez con la API de XML.

    La respuesta se ve como el siguiente ejemplo: <LocationConstraint>US</LocationConstraint>.

Próximos pasos