Introdução

Neste tutorial, vamos explorar como integrar microservices em aplicações ‘Red’ utilizando Node.js e Docker. A arquitetura baseada em microservices é uma abordagem moderna e eficiente para construir sistemas escaláveis e de fácil manutenção. Com o uso do Node.js, podemos desenvolver serviços leves e ágeis, enquanto o Docker nos permite containerizar esses serviços, facilitando a implementação e a gestão de dependências. Ao longo deste artigo, vamos construir um sistema básico de microservices, adicionando práticas recomendadas e ferramentas essenciais que ajudam na escalabilidade e na eficiência do desenvolvimento. Se você está buscando aumentar suas habilidades em desenvolvimento de software e entender como construir sistemas complexos com microservices, está no lugar certo.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Antes de começarmos, verifique se você tem o Node.js e o Docker instalados nas versões mais recentes. Use os seguintes comandos para verificar as instalações:

    commands
    # Verificar versao do Node.js
    node -v
    # Verificar versao do NPM
    npm -v
    # Verificar versao do Docker
    docker --version

  2. Criação do Projeto Node.js

    Vamos criar um novo projeto Node.js. Crie um diretório para o projeto e inicialize um novo projeto Node.js usando npm.

    commands
    # Criar diretório do projeto
    mkdir microservice-example && cd microservice-example
    # Inicializar um novo projeto Node.js
    npm init -y

  3. Instalação de Dependências

    Vamos instalar as principais dependências que precisamos para o projeto, como Express para criação da API.

    commands
    npm install express

  4. Criação do Service ‘Produto’

    Crie um arquivo `produto.js` na raiz do projeto para definir a lógica do nosso service de produtos.

    produto.js
    const express = require('express');
const router = express.Router();

let produtos = [];

// Lista todos os produtos
router.get('/', (req, res) => {
    res.json(produtos);
});

// Cria um novo produto
router.post('/', (req, res) => {
    const produto = req.body;
    produtos.push(produto);
    res.status(201).json(produto);
});

module.exports = router;

  5. Configurando o Servidor Express

    Crie o arquivo principal `server.js` onde será configurado o servidor Express para utilizar o service de produtos.

    server.js
    const express = require('express');
const produtoRouter = require('./produto');

const app = express();
app.use(express.json());

// Configurar rotas
app.use('/api/produtos', produtoRouter);

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Servidor rodando na porta ${PORT}`);
});

  6. Testando o Serviço Localmente

    Use ferramentas como Postman ou cURL para testar as rotas do seu serviço localmente.

    commands
    # Inicie o servidor
    node server.js
    # Exemplo de requisições cURL
    curl -X GET http://localhost:3000/api/produtos
    curl -X POST -H 'Content-Type: application/json' -d '{"nome":"Produto 1", "preco":10.0}' http://localhost:3000/api/produtos

  7. Criando o Dockerfile

    Crie um arquivo `Dockerfile` na raiz do projeto para containerizar sua aplicação Node.js.

    Dockerfile
    FROM node:14

WORKDIR /usr/src/app

COPY package*.json ./

RUN npm install

COPY . .

CMD [ "node", "server.js" ]

EXPOSE 3000

  8. Construindo e Executando o Container Docker

    Construa a imagem Docker e execute o container com os seguintes comandos.

    commands
    # Construir a imagem Docker
    docker build -t microservice-example .
    # Executar o container
    docker run -p 3000:3000 microservice-example

  9. Testando o Serviço em Docker

    Uma vez que o container esteja rodando, você pode testar as rotas novamente, desta vez no Docker.

    commands
    # Exemplo de requisições cURL após subir o container
    curl -X GET http://localhost:3000/api/produtos
    curl -X POST -H 'Content-Type: application/json' -d '{"nome":"Produto 2", "preco":20.0}' http://localhost:3000/api/produtos

  10. Implementação de Testes Unitários

    Vamos criar testes unitários para nosso service usando o Jest. Primeiro, instale o Jest como dependência de desenvolvimento.

    commands
    npm install --save-dev jest supertest

    produto.test.js
    const request = require('supertest');
const express = require('express');
const produtoRouter = require('./produto');

const app = express();
app.use(express.json());
app.use('/api/produtos', produtoRouter);

describe('Testes de Produtos', () => {
    it('Deve listar todos os produtos', async () => {
        const response = await request(app).get('/');
        expect(response.status).toBe(200);
    });

    it('Deve criar um novo produto', async () => {
        const response = await request(app)
            .post('/')
            .send({ nome: 'Produto Teste', preco: 30.0 });
        expect(response.status).toBe(201);
        expect(response.body.nome).toBe('Produto Teste');
    });
});

  11. Executando os Testes

    Adicione um script no `package.json` para executar os testes e execute-os.

    package.json
    {
  // outras propriedades
  "scripts": {
    "test": "jest"
  }
}

    commands
    # Executar os testes unitários
    npm test

Conclusão

Neste tutorial, abordamos como construir e integrar microservices em aplicações ‘Red’ utilizando Node.js e Docker. Vimos desde a criação da API utilizando o Express, a configuração do ambiente até a implementação e execução de testes unitários para garantir a qualidade do código. Através da containerização com Docker, facilitamos o processo de escalabilidade e implementação em diferentes ambientes. Com estas ferramentas e práticas, você está bem equipado para construir sistemas complexos e escaláveis, aproveitando as vantagens dos microservices.

Hashtags

#NodeJS #Docker #Microservices #APIs #DesenvolvimentoDeSoftware