Sube objetos

En esta página, se muestra cómo subir objetos a tu bucket de Cloud Storage. Un objeto subido consiste en los datos que deseas almacenar junto con metadatos asociados. Para obtener una descripción general conceptual, consulta Cargas y descargas.

Requisitos previos

Los requisitos previos pueden variar según la herramienta que se use:

Console

Para completar esta guía con Google Cloud Console, debes tener los permisos de IAM adecuados. Si el bucket que deseas subir existe en un proyecto que no creaste, tal vez necesites que el propietario del proyecto te otorgue un rol con los permisos necesarios.

A fin de obtener una lista de los permisos necesarios para acciones específicas, consulta Permisos de IAM para Google Cloud Console.

Para obtener una lista de los roles relevantes, consulta Funciones de Cloud Storage. Como alternativa, puedes crear un rol personalizado que tenga permisos más limitados.

gsutil

Para completar esta guía con gsutil, debes tener los permisos de IAM adecuados. Si el bucket que deseas subir existe en un proyecto que no creaste, tal vez necesites que el propietario del proyecto te otorgue un rol con los permisos necesarios.

Si deseas obtener una lista de los permisos necesarios para acciones específicas, consulta Permisos de IAM para los comandos de gsutil.

Para obtener una lista de los roles relevantes, consulta Funciones de Cloud Storage. Como alternativa, puedes crear un rol personalizado que tenga permisos más limitados.

Muestras de código

Para completar esta guía con las bibliotecas cliente de Cloud Storage, debes tener los permisos de IAM adecuados. Si el bucket que deseas subir existe en un proyecto que no creaste, tal vez necesites que el propietario del proyecto te otorgue un rol con los permisos necesarios. A menos que se indique lo contrario, las solicitudes de la biblioteca cliente se realizan mediante la API de JSON.

Si deseas obtener una lista de los permisos necesarios para acciones específicas, consulta Permisos de IAM para métodos JSON.

Para obtener una lista de los roles relevantes, consulta Funciones de Cloud Storage. Como alternativa, puedes crear un rol personalizado que tenga permisos más limitados.

API de REST

API de JSON

Para completar esta guía con la API de JSON, debes tener los permisos de IAM adecuados. Si el bucket que deseas subir existe en un proyecto que no creaste, tal vez necesites que el propietario del proyecto te otorgue un rol con los permisos necesarios.

Si deseas obtener una lista de los permisos necesarios para acciones específicas, consulta Permisos de IAM para métodos JSON.

Para obtener una lista de los roles relevantes, consulta Funciones de Cloud Storage. Como alternativa, puedes crear un rol personalizado que tenga permisos más limitados.

Sube un objeto a un bucket

Sigue los pasos a continuación para subir un objeto a un bucket:

Console

1. En Google Cloud Console, ve a la página Navegador de Cloud Storage.
   

   Ir al navegador

2. En la lista de bucket s, haz clic en el nombre del bucket en el que deseas subir un objeto.

3. En la pestaña Objetos para el depósito, realiza una de las siguientes dos acciones:

   • Arrastra y suelta los archivos deseados desde tu escritorio o administrador de archivos en el panel principal de Cloud Console.

   • Haz clic en el botón Subir archivos, selecciona los archivos que deseas subir en el cuadro de diálogo que aparece y haz clic en Abrir.

   Nota: Si usas el navegador Chrome, las cargas de carpetas también son compatibles.

Para aprender a obtener información detallada sobre errores en las operaciones fallidas en el navegador de Cloud Storage, consulta Solución de problemas.

gsutil

Usa el comando gsutil cp:

gsutil cp OBJECT_LOCATION gs://DESTINATION_BUCKET_NAME/

Donde:

• OBJECT_LOCATION es la ruta de acceso local a tu objeto. Por ejemplo, Desktop/dog.png.

• DESTINATION_BUCKET_NAME es el nombre del bucket al que subes el objeto. Por ejemplo, my-bucket.

Si es correcto, la respuesta se parece al siguiente ejemplo:

Operation completed over 1 objects/58.8 KiB.

Nota: Usa la marca -r para subir directorios de forma recursiva.

Puedes configurar metadatos de objetos de clave fija y personalizados como parte de la carga de tu objeto en los encabezados de la solicitud mediante la opción global -h.

Muestras de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

Ver en GitHub Comentarios

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#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C#.

Ver en GitHub Comentarios

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

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

Ver en GitHub Comentarios

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Java.

Ver en GitHub Comentarios

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.

Para obtener más información sobre cómo subir una transmisión, una string o un búfer, consulta File.save().

Ver en GitHub Comentarios

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

PHP

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.

Ver en GitHub Comentarios

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

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

Usa el método Blob.upload_from_file(), Blob.upload_from_filename() o Blob.upload_from_string() para subir un objeto.

Ver en GitHub Comentarios

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(
        "File {} uploaded to {}.".format(
            source_file_name, destination_blob_name
        )
    )

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

Ver en GitHub Comentarios

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

API de REST

API de JSON

Carga de una sola solicitud sin metadatos de objeto

1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.

2. Usa cURL para llamar a la API de JSON con una solicitud 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"

   Donde:

   • OBJECT_LOCATION es la ruta de acceso local a tu objeto. Por ejemplo, Desktop/dog.png.
   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • OBJECT_CONTENT_TYPE es el tipo de contenido del objeto. Por ejemplo, image/png.
   • BUCKET_NAME es el nombre del bucket al que subes el objeto. Por ejemplo, my-bucket.
   • OBJECT_NAME es el nombre nuevo que deseas dar a tu objeto. Por ejemplo, pets/dog.png.

Carga de una sola solicitud que incluye metadatos de objeto

Nota: Para agregar o cambiar metadatos de un objeto existente en Cloud Storage, consulta Visualiza y edita metadatos de objeto.

1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.

2. Crea un archivo multipart/related que contenga la siguiente información:

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

   Donde:

   • BOUNDARY_STRING es una string que defines para identificar las diferentes partes del archivo de varias partes. Por ejemplo, my-boundary.
   • OBJECT_METADATA son metadatos que deseas incluir para el archivo, en formato JSON. Como mínimo, esta sección debe incluir un atributo name para el objeto, por ejemplo {"name": "myObject"}.
   • OBJECT_CONTENT_TYPE es el tipo de contenido del objeto. Por ejemplo, image/png.
   • OBJECT_DATA son los datos del objeto.

3. Usa cURL para llamar a la API de JSON con una solicitud 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"

   Donde:

   • MULTIPART_FILE_LOCATION es la ruta local al archivo multiparte que creaste en el paso 2. Por ejemplo, Desktop/my-upload.multipart.
   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • BOUNDARY_STRING es la string de límite que definiste en el paso 2. Por ejemplo, my-boundary.
   • MULTIPART_FILE_SIZE es el tamaño total, en bytes, del archivo de varias partes que creaste en el paso 2. Por ejemplo, 2000000.
   • BUCKET_NAME es el nombre del bucket al que subes el objeto. Por ejemplo, my-bucket.

Si la solicitud se realiza correctamente, el servidor muestra el código de estado HTTP 200 OK junto con los metadatos del archivo.

API de XML

1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.

2. Usa cURL para llamar a la API de XML con una solicitud 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"

   Donde:

   • OBJECT_LOCATION es la ruta de acceso local a tu objeto. Por ejemplo, Desktop/dog.png.
   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • OBJECT_CONTENT_TYPE es el tipo de contenido del objeto. Por ejemplo, image/png.
   • BUCKET_NAME es el nombre del bucket al que subes el objeto. Por ejemplo, my-bucket.
   • OBJECT_NAME es el nombre nuevo que deseas dar a tu objeto. Por ejemplo, pets/dog.png.

Puedes configurar metadatos de objeto adicionales como parte de la carga del objeto en los encabezados de la solicitud, de la misma manera que el ejemplo anterior configura Content-Type. Cuando trabajas con la API de XML, los metadatos solo pueden configurarse en el momento en que se escribe el objeto, como cuando se lo sube, copia o reemplaza. Para obtener más información, consulta Edita los metadatos de objetos.

¿Qué sigue?

• Lee la descripción general conceptual para subir y descargar contenido.
• Obtén más información sobre cómo nombrar nombres para objetos.
• Transfiere objetos desde tu instancia de Compute Engine.
• Transfiere datos desde proveedores de servicios en la nube u otras fuentes en línea (por ejemplo, mediante listas de URL).
• Haz que tus datos sean de acceso público.
• Controla quién tiene acceso a tus objetos y buckets.

Pruébalo tú mismo

Si es la primera vez que usas Google Cloud, crea una cuenta para evaluar el rendimiento de Cloud Storage en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Probar Cloud Storage gratis