Migrar do MongoDB Mongoose para o Couchbase com o Ottoman

Ao conversar com desenvolvedores de Node.js, é comum ouvir falar de NoSQL como o banco de dados preferido para desenvolvimento. JavaScript e JSON andam de mãos dadas porque, afinal, JSON significa JavaScript Object Notation. Esse é um formato mais comum em bancos de dados orientados a documentos que os desenvolvedores de Node.js tendem a usar.

Uma pilha muito popular de tecnologias de desenvolvimento é a pilha MongoDB, Express Framework, Angular e Node.js (MEAN), mas também existe a pilha Couchbase, Express Framework, Angular e Node.js (CEAN). Não me entenda mal, todas as tecnologias que listei são excelentes, mas quando seus aplicativos precisam ser dimensionados e manter o desempenho, talvez você tenha mais sorte com Couchbase devido à forma como ele funciona por design.

E se você já estiver usando o MongoDB em seu aplicativo Node.js?

É provável que você esteja usando Mongoose que é um modelo de documento de objeto (ODM) para interagir com o banco de dados. O Couchbase também tem um ODM, chamado Otomana. O melhor dessas duas tecnologias ODM é que elas compartilham praticamente o mesmo conjunto de APIs, o que torna qualquer transição incrivelmente fácil.

Veremos como tirar proveito da API REST do MongoDB para fazer a transição de um aplicativo Node.js usando o Mongoose e migrá-lo para o Couchbase, com o Ottoman.

Os requisitos

Este tutorial será um pouco diferente devido a todas as tecnologias envolvidas. Vamos criar tudo do zero para simplificar, portanto, os requisitos e as recomendações a seguir são:

• Servidor Couchbase 4.5+
• MongoDB 3.4+
• Node.js 6.0+

Vamos começar criando uma API REST do MongoDB no Node.js usando o Mongoose, daí a necessidade do Node.js e do MongoDB. Em seguida, pegaremos esse aplicativo e o migraremos para o Couchbase.

Para fins deste exemplo, não veremos como configurar o Node.js, o MongoDB ou o Couchbase Server.

Compreensão do nosso modelo de dados NoSQL

Tanto o MongoDB quanto o Couchbase são bancos de dados de documentos. Um armazena dados BSON e o outro armazena JSON, mas, do ponto de vista do desenvolvedor, eles são incrivelmente semelhantes. Dito isso, vamos criar alguns modelos baseados em alunos que frequentam cursos em uma escola. O primeiro modelo que criamos pode ser para cursos reais, em que um único curso pode se parecer com o seguinte:

No exemplo acima, observe que o curso tem um ID exclusivo e que o definimos como sendo um curso. O curso tem informações de nomenclatura, bem como uma lista de alunos que estão matriculados.

Agora, digamos que queremos definir nosso modelo para documentos de alunos:

Observe que o modelo acima tem um formato semelhante ao dos cursos. O que estamos dizendo aqui é que ambos os documentos estão relacionados, mas ainda são semiestruturados. Estamos dizendo que cada curso mantém o controle de seus alunos e cada aluno mantém o controle de seus cursos. Isso é útil quando tentamos consultar os dados.

Há possibilidades ilimitadas quando se trata de modelar seus dados NoSQL. De fato, provavelmente há mais de cem maneiras de definir um modelo de "cursos e alunos", em comparação com o que eu havia decidido. Depende totalmente de você, e essa é a flexibilidade que o NoSQL oferece. Mais informações sobre modelagem de dados podem ser encontradas em aqui.

Com um modelo de dados em mente, podemos criar um conjunto simples de pontos de extremidade de API usando cada MongoDB com Mongoose e Couchbase com Ottoman.

Desenvolvimento de uma API com a estrutura Express e o MongoDB

Como estamos, em teoria, migrando do MongoDB para o Couchbase, faria sentido descobrir primeiro o que queremos em um aplicativo MongoDB.

Crie um novo diretório em algum lugar do seu computador para representar a primeira parte do nosso projeto. Nesse diretório, execute o seguinte:

Os comandos acima criarão um arquivo chamado package.json que manterá o controle de cada uma das quatro dependências do projeto. As expresso é para a estrutura do Express e a dependência analisador de corpo A dependência permite a existência de corpos de solicitação em solicitações POST, PUT e DELETE, que são comuns para a alteração de dados. Em seguida mongodb e mangusto são necessários para trabalhar com o banco de dados.

O projeto que criamos terá a seguinte estrutura:

Vá em frente e crie esses diretórios e arquivos se eles ainda não existirem. Os app.js será o driver do aplicativo, enquanto o arquivo rotas conterá nossos pontos de extremidade da API e o modelos conterá as definições do banco de dados para o nosso aplicativo.

Definição dos esquemas do Mongoose

Então, vamos trabalhar de trás para frente, começando com o modelo Mongoose que se comunicará com o MongoDB. Abra a seção models/models.js e inclua o seguinte:

No exemplo acima, estamos criando esquemas de documentos do MongoDB e, em seguida, criando modelos a partir deles. Observe como os esquemas são semelhantes aos modelos JSON que definimos anteriormente fora do aplicativo. Não estamos declarando um id e tipo porque o ODM cuida disso para nós. Em cada uma das matrizes, usamos uma referência a outro esquema. O que veremos ao salvar é um ID de documento, mas podemos aproveitar as tecnologias de consulta para carregar esse ID em dados reais.

Então, como usamos esses modelos?

Criação das rotas da API REST

Agora, queremos criar informações de roteamento ou, em outras palavras, pontos de extremidade de API. Por exemplo, vamos criar todos os pontos de extremidade CRUD para as informações do curso. Na seção rotas/cursos.js adicione o seguinte:

No exemplo acima, temos três pontos de extremidade. Podemos visualizar todos os cursos disponíveis, visualizar os cursos por id e criar novos cursos. Cada ponto de extremidade é alimentado pelo Mongoose.

Ao criar um documento, os dados POST da solicitação são adicionados a uma nova instanciação de modelo. Uma vez que salvar é chamado, ele é salvo no MongoDB. Coisas semelhantes acontecem ao ler dados do banco de dados.

No caso dos itens acima, o encontrar é chamada e os parâmetros são passados. Quando não há parâmetros, todos os documentos são retornados da função Curso caso contrário, os dados são consultados pelas propriedades passadas. O preencher permite que as referências de documentos sejam carregadas, portanto, em vez de retornar os valores de id, os documentos reais são retornados.

Agora vamos dar uma olhada na outra rota.

A segunda rota é responsável pela criação dos dados do aluno, mas há uma exceção aqui. Também estaremos gerenciando as relações de documentos aqui. Abra a seção routes/students.js e inclua o seguinte código-fonte:

Os três primeiros endpoints da API devem parecer familiares. O novo endpoint aluno/curso é responsável por adicionar alunos a um curso e cursos a um aluno.

A primeira coisa que acontece é que um curso é encontrado com base em um ID de solicitação. Em seguida, um aluno é encontrado com base em um ID de solicitação diferente. Se ambos os documentos forem encontrados, os ids serão adicionados a cada uma das matrizes apropriadas e os documentos serão salvos mais uma vez.

A etapa final aqui é criar nosso driver de aplicativo. Ele se conectará ao banco de dados e servirá o aplicativo para ser consumido pelos clientes.

Conectando-se ao MongoDB e atendendo ao aplicativo

Abra o arquivo app.js e adicione o seguinte código:

No código acima, estamos importando cada uma das dependências que instalamos anteriormente. Em seguida, estamos inicializando o Express e dizendo a ele para aceitar corpos JSON nas solicitações.

As rotas que foram criadas anteriormente precisam ser vinculadas ao Express, portanto, estamos importando-as e passando a instância do Express. Por fim, uma conexão com o MongoDB é feita com o Mongoose e o aplicativo começa a servir.

Não é particularmente difícil, certo?

Desenvolvimento de uma API com o Express Framework e o Couchbase

Vimos como criar uma API com o Node.js, o Mongoose e o MongoDB, então agora precisamos fazer a mesma coisa com o Node.js, o Ottoman e o Couchbase. Mais uma vez, isso serve para mostrar como é fácil fazer a transição do MongoDB para o Couchbase e obter todos os benefícios de um banco de dados NoSQL avançado e pronto para empresas.

Crie um novo diretório em algum lugar de seu computador e, dentro dele, execute o seguinte para criar um novo projeto:

Os comandos acima são semelhantes aos que vimos anteriormente, com a exceção de que agora estamos usando o Couchbase e o Ottoman. O projeto que criamos terá exatamente a mesma estrutura e, para relembrar, ele se parece com o seguinte:

Todos os modelos Ottoman existirão no modelos todos os pontos de extremidade da API e a lógica Ottoman existirão no diretório rotas e toda a lógica do driver existirá no diretório app.js arquivo.

Definição dos modelos otomanos

Vamos trabalhar na mesma direção que fizemos para o aplicativo MongoDB para mostrar a facilidade de transição. Isso significa começar com os modelos Ottoman que representarão nossos dados no Couchbase Server.

Abra o arquivo models/models.js e inclua o seguinte:

O que foi dito acima deve parecer familiar, mas você precisa perceber que esses são dois ODMs muito diferentes. Em vez de projetar esquemas do MongoDB por meio do Mongoose, podemos ir direto para o projeto de modelos JSON para o Couchbase com o Ottoman. Lembre-se de que não há esquemas nos Buckets do Couchbase.

Cada modelo Ottoman tem um conjunto de propriedades e uma matriz que faz referência a outros documentos. Embora a sintaxe seja um pouco diferente, ela realiza a mesma coisa.

Isso nos leva aos pontos de extremidade da API que usam esses modelos.

Criação dos pontos de extremidade da API REST

O primeiro conjunto de pontos de extremidade que queremos criar está relacionado ao gerenciamento de cursos. Abra a seção rotas/cursos.js e inclua o seguinte código JavaScript:

No código acima, temos três pontos de extremidade estruturados de forma quase idêntica ao que vimos com o MongoDB e o Mongoose. No entanto, há algumas pequenas diferenças. Por exemplo, em vez de usar promessas, estamos usando retornos de chamada.

Uma das diferenças mais visíveis é a forma como a consulta é feita. Não só temos acesso a um encontrar como vimos no Mongoose, mas também temos acesso a uma função getById função. Em ambos os cenários, podemos passar informações sobre como esperamos que uma consulta ocorra. Em vez de usar um preencher podemos usar a função carregar e fornecer os documentos de referência que desejamos carregar. Os conceitos entre o Mongoose e o Ottoman são praticamente os mesmos.

Isso nos leva ao nosso segundo conjunto de rotas. Abra o diretório routes/students.js e inclua o seguinte código JavaScript:

Já sabemos que os três primeiros endpoints terão o mesmo formato. Queremos prestar atenção ao último endpoint, que gerencia nossos relacionamentos.

Com esse ponto de extremidade, estamos obtendo um curso por seu valor de id e um aluno com base em seu valor de id. Desde que ambos retornem um documento, podemos adicionar uma referência de cada um a cada um de seus arrays e salvar novamente o documento. A mesma coisa e quase o mesmo código foram encontrados na versão do Mongoose.

Agora podemos examinar a lógica para começar a servir o aplicativo após a conexão com o banco de dados.

Conexão com o Couchbase e fornecimento do aplicativo

Abra o arquivo app.js e inclua o seguinte JavaScript:

A imagem acima lhe parece familiar? Deveria! Estamos apenas trocando as informações de conexão do Mongoose pelas informações de conexão do Couchbase. Após a conexão com o banco de dados, podemos começar a servir o aplicativo.

Conclusão

A migração do Mongoose e do MongoDB é mais fácil do que você imagina. De fato, vocêVocê acabou de ver como criar uma API REST com o Node.js, o Mongoose e o MongoDB e, em seguida, trazê-la para o Couchbase de uma maneira muito simples. Isso foi feito para provar que não é preciso ter medo do processo de migração, especialmente se você estiver usando o Node.js como sua tecnologia de back-end.

Com o Couchbase, você tem um banco de dados NoSQL distribuído e de alto desempenho que funciona em qualquer escala. A necessidade de usar o cache na frente do seu banco de dados é eliminada porque ele está integrado ao Couchbase. Para obter mais informações sobre o uso do Ottoman, você pode conferir um blog anterior que escrevi. Mais informações sobre o uso do Couchbase com o Node.js podem ser encontradas na seção Portal do desenvolvedor do Couchbase.