Implementando um Sistema de Autenticação com JWT em Aplicações Node.js

“`html

Introdução

Nos dias de hoje, a segurança em aplicações web é uma preocupação constante para desenvolvedores. Um dos métodos mais eficazes para gerenciar autenticações em aplicações modernas é o uso de JSON Web Tokens (JWT). Este artigo explora a implementação de um sistema de autenticação utilizando JWT em uma aplicação Node.js, fornecendo um passo a passo prático e acessível para iniciantes e desenvolvedores intermediários.

Contexto ou Teoria

JSON Web Token (JWT) é um padrão aberto (RFC 7519) que define um método compacto e autocontido para a transmissão segura de informações entre partes como um objeto JSON. Essas informações podem ser verificadas e confiáveis porque são assinadas digitalmente. O JWT pode ser assinado usando uma chave secreta (com o algoritmo HMAC) ou um par de chaves pública/privada usando RSA ou ECDSA.

Uma das principais vantagens do JWT é que ele permite a autenticação stateless, ou seja, o servidor não precisa armazenar uma sessão. Todas as informações necessárias para verificar a identidade do usuário estão contidas no próprio token. Isso simplifica a escalabilidade da aplicação, pois não há necessidade de um banco de dados de sessões.

Demonstrações Práticas

A seguir, implementaremos um sistema de autenticação básico utilizando Node.js, Express e JWT. O exemplo incluirá a configuração do servidor, rotas para registro e login de usuários, bem como a proteção de rotas usando tokens JWT.

1. Configuração do Ambiente

Primeiro, vamos criar um novo projeto Node.js. Abra seu terminal e execute os seguintes comandos:

mkdir jwt-auth-example
cd jwt-auth-example
npm init -y
npm install express jsonwebtoken bcryptjs mongoose dotenv

Esses comandos criam um novo diretório para o projeto, inicializam um novo projeto Node.js e instalam as dependências necessárias: express para a criação do servidor, jsonwebtoken para gerar e verificar tokens, bcryptjs para hash de senhas, mongoose para interagir com MongoDB, e dotenv para gerenciar variáveis de ambiente.

2. Estrutura do Projeto

Organize a estrutura do seu projeto da seguinte forma:

jwt-auth-example/
├── .env
├── index.js
└── models/
    └── User.js

O arquivo .env conterá as variáveis de ambiente, como a chave secreta do JWT. O arquivo User.js será o modelo do usuário, e index.js será o ponto de entrada da aplicação.

3. Configurando o Modelo do Usuário

Abra o arquivo models/User.js e defina o modelo do usuário:

const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const UserSchema = new mongoose.Schema({
    username: { type: String, required: true, unique: true },
    password: { type: String, required: true }
});

// Método para hash da senha
UserSchema.pre('save', async function(next) {
    if (!this.isModified('password')) return next();
    this.password = await bcrypt.hash(this.password, 8);
    next();
});

// Método para comparar a senha
UserSchema.methods.comparePassword = function(password) {
    return bcrypt.compare(password, this.password);
};

module.exports = mongoose.model('User', UserSchema);

Neste modelo, o bcrypt é utilizado para garantir que a senha do usuário seja armazenada de forma segura. O método comparePassword permite comparar a senha fornecida com a senha armazenada no banco de dados.

4. Configurando o Servidor

Agora, abra o arquivo index.js e configure o servidor Express:

require('dotenv').config();

const express = require('express');

const mongoose = require('mongoose');

const User = require('./models/User');

const jwt = require('jsonwebtoken');

const app = express();

app.use(express.json());
// Conexão com o MongoDB

mongoose.connect(process.env.MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true })

    .then(() => console.log('MongoDB conectado'))

    .catch(err => console.log(err));
// Rota para registro de usuários

app.post('/register', async (req, res) => {

    const { username, password } = req.body;

    try {

        const user = new User({ username, password });

        await user.save();

        res.status(201).send({ message: 'Usuário criado com sucesso!' });

    } catch (error) {

        res.status(400).send({ error: error.message });

    }

});
// Rota para login de usuários

app.post('/login', async (req, res) => {

    const { username, password } = req.body;

    try {

        const user = await User.findOne({ username });

        if (!user || !await user.comparePassword(password)) {

            return res.status(401).send({ error: 'Credenciais inválidas' });

        }

        const token = jwt.sign({ id: user._id },