Couchbase Server and Couchbase Mobile together with Node.js

A criação de aplicativos da Web e aplicativos móveis que compartilham os mesmos dados costuma ser considerada uma tarefa desafiadora. Como você projeta seu aplicativo Web para se adequar ao seu aplicativo móvel e vice-versa? O que acontece quando você deseja usar o Couchbase para sincronizar seus dados entre dispositivos móveis em tempo real, mas também tê-los disponíveis em um navegador da Web?

Há várias maneiras de realizar essa tarefa com o Couchbase, mas vamos explorar uma das minhas favoritas neste guia específico. Usaremos um SDK do lado do servidor para consultar dados e uma API RESTful para gravar dados.

Os requisitos

Para este exemplo específico, seremos usando Node.jsmas, na verdade, não importa qual linguagem você usa, desde que haja um SDK do Couchbase Server disponível. Os requisitos para esse projeto incluem o seguinte:

Servidor Couchbase 4.1+
Gateway de sincronização do Couchbase 1.3+
Node.js 4.0+

Do ponto de vista dos componentes, o Couchbase Server abrigará todos os nossos dados. Além disso, ele será responsável pelo trabalho pesado envolvido na consulta. Não escreveremos diretamente no Couchbase Server a partir do SDK do Node.js, mas, em vez disso, usaremos o Couchbase Sync Gateway. O Sync Gateway salvará os dados no Couchbase Server e os transmitirá entre os dispositivos móveis. O Node.js será a camada de aplicativo da Web.

Não criaremos um aplicativo móvel neste exemplo específico, mas um aplicativo móvel se comunicaria com o Sync Gateway e seria usado de maneira semelhante. Os aplicativos móveis não se comunicam diretamente com o Couchbase Server.

Configuração do Couchbase Server e do Couchbase Sync Gateway

Antes que o aplicativo possa ser desenvolvido, o Couchbase Server e o Couchbase Sync Gateway precisam ser instalados e configurados.

Download do servidor Couchbase para o seu sistema operacional e prossiga com a instalação, certificando-se de que o serviço de consulta (N1QL) esteja ativado. Para este exemplo, usarei um bucket do Couchbase chamado exemplomas fique à vontade para chamá-lo do que quiser.

Com o exemplo criado, um índice N1QL deve ser adicionado para permitir a consulta dos dados. No Query Workbench ou CBQ, execute o seguinte:

CREATE PRIMARY INDEX ON `example` USING GSI;

1	CRIAR PRIMÁRIO ÍNDICE ON `exemplo` USO GSI;

O Query Workbench está disponível no Couchbase Server Enterprise Edition, mas a ferramenta de linha de comando CBQ está disponível em ambas as adições.

Nesse ponto, o Couchbase Server está pronto para funcionar.

Baixe e instale o Couchbase Sync Gateway para o seu sistema operacional. O Sync Gateway em si não será configurado, mas teremos um arquivo de configuração de projeto parecido com o seguinte em execução:

{
    "log":["CRUD+", "REST+", "Changes+", "Attach+"],
    "databases": {
        "example": {
            "server":"http://localhost:8091",
            "sync":`
                function (doc) {
                    channel (doc.channels);
                }
            `,
            "users": {
                "GUEST": {
                    "disabled": false,
                    "admin_channels": ["*"]
                }
            }
        }
    },
    "CORS": {
        "Origin": ["http://localhost:3000"],
        "LoginOrigin": ["http://localhost:3000"],
        "Headers": ["Content-Type"],
        "MaxAge": 17280000
    }
}

{

"log":["CRUD+", "REST+", "Mudanças+", "Anexar+"],

"bancos de dados": {

"exemplo": {

"servidor":"http://localhost:8091",

"sync":`

função (doc) {

canal (doc.canais);

}

"usuários": {

"CONVIDADO": {

"desativado": falso,

"admin_channels": ["*"]

}

"CORS": {

"Origem": ["http://localhost:3000"],

"LoginOrigin": ["http://localhost:3000"],

"Headers" (Cabeçalhos): ["Content-Type"],

"MaxAge": 17280000

}

Chame o arquivo acima sync-gateway-config.json e armazená-lo em seu projeto. Essencialmente, estamos dizendo ao Sync Gateway que queremos nos conectar a um determinado cluster do Couchbase Server e usar o bucket exemplo. Como usaremos solicitações RESTful da mesma máquina, precisamos permitir CORS na porta 3000.

Para manter as coisas simples, a lógica de sincronização permitirá que todos os documentos sejam transmitidos sem regras de leitura ou gravação.

Criação do aplicativo Web

Na verdade, ainda não estamos executando o Sync Gateway, mas tanto o Couchbase Server quanto o Sync Gateway estão prontos para uso. Agora podemos nos concentrar na criação do nosso projeto Node.js.

O projeto em si será um exemplo muito simples. Vamos criar uma API RESTful com dois pontos de extremidade, um para criar dados e outro para listar dados. O problema aqui é que um ponto de extremidade consultará o Couchbase Server diretamente com o SDK do Node.js e um ponto de extremidade gravará dados no Couchbase Sync Gateway por meio da API RESTful do Sync Gateway.

Antes de nos adiantarmos, vamos começar a criar o projeto.

Criação de um novo projeto e inicialização do código

Como estamos usando o Node.js, tudo será realizado no prompt de comando (Windows) ou no Terminal (Mac e Linux). Usando um deles, execute o seguinte:

npm init --y

1	npm inicial --y

O comando acima criará um novo package.json para o nosso projeto. Todas as dependências do nosso projeto serão armazenadas nesse arquivo.

Em seguida, execute o seguinte para obter todas as dependências de que precisamos:

npm install couchbase express body-parser request --save

1	npm instalar couchbase expresso corpo-analisador solicitação --salvar

Vamos usar couchbase para se comunicar com nosso banco de dados, expresso para o Express Framework, analisador de corpo para aceitar dados do corpo em solicitações, e solicitação para fazer solicitações HTTP de dentro do Node.js, não para o Node.js.

Nesse ponto, podemos começar a inicializar o aplicativo.

Crie um arquivo chamado index.js dentro do projeto. Vamos usá-lo para todo o nosso aplicativo. Em aplicativos maiores ou de produção, você pode considerar a possibilidade de dividi-lo em arquivos mais precisos para facilitar a manutenção, mas, neste exemplo, não há problema.

Aberto index.js e incluem as seguintes importações:

var Couchbase = require("couchbase");
var Express = require("express");
var BodyParser = require("body-parser");
var Request = require("request");

var Couchbase = exigir("couchbase");

var Expresso = exigir("expresso");

var Analisador de corpo = exigir("body-parser");

var Solicitação = exigir("request" (solicitação));

As dependências que baixamos anteriormente foram importadas para o projeto. No entanto, elas não foram inicializadas.

var app = Express();
var N1qlQuery = Couchbase.N1qlQuery;

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

var aplicativo = Expresso();

var N1qlQuery = Couchbase.N1qlQuery;

aplicativo.uso(Analisador de corpo.json());

aplicativo.uso(Analisador de corpo.codificado por url({ estendido: verdadeiro }));

As linhas acima inicializam o Express Framework, preparam o N1QL no aplicativo e permitem a aceitação de dados codificados em JSON e URL nos corpos das solicitações.

Embora o N1QL esteja praticamente pronto para funcionar, ainda não nos conectamos ao cluster de servidores nem abrimos nosso bucket. Isso pode ser feito da seguinte forma:

var bucket = (new Couchbase.Cluster("couchbase://localhost")).openBucket("example");

1	var balde = (novo Couchbase.Aglomerado("couchbase://localhost")).openBucket("exemplo");

Novamente, estamos usando um bucket que chamei de exemplo em uma etapa anterior.

Por fim, como a última parte da inicialização do nosso projeto, podemos começar a servir o aplicativo:

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

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

console.registro("Escutando na porta %s...", servidor.endereço().porto);

});

Quando estiver em execução, o aplicativo da Web poderá ser acessado em http://localhost:3000 em um navegador da Web e em outros lugares.

Adição do SDK do Couchbase Node.js e da lógica do gateway de sincronização RESTful

Como mencionado anteriormente, este aplicativo permanecerá simples para que seja fácil de entender. Teremos apenas dois pontos de extremidade, um que usa o SDK do Couchbase Server e outro que usa a API RESTful do Sync Gateway.

Esses dois pontos de extremidade terão a seguinte aparência:

GET /list
POST /create

1 2	OBTER /lista POST /criar

Começando com o /lista temos o seguinte código:

app.get("/list", function(req, res) {
    bucket.query(N1qlQuery.fromString("SELECT type, firstname, lastname FROM `" + bucket._name + "` WHERE type = 'person'"), function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.send(result);
    });
});

aplicativo.obter("/lista", função(req, res) {

balde.consulta(N1qlQuery.fromString("SELECT type, firstname, lastname FROM `" + balde._nome + "` WHERE type = 'person'"), função(erro, resultado) {

se(erro) {

retorno res.status(400).enviar(erro);

}

res.enviar(resultado);

});

Quando uma solicitação GET for feita a esse ponto de extremidade, uma consulta N1QL será executada no Couchbase Server. Essa consulta obterá o tipo, primeiro nomee sobrenome propriedades de todos os documentos no bucket específico, desde que esses documentos tenham um tipo propriedade que é igual a pessoa. Se houver um erro, retorne um erro para o usuário; caso contrário, retorne os dados que foram recuperados.

O próximo endpoint usa solicitações HTTP no Node.js. Antes de ir direto para o endpoint, pode fazer sentido criar um método auxiliar para fazer essas solicitações:

var makePostRequest = function(url, body, callback) {
    Request.post(url, { json: body },
        function (error, response, body) {
            if (!error &amp;&amp; response.statusCode == 200) {
                callback(null, body);
            } else {
                callback(error, null);
            }
        }
    );
}

var makePostRequest = função(url, corpo, retorno de chamada) {

Solicitação.postagem(url, { json: corpo },

função (erro, resposta, corpo) {

se (!erro &amplificador;&amplificador; resposta.statusCode == 200) {

retorno de chamada(nulo, corpo);

} mais {

retorno de chamada(erro, nulo);

}

);

}

O método acima fará uma solicitação POST para um URL específico, passando um objeto JavaScript como corpo. Se for bem-sucedido, a resposta será retornada; caso contrário, será exibido um erro.

O makePostRequest O método pode ser visto em ação no seguinte:

app.post("/create", function(req, res) {
    if(!req.body.firstname) {
        return res.status(400).send({"status": "error", "message": "A firstname is required"});
    } else if(!req.body.lastname) {
        return res.status(400).send({"status": "error", "message": "A lastname is required"});
    }
    makePostRequest("http://localhost:4984/" + bucket._name + "/", {type: "person", firstname: req.body.firstname, lastname: req.body.lastname}, function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.send(req.body);
    });
});

aplicativo.postagem("/create", função(req, res) {

se(!req.corpo.primeiro nome) {

retorno res.status(400).enviar({"status": "error" (erro), "mensagem": "É necessário um nome próprio"});

} mais se(!req.corpo.sobrenome) {

retorno res.status(400).enviar({"status": "error" (erro), "mensagem": "É necessário um sobrenome"});

}

makePostRequest("http://localhost:4984/" + balde._nome + "/", {tipo: "pessoa", primeiro nome: req.corpo.primeiro nome, sobrenome: req.corpo.sobrenome}, função(erro, resultado) {

se(erro) {

retorno res.status(400).enviar(erro);

}

res.enviar(req.corpo);

});

No código acima, quando uma solicitação POST é feita para o /criar primeiro verificamos se determinadas propriedades existem no corpo, caso contrário, lançamos um erro. Se elas existirem, usaremos a função makePostRequest passando o URL do método Documentação da API RESTful do Sync Gateway.

Nesse ponto, se for bem-sucedido, os dados serão salvos do Sync Gateway no Couchbase Server e transmitidos a todos os dispositivos conectados.

O código-fonte completo do aplicativo

Caso queira ver o aplicativo inteiro montado, o código-fonte pode ser encontrado abaixo:

var Couchbase = require("couchbase");
var Express = require("express");
var BodyParser = require("body-parser");
var Request = require("request");

var app = Express();
var N1qlQuery = Couchbase.N1qlQuery;

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

var bucket = (new Couchbase.Cluster("couchbase://localhost")).openBucket("example");

var makePostRequest = function(url, body, callback) {
    Request.post(url, { json: body },
        function (error, response, body) {
            if (!error &amp;&amp; response.statusCode == 200) {
                callback(null, body);
            } else {
                callback(error, null);
            }
        }
    );
}

app.get("/list", function(req, res) {
    bucket.query(N1qlQuery.fromString("SELECT type, firstname, lastname FROM `" + bucket._name + "` WHERE type = 'person'"), function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.send(result);
    });
});

app.post("/create", function(req, res) {
    if(!req.body.firstname) {
        return res.status(400).send({"status": "error", "message": "A firstname is required"});
    } else if(!req.body.lastname) {
        return res.status(400).send({"status": "error", "message": "A lastname is required"});
    }
    makePostRequest("http://localhost:4984/" + bucket._name + "/", {type: "person", firstname: req.body.firstname, lastname: req.body.lastname}, function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.send(req.body);
    });
});

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

var Couchbase = exigir("couchbase");

var Expresso = exigir("expresso");

var Analisador de corpo = exigir("body-parser");

var Solicitação = exigir("request" (solicitação));

var aplicativo = Expresso();

var N1qlQuery = Couchbase.N1qlQuery;

aplicativo.uso(Analisador de corpo.json());

aplicativo.uso(Analisador de corpo.codificado por url({ estendido: verdadeiro }));

var balde = (novo Couchbase.Aglomerado("couchbase://localhost")).openBucket("exemplo");

var makePostRequest = função(url, corpo, retorno de chamada) {

Solicitação.postagem(url, { json: corpo },

função (erro, resposta, corpo) {

se (!erro &amplificador;&amplificador; resposta.statusCode == 200) {

retorno de chamada(nulo, corpo);

} mais {

retorno de chamada(erro, nulo);

}

);

}

aplicativo.obter("/lista", função(req, res) {

balde.consulta(N1qlQuery.fromString("SELECT type, firstname, lastname FROM `" + balde._nome + "` WHERE type = 'person'"), função(erro, resultado) {

se(erro) {

retorno res.status(400).enviar(erro);

}

res.enviar(resultado);

});

aplicativo.postagem("/create", função(req, res) {

se(!req.corpo.primeiro nome) {

retorno res.status(400).enviar({"status": "error" (erro), "mensagem": "É necessário um nome próprio"});

} mais se(!req.corpo.sobrenome) {

retorno res.status(400).enviar({"status": "error" (erro), "mensagem": "É necessário um sobrenome"});

}

makePostRequest("http://localhost:4984/" + balde._nome + "/", {tipo: "pessoa", primeiro nome: req.corpo.primeiro nome, sobrenome: req.corpo.sobrenome}, função(erro, resultado) {

se(erro) {

retorno res.status(400).enviar(erro);

}

res.enviar(req.corpo);

});

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

console.registro("Escutando na porta %s...", servidor.endereço().porto);

});

Vamos explorar a execução desse aplicativo na próxima etapa.

Execução do aplicativo

Há muitas peças em movimento neste exemplo específico. Temos um aplicativo Node.js, o Couchbase Server e o Couchbase Sync Gateway. No futuro, você provavelmente também terá um aplicativo móvel.

A primeira coisa que queremos fazer é iniciar o Sync Gateway e fazer com que ele se conecte ao nosso cluster do Couchbase Server já em execução. Execute o seguinte em sua linha de comando:

/path/to/sync_gateway /path/to/sync-gateway-config.json

1	/caminho/para/portais de sincronização /caminho/para/sincronização-portal-configuração.json

Com o Sync Gateway em execução, você pode executar o aplicativo Node.js executando:

node index.js

1	nó índice.js

O aplicativo agora deve estar acessível em http://localhost:3000 nos caminhos específicos do ponto de extremidade.

Conclusão

Você acabou de ver uma maneira possível de reunir seus aplicativos Couchbase Mobile e Couchbase Server. Embora não tenhamos realmente criado um aplicativo móvel neste guia, usamos todos os componentes que o tornariam possível como uma etapa final. Criamos um aplicativo Node.js que usou o SDK do Couchbase Server Node.js e o Couchbase Sync Gateway.

Nic Raboy, defensor dos desenvolvedores, Couchbase

3 Comentários

glenn junho 6, 2017 em 5:36 am

Olá, senhor,

Gostaríamos de usar sua abordagem, mas há uma consideração que encontramos. Trata-se de casos off-line para dispositivos móveis. Como não foi possível fazer uma chamada, como poderíamos superar esse problema? Devemos escrever alterações no couchbase lite e, quando a Internet estiver disponível, fazer uma chamada de API para o nosso servidor?

Em segundo lugar, você mencionou que há outras abordagens possíveis para usar o couchbase mobile e o couchbase server. Você poderia fornecer informações breves sobre isso?

Obrigado.

Acesse para responder
1. Nic Raboy, defensor dos desenvolvedores, Couchbase junho 6, 2017 em 6:01 am
  
  Você não precisará se preocupar com os casos extremos com o Couchbase mobile porque, por padrão, o Couchbase Lite se comunicará com o Sync Gateway sempre que houver uma conexão com a Internet disponível.
  
  Com o Node e o Couchbase Lite se comunicando com o Sync Gateway, tudo ficará bem.
  
  Quando o Couchbase 5.0 for lançado, você não precisará se comunicar dessa forma, pois tudo será incorporado aos SDKs.
  
  Acesse para responder
  1. glenn junho 6, 2017 em 6:18 am
    
    Portanto, no nosso caso, se a Internet estiver ativa, ele fará uma chamada para o servidor de aplicativos que recebe a solicitação e se comunica com o gateway de sincronização. Por outro lado, se a Internet não estiver disponível, o aplicativo móvel insere os dados em seu próprio couchbase lite local. Sempre que houver uma conexão com a Internet disponível, as operações de sincronização serão realizadas e os dados serão mantidos.
    
    Obrigado.
    
    Acesse para responder

Deixar uma resposta Cancelar resposta

Você precisa fazer o login para publicar um comentário.

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

Todas as publicações

Usando o Couchbase Server e o Couchbase Mobile no mesmo projeto com o Node.js

Os requisitos

Configuração do Couchbase Server e do Couchbase Sync Gateway

Criação do aplicativo Web

Criação de um novo projeto e inicialização do código

Adição do SDK do Couchbase Node.js e da lógica do gateway de sincronização RESTful

O código-fonte completo do aplicativo

Execução do aplicativo

Conclusão

Autor

Postado por Nic Raboy, defensor dos desenvolvedores, Couchbase

3 Comentários

Deixar uma resposta Cancelar resposta