Como 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, consulte Uploads e downloads.

Console

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

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 Fazer upload de arquivos, selecione os arquivos que você quer enviar na caixa de diálogo exibida e clique em Abrir.

   Observação: o navegador Chrome também é compatível com uploads de pastas.

Consulte a Solução de problemas para informações detalhadas sobre erros de operações com falha no navegador do Cloud Storage.

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 para o qual você está fazendo o upload do objeto. Por exemplo, my-bucket.

Se funcionar, a resposta será parecida com esta:

Operation completed over 1 objects/58.8 KiB.

Observação: use a sinalização -r para fazer upload de diretórios de maneira recorrente.

Amostras de código

C++

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

Veja no GitHub Feedback

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";
}

C#

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

Veja no GitHub Feedback

private void UploadFile(string bucketName, string localPath,
    string objectName = null)
{
    var storage = StorageClient.Create();
    using (var f = File.OpenRead(localPath))
    {
        objectName = objectName ?? Path.GetFileName(localPath);
        storage.UploadObject(bucketName, objectName, null, f);
        Console.WriteLine($"Uploaded {objectName}.");
    }
}

Go

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

Veja no GitHub Feedback

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

	// Upload an object with storage.Writer.
	wc := client.Bucket(bucket).Object(object).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
}

Java

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

Veja no GitHub Feedback

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);
  }
}

Node.js

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

Para mais informações sobre como fazer upload de um stream, string ou buffer, consulte File.save().

Ver no GitHub Feedback

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'Local file to upload, e.g. ./local/path/to/file.txt';
// const destination = 'Destination object name, 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 uploadFile() {
  // Uploads a local file to the bucket
  await storage.bucket(bucketName).upload(filename, {
    // By setting the option `destination`, you can change the name of the
    // object you are uploading to a bucket.
    destination: destination,
    metadata: {
      // Enable long-lived HTTP caching headers
      // Use only if the contents of the file will never change
      // (If the contents will change, use cacheControl: 'no-cache')
      cacheControl: 'public, max-age=31536000',
    },
  });

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

uploadFile().catch(console.error);

PHP

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

Veja no GitHub Feedback

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file.
 *
 * @param string $bucketName the name of your Google Cloud bucket.
 * @param string $objectName the name of the object.
 * @param string $source the path to the file to upload.
 *
 * @return Psr\Http\Message\StreamInterface
 */
function upload_object($bucketName, $objectName, $source)
{
    $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);
}

Python

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

Use o método Blob.upload_from_file(), Blob.upload_from_filename() ou Blob.upload_from_string() para fazer upload de um objeto.

Ver no GitHub Feedback

from google.cloud import storage

def upload_blob(bucket_name, source_file_name, destination_blob_name):
    """Uploads a file to the bucket."""
    # bucket_name = "your-bucket-name"
    # source_file_name = "local/path/to/file"
    # 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(
        "File {} uploaded to {}.".format(
            source_file_name, destination_blob_name
        )
    )

Ruby

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

Veja no GitHub Feedback

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

  file = bucket.create_file local_file_path, file_name

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

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.

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

   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 que você quer dar ao objeto. Por exemplo, pets/dog.png.

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

Observação: para adicionar ou alterar metadados de um objeto no Cloud Storage, consulteComo visualizar e editar metadados de objetos.

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 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. Consiga 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 para chamar a API XML com uma solicitação de objeto PUT:

   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 que você quer dar ao objeto. Por exemplo, pets/dog.png.

A seguir

• Consulte a visão geral conceitual para saber mais sobre uploads e downloads.
• Saiba mais sobre requisitos de nomenclatura para objetos.
• Transferir objetos da instância do Compute Engine.
• Torne seus dados acessíveis publicamente.
• Veja e edite os metadados do objeto.
• Controle o acesso aos objetos e buckets.

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. Novos clientes 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