---
title: "Subir objeto"
url: https://docs.catalyst.zoho.com/es/sdk/nodejs/v2/cloud-scale/stratus/upload-object/
description: "Esta página lista el método del SDK de Node.js para subir objetos a un bucket."
last_updated: 2026-03-30T08:10:30Z
service: Cloud Scale
type: general
related_links:
  - name: "Stratus Component Help Documentation"
    url: /es/cloud-scale/help/stratus/introduction
  - name: "Upload Object Help Documentation"
    url: /es/cloud-scale/help/stratus/objects/upload-object/
  - name: "Java SDK"
    url: /es/sdk/java/v1/cloud-scale/stratus/upload-object/
  - name: "Python SDK"
    url: /es/sdk/python/v1/cloud-scale/stratus/upload-object/
  - name: "Web SDK"
    url: /es/sdk/web/v4/cloud-scale/stratus/upload-object/
  - name: "iOS SDK"
    url: /es/sdk/ios/v2/cloud-scale/stratus/upload-object/
  - name: "Android SDK"
    url: /es/sdk/android/v2/cloud-scale/stratus/upload-object/
  - name: "Flutter SDK"
    url: /es/sdk/flutter/v2/cloud-scale/stratus/upload-object/
  - name: "REST API"
    url: /es/api/code-reference/cloud-scale/stratus/get-all-buckets/#GetAllBuckets
---

# Subir objeto

Los métodos del SDK listados en esta sección te permitirán [subir objetos](https://docs.catalyst.zoho.com/es/cloud-scale/help/stratus/objects/upload-object/) al [bucket](https://docs.catalyst.zoho.com/es/cloud-scale/help/stratus/buckets/name-bucket/) de diversas maneras. Puedes subir objetos como una **cadena** o como un **stream**. La referencia del Bucket utilizada en el fragmento de código a continuación es la [instancia del componente](https://docs.catalyst.zoho.com/es/sdk/nodejs/v2/cloud-scale/stratus/create-bucket-instance/).

Si no tienes el [Versionado](https://docs.catalyst.zoho.com/es/cloud-scale/help/stratus/stratus-config/general-settings/#versioning) habilitado para tu objeto, y si Stratus recibe múltiples solicitudes de escritura para el mismo objeto, el objeto será sobrescrito continuamente. La última subida del objeto será el único objeto que se almacene.

Sin embargo, con el Versionado habilitado, cada subida se considerará una versión del objeto, y todas ellas se almacenarán en el bucket, cada una con un `versionId` único.

> **Note:** Los siguientes caracteres, incluyendo el espacio, no son compatibles cuando creas una ruta o un objeto: comilla doble, ambos corchetes angulares, hashtag, barra invertida y símbolo de barra vertical.

### Upload Object as a Stream

Usando este método del SDK, puedes subir objetos a un bucket como un stream. Almacena el stream en una variable y luego pasa esa variable en el método de subida; `putObject()`

```javascript
// crear un stream de lectura para subir el objeto
const file = fs.createReadStream("file_path");
// llamar al método de subida
const res = await bucket.putObject("sam/out/sample.txt", file);
console.log(res);
```

### Upload Object as a String

Usando este método del SDK, puedes subir el objeto como una cadena. Pasarás el nombre del objeto y los datos a almacenar en el objeto en formato de cadena en el método de subida; `putObject()`

```javascript
//Subir el objeto como cadena de texto
const res = await bucket.putObject("sam/out/sample.txt", "Content of the file");
console.log(res);
```

### Upload Object with Options

Usando este método del SDK, puedes utilizar las siguientes opciones mientras subes un objeto.

* `overwrite`: Esta es una opción que puedes usar si el *Versionado* de tu bucket no está habilitado. Sin versionado, necesitas usar esta opción si deseas sobrescribir un recurso. El valor predeterminado es '**false**'.

* `ttl`: Esta es una opción que puedes usar para establecer el **Time-to-Live** (TTL) en segundos para un objeto. El valor debe ser mayor o igual a **60 segundos**.

* `metaData`: Esta es una opción que puedes usar para subir [detalles de metadatos](https://docs.catalyst.zoho.com/es/cloud-scale/help/stratus/objects/introduction/#metadata) del objeto que se está subiendo.

* `contentType`: Esta es una opción que puedes proporcionar si necesitas establecer el tipo MIME del objeto.

```javascript
const options = {
'overwrite': true, //Esto sobrescribirá tu objeto existente
'ttl': '300', //tiempo de vida en segundos
'metaData': {
'author': 'John'
}
};
const file = fs.createReadStream("filePath");
const uploadRes = await bucket.putObject("sam/out/sample.txt", file, options);
console.log(uploadRes);
```

### Upload Object With Extract Option

Cuando subes un objeto comprimido usando este método del SDK, los objetos presentes en el zip serán extraídos y subidos.

```java
const options = {
'ttl': '300', //tiempo de vida en segundos
'metaData': {
'author': 'John'
},
// Extraer el contenido del archivo ZIP dado y subir cada archivo como un objeto separado al bucket
'extractUpload': true
};
const file = fs.createReadStream("filePath");
const uploadRes = await bucket.putObject("sam/out/sample.zip", file, options);
console.log(uploadRes);
```

Este método del SDK devolverá el valor de un `taskId`. Puedes usar este valor para conocer el estado de la extracción usando este [método del SDK](https://docs.catalyst.zoho.com/es/sdk/nodejs/v2/cloud-scale/stratus/extract-zipped-object/#get-zip-extraction-status).

**Respuesta de ejemplo**

```json
{ 'task_id': '1234263749' }
```

### Upload Object Using Multipart

En esta sección vamos a revisar los métodos del SDK que te permitirán subir exitosamente un objeto grande a un bucket en Stratus.

La función de subida multipart subirá un archivo grande al bucket en múltiples solicitudes HTTPS. Todas estas solicitudes se combinarán en un único objeto una vez que todas las partes individuales hayan sido subidas.

> **Note:** Se recomienda que consideres la **Subida Multipart** como el método preferido para subir objetos de **100 MB o más**.

#### Initiate Upload

Para realizar operaciones multipart, necesitas obtener una instancia de objeto multipart. Nos referiremos a esta instancia del componente en varios fragmentos de código donde trabajamos con operaciones multipart que se realizan en objetos almacenados en un bucket en Stratus.

**Parámetro utilizado**

`bucket`: Esta es la instancia del bucket que necesitas haber inicializado anteriormente usando este [método del SDK](https://docs.catalyst.zoho.com/es/sdk/nodejs/v2/cloud-scale/stratus/create-bucket-instance/). 

```javascript
const initRes = await bucket.initiateMultipartUpload("sam/out/sample.txt");
console.log(initRes);
```

**Respuesta de ejemplo**

```json
{
"bucket": "zcstratus123-development",
"key": "sam/out/sample.txt",
"upload_id": "01j7xbm4vm5750zbedxqgc4q6m",
"status": "PENDING"
}
```

#### Upload Parts of the Object

En el siguiente método del SDK, vamos a realizar subidas de las partes individuales del objeto. Cada parte tendrá un partNumber distinto que varía entre 1 y 1000. Si bien esto representa el orden de las partes, estas partes no necesariamente se subirán en secuencia. Estas partes se combinarán en secuencia una vez que la subida de todas las partes de los objetos esté completa.

```javascript
let partNumber = 1;
const file = fs.createReadStream("filePath");
const uploadPartRes = await bucket.uploadPart("sam/out/sample.txt", "uploadId", file, partNumber);
console.log(uploadPartRes);
```

#### Get Multipart Upload Summary

El siguiente método del SDK se puede usar para obtener un resumen operativo de todas las partes subidas. Para ver el resumen, usaremos el método `getMultipartUploadSummary()`.

```javascript
const uploadSummaryRes = await bucket.getMultipartUploadSummary("sam/out/sample.txt", "upload_id");
console.log(uploadSummaryRes);
```

**Respuesta de ejemplo**

```json
{
"bucket": "zcstratus12345-development",
"key": "sam/out/sample.txt",
"upload_id": "01hyfyeazrrstmt7k5fa7ej726",
"status": "PENDING",
"parts": [
{
"part_number": 1,
"size": 0,
"uploaded_at": 1716374678999
 },
{
"part_number": 2,
"size": 2797094,
"uploaded_at": 1716374678576
},
{
"part_number": 4,
"size": 0,
"uploaded_at": 1716374679136
}
]
}
```

#### Complete Multipart Upload of the Object

El siguiente método nos permite finalizar el proceso multipart una vez que todas las partes han sido subidas exitosamente. Para completar el proceso pasaremos el uploadId al método `completeMultipartUpload()`.

```javascript
const completeUploadRes = await bucket.completeMultipartUpload("sam/out/sample.txt", "uploadId");
console.log(completeUploadRes);
```

**Implementación de ejemplo del SDK**

```javascript
const catalyst = require('zcatalyst-sdk-node');
const fs = require('fs');
module.exports = async (req, res) => {
url = req.url;
switch (url) {
case '/':
const app = catalyst.initialize(req);
const stratus = app.stratus();
// crear una instancia del bucket
const bucket = stratus.bucket("bucket_name");
// Subida multipart
const key = 'sample.mp4';
// iniciar subida multiparte
const initRes = await bucket.initiateMultipartUpload(key);
// obtener el Id de subida de la respuesta de inicio de subida.
const uploadId = initRes['upload_id'];
const filePath = '/Users/Aliza//sam.mp4';
const partSize = 50 * 1024 * 1024; // en MB
const fileStream = fs.createReadStream(
filePath,
{ highWaterMark: partSize }
);
let partNumber = 1;
const uploadPromises = [];
fileStream.on('data', async (partData) => {
// Agregar cada subida de parte al arreglo de promesas para subida en paralelo
const partUploadPromise = bucket.uploadPart(
key,
uploadId,
partData,
partNumber
);
uploadPromises.push(partUploadPromise);
console.log('Part Number: ', partNumber);
partNumber++;
});
// Esperar a que todas las partes se suban en paralelo
fileStream.on('end', async () => {			
await Promise.all(uploadPromises);
// Completar la subida multipart
await bucket.completeMultipartUpload(key, uploadId);
console.log('Successfully Uploaded');
});
res.end();
break;
default:
res.writeHead(404);
res.write('You might find the page you are looking for at "/" path');
break;
}
}
```

### Upload an Object Using Transfer Manager

**Asegúrate de que los siguientes paquetes estén importados**

```javascript
const { TransferManager } = require('zcatalyst-sdk-node/lib/stratus');
```

#### Create Transfer Manager Instance

```javascript
 const transferManager = new TransferManager(bucket); // crear instancia de transfer manager
```

#### Multipart Upload

**Crear instancia de subida Multipart**

El siguiente método del SDK creará una instancia multipart iniciando la subida multipart.

```javascript
const multipart = await transferManager.createMultipartInstance("sam/out/sample.txt"); // crear instancia multipart
```

Si necesitas crear una instancia para una operación de subida multipart ya inicializada, entonces copia y usa el fragmento de código proporcionado a continuación

```javascript
const multipart = await transferManager.createMultipartInstance("sam/out/sample.txt", "uploadId");
```

#### Upload Part

En el siguiente método del SDK vamos a usar la instancia `multipart` que inicializamos en la sección *Create Multipart Upload Instance*.

```javascript
const uploadRes = await multipart.uploadPart(fs.createReadStream("filePath"), partNumber);
console.log(uploadRes);
```

#### Upload Summary

```javascript
const summaryRes = await multipart.getUploadSummary();
console.log(summaryRes);
```

#### Complete Upload

```javascript
const completeRes = await multipart.completeUpload();
console.log(completeRes);
```

#### Upload Object Using Wrapper

El siguiente método del SDK actúa como un wrapper, donde toda la operación de subida multipart se lleva a cabo sin emplear múltiples pasos. Usando este método, el objeto se divide en múltiples partes, se sube al bucket en múltiples partes y luego se combina una vez que todas las partes han sido subidas.

```javascript
const file = fs.createReadStream("filePath");
const partSize = 50 // en MB
const objectPartUploadRes = await transferManager.putObjectAsParts("sam/out/sample.txt",file, partSize);
console.log(objectPartUploadRes);
```

### Generate Presigned URL to Upload an Object

Las URLs prefirmadas son URLs seguras que los usuarios autenticados pueden compartir con sus usuarios no autenticados. Esta URL proporcionará a los usuarios no autenticados autorización temporal para acceder a objetos. La referencia del Bucket utilizada en el fragmento de código a continuación es la [instancia del componente](https://docs.catalyst.zoho.com/es/sdk/nodejs/v2/cloud-scale/stratus/create-bucket-instance/).

> **Info:** Para usar este método del SDK, necesitas inicializarlo con el ámbito **Admin**. Puedes obtener más información sobre este requisito en esta [sección](https://docs.catalyst.zoho.com/es/sdk/nodejs/v2/overview/#initialize-sdk-with-scopes)

**Parámetros utilizados**

<table class="content-table">
	<thead>
		<tr>
			<th class="w20p">Nombre del parámetro</th>
			<th class="w20p">Tipo de dato</th>
      <th class="w60p">Definición</th>
		</tr>
	</thead>
	<tbody>
		<tr>
			<td>`key`</td>
			<td>**String**</td>
			<td>Un parámetro **obligatorio**. Contendrá el nombre completo del objeto junto con su [ruta](https://docs.catalyst.zoho.com/es/cloud-scale/help/stratus/objects/introduction/#path).</td>
		</tr>
		<tr>
			<td>`urlAction`</td>
			<td>**Request Method**</td>
			<td>Un parámetro **obligatorio**. Este es el parámetro que te permitirá generar una URL prefirmada para una acción de subida (PUT).
        <ul>
          <li>`PUT`: Para subir un objeto</li>
        </ul>
      </td>
    </tr>
    <tr>
      <td>`expiry`</td>
      <td>**String**</td>
      <td>Este es un parámetro **opcional**. El tiempo de validez de la URL en segundos.
        <ul>
          <li>Valor predeterminado: **3600 segundos**</li>
          <li>Valor mínimo: **30 segundos**</li>
          <li>Valor máximo: **7 días**</li>
        </ul>
      </td>
    </tr>
    <tr>
      <td>`activeFrom`</td>
      <td>**String**</td>
      <td>Este es un parámetro **opcional**. Este parámetro contendrá el momento a partir del cual la URL es válida. El valor máximo es **7 días**. Las URLs se activan tan pronto como se generan de forma predeterminada.</td>
		</tr>
	</tbody>
</table>

```javascript
const signedURLRes = await bucket.generatePreSignedUrl("sam/out/sample.txt", 'PUT', {
'expiryIn': 100, // tiempo de expiración en segundos
'activeFrom':'12334454327', // activar la URL en la fecha dada
});
console.log(signedURLRes);
```

**Respuesta de ejemplo para generar una URL prefirmada para subida**

```json
{
signature: "https://sadi-development.zohostratus.com/_signed/text.txt?organizationId=96862383&stsCredential=96858154-96862383&stsDate=1747896279887&stsExpiresAfter=300&stsSignedHeaders=host&stsSignature=3YBUX1HFSxNQzQJjFrln82AyJsEEuC5T9dsZwWxGyEE"
}
```

**Fragmento de ejemplo que ilustra el uso de una URL prefirmada para subir un objeto**

> **Info:** Este ejemplo se muestra usando el paquete de manejo de solicitudes **Axios**.

```javascript
const axios = require('axios');
const fs = require('fs');
// Reemplazar esto con la URL pre-firmada real generada para tu subida.
const url = 'https://sadi-development.zohostratus.com/_signed/text.txt?organizationId=96862383&stsCredential=96858154-96862383&stsDate=1747911331272&stsExpiresAfter=300&stsSignedHeaders=host&stsSignature=K9vuqC7JaATLeM3TX4xXWx0OHcSflbYQ2jCrbKSAAIE';
// Reemplazar 'file_path' con la ruta real de tu archivo
const data = fs.createReadStream('/Users/ranjitha-18338/Documents/NODE-SDK/Stratus/sam.py');
// Encabezados opcionales; el tipo de contenido puede variar según el tipo de archivo
const headers = {
// 'Content-Type': 'application/json', 
// ajustar si se suben archivos no JSON (ej., 'text/plain' o 'application/octet-stream')
// 'overwrite': 'true', // encabezado opcional
};
(async () => {
try {
const response = await axios.put(url, data, { headers });
if (response.status === 200) {
console.log('Object uploaded successfully');
} else {
console.log('⚠️ Error uploading object:', response.data);
}
} catch (error) {
console.error('Upload failed:', error.response?.data || error.message);
}
})();
```