Arquitetura de micro serviços em Node.js + MongoDB: Parte 3

Atualizado em 10/02/21!

E chegamos à terceira parte da nossa série de artigos sobre como implementar na prática um projeto de sistema usando arquitetura de microservices usando Node.js e MongoDB.

Na primeira parte desta série eu dei uma introdução teórica sobre microservices e porque você deveria estar olhando para esta arquitetura e principalmente para as tecnologias Node e Mongo para implementá-la. Finalizei este artigo dando um case de exemplo que usaríamos para desenvolvimento ao longo dos outros artigos.

Na segunda parte, começamos a estruturar nosso projeto, definindo camadas, serviços e responsabilidades. Na sequência modelamos o nosso banco de dados, criamos o módulo de conexão e o módulo de acesso a dados (repositório), tudo isso usando configurações através de variáveis de ambiente (com dotenv-safe) e testes unitários com Tape.

Nesta terceira parte vamos finalmente finalizar o desenvolvimento do nosso primeiro microservice, o movie-service, que fornecerá acesso a consultas de filmes por ID, filmes que são lançamento e todos os filmes de maneira genérica. Lembrando que este serviço será utilizado por outro que fará a interface com a aplicação propriamente dita, como ilustrado pelo diagrama abaixo.

Veremos neste artigo:

Programando o servidor
Programando a API
Programando o Index

Então mãos à obra!

#1- Programando o servidor

Agora é hora de programarmos os comportamentos da nossa API, mas antes disso precisamos construir nosso servidor.

Qualquer um que já leu alguma coisa a respeito na Internet sabe que este é o ponto forte do Node.js. É possível construir servidores web muito facilmente com Node a partir de 12 linhas de código sem nem mesmo usar pacotes de terceiros.

Como cada micro serviço deve rodar standalone, sem depender de outros, é extremamente interessante que cada um tenha o seu próprio módulo de server/server.js para ser instanciado isoladamente.

O conteúdo do server.js pode ser visto abaixo:

//server.js
require(''express-async-errors")
const express = require('express');
const morgan = require('morgan');
let server = null;

async function start(api, repository) {
    const app = express();
    app.use(morgan('dev'));

    app.use((err, req, res, next) => {
        console.error(err);
        res.sendStatus(500);
    })

    api(app, repository);

    server = app.listen(process.env.PORT);
    return server;
}

async function stop() {
    if (server) await server.close();
    return true;
}

module.exports = { start, stop }

//server.js

require(''express-async-errors")

const express = require('express');

const morgan = require('morgan');

let server = null;

async function start(api, repository) {

const app = express();

app.use(morgan('dev'));

app.use((err, req, res, next) => {

console.error(err);

res.sendStatus(500);

})

api(app, repository);

server = app.listen(process.env.PORT);

return server;

}

async function stop() {

if (server) await server.close();

return true;

}

module.exports = { start, stop }

Este servidor é genérico e simples, com uma função para iniciá-lo e outra para encerrá-lo e ele usa o pacote morgan para logging de requisições no terminal/console. Além disso, o pacote express-async-errors serve para que possamos capturar erros dentro de funções assíncronas automaticamente no Error Middleware, que é a função que passamos para o app.use e que começa com um objeto err. Ela é chamada automaticamente sempre que um erro acontece e nela podemos definir o comportamento padrão de erros do sistema. Se você quiser registrar logs de erro da aplicação, por exemplo, é aqui que você vai fazê-lo.

A função start espera a api, que vamos construir na sequência e o repositório, que já construímos. A api em si é que faz a magia de definição e tratamento das requisições em rotas específicas, tal qual já fizemos em outros tutoriais de Express aqui do blog.

Seguindo a nossa linha de ter unit tests para cada módulo do nosso projeto, vamos criar dentro da pasta cinema-microservice/movies-service/src/server um arquivo server.test.js contendo os testes abaixo:

//server.test.js
require('dotenv-safe').config();
const server = require('./server');

function apiMock(app, repo) {
    console.log("do nothing");
}

test('Server Start', async () => {
    const instance = await server.start(apiMock, null);
    expect(instance).toBeTruthy();
})

test('Server Stop', async () => {
    const isStopped = await server.stop();
    expect(isStopped).toBeTruthy();
})

//server.test.js

require('dotenv-safe').config();

const server = require('./server');

function apiMock(app, repo) {

console.log("do nothing");

}

test('Server Start', async () => {

const instance = await server.start(apiMock, null);

expect(instance).toBeTruthy();

})

test('Server Stop', async () => {

const isStopped = await server.stop();

expect(isStopped).toBeTruthy();

})

Nestes testes nós iniciaremos o servidor usando uma API mockada (fake) e depois encerraremos este mesmo servidor. Bem simples, apenas para saber se ele está de fato subindo e sendo encerrado com sucesso.

E com isso você já consegue garantir também que nosso servidor está funcionando, rodando um ‘npm test’ no console e vendo os resultados de todos os testes criados até o momento.

E agora, vamos finalmente criar a API em si?

#2 – Programando a API

Agora que temos o banco de dados, o repositório, o servidor e uma bateria de unit tests garantindo que tudo está funcionando como deveria, é hora de programarmos a API.

Na arquitetura desenhada até o momento, temos o arcabouço de servidor que espera que seja plugado um repositório e uma API, usando o Princípio da Inversão de Dependência (o DIP do SOLID). O repositório já temos pronto e a API vamos criar agora, dentro do que o servidor espera.

Para isso, dentro da pasta cinema-microservice/movies-service/src/api, crie um arquivo movies.js com o conteúdo abaixo:

//movies.js
module.exports = (app, repository) => {
    app.get('/movies', async (req, res, next) => {
        const movies = await repository.getAllMovies();
        if (!movies || movies.length === 0) return res.sendStatus(404);
        res.json(movies);
    })

    app.get('/movies/premieres', async (req, res, next) => {
        const movies = await repository.getMoviePremieres();
        if (!movies || movies.length === 0) return res.sendStatus(404);
        res.json(movies);
    })

    app.get('/movies/:id', async (req, res, next) => {
        const movie = await repository.getMovieById(req.params.id);
        if (!movie) return res.sendStatus(404);
        res.json(movie);
    })
}

//movies.js

module.exports = (app, repository) => {

app.get('/movies', async (req, res, next) => {

const movies = await repository.getAllMovies();

if (!movies || movies.length === 0) return res.sendStatus(404);

res.json(movies);

})

app.get('/movies/premieres', async (req, res, next) => {

const movies = await repository.getMoviePremieres();

if (!movies || movies.length === 0) return res.sendStatus(404);

res.json(movies);

})

app.get('/movies/:id', async (req, res, next) => {

const movie = await repository.getMovieById(req.params.id);

if (!movie) return res.sendStatus(404);

res.json(movie);

})

}

Note que uma vez que grande parte do trabalho já foi segregado em outros módulos, coube ao módulo da API em si uma responsabilidade bem específica e ao mesmo tempo pequena, que é o tratamento das requisições.

Mais tarde, conforme você for adicionando rotas nesta API, é importante pensar também em validação dos inputs, tema que abordo neste artigo, pois não quis deixar este mais extenso ainda.

Para garantir que esta nossa API está funcionando, vamos criar um movies.test.js na mesma pasta api para criarmos os testes abaixo:

//movies.test.js
require('dotenv-safe').config();
const supertest = require('supertest');
const movies = require('./movies');
const server = require("../server/server");
const repository = require("../repository/repository");

var testId = null;
let app = null;

beforeAll(async () => {
    app = await server.start(movies, repository);
    const result = await repository.getAllMovies();
    testId = `${result[0]._id}`;
})

afterAll(async () => {
    await server.stop();
})

test('GET /movies', async () => {
    const response = await supertest(app)
        .get('/movies');

    expect(response.status).toEqual(200);
    expect(Array.isArray(response.body)).toBeTruthy();
    expect(response.body.length).toBeGreaterThan(0);
})

test('GET /movies/:id', async () => {
    const response = await supertest(app)
        .get('/movies/' + testId);

    expect(response.status).toEqual(200);
    expect(response.body).toBeTruthy();
    expect(response.body._id).toEqual(testId);
})

test('GET /movies/premieres', async () => {
    const response = await supertest(app)
        .get('/movies/premieres');

    expect(response.status).toEqual(200);
    expect(Array.isArray(response.body)).toBeTruthy();
    expect(response.body.length).toBeGreaterThan(0);
})

//movies.test.js

require('dotenv-safe').config();

const supertest = require('supertest');

const movies = require('./movies');

const server = require("../server/server");

const repository = require("../repository/repository");

var testId = null;

let app = null;

beforeAll(async () => {

app = await server.start(movies, repository);

const result = await repository.getAllMovies();

testId = `${result[0]._id}`;

})

afterAll(async () => {

await server.stop();

})

test('GET /movies', async () => {

const response = await supertest(app)

.get('/movies');

expect(response.status).toEqual(200);

expect(Array.isArray(response.body)).toBeTruthy();

expect(response.body.length).toBeGreaterThan(0);

})

test('GET /movies/:id', async () => {

const response = await supertest(app)

.get('/movies/' + testId);

expect(response.status).toEqual(200);

expect(response.body).toBeTruthy();

expect(response.body._id).toEqual(testId);

})

test('GET /movies/premieres', async () => {

const response = await supertest(app)

.get('/movies/premieres');

expect(response.status).toEqual(200);

expect(Array.isArray(response.body)).toBeTruthy();

expect(response.body.length).toBeGreaterThan(0);

})

Esse arquivo de teste ficou mais complicado que os demais, afinal, para conseguir testar nossa API temos de subir um servidor no beforeAll e depois derrubá-lo no afterAll e usar a biblioteca supertest para simular as chamadas HTTP e com isso verificar se tudo está sendo retornado nos três endpoints como deveria.

Não vou entrar em detalhes do supertest aqui pois já falei dele no capítulo de testes, mas rode tudo com um npm test para ver o resultado com seus próprio olhos.

Agora que temos a nossa API pronta e funcionando, vamos atar tudo no arquivo index.js do projeto movies-service.

#3 – Programando o Index

Como última etapa para fazer a nossa API de filmes funcionar, temos de orquestrar todos os módulos que compõem a API no arquivo index.js, pois é ele que será chamado para startar o nosso microsserviço quando colocarmos ele em um servidor (preferencialmente em um container Docker, mas isso é outra história).

Na verdade, uma vez que chegamos até aqui, com essa quantidade de testes e arquitetura de micro serviços bem definida, o index.js ficará tão simples quanto abaixo:

//index.js
(async () => {
    require("dotenv-safe").config();
    const movies = require('./api/movies');
    const server = require("./server/server");
    const repository = require("./repository/repository");

    try {
        await server.start(movies, repository);
        console.log('Server is up and running at ' + process.env.PORT);
    } catch (error) {
        console.error(error);
    }
})();

//index.js

(async () => {

require("dotenv-safe").config();

const movies = require('./api/movies');

const server = require("./server/server");

const repository = require("./repository/repository");

try {

await server.start(movies, repository);

console.log('Server is up and running at ' + process.env.PORT);

} catch (error) {

console.error(error);

}

})();

Se você duvida que é apenas isso, experimente rodar este index através de ‘node index’ ou ‘npm start’ e você vai poder testar, seja via POSTMAN ou diretamente no navegador mesmo.

De novidade neste arquivo temos apenas o uso de uma Immediately Invoked Function Expression (IIFE) do JavaScript, que é uma função que se auto executa automaticamente. usei ela pois como temos um await dentro do código, precisamos que ele esteja dentro de uma função async, logo, criei um IIFE async ao redor.

Algumas boas práticas relacionadas a construção de APIs RESTful podem ser encontradas neste ótimo post (em inglês), mas te garanto que com esse basicão que vimos aqui você já está bem preparado para construir coisas mais poderosas e em cenários reais.

E não se preocupe, com o que lhe mostrei neste artigo conseguimos concluir apenas o primeiro microservice do nosso sistema completo. Quero que no mínimo consigamos avançar para o funcionamento do segundo microservice para fazer o fluxo básico de consultar filmes em cartaz em um cinema específico de uma cidade.

Mas isso fica para o próximo post da série!

Curtiu o post? Então clica no banner abaixo e dá uma conferida no meu livro sobre microservices com Node.js!