Como receber informações de intervalos

Nesta página, você aprenderá como receber informações sobre o tamanho e os metadados de intervalos do Cloud Storage. Para uma visão geral dos intervalos, leia os Termos-chave. Para saber mais sobre as propriedades específicas de intervalos, consulte Classes de armazenamento e Locais de intervalos.

Como determinar o tamanho de um intervalo

Para determinar o tamanho de um intervalo:

Stackdriver

Proceda da seguinte forma para visualizar as métricas de um recurso monitorado usando o Metrics Explorer:

  1. No Console do Google Cloud, acesse Monitoring ou use o botão
    Acessar Monitoring
  2. Se o painel de navegação não estiver expandido, clique em Expand . Esse botão está localizado no canto inferior esquerdo do console.
  3. Clique em Metrics Explorer se ele aparecer no painel de navegação. Caso contrário, selecione Resources e, em seguida, Metrics Explorer.
  4. Verifique se Metric é a guia selecionada.
  5. Clique na caixa Find resource type and metric e, em seguida, insira ou selecione no menu o nome do recurso e da métrica. Use as informações a seguir para preencher os campos dessa caixa de texto:
    1. Em Resource, selecione ou insira gcs_bucket.
    2. Em Metric, selecione ou digite o Total bytes.
    O nome totalmente qualificado desse recurso monitorado é storage.googleapis.com/storage/total_bytes.
  6. Use os menus Filter, Group By e Aggregation para modificar como os dados são exibidos. Por exemplo, é possível agrupar por rótulos de recurso ou métrica. Para mais informações, consulte o tópico Outras configurações da página "Como selecionar métricas".

Use o Metrics Explorer também para medir outras métricas de intervalo, como storage.googleapis.com/storage/object_count e storage.googleapis.com/storage/total_byte_seconds, que calculam, respectivamente, o número de objetos e a quantidade de armazenamento consumido diariamente. Consulte a documentação sobre métricas do Stackdriver para ver a lista completa de métricas disponíveis. Para mais informações sobre como usar o Metrics Explorer, leia Métricas, séries temporais e recursos.

gsutil

Use o comando gsutil du com uma sinalização -s:

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

em que [BUCKET_NAME] é o nome do intervalo pertinente.

A resposta será parecida com este exemplo:

134620      gs://[BUCKET_NAME]

Nesse exemplo, o tamanho do intervalo é 134.620 bytes.

Como exibir os metadados de um intervalo

Para exibir os metadados associados a um intervalo:

Console

  1. Abra o navegador do Cloud Storage no Console do Google Cloud.
    Abrir o navegador do Cloud Storage
  2. Opcional: é possível limitar as colunas exibidas na lista de intervalos do Console do Cloud clicando no menu Opções de exibição de coluna (Ícone de opções da coluna.).

  3. Na lista de intervalos, encontre o intervalo que você quer verificar e analise os cabeçalhos das colunas dos metadados a serem visualizados.

gsutil

use o comando gsutil ls a seguir:

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

em que [BUCKET_NAME] é o nome do intervalo pertinente.

A resposta será parecida com este exemplo:

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

Amostras de código

C++

Para mais informações, consulte a documentação de referência da API do 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#

Para mais informações, consulte a documentação de referência da API do 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

Para mais informações, consulte a documentação de referência da API do 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

Para mais informações, consulte a documentação de referência da API do 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

Para mais informações, consulte a documentação de referência da API 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

Para mais informações, consulte a documentação de referência da API do 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

Para mais informações, consulte a documentação de referência da API do Cloud Storage para Python.

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

Para mais informações, consulte a documentação de referência da API do 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

APIs REST

API JSON

  1. Receba um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth.
  2. Use cURL (em inglês) para chamar a API JSON com uma solicitação GET Bucket:

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

    Em que:

    • [OAUTH2_TOKEN] é o nome do token de acesso gerado na Etapa 1;
    • [BUCKET_NAME] é o nome do intervalo pertinente. Por exemplo, my-bucket.
  3. Reduza os resultados aos campos do interesse usando parâmetros de consulta:

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

    Em que [FIELD#] é uma propriedade de intervalo que você quer incluir no resultado. Por exemplo, location e storageClass.

A resposta será parecida com este exemplo:

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

API XML

  1. Receba um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth.
  2. Use cURL (em inglês) para chamar a API XML com uma solicitação GET Bucket:

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

    Em que:

    • [OAUTH2_TOKEN] é o nome do token de acesso gerado na Etapa 1;
    • [BUCKET_NAME] é o nome do intervalo pertinente. Por exemplo, my-bucket;
    • [QUERY_PARAMETER] é o campo de metadados que você quer retornar. Por exemplo, location para receber o local do intervalo. Somente é possível usar um parâmetro de consulta por vez com a API XML.

    A resposta será parecida com este exemplo: <LocationConstraint>US</LocationConstraint>.

A seguir