Como visualizar e editar metadados de objetos

Nesta página, você aprenderá como visualizar e editar os metadados associados a objetos armazenados no Cloud Storage. Para uma visão geral dos metadados de objetos, consulte este documento.

Esta página não abrange a visualização ou edição das políticas de gerenciamento de identidade e acesso (IAM, na sigla em inglês) ou das listas de controle de acesso (ACLs, na sigla em inglês) ao objeto, que controlam quem tem permissão para acessar seus dados. Consulte os guias Como usar permissões de IAM e Como criar e gerenciar ACLs para realizar essas tarefas.

Como ver os metadados de objetos

Para visualizar os metadados associados a um objeto:

Console

  1. Abra o navegador do Cloud Storage no Console do Google Cloud Platform.
    Abrir o navegador do Cloud Storage

  2. Na lista de intervalos, clique no nome daquele que contém o objeto que você quer e navegue até ele.

    Alguns metadados do objeto, como o tamanho e a classe de armazenamento, são exibidos ao lado do nome do objeto.

  3. Clique no botão de mais opções (Ícone ) associado ao objeto.

  4. Clique em Editar metadados.

    Aparecerá uma janela de sobreposição que mostra os valores atuais dos metadados editáveis do objeto.

gsutil

Use o comando gsutil stat:

gsutil stat gs://[BUCKET_NAME]/[OBJECT_NAME]

Em que:

  • [BUCKET_NAME] é o nome do intervalo que contém o objeto com os metadados que você quer ver. Por exemplo, my-awesome-bucket;
  • [OBJECT_NAME] é o nome do objeto com os metadados que você quer ver. Por exemplo, cat.jpeg.

Se a operação for bem-sucedida, a resposta será semelhante a esta:

gs://my-awesome-bucket/cat.jpeg:
Creation time:          Fri, 03 Feb 2017 22:43:31 GMT
Update time:            Wed, 10 May 2017 18:33:07 GMT
Storage class:          STANDARD
Content-Length:         11012
Content-Type:           image/jpeg
Metadata:
    Breed:              Tabby
Hash (crc32c):          HQbzrB==
Hash (md5):             OBydg25+pPG1Cwawjsl7DA==
ETag:                   CJCh9apA9dECAEs=
Generation:             1486161811706000
Metageneration:         11

Amostras de código

C++

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

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string object_name) {
  StatusOr<gcs::ObjectMetadata> object_metadata =
      client.GetObjectMetadata(bucket_name, object_name);

  if (!object_metadata) {
    throw std::runtime_error(object_metadata.status().message());
  }

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

C#

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

private void GetMetadata(string bucketName, string objectName)
{
    var storage = StorageClient.Create();
    var storageObject = storage.GetObject(bucketName, objectName);
    Console.WriteLine($"Bucket:\t{storageObject.Bucket}");
    Console.WriteLine($"CacheControl:\t{storageObject.CacheControl}");
    Console.WriteLine($"ComponentCount:\t{storageObject.ComponentCount}");
    Console.WriteLine($"ContentDisposition:\t{storageObject.ContentDisposition}");
    Console.WriteLine($"ContentEncoding:\t{storageObject.ContentEncoding}");
    Console.WriteLine($"ContentLanguage:\t{storageObject.ContentLanguage}");
    Console.WriteLine($"ContentType:\t{storageObject.ContentType}");
    Console.WriteLine($"Crc32c:\t{storageObject.Crc32c}");
    Console.WriteLine($"ETag:\t{storageObject.ETag}");
    Console.WriteLine($"Generation:\t{storageObject.Generation}");
    Console.WriteLine($"Id:\t{storageObject.Id}");
    Console.WriteLine($"Kind:\t{storageObject.Kind}");
    Console.WriteLine($"KmsKeyName:\t{storageObject.KmsKeyName}");
    Console.WriteLine($"Md5Hash:\t{storageObject.Md5Hash}");
    Console.WriteLine($"MediaLink:\t{storageObject.MediaLink}");
    Console.WriteLine($"Metageneration:\t{storageObject.Metageneration}");
    Console.WriteLine($"Name:\t{storageObject.Name}");
    Console.WriteLine($"Size:\t{storageObject.Size}");
    Console.WriteLine($"StorageClass:\t{storageObject.StorageClass}");
    Console.WriteLine($"TimeCreated:\t{storageObject.TimeCreated}");
    Console.WriteLine($"Updated:\t{storageObject.Updated}");
    bool? eventBasedHoldOrNull = storageObject?.EventBasedHold;
    bool eventBasedHold =
        eventBasedHoldOrNull.HasValue ? eventBasedHoldOrNull.Value : false;
    Console.WriteLine("Event-based hold enabled? {0}", eventBasedHold);
    bool? temporaryHoldOrNull = storageObject?.TemporaryHold;
    bool temporaryHold =
        temporaryHoldOrNull.HasValue ? temporaryHoldOrNull.Value : false;
    Console.WriteLine("Temporary hold enabled? {0}", temporaryHold);
    Console.WriteLine($"RetentionExpirationTime\t{storageObject.RetentionExpirationTime}");
}

Go

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

o := client.Bucket(bucket).Object(object)
attrs, err := o.Attrs(ctx)
if err != nil {
	return nil, err
}
log.Printf("Bucket: %v\n", attrs.Bucket)
log.Printf("CacheControl: %v\n", attrs.CacheControl)
log.Printf("ContentDisposition: %v\n", attrs.ContentDisposition)
log.Printf("ContentEncoding: %v\n", attrs.ContentEncoding)
log.Printf("ContentLanguage: %v\n", attrs.ContentLanguage)
log.Printf("ContentType: %v\n", attrs.ContentType)
log.Printf("Crc32c: %v\n", attrs.CRC32C)
log.Printf("Generation: %v\n", attrs.Generation)
log.Printf("KmsKeyName: %v\n", attrs.KMSKeyName)
log.Printf("Md5Hash: %v\n", attrs.MD5)
log.Printf("MediaLink: %v\n", attrs.MediaLink)
log.Printf("Metageneration: %v\n", attrs.Metageneration)
log.Printf("Name: %v\n", attrs.Name)
log.Printf("Size: %v\n", attrs.Size)
log.Printf("StorageClass: %v\n", attrs.StorageClass)
log.Printf("TimeCreated: %v\n", attrs.Created)
log.Printf("Updated: %v\n", attrs.Updated)
log.Printf("Event-based hold enabled? %t\n", attrs.EventBasedHold)
log.Printf("Temporary hold enabled? %t\n", attrs.TemporaryHold)
log.Printf("Retention expiration time %v\n", attrs.RetentionExpirationTime)
log.Print("\n\nMetadata\n")
for key, value := range attrs.Metadata {
	log.Printf("\t%v = %v\n", key, value)
}

return attrs, nil

Java

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

// Instantiate a Google Cloud Storage client
Storage storage = StorageOptions.getDefaultInstance().getService();

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

// The name of a blob, e.g. "my-blob"
// String blobName = "my-blob";

// Select all fields
// Fields can be selected individually e.g. Storage.BlobField.CACHE_CONTROL
Blob blob = storage.get(bucketName, blobName, BlobGetOption.fields(Storage.BlobField.values()));

// Print blob metadata
System.out.println("Bucket: " + blob.getBucket());
System.out.println("CacheControl: " + blob.getCacheControl());
System.out.println("ComponentCount: " + blob.getComponentCount());
System.out.println("ContentDisposition: " + blob.getContentDisposition());
System.out.println("ContentEncoding: " + blob.getContentEncoding());
System.out.println("ContentLanguage: " + blob.getContentLanguage());
System.out.println("ContentType: " + blob.getContentType());
System.out.println("Crc32c: " + blob.getCrc32c());
System.out.println("Crc32cHexString: " + blob.getCrc32cToHexString());
System.out.println("ETag: " + blob.getEtag());
System.out.println("Generation: " + blob.getGeneration());
System.out.println("Id: " + blob.getBlobId());
System.out.println("KmsKeyName: " + blob.getKmsKeyName());
System.out.println("Md5Hash: " + blob.getMd5());
System.out.println("Md5HexString: " + blob.getMd5ToHexString());
System.out.println("MediaLink: " + blob.getMediaLink());
System.out.println("Metageneration: " + blob.getMetageneration());
System.out.println("Name: " + blob.getName());
System.out.println("Size: " + blob.getSize());
System.out.println("StorageClass: " + blob.getStorageClass());
System.out.println("TimeCreated: " + new Date(blob.getCreateTime()));
System.out.println("Last Metadata Update: " + new Date(blob.getUpdateTime()));
Boolean temporaryHoldIsEnabled = (blob.getTemporaryHold() != null && blob.getTemporaryHold());
System.out.println("temporaryHold: " + (temporaryHoldIsEnabled ? "enabled" : "disabled"));
Boolean eventBasedHoldIsEnabled =
    (blob.getEventBasedHold() != null && blob.getEventBasedHold());
System.out.println("eventBasedHold: " + (eventBasedHoldIsEnabled ? "enabled" : "disabled"));
if (blob.getRetentionExpirationTime() != null) {
  System.out.println("retentionExpirationTime: " + new Date(blob.getRetentionExpirationTime()));
}
if (blob.getMetadata() != null) {
  System.out.println("\n\n\nUser metadata:");
  for (Map.Entry<String, String> userMetadata : blob.getMetadata().entrySet()) {
    System.out.println(userMetadata.getKey() + "=" + userMetadata.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();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'File to access, e.g. file.txt';

// Gets the metadata for the file
const [metadata] = await storage
  .bucket(bucketName)
  .file(filename)
  .getMetadata();

console.log(`File: ${metadata.name}`);
console.log(`Bucket: ${metadata.bucket}`);
console.log(`Storage class: ${metadata.storageClass}`);
console.log(`Self link: ${metadata.selfLink}`);
console.log(`ID: ${metadata.id}`);
console.log(`Size: ${metadata.size}`);
console.log(`Updated: ${metadata.updated}`);
console.log(`Generation: ${metadata.generation}`);
console.log(`Metageneration: ${metadata.metageneration}`);
console.log(`Etag: ${metadata.etag}`);
console.log(`Owner: ${metadata.owner}`);
console.log(`Component count: ${metadata.component_count}`);
console.log(`Crc32c: ${metadata.crc32c}`);
console.log(`md5Hash: ${metadata.md5Hash}`);
console.log(`Cache-control: ${metadata.cacheControl}`);
console.log(`Content-type: ${metadata.contentType}`);
console.log(`Content-disposition: ${metadata.contentDisposition}`);
console.log(`Content-encoding: ${metadata.contentEncoding}`);
console.log(`Content-language: ${metadata.contentLanguage}`);
console.log(`Media link: ${metadata.mediaLink}`);
console.log(`KMS Key Name: ${metadata.kmsKeyName}`);
console.log(`Temporary Hold: ${metadata.temporaryHold}`);
console.log(`Event-based hold: ${metadata.eventBasedHold}`);
console.log(`Effective Expiration Time: ${metadata.effectiveExpirationTime}`);
console.log(`Metadata: ${metadata.metadata}`);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * List object metadata.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 * @param string $objectName the name of your Cloud Storage object.
 *
 * @return void
 */
function object_metadata($bucketName, $objectName)
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $info = $object->info();
    printf('Blob: %s' . PHP_EOL, $info['name']);
    printf('Bucket: %s' . PHP_EOL, $info['bucket']);
    printf('Storage class: %s' . PHP_EOL, $info['storageClass']);
    printf('ID: %s' . PHP_EOL, $info['id']);
    printf('Size: %s' . PHP_EOL, $info['size']);
    printf('Updated: %s' . PHP_EOL, $info['updated']);
    printf('Generation: %s' . PHP_EOL, $info['generation']);
    printf('Metageneration: %s' . PHP_EOL, $info['metageneration']);
    printf('Etag: %s' . PHP_EOL, $info['etag']);
    printf('Crc32c: %s' . PHP_EOL, $info['crc32c']);
    printf('MD5 Hash: %s' . PHP_EOL, $info['md5Hash']);
    printf('Content-type: %s' . PHP_EOL, $info['contentType']);
    printf("Temporary hold: " . ($info['temporaryHold'] ? "enabled" : "disabled") . PHP_EOL);
    printf("Event-based hold: " . ($info['eventBasedHold'] ? "enabled" : "disabled") . PHP_EOL);
    if ($info['retentionExpirationTime']) {
        printf("retentionExpirationTime: " . $info['retentionExpirationTime'] . PHP_EOL);
    }
    if (isset($info['metadata'])) {
        printf('Metadata: %s', print_r($info['metadata'], true));
    }
}

Python

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

def blob_metadata(bucket_name, blob_name):
    """Prints out a blob's metadata."""
    storage_client = storage.Client()
    bucket = storage_client.get_bucket(bucket_name)
    blob = bucket.get_blob(blob_name)

    print('Blob: {}'.format(blob.name))
    print('Bucket: {}'.format(blob.bucket.name))
    print('Storage class: {}'.format(blob.storage_class))
    print('ID: {}'.format(blob.id))
    print('Size: {} bytes'.format(blob.size))
    print('Updated: {}'.format(blob.updated))
    print('Generation: {}'.format(blob.generation))
    print('Metageneration: {}'.format(blob.metageneration))
    print('Etag: {}'.format(blob.etag))
    print('Owner: {}'.format(blob.owner))
    print('Component count: {}'.format(blob.component_count))
    print('Crc32c: {}'.format(blob.crc32c))
    print('md5_hash: {}'.format(blob.md5_hash))
    print('Cache-control: {}'.format(blob.cache_control))
    print('Content-type: {}'.format(blob.content_type))
    print('Content-disposition: {}'.format(blob.content_disposition))
    print('Content-encoding: {}'.format(blob.content_encoding))
    print('Content-language: {}'.format(blob.content_language))
    print('Metadata: {}'.format(blob.metadata))
    print("Temporary hold: ",
          'enabled' if blob.temporary_hold else 'disabled')
    print("Event based hold: ",
          'enabled' if blob.event_based_hold else 'disabled')
    if blob.retention_expiration_time:
        print("retentionExpirationTime: {}"
              .format(blob.retention_expiration_time))

Ruby

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

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage bucket name"
# file_name   = "Name of file in Google Cloud Storage"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new project_id: project_id
bucket  = storage.bucket bucket_name
file    = bucket.file file_name

puts "Name: #{file.name}"
puts "Bucket: #{bucket.name}"
puts "Storage class: #{bucket.storage_class}"
puts "ID: #{file.id}"
puts "Size: #{file.size} bytes"
puts "Created: #{file.created_at}"
puts "Updated: #{file.updated_at}"
puts "Generation: #{file.generation}"
puts "Metageneration: #{file.metageneration}"
puts "Etag: #{file.etag}"
puts "Owners: #{file.acl.owners.join ','}"
puts "Crc32c: #{file.crc32c}"
puts "md5_hash: #{file.md5}"
puts "Cache-control: #{file.cache_control}"
puts "Content-type: #{file.content_type}"
puts "Content-disposition: #{file.content_disposition}"
puts "Content-encoding: #{file.content_encoding}"
puts "Content-language: #{file.content_language}"
puts "KmsKeyName: #{file.kms_key}"
puts "Event-based hold enabled?: #{file.event_based_hold?}"
puts "Temporary hold enaled?: #{file.temporary_hold?}"
puts "Retention Expiration: #{file.retention_expires_at}"
puts "Metadata:"
file.metadata.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 (em inglês). 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 Object:

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

    Em que:

    • [OAUTH2_TOKEN] é o token de acesso gerado na Etapa 1;
    • [BUCKET_NAME] é o nome do intervalo que contém o objeto com os metadados que você quer ver. Por exemplo, my-bucket;
    • [OBJECT_NAME] é o nome do objeto com os metadados que você quer ver. Por exemplo, pets/dog.png.

API XML

  1. Receba um token de acesso de autorização do OAuth 2.0 Playground (em inglês). Configure o Playground para usar suas credenciais do OAuth.

  2. Use cURL (em inglês) para chamar a API XML com uma solicitação HEAD Object:

    curl -I HEAD \
  -H "Authorization: Bearer [OAUTH2_TOKEN]" \
  "https://storage.googleapis.com/[BUCKET_NAME]/[OBJECT_NAME]"

    Em que:

    • [OAUTH2_TOKEN] é o token de acesso gerado na Etapa 1;
    • [BUCKET_NAME] é o nome do intervalo que contém o objeto com os metadados que você quer ver. Por exemplo, my-bucket;
    • [OBJECT_NAME] é o nome do objeto com os metadados que você quer ver. Por exemplo, pets/dog.png.

Como editar metadados de objetos

Para editar os metadados associados a um objeto:

Console

  1. Abra o navegador do Cloud Storage no Console do Google Cloud Platform.
    Abrir o navegador do Cloud Storage

  2. Na lista de intervalos, clique no nome daquele que contém o objeto que você quer e navegue até ele.

  3. Clique no botão de mais opções (Ícone ) associado ao objeto.

  4. Clique em Editar metadados.

  5. Na janela de sobreposição que aparece, faça as edições que você quiser nos metadados.

    • Nos campos de metadados padrão, edite o Valor.

    • Adicione os próprios metadados personalizados clicando no botão + Adicionar item.

    • Edite a chave e o valor dos metadados personalizados.

    • Exclua os metadados personalizados clicando nos respectivos X.

  6. Clique em Salvar.

gsutil

Use o comando gsutil setmeta -h:

gsutil setmeta -h "[METADATA_KEY]:[METADATA_VALUE]" gs://[BUCKET_NAME]/[OBJECT_NAME]

Em que:

  • [METADATA_KEY] é a chave dos metadados que você quer definir. Por exemplo, Content-Type;
  • [METADATA_VALUE] é o valor dos metadados que você quer definir. Por exemplo, image/png;
  • [BUCKET_NAME] é o nome do intervalo que contém o objeto com os metadados que você quer editar. Por exemplo, my-bucket;
  • [OBJECT_NAME] é o nome do objeto com os metadados que você quer editar. Por exemplo, pets/dog.png.

Se bem-sucedido, a resposta será parecida com esta:

Operation completed over 1 objects.

Se você estiver adicionando metadados personalizados com a gsutil, precisará incluir x-goog-meta- como prefixo da chave de metadados para que a ferramenta reconheça que se trata de um atributo de metadados personalizados, não um cabeçalho HTTP padrão. A chave de metadados não é armazenada com o prefixo x-goog-meta-. Um exemplo de "[METADATA_KEY]:[METADATA_VALUE]" personalizado é "x-goog-meta-dogbreed:shibainu".

APIs REST

API JSON

  1. Receba um token de acesso de autorização do OAuth 2.0 Playground (em inglês). Configure o Playground para usar suas credenciais do OAuth.

  2. Crie um arquivo .json com os metadados que pretende adicionar.

    No caso de metadados de chave fixa, como contentType, use o seguinte formato:

    {
  "[STANDARD_METADATA_KEY]": "[STANDARD_METADATA_VALUE]"
}

    Em que:

    • [STANDARD_METADATA_KEY] é a chave dos metadados que você quer definir. Por exemplo, Content-Type.
    • [STANDARD_METADATA_VALUE] é o valor dos metadados que você quer definir. Por exemplo, image/png.

    No caso de metadados personalizados, use o seguinte formato:

    {
  "metadata": {
    "[CUSTOM_METADATA_KEY]": "[CUSTOM_METADATA_VALUE]"
  }
}

    Em que:

    • [CUSTOM_METADATA_KEY] é a chave dos metadados personalizados que você quer definir. Por exemplo, dogbreed;
    • [CUSTOM_METADATA_VALUE] é o valor dos metadados personalizados que você quer definir. Por exemplo, shibainu.

  3. Use cURL (em inglês) para chamar a API JSON com uma solicitação PATCH Object:

    curl -X PATCH --data-binary @[JSON_FILE_NAME].json \
  -H "Authorization: Bearer [OAUTH2_TOKEN]" \
  -H "Content-Type: application/json" \
  "https://www.googleapis.com/storage/v1/b/[BUCKET_NAME]/o/[OBJECT_NAME]"

    Em que:

    • [JSON_FILE_NAME] é o nome do arquivo JSON criado na Etapa 2;
    • [OAUTH2_TOKEN] é o nome do token de acesso gerado na Etapa 1;
    • [BUCKET_NAME] é o nome do intervalo que contém o objeto com os metadados que você quer editar. Por exemplo, my-bucket.
    • [OBJECT_NAME] é o nome do objeto com os metadados que você quer editar. Por exemplo, pets/dog.png.

Também é possível alterar os metadados de um objeto com uma solicitação UPDATE Object. Ao usar esse método, todos os metadados que não estiverem explicitamente especificados na solicitação serão removidos do objeto.

API XML

Ao trabalhar com a API XML, os metadados são definidos somente no momento em que o objeto é gravado, por exemplo, ao fazer upload, migrar ou substituir o objeto. Siga as instruções de como fazer o upload de um objeto com as seguintes orientações:

  • Adicione -H "[METADATA_KEY]:[METADATA_VALUE]" ao cabeçalho da solicitação para cada valor de metadado a ser definido. Por exemplo, -H "Content-Type:image/png".

  • Inclua x-goog-meta- com prefixo em todos os valores de metadados personalizados. Um exemplo de "[METADATA_KEY]:[METADATA_VALUE]" personalizado é "x-goog-meta-dogbreed:shibainu".

Para mais informações, consulte Upload de um objeto para XML.

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Esta página
Comentários sobre a documentação
Cloud Storage
Comentários sobre o produto
Precisa de ajuda? Acesse nossa página de suporte.