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.
   Abra 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 menu mais ações () 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.

Observação: o Console do Cloud não fornece uma lista completa de metadados associados a objetos. Para ver todos os metadados de um objeto, siga as instruções da gsutil.

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

Ver no GitHub Feedback

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

Ver no GitHub Feedback

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.

Ver no GitHub Feedback

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.

Ver no GitHub Feedback

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

Ver no GitHub Feedback

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

Ver no GitHub Feedback

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();
    if (isset($info['name'])) {
        printf('Blob: %s' . PHP_EOL, $info['name']);
    }
    if (isset($info['bucket'])) {
        printf('Bucket: %s' . PHP_EOL, $info['bucket']);
    }
    if (isset($info['storageClass'])) {
        printf('Storage class: %s' . PHP_EOL, $info['storageClass']);
    }
    if (isset($info['id'])) {
        printf('ID: %s' . PHP_EOL, $info['id']);
    }
    if (isset($info['size'])) {
        printf('Size: %s' . PHP_EOL, $info['size']);
    }
    if (isset($info['updated'])) {
        printf('Updated: %s' . PHP_EOL, $info['updated']);
    }
    if (isset($info['generation'])) {
        printf('Generation: %s' . PHP_EOL, $info['generation']);
    }
    if (isset($info['metageneration'])) {
        printf('Metageneration: %s' . PHP_EOL, $info['metageneration']);
    }
    if (isset($info['etag'])) {
        printf('Etag: %s' . PHP_EOL, $info['etag']);
    }
    if (isset($info['crc32c'])) {
        printf('Crc32c: %s' . PHP_EOL, $info['crc32c']);
    }
    if (isset($info['md5Hash'])) {
        printf('MD5 Hash: %s' . PHP_EOL, $info['md5Hash']);
    }
    if (isset($info['contentType'])) {
        printf('Content-type: %s' . PHP_EOL, $info['contentType']);
    }
    if (isset($info['temporaryHold'])) {
        printf("Temporary hold: " . ($info['temporaryHold'] ? "enabled" : "disabled") . PHP_EOL);
    }
    if (isset($info['eventBasedHold'])) {
        printf("Event-based hold: " . ($info['eventBasedHold'] ? "enabled" : "disabled") . PHP_EOL);
    }
    if (isset($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.

Ver no GitHub Feedback

from google.cloud import storage

def blob_metadata(bucket_name, blob_name):
    """Prints out a blob's metadata."""
    # bucket_name = 'your-bucket-name'
    # blob_name = 'your-object-name'

    storage_client = storage.Client()
    bucket = storage_client.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.

Ver no GitHubFeedback

# 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. Configure o Playground para usar suas credenciais do OAuth.

2. Use cURL para chamar a API JSON com uma solicitação de GET Objeto:

   curl -X GET \
     -H "Authorization: Bearer [OAUTH2_TOKEN]" \
     "https://storage.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. 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.
   Abra 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 menu mais ações () 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 Save.

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

Amostras de código

C++

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

Ver no GitHub Feedback

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

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

  gcs::ObjectMetadata desired = *object_metadata;
  desired.mutable_metadata().emplace(key, value);

  StatusOr<gcs::ObjectMetadata> updated =
      client.UpdateObject(bucket_name, object_name, desired,
                          gcs::Generation(object_metadata->generation()));

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

  std::cout << "Object updated. The full metadata after the update is: "
            << *updated << "\n";
}

C#

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

Para editar os metadados associados a um objeto usando C#, consulte a documentação de referência do PatchObject.

Go

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

Para editar os metadados associados a um objeto usando o Go, consulte a documentação de referência do ObjectHandle.

Java

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

Para editar os metadados associados a um objeto usando Java, consulte a documentação de referência do Blob.

Node.js

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

Para editar os metadados associados a um objeto usando o NodeJS, consulte a documentação de referência do Arquivo .

PHP

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

Para editar os metadados associados a um objeto usando PHP, consulte a documentação de referência do Google\Cloud Storage\StorageObject.

Python

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

Para editar os metadados associados a um objeto usando Python, consulte a documentação de referência do Blobs/Objects.

Ruby

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

Para editar os metadados associados a um objeto usando Ruby, consulte a documentação de referência do Google::Cloud::Storage::File.

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. 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://storage.googleapis.com/storage/v1/b/[BUCKET_NAME]/o/[OBJECT_NAME]"

   Em que:

   • [JSON_FILE_NAME] é o nome do arquivo JSON que você criou 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.

A seguir

• Saiba mais sobre os metadados associados a um objeto.
• Alterar classe de armazenamento associada a um objeto.
• Adicionar uma retenção a um objeto.