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.
    Abrir o navegador do Cloud Storage
  2. Na lista de intervalos, clique no nome do intervalo que contém o objeto desejado e navegue até o objeto.

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

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 do 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 do 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 do Cloud Storage para Go.

ctx := context.Background()

    ctx, cancel := context.WithTimeout(ctx, time.Second*10)
    defer cancel()
    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 do 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.

/**
     * 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';

    // Imports the Google Cloud client library
    const {Storage} = require('@google-cloud/storage');

    // Creates a client
    const storage = new Storage();

    async function getMetadata() {
      // 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}`);
    }

    getMetadata().catch(console.error);

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();
        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.

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 do 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. 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 para chamar a API XML com uma solicitação de HEAD Objeto:

    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.
    Abrir o navegador do Cloud Storage
  2. Na lista de intervalos, clique no nome do intervalo que contém o objeto desejado e navegue até o objeto.

  3. Clique no menu de mais ações () associado ao objeto.

  4. Clique em Editar metadados.

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

    • Para campos de metadados padrão, edite o valor.

    • Adicione seus 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 a operação for 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 do Cloud Storage para C++.

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 do 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 do 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 do 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 do 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 para chamar a API JSON com uma solicitação de PATCH Objeto:

    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 que você gerou 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 Object UPDATE. 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