Microserviços são uma arquitetura de software que divide uma aplicação em serviços pequenos e independentes, cada um executando uma função específica. Essa abordagem facilita a escalabilidade e a manutenção de aplicações complexas. Node.js, com sua natureza assíncrona e leve, é uma escolha popular para desenvolver microserviços. Docker, por sua vez, é uma plataforma de contêineres que simplifica o desenvolvimento, a distribuição e a execução de aplicações em ambientes isolados. Neste artigo, vamos explorar como desenvolver microserviços escaláveis com Node.js e Docker.

Pré-requisitos

Antes de começar, certifique-se de ter:

• Node.js instalado em sua máquina.
• Docker instalado.
• Conhecimento básico de JavaScript, Node.js e Docker.
• Um editor de texto, como VSCode.

Configuração do Ambiente

1. Instalando Node.js e Docker

Instalando Node.js:

Acesse o site oficial do Node.js e baixe a versão apropriada para o seu sistema operacional.

Instalando Docker:

Acesse o site oficial do Docker e siga as instruções de instalação para o seu sistema operacional.

2. Configurando o Projeto

Crie um diretório para o seu projeto e inicialize um novo projeto Node.js:

mkdir microservices-node-docker
cd microservices-node-docker
npm init -y

Criando o Primeiro Microserviço

Vamos criar um microserviço simples que gerencia informações de usuários.

1. Estrutura do Projeto

Crie a seguinte estrutura de diretórios:

microservices-node-docker/
├── user-service/
│   ├── src/
│   │   ├── index.js
│   │   └── userController.js
│   ├── Dockerfile
│   ├── package.json
│   └── .dockerignore
└── docker-compose.yml

2. Desenvolvendo o Serviço de Usuários

Arquivo user-service/src/index.js:

const express = require('express');
const userController = require('./userController');

const app = express();
const port = 3000;

app.use(express.json());

app.get('/users', userController.getAllUsers);
app.post('/users', userController.createUser);

app.listen(port, () => {
  console.log(`User service running on port ${port}`);
});

Arquivo user-service/src/userController.js:

const users = [];

exports.getAllUsers = (req, res) => {
  res.json(users);
};

exports.createUser = (req, res) => {
  const user = req.body;
  users.push(user);
  res.status(201).json(user);
};

Arquivo user-service/package.json:

{
  "name": "user-service",
  "version": "1.0.0",
  "description": "Microservice for managing users",
  "main": "src/index.js",
  "scripts": {
    "start": "node src/index.js"
  },
  "dependencies": {
    "express": "^4.17.1"
  }
}

Arquivo user-service/Dockerfile:

# Use a imagem base do Node.js
FROM node:14

# Defina o diretório de trabalho no contêiner
WORKDIR /usr/src/app

# Copie os arquivos package.json e package-lock.json para o contêiner
COPY package*.json ./

# Instale as dependências do projeto
RUN npm install

# Copie o restante dos arquivos do projeto para o contêiner
COPY . .

# Exponha a porta que o serviço irá usar
EXPOSE 3000

# Comando para iniciar o serviço
CMD ["npm", "start"]

Arquivo user-service/.dockerignore:

node_modules
npm-debug.log

Usando Docker Compose para Orquestrar os Microserviços

Docker Compose é uma ferramenta que permite definir e gerenciar múltiplos contêineres Docker. Vamos configurar o Docker Compose para orquestrar nosso serviço de usuários.

Arquivo docker-compose.yml:

version: '3.8'

services:
  user-service:
    build: ./user-service
    ports:
      - "3000:3000"

Construindo e Executando os Microserviços com Docker

Para construir e executar o microserviço, execute os seguintes comandos na raiz do projeto:

docker-compose build
docker-compose up

Testando o Microserviço

Para testar o microserviço, você pode usar o curl ou um cliente HTTP como o Postman.

Para obter todos os usuários:

curl http://localhost:3000/users

Para criar um novo usuário:

curl -X POST http://localhost:3000/users -H "Content-Type: application/json" -d '{"name":"John Doe","email":"john@example.com"}'

Conclusão

Desenvolver microserviços escaláveis com Node.js e Docker oferece muitas vantagens em termos de manutenção, escalabilidade e facilidade de implementação. Com este guia, você aprendeu a criar um microserviço básico, configurar o ambiente Docker e orquestrar múltiplos serviços usando Docker Compose. Agora você está pronto para expandir essa arquitetura, adicionando mais microserviços e funcionalidades conforme necessário.