Storing Base64 Files Directly in Couchbase via Node.js

Então você está desenvolvendo um aplicativo e deseja armazenar seus arquivos no Couchbase. No momento, o Couchbase permite documentos com até 20 MB de tamanho, o que é maior do que você imagina. Por que armazenar nossos arquivos no Couchbase em vez de no sistema de arquivos? Talvez você não tenha muito espaço de armazenamento no sistema de arquivos do seu aplicativo ou, melhor ainda, talvez queira aproveitar os recursos de replicação que o Couchbase oferece para que você nunca corra o risco de perder seus dados preciosos.

Vamos dar uma olhada na aceitação de uploads de arquivos, convertendo-os em cadeias de caracteres base64 e, em seguida, armazenando as cadeias de caracteres no Couchbase junto com os metadados necessários.

Como configurar o Couchbase

O Couchbase Server será o nosso banco de dados NoSQL escolhido aqui. Como se trata de um banco de dados de documentos, o armazenamento de objetos JavaScript faz todo o sentido.

Se você ainda não tiver uma cópia do Couchbase Server 4.1 ou superior, vá para o site downloads e obtenha o binário que atenda às suas necessidades de plataforma (Mac, Linux, Windows).

Com o Couchbase instalado, precisamos adicionar algo que nos permita usar a linguagem de consulta N1QL. Precisamos adicionar um índice primário. Isso pode ser feito usando o cliente Couchbase Query (CBQ).

No Mac, inicie o CBQ executando o seguinte no Terminal:


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

./Aplicativos/Couchbase Servidor.aplicativo/Conteúdo/Recursos/couchbase-núcleo/caixa/cbq

No Microsoft Windows, o mesmo pode ser feito executando o seguinte:


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

C:/Programa Arquivos/Couchbase/Servidor/caixa/cbq.exe

Se você nunca usou o CBQ antes, verá que ele é muito parecido com a ferramenta de linha de comando do MySQL ou com o SQLPlus da Oracle. Podemos executar consultas com ele, entre outras coisas. A consulta que executaremos criará um índice primário. Execute o seguinte:


CREATE PRIMARY INDEX ON `default` USING GSI;

CRIAR PRIMÁRIO ÍNDICE ON `padrão` USO GSI;

O Couchbase Server agora está pronto para ser usado com nosso aplicativo Node.js.

Configuração de um aplicativo básico do Node.js

Muito do que vemos aqui foi extraído de dois tutoriais diferentes que escrevi sobre o assunto. Uma vez demonstrei como aceitar uploads de arquivos no Node.js por meio de um aplicativo Angular 2, bem como como converter esses arquivos em dados base64. Desta vez, vamos apenas inserir os dados base64 no Couchbase Server.

Primeiro, vamos criar um novo projeto Node.js. Ele não terá um front-end, mas você pode criar o seu próprio ou usar uma ferramenta como o Postman para testes. Seu projeto deve ter os seguintes arquivos e diretórios:


uploads/
config.json
app.js

uploads/

configuração.json

aplicativo.js

Usando um Terminal (Mac e Linux) ou um Prompt de Comando (Windows), execute o seguinte no diretório do projeto:


npm init -y

npm inicial -y

O comando acima criará um novo package.json arquivo. Agora precisamos instalar as dependências do nosso projeto. Isso pode ser feito executando o seguinte no prompt de comando ou no terminal:


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

npm instalar couchbase expresso uuid corpo-analisador multer --salvar

Agora podemos começar a desenvolver nosso pequeno aplicativo Node.js. Vamos mantê-lo bem simples. Na seção config.json inclui as seguintes informações sobre nosso nó do Couchbase:


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

{

"couchbase": {

"servidor": "127.0.0.1:8091",

"bucket" (balde): "default"

}

Isso evitará que tenhamos que codificar nossas informações de servidor em todo o projeto.

Agora, queremos preencher nosso arquivo de lógica central do Node.js, o arquivo app.js arquivo. Vá em frente e adicione o seguinte 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 expresso = exigir("expresso");

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

var multer = exigir("multer");

var fs = exigir("fs");

var aplicativo = expresso();

aplicativo.uso(bodyParser.json());

aplicativo.uso(bodyParser.codificado por url({ estendido: verdadeiro }));

aplicativo.uso(função(req, res, próxima) {

res.cabeçalho("Access-Control-Allow-Origin", "*");

res.cabeçalho("Access-Control-Allow-Headers", "Origem, X-Requested-With, Content-Type, Accept");

próxima();

});

aplicativo.postagem("/upload", multer({dest: "./uploads/"}).matriz("uploads", 12), função(req, res) {

var fileInfo = [];

para(var i = 0; i < req.arquivos.comprimento; i++) {

fileInfo.empurrar({

&cotação;originalName&cotação;: req.arquivos[i].originalName,

&cotação;tamanho&cotação;: req.arquivos[i].tamanho,

&cotação;b64&cotação;: novo Buffer(fs.readFileSync(req.arquivos[i].caminho)).toString(&cotação;base64&cotação;)

});

fs.desvincular(req.arquivos[i].caminho);

}

res.enviar(fileInfo);

});

var servidor = aplicativo.ouvir(3000, função() {

console.registro(&cotação;Escuta em porto %s...&cotação;, servidor.endereço().porto);

});

Na verdade, você chegou ao ponto em que eu parei na minha Tutorial de conversão base64 do Node.js. O problema é que agora queremos armazenar esses dados no Couchbase Server.

Inserção de dados de arquivo no Couchbase por meio de consultas N1QL

Vamos começar incluindo as várias informações de dependência que baixamos nas etapas anteriores. Na parte superior do arquivo app.js com as outras importações, inclua o seguinte:


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

var couchbase = exigir("couchbase");

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

var uuid = exigir("uuid");

var configuração = exigir("./config");

Estamos incluindo o Couchbase, o mecanismo N1QL, nossas informações de servidor e a biblioteca para gerar valores exclusivos. Agora, antes ou acima do bloco de código para compartilhamento de recursos entre origens, adicione a seguinte linha:


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

var balde = (novo couchbase.Aglomerado(configuração.couchbase.servidor)).openBucket(configuração.couchbase.balde);

Como eu disse, não importa realmente onde você a coloca, mas essa linha se conectará a um cluster do Couchbase e abrirá o bucket, ambos definidos na linha config.json arquivo.

Agora vamos ao que interessa!

Vamos alterar a função de ponto de extremidade para que os uploads sejam salvos no Couchbase antes de devolver os dados ao usuário. Vá em frente e altere a função de endpoint para que se pareça com o seguinte:


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

aplicativo.postagem("/upload", multer({dest: "./uploads/"}).matriz("uploads", 12), função(req, res) {

var fileInfo = [];

para(var i = 0; i < req.arquivos.comprimento; i++) {

fileInfo.empurrar({

&cotação;originalName&cotação;: req.arquivos[i].originalName,

&cotação;tamanho&cotação;: req.arquivos[i].tamanho,

&cotação;b64&cotação;: novo Buffer(fs.readFileSync(req.arquivos[i].caminho)).toString(&cotação;base64&cotação;)

});

fs.desvincular(req.arquivos[i].caminho);

}

var declaração = &cotação;INSERIR PARA `&cotação; + configuração.couchbase.balde + &cotação;` (CHAVE,VALOR) VALORES &cotação; +

&cotação;($1, {&amplificador;apos;arquivos&amplificador;apos;: $2})&cotação;;

var consulta = N1qlQuery.fromString(declaração);

balde.consulta(consulta, [uuid.v4(), fileInfo], função(erro, resultado) {

se(erro) {

retorno res.status(400).enviar({&cotação;status&cotação;: &cotação;erro&cotação;, &cotação;mensagem&cotação;: erro});

}

res.enviar(fileInfo);

});

Observe que agora estamos criando um INSERIR statement? Essa é uma consulta parametrizada para evitar qualquer tipo de ataque de injeção de SQL. Os parâmetros são definidos na consulta real e são o valor de identificação exclusivo para a chave e a matriz de arquivos que criamos. Somente depois que os dados forem salvos, eles serão retornados ao usuário.

Conclusão

Sim, houve um pouco de manipulação aqui no que diz respeito aos uploads reais de arquivos, mas isso se deve ao fato de que nos preocupamos mais com a inserção no Couchbase. Também porque isso foi explicado em meu tutorial anterior. Aqui vimos como fazer uma consulta N1QL para inserir a matriz que continha todos os nossos arquivos base64 que foram carregados. Desde que o tamanho dos arquivos não ultrapasse os limites do Couchbase, essa é uma solução perfeitamente aceitável e permitirá a replicação, caso ela seja ativada.

Nic Raboy, defensor dos desenvolvedores, Couchbase

Compartilhe este artigo

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

Armazenamento de arquivos Base64 diretamente no Couchbase via Node.js

Como configurar o Couchbase

Configuração de um aplicativo básico do Node.js

Inserção de dados de arquivo no Couchbase por meio de consultas N1QL

Conclusão

Receba atualizações do blog do Couchbase em sua caixa de entrada

Autor

Postado por Nic Raboy, defensor dos desenvolvedores, Couchbase

Deixe um comentário Cancelar resposta

Pronto para começar a usar o Couchbase Capella?

Iniciar a construção

Use o Capella gratuitamente

Entre em contato