Storing Base64 Files Directly in Couchbase via Node.js

Así que estás desarrollando una aplicación y quieres almacenar tus archivos en Couchbase. A partir de ahora, Couchbase permite documentos de hasta 20 MB de tamaño, que es más grande de lo que piensas. ¿Por qué almacenar nuestros archivos en Couchbase en lugar de en el sistema de archivos? Tal vez no tienes mucho espacio de almacenamiento en el sistema de archivos de tu aplicación o mejor aún, tal vez te gustaría tomar ventaja de las características de replicación que Couchbase ofrece para que nunca estés en riesgo de perder tus preciosos datos.

Vamos a echar un vistazo a la aceptación de la carga de archivos, convirtiéndolos en cadenas base64, y luego almacenar las cadenas en Couchbase junto con los metadatos necesarios.

Configuración de Couchbase

Couchbase Server será nuestra base de datos NoSQL de elección aquí. Al ser una base de datos de documentos, almacenar objetos JavaScript tiene mucho sentido.

Si aún no dispone de una copia de Couchbase Server 4.1 o superior, diríjase a la dirección descargas y obtenga el binario que se ajuste a sus necesidades de plataforma (Mac, Linux, Windows).

Con Couchbase instalado necesitamos añadir algo que nos permita usar el lenguaje de consulta N1QL. Necesitamos añadir un índice primario. Esto se puede hacer utilizando el cliente Couchbase Query (CBQ).

En Mac, inicie CBQ ejecutando lo siguiente desde el Terminal:


./Applications/Couchbase Server.app/Contents/Resources/couchbase-core/bin/cbq

./Aplicaciones/Couchbase Servidor.aplicación/Contenido/Recursos/couchbase-núcleo/papelera/cbq

En Microsoft Windows, se puede hacer lo mismo ejecutando lo siguiente:


C:/Program Files/Couchbase/Server/bin/cbq.exe

C:/Programa Archivos/Couchbase/Servidor/papelera/cbq.exe

Si nunca has utilizado CBQ, te parecerá mucho a la herramienta de línea de comandos MySQL o a SQLPlus de Oracle. Podemos ejecutar consultas con ella, entre otras cosas. La consulta que ejecutaremos creará un índice primario. Ejecuta lo siguiente:


CREATE PRIMARY INDEX ON `default` USING GSI;

CREAR PRIMARIO ÍNDICE EN `por defecto` USO DE GSI;

Couchbase Server ya está listo para ser utilizado con nuestra aplicación Node.js.

Configuración de una aplicación Node.js básica

Gran parte de lo que vemos aquí procede de dos tutoriales diferentes que escribí sobre el tema. Una vez demostré cómo aceptar carga de archivos en Node.js a través de una aplicación Angular 2así como cómo convertir esos archivos en datos base64. Esta vez sólo vamos a insertar los datos base64 en Couchbase Server.

Primero vamos a crear un nuevo proyecto Node.js. No tendrá un front-end, pero puedes crear el tuyo propio o usar una herramienta como Postman para hacer pruebas. Tu proyecto debería tener los siguientes archivos y directorios:


uploads/
config.json
app.js

carga/

config.json

aplicación.js

Utilizando un Terminal (Mac y Linux) o un símbolo del sistema (Windows), ejecute lo siguiente desde el directorio del proyecto:


npm init -y

npm init -y

El comando anterior creará un nuevo paquete.json archivo. Ahora necesitamos instalar las dependencias de nuestro proyecto. Esto se puede hacer ejecutando lo siguiente desde el símbolo del sistema o Terminal:


npm install couchbase express uuid body-parser multer --save

npm instale couchbase express uuid cuerpo-analizador multer --guardar

Ahora podemos empezar a desarrollar nuestra pequeña aplicación Node.js. Vamos a mantenerla muy simple. En el config.json incluye la siguiente información sobre nuestro nodo Couchbase:


{
    "couchbase": {
        "server": "127.0.0.1:8091",
        "bucket": "default"
    }
}

{

"couchbase": {

"servidor": "127.0.0.1:8091",

"cubo": "por defecto"

}

Esto nos evitará tener que codificar la información de nuestro servidor a lo largo del proyecto.

Ahora queremos rellenar nuestro archivo lógico central de Node.js, el archivo app.js archivo. Siga adelante y añada el siguiente código:


var express = require("express");
var bodyParser = require("body-parser");
var multer = require("multer");
var fs = require("fs");
var app = express();

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));

app.use(function(req, res, next) {
    res.header("Access-Control-Allow-Origin", "*");
    res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
    next();
});

app.post("/upload", multer({dest: "./uploads/"}).array("uploads", 12), function(req, res) {
    var fileInfo = [];
    for(var i = 0; i &lt; req.files.length; i++) {
        fileInfo.push({
            &quot;originalName&quot;: req.files[i].originalName,
            &quot;size&quot;: req.files[i].size,
            &quot;b64&quot;: new Buffer(fs.readFileSync(req.files[i].path)).toString(&quot;base64&quot;)
        });
        fs.unlink(req.files[i].path);
    }
    res.send(fileInfo);
});

var server = app.listen(3000, function() {
    console.log(&quot;Listening on port %s...&quot;, server.address().port);
});

var express = requiere("express");

var bodyParser = requiere("body-parser");

var multer = requiere("multer");

var fs = requiere("fs");

var aplicación = express();

aplicación.utilice(bodyParser.json());

aplicación.utilice(bodyParser.urlencoded({ ampliado: verdadero }));

aplicación.utilice(función(consulte, res, siguiente) {

res.cabecera("Access-Control-Allow-Origin" (Control de acceso: permitir origen), "*");

res.cabecera("Access-Control-Allow-Headers" (Control de acceso: permitir encabezados), "Origin, X-Requested-With, Content-Type, Accept");

siguiente();

});

aplicación.Correo electrónico:("/upload", multer({dest: "./uploads/"}).matriz("subidas", 12), función(consulte, res) {

var fileInfo = [];

para(var i = 0; i < consulte.archivos.longitud; i++) {

fileInfo.pulse({

"originalName": consulte.archivos[i].originalName,

"talla": consulte.archivos[i].talla,

"b64": nuevo Tampón(fs.readFileSync(consulte.archivos[i].ruta)).toString("base64")

});

fs.desvincular(consulte.archivos[i].ruta);

}

res.enviar(fileInfo);

});

var servidor = aplicación.escuche(3000, función() {

consola.registro("Escuchar en puerto %s...", servidor.dirección().puerto);

});

You're realmente atrapado hasta donde lo dejé en mi Tutorial de conversión a base64 de Node.js. El caso es que ahora queremos almacenar esos datos en Couchbase Server.

Inserción de datos de archivos en Couchbase mediante consultas N1QL

Empecemos por incluir la información sobre las distintas dependencias que hemos descargado en los pasos anteriores. En la parte superior del archivo app.js con las otras importaciones, incluya lo siguiente:


var couchbase = require("couchbase");
var N1qlQuery = require(&apos;couchbase&apos;).N1qlQuery;
var uuid = require("uuid");
var config = require("./config");

var couchbase = requiere("couchbase");

var N1qlQuery = requiere('couchbase').N1qlQuery;

var uuid = requiere("uuid");

var config = requiere("./config");

Estamos incluyendo Couchbase, el motor N1QL, la información de nuestro servidor, y la librería para generar valores únicos. Ahora, antes o encima del bloque de código para compartir recursos entre orígenes, añade la siguiente línea:


var bucket = (new couchbase.Cluster(config.couchbase.server)).openBucket(config.couchbase.bucket);

var cubo = (nuevo couchbase.Grupo(config.couchbase.servidor)).openBucket(config.couchbase.cubo);

Como ya he dicho, no importa dónde lo pongas, pero esta línea se conectará a un clúster Couchbase y abrirá el bucket, ambos definidos en el archivo config.json archivo.

Ahora viene lo más jugoso.

Vamos a cambiar la función endpoint para que las subidas se guarden en Couchbase antes de devolver los datos al usuario. Sigue adelante y cambia la función endpoint para que se parezca a la siguiente:


app.post("/upload", multer({dest: "./uploads/"}).array("uploads", 12), function(req, res) {
    var fileInfo = [];
    for(var i = 0; i &lt; req.files.length; i++) {
        fileInfo.push({
            &quot;originalName&quot;: req.files[i].originalName,
            &quot;size&quot;: req.files[i].size,
            &quot;b64&quot;: new Buffer(fs.readFileSync(req.files[i].path)).toString(&quot;base64&quot;)
        });
        fs.unlink(req.files[i].path);
    }
    var statement = &quot;INSERT INTO `&quot; + config.couchbase.bucket + &quot;` (KEY,VALUE) VALUES &quot; +
                    &quot;($1, {&amp;apos;files&amp;apos;: $2})&quot;;
    var query = N1qlQuery.fromString(statement);
    bucket.query(query, [uuid.v4(), fileInfo], function(error, result) {
        if(error) {
            return res.status(400).send({&quot;status&quot;: &quot;error&quot;, &quot;message&quot;: error});
        }
        res.send(fileInfo);
    });
});

aplicación.Correo electrónico:("/upload", multer({dest: "./uploads/"}).matriz("subidas", 12), función(consulte, res) {

var fileInfo = [];

para(var i = 0; i < consulte.archivos.longitud; i++) {

fileInfo.pulse({

"originalName": consulte.archivos[i].originalName,

"talla": consulte.archivos[i].talla,

"b64": nuevo Tampón(fs.readFileSync(consulte.archivos[i].ruta)).toString("base64")

});

fs.desvincular(consulte.archivos[i].ruta);

}

var declaración = "INSERTAR EN `" + config.couchbase.cubo + "` (CLAVE,VALOR) VALORES " +

"($1, {&apos;archivos&apos;: $2})";

var consulta = N1qlQuery.fromString(declaración);

cubo.consulta(consulta, [uuid.v4(), fileInfo], función(error, resultado) {

si(error) {

devolver res.estado(400).enviar({"estado": "error", "mensaje": error});

}

res.enviar(fileInfo);

});

Observe que ahora estamos creando un INSERTAR ¿declaración? Se trata de una consulta parametrizada para evitar cualquier tipo de ataque de inyección SQL. Los parámetros se definen en la propia consulta y son el valor de id único para la clave y la matriz de archivos que hemos creado. Sólo una vez que los datos han sido guardados serán devueltos al usuario.

Conclusión

Sí, hubo un poco de manipulación aquí cuando se trata de la carga de archivos reales, pero eso es porque nos preocupamos más por la inserción en Couchbase. También porque fue explicado en mi tutorial anterior. Aquí vimos cómo hacer una consulta N1QL para insertar el array que contenía todos nuestros archivos base64 que fueron subidos. Mientras el tamaño de los archivos no exceda los límites de Couchbase, es una solución perfectamente aceptable y permitirá la replicación en caso de que esté habilitada.

Nic Raboy, Defensor del Desarrollador, Couchbase

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Todos los mensajes

Almacenamiento de archivos Base64 directamente en Couchbase a través de Node.js

Configuración de Couchbase

Configuración de una aplicación Node.js básica

Inserción de datos de archivos en Couchbase mediante consultas N1QL

Conclusión

Autor

Publicado por Nic Raboy, Defensor del Desarrollador, Couchbase

Dejar una respuesta Cancelar respuesta