Fazer upload de objetos

Nesta página, mostramos como fazer o upload de objetos para um bucket do Cloud Storage. Um objeto enviado por upload consiste nos dados que você quer armazenar com os metadados associados. Para uma visão geral conceitual, incluindo como escolher o método de upload ideal com base no tamanho do arquivo, consulte Uploads e downloads.

Pré-requisitos

Os pré-requisitos podem variar com base na ferramenta usada:

Console

Para concluir este guia usando o Console do Google Cloud, é preciso ter as permissões de IAM adequadas. Se o bucket que você quer enviar existir em um projeto criado por você, talvez seja necessário que o proprietário do projeto conceda um papel que contenha as permissões necessárias.

Para uma lista de permissões necessárias para ações específicas, consulte Permissões do IAM para o Console do Google Cloud.

Para ver a lista de papéis relevantes, consulte Papéis do Cloud Storage. Como alternativa, é possível criar um papel personalizado que tenha permissões mais limitadas.

Linha de comando

Para concluir este guia usando um utilitário de linha de comando, você precisa ter as permissões de IAM adequadas. Se o bucket que você quer enviar existir em um projeto que você não criou, talvez seja necessário que o proprietário do projeto conceda um papel que contenha as permissões necessárias.

Para uma lista de permissões necessárias para ações específicas, consulte Permissões do IAM para comandos gsutil.

Para ver a lista de papéis relevantes, consulte Papéis do Cloud Storage. Como alternativa, é possível criar um papel personalizado que tenha permissões mais limitadas.

Exemplos de código

Para concluir este guia usando as bibliotecas de cliente do Cloud Storage, é preciso ter as permissões de IAM adequadas. Se o bucket que você quer enviar existir em um projeto criado por você, talvez seja necessário que o proprietário do projeto conceda um papel que contenha as permissões necessárias. Salvo indicação em contrário, as solicitações de biblioteca de cliente são feitas por meio da API JSON.

Para uma lista de permissões necessárias para ações específicas, consulte Permissões do IAM para métodos JSON.

Para ver a lista de papéis relevantes, consulte Papéis do Cloud Storage. Como alternativa, é possível criar um papel personalizado que tenha permissões mais limitadas.

APIs REST

API JSON

Para concluir este guia usando a API JSON, é preciso ter as permissões do IAM adequadas. Se o bucket que você quer enviar existir em um projeto criado por você, o proprietário do projeto poderá precisar de um papel que contenha as permissões necessárias.

Para uma lista de permissões necessárias para ações específicas, consulte Permissões do IAM para métodos JSON.

Para ver a lista de papéis relevantes, consulte Papéis do Cloud Storage. Como alternativa, é possível criar um papel personalizado que tenha permissões mais limitadas.

Faça upload de um objeto em um bucket

Siga estas etapas para fazer upload de um objeto para um bucket:

Console

  1. No Console do Cloud, acesse a página Navegador do Cloud Storage.

    Acessar o navegador

  2. Na lista de buckets, clique no nome daquele que receberá o upload de um objeto.

  3. Na guia Objetos do bucket, realize uma destas ações:

    • Arraste e solte os arquivos que você quer enviar da área de trabalho ou do gerenciador de arquivos para o painel principal no Console do Cloud.

    • Clique no botão Enviar arquivos, selecione os arquivos que serão enviados na caixa de diálogo exibida e clique em Abrir.

Para informações detalhadas sobre erros de operações com falha no navegador do Cloud Storage, consulte Solução de problemas.

Linha de comando

gcloud

Use o comando gcloud alpha storage cp:

gcloud alpha storage cp OBJECT_LOCATION gs://DESTINATION_BUCKET_NAME/

Em que:

  • OBJECT_LOCATION é o caminho local do objeto. Por exemplo, Desktop/dog.png.

  • DESTINATION_BUCKET_NAME é o nome do bucket de upload do objeto. Por exemplo, my-bucket.

Se funcionar, a resposta será parecida com esta:

Completed files 1/1 | 164.3kiB/164.3kiB

É possível definir metadados de objetos personalizados e de chave fixa como parte do upload do objeto usando sinalizações de comando.

gsutil

Use o comando gsutil cp:

gsutil cp OBJECT_LOCATION gs://DESTINATION_BUCKET_NAME/

Em que:

  • OBJECT_LOCATION é o caminho local do objeto. Por exemplo, Desktop/dog.png.

  • DESTINATION_BUCKET_NAME é o nome do bucket de upload do objeto. Por exemplo, my-bucket.

Se funcionar, a resposta será parecida com esta:

Operation completed over 1 objects/58.8 KiB.

É possível definir metadados de objeto de chave fixa e personalizados como parte do upload do objeto nos cabeçalhos da solicitação usando a opção global -h.

Amostras de código

C++

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

No exemplo a seguir, um objeto é enviado de um arquivo:

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& file_name,
   std::string const& bucket_name, std::string const& object_name) {
  // Note that the client library automatically computes a hash on the
  // client-side to verify data integrity during transmission.
  StatusOr<gcs::ObjectMetadata> metadata = client.UploadFile(
      file_name, bucket_name, object_name, gcs::IfGenerationMatch(0));
  if (!metadata) throw std::runtime_error(metadata.status().message());

  std::cout << "Uploaded " << file_name << " to object " << metadata->name()
            << " in bucket " << metadata->bucket()
            << "\nFull metadata: " << *metadata << "\n";
}

O exemplo a seguir, um objeto é enviado da memória:

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name) {
  std::string const text = "Lorem ipsum dolor sit amet";
  std::vector<std::string> v(100, text);
  gcs::ObjectWriteStream stream =
      client.WriteObject(bucket_name, object_name);

  std::copy(v.begin(), v.end(), std::ostream_iterator<std::string>(stream));

  stream.Close();

  StatusOr<gcs::ObjectMetadata> metadata = std::move(stream).metadata();
  if (!metadata) throw std::runtime_error(metadata.status().message());
  std::cout << "Successfully wrote to object " << metadata->name()
            << " its size is: " << metadata->size()
            << "\nFull metadata: " << *metadata << "\n";
}

C#

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

No exemplo a seguir, um objeto é enviado de um arquivo:


using Google.Cloud.Storage.V1;
using System;
using System.IO;

public class UploadFileSample
{
    public void UploadFile(
        string bucketName = "your-unique-bucket-name",
        string localPath = "my-local-path/my-file-name",
        string objectName = "my-file-name")
    {
        var storage = StorageClient.Create();
        using var fileStream = File.OpenRead(localPath);
        storage.UploadObject(bucketName, objectName, null, fileStream);
        Console.WriteLine($"Uploaded {objectName}.");
    }
}

O exemplo a seguir, um objeto é enviado da memória:


using Google.Cloud.Storage.V1;
using System;
using System.IO;
using System.Text;

public class UploadObjectFromMemorySample
{
    public void UploadObjectFromMemory(
        string bucketName = "unique-bucket-name",
        string objectName = "file-name",
        string contents = "Hello world!")
    {
        var storage = StorageClient.Create();
        byte[] byteArray = Encoding.UTF8.GetBytes(contents);
        MemoryStream stream = new MemoryStream(byteArray);
        storage.UploadObject(bucketName, objectName, "application/octet-stream" , stream);

        Console.WriteLine($" {objectName} uploaded to bucket {bucketName} with contents: {contents}");
    }
}

Go

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

No exemplo a seguir, um objeto é enviado de um arquivo:

import (
	"context"
	"fmt"
	"io"
	"os"
	"time"

	"cloud.google.com/go/storage"
)

// uploadFile uploads an object.
func uploadFile(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	// Open local file.
	f, err := os.Open("notes.txt")
	if err != nil {
		return fmt.Errorf("os.Open: %v", err)
	}
	defer f.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*50)
	defer cancel()

	o := client.Bucket(bucket).Object(object)

	// Optional: set a generation-match precondition to avoid potential race
	// conditions and data corruptions. The request to upload is aborted if the
	// object's generation number does not match your precondition.
	// For an object that does not yet exist, set the DoesNotExist precondition.
	o = o.If(storage.Conditions{DoesNotExist: true})
	// If the live object already exists in your bucket, set instead a
	// generation-match precondition using the live object's generation number.
	// attrs, err := o.Attrs(ctx)
	// if err != nil {
	// 	return fmt.Errorf("object.Attrs: %v", err)
	// }
	// o = o.If(storage.Conditions{GenerationMatch: attrs.Generation})

	// Upload an object with storage.Writer.
	wc := o.NewWriter(ctx)
	if _, err = io.Copy(wc, f); err != nil {
		return fmt.Errorf("io.Copy: %v", err)
	}
	if err := wc.Close(); err != nil {
		return fmt.Errorf("Writer.Close: %v", err)
	}
	fmt.Fprintf(w, "Blob %v uploaded.\n", object)
	return nil
}

O exemplo a seguir, um objeto é enviado da memória:

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// streamFileUpload uploads an object via a stream.
func streamFileUpload(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	b := []byte("Hello world.")
	buf := bytes.NewBuffer(b)

	ctx, cancel := context.WithTimeout(ctx, time.Second*50)
	defer cancel()

	// Upload an object with storage.Writer.
	wc := client.Bucket(bucket).Object(object).NewWriter(ctx)
	wc.ChunkSize = 0 // note retries are not supported for chunk size 0.

	if _, err = io.Copy(wc, buf); err != nil {
		return fmt.Errorf("io.Copy: %v", err)
	}
	// Data can continue to be added to the file until the writer is closed.
	if err := wc.Close(); err != nil {
		return fmt.Errorf("Writer.Close: %v", err)
	}
	fmt.Fprintf(w, "%v uploaded to %v.\n", object, bucket)

	return nil
}

Java

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

No exemplo a seguir, um objeto é enviado de um arquivo:


import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.BlobInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class UploadObject {
  public static void uploadObject(
      String projectId, String bucketName, String objectName, String filePath) throws IOException {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The ID of your GCS object
    // String objectName = "your-object-name";

    // The path to your file to upload
    // String filePath = "path/to/your/file"

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    BlobId blobId = BlobId.of(bucketName, objectName);
    BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();
    storage.create(blobInfo, Files.readAllBytes(Paths.get(filePath)));

    System.out.println(
        "File " + filePath + " uploaded to bucket " + bucketName + " as " + objectName);
  }
}

O exemplo a seguir, um objeto é enviado da memória:


import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.BlobInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class UploadObjectFromMemory {
  public static void uploadObjectFromMemory(
      String projectId, String bucketName, String objectName, String contents) throws IOException {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The ID of your GCS object
    // String objectName = "your-object-name";

    // The string of contents you wish to upload
    // String contents = "Hello world!";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    BlobId blobId = BlobId.of(bucketName, objectName);
    BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();
    byte[] content = contents.getBytes(StandardCharsets.UTF_8);
    storage.createFrom(blobInfo, new ByteArrayInputStream(content));

    System.out.println(
        "Object "
            + objectName
            + " uploaded to bucket "
            + bucketName
            + " with contents "
            + contents);
  }
}

Node.js

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

No exemplo a seguir, um objeto é enviado de um arquivo:

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The path to your file to upload
// const filePath = 'path/to/your/file';

// The new ID for your GCS file
// const destFileName = 'your-new-file-name';

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

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

async function uploadFile() {
  await storage.bucket(bucketName).upload(filePath, {
    destination: destFileName,
  });

  console.log(`${filePath} uploaded to ${bucketName}`);
}

uploadFile().catch(console.error);

O exemplo a seguir, um objeto é enviado da memória:

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The contents that you want to upload
// const contents = 'these are my contents';

// The new ID for your GCS file
// const destFileName = 'your-new-file-name';

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

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

async function uploadFromMemory() {
  await storage.bucket(bucketName).file(destFileName).save(contents);

  console.log(
    `${destFileName} with contents ${contents} uploaded to ${bucketName}.`
  );
}

uploadFromMemory().catch(console.error);

PHP

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

No exemplo a seguir, um objeto é enviado de um arquivo:

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 * @param string $source The path to the file to upload.
 */
function upload_object($bucketName, $objectName, $source)
{
    // $bucketName = 'my-bucket';
    // $objectName = 'my-object';
    // $source = '/path/to/your/file';

    $storage = new StorageClient();
    $file = fopen($source, 'r');
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->upload($file, [
        'name' => $objectName
    ]);
    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, basename($source), $bucketName, $objectName);
}

O exemplo a seguir, um objeto é enviado da memória:

use Google\Cloud\Storage\StorageClient;

/**
 * Upload an object from memory buffer.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 * @param string $contents The contents to upload to the file.
 */
function upload_object_from_memory(
    string $bucketName,
    string $objectName,
    string $contents
): void {
    // $bucketName = 'my-bucket';
    // $objectName = 'my-object';
    // $contents = 'these are my contents';

    $storage = new StorageClient();
    $stream = fopen('data://text/plain,' . $contents, 'r');
    $bucket = $storage->bucket($bucketName);
    $bucket->upload($stream, [
        'name' => $objectName,
    ]);
    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, $contents, $bucketName, $objectName);
}

Python

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

No exemplo a seguir, um objeto é enviado de um arquivo:

from google.cloud import storage

def upload_blob(bucket_name, source_file_name, destination_blob_name):
    """Uploads a file to the bucket."""
    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"
    # The path to your file to upload
    # source_file_name = "local/path/to/file"
    # The ID of your GCS object
    # destination_blob_name = "storage-object-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(destination_blob_name)

    blob.upload_from_filename(source_file_name)

    print(
        f"File {source_file_name} uploaded to {destination_blob_name}."
    )

O exemplo a seguir, um objeto é enviado da memória:

from google.cloud import storage

def upload_blob_from_memory(bucket_name, contents, destination_blob_name):
    """Uploads a file to the bucket."""

    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"

    # The contents to upload to the file
    # contents = "these are my contents"

    # The ID of your GCS object
    # destination_blob_name = "storage-object-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(destination_blob_name)

    blob.upload_from_string(contents)

    print(
        f"{destination_blob_name} with contents {contents} uploaded to {bucket_name}."
    )

Ruby

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

No exemplo a seguir, um objeto é enviado de um arquivo:

def upload_file bucket_name:, local_file_path:, file_name: nil
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The path to your file to upload
  # local_file_path = "/local/path/to/file.txt"

  # The ID of your GCS object
  # file_name = "your-file-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name, skip_lookup: true

  file = bucket.create_file local_file_path, file_name

  puts "Uploaded #{local_file_path} as #{file.name} in bucket #{bucket_name}"
end

O exemplo a seguir, um objeto é enviado da memória:

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"

# The ID of your GCS object
# file_name = "your-file-name"

# The contents to upload to your file
# file_content = "Hello, world!"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name, skip_lookup: true

file = bucket.create_file StringIO.new(file_content), file_name

puts "Uploaded file #{file.name} to bucket #{bucket_name} with content: #{file_content}"

Terraform

É possível usar um recurso Terraform para fazer upload de um objeto. É preciso especificar content ou source. Você também pode especificar ambos.

# Upload files
# Discussion about using tf to upload a large number of objects
# https://stackoverflow.com/questions/68455132/terraform-copy-multiple-files-to-bucket-at-the-same-time-bucket-creation

# The text object in Cloud Storage
resource "google_storage_bucket_object" "default" {
  name         = "new-object"
# Uncomment and add valid path to an object.
#  source       = "/path/to/an/object"
  content      = "Data as string to be uploaded"
  content_type = "text/plain"
  bucket       = google_storage_bucket.static.id
}

APIs REST

API JSON

Upload de solicitação única sem metadados de objeto

  1. Receba um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth. Para ver instruções, consulte Autenticação de APIs.

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

    curl -X POST --data-binary @OBJECT_LOCATION \
    -H "Authorization: Bearer OAUTH2_TOKEN" \
    -H "Content-Type: OBJECT_CONTENT_TYPE" \
    "https://storage.googleapis.com/upload/storage/v1/b/BUCKET_NAME/o?uploadType=media&name=OBJECT_NAME"

    Em que:

    • OBJECT_LOCATION é o caminho local do objeto. Por exemplo, Desktop/dog.png.
    • OAUTH2_TOKEN é o token de acesso gerado na etapa 1;
    • OBJECT_CONTENT_TYPE é o tipo de conteúdo do objeto. Por exemplo, image/png.
    • BUCKET_NAME é o nome do bucket para o qual você está fazendo o upload do objeto. Por exemplo, my-bucket.
    • OBJECT_NAME é o nome codificado por URL que você quer dar ao objeto. Por exemplo, pets/dog.png, codificado por URL como pets%2Fdog.png.

Upload de solicitação única com metadados de objeto

  1. Receba um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth. Para ver instruções, consulte Autenticação de APIs.

  2. Crie um arquivo multipart/related com estas informações:

    --BOUNDARY_STRING
Content-Type: application/json; charset=UTF-8

OBJECT_METADATA

--BOUNDARY_STRING
Content-Type: OBJECT_CONTENT_TYPE

OBJECT_DATA
--BOUNDARY_STRING--

    Em que:

    • BOUNDARY_STRING é uma string que você define e identifica as partes do arquivo de várias partes. Por exemplo, my-boundary.
    • OBJECT_METADATA são os metadados que você quer incluir no arquivo, no formato JSON. No mínimo, essa seção precisa incluir um atributo name para o objeto, por exemplo, {"name": "myObject"}
    • OBJECT_CONTENT_TYPE é o tipo de conteúdo do objeto. Por exemplo, image/png.
    • OBJECT_DATA são os dados do objeto.

  3. Use cURL para chamar a API JSON com uma solicitação de objeto POST:

    curl -X POST --data-binary @MULTIPART_FILE_LOCATION \
    -H "Authorization: Bearer OAUTH2_TOKEN" \
    -H "Content-Type: multipart/related; boundary=BOUNDARY_STRING" \
    -H "Content-Length: MULTIPART_FILE_SIZE" \
    "https://storage.googleapis.com/upload/storage/v1/b/BUCKET_NAME/o?uploadType=multipart"

    Em que:

    • MULTIPART_FILE_LOCATION é o caminho local para o arquivo de várias partes criado na etapa 2. Por exemplo, Desktop/my-upload.multipart.
    • OAUTH2_TOKEN é o token de acesso gerado na etapa 1;
    • BOUNDARY_STRING é a string de limite definida na etapa 2. Por exemplo, my-boundary.
    • MULTIPART_FILE_SIZE é o tamanho total, em bytes, do arquivo de várias partes criado na etapa 2. Por exemplo, 2000000.
    • BUCKET_NAME é o nome do bucket de upload do objeto. Por exemplo, my-bucket.

Se a solicitação for bem-sucedida, o servidor retornará o código de status HTTP 200 OK junto com os metadados do arquivo.

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. Para ver instruções, consulte Autenticação de APIs.

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

    curl -X PUT --data-binary @OBJECT_LOCATION \
    -H "Authorization: Bearer OAUTH2_TOKEN" \
    -H "Content-Type: OBJECT_CONTENT_TYPE" \
    "https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME"

    Em que:

    • OBJECT_LOCATION é o caminho local do objeto. Por exemplo, Desktop/dog.png.
    • OAUTH2_TOKEN é o token de acesso gerado na etapa 1;
    • OBJECT_CONTENT_TYPE é o tipo de conteúdo do objeto. Por exemplo, image/png.
    • BUCKET_NAME é o nome do bucket para o qual você está fazendo o upload do objeto. Por exemplo, my-bucket.
    • OBJECT_NAME é o nome codificado por URL que você quer dar ao objeto. Por exemplo, pets/dog.png, codificado por URL como pets%2Fdog.png.

É possível definir metadados de objeto adicionais como parte do upload do objeto nos cabeçalhos da solicitação da mesma maneira que o exemplo acima define Content-Type. Ao trabalhar com a API XML, os metadados são definidos somente no momento em que o objeto é gravado, como ao fazer upload, copiar ou substituir o objeto. Para mais informações, consulte Como editar metadados de objeto.

A seguir

Faça um teste

Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho do Cloud Storage em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

Faça uma avaliação gratuita do Cloud Storage