As APIs (Interfaces de Programação de Aplicações) desempenham um papel crucial no desenvolvimento de software moderno, permitindo a comunicação entre diferentes sistemas. Node.js, com sua natureza assíncrona e eficiência, é uma escolha popular para a criação de APIs robustas. Neste artigo, vamos explorar o desenvolvimento de APIs com Node.js em três níveis: básico, intermediário e avançado, proporcionando exemplos práticos para cada estágio.
1. Criando uma API Simples com Express.js
Instalação do Express.js:
O primeiro passo é instalar o framework Express.js, que simplifica a criação de APIs em Node.js.
npm install expressCriando uma Rota:
Vamos criar uma API simples que responde a uma requisição GET em uma rota específica.
Exemplo:
const express = require('express'); const app = express(); const porta = 3000; app.get('/api/saudacao', (req, res) => { res.json({ mensagem: 'Olá, mundo!' }); }); app.listen(porta, () => { console.log(`Servidor Express rodando em http://localhost:${porta}/`); });2. Utilizando Middlewares e Trabalhando com Dados
Adicionando Middlewares:
Integre middlewares para processar as requisições antes de chegarem às rotas.
Exemplo:
const express = require('express'); const app = express(); const porta = 3000; // Middleware de log para todas as requisições app.use((req, res, next) => { console.log(`Requisição para: ${req.url}`); next(); }); app.get('/api/saudacao', (req, res) => { res.json({ mensagem: 'Olá, mundo!' }); }); app.listen(porta, () => { console.log(`Servidor Express rodando em http://localhost:${porta}/`); });Integrando MongoDB para Persistência de Dados:
Vamos adicionar uma camada de persistência de dados usando o MongoDB para armazenar e recuperar informações.
Exemplo:
npm install mongoose const express = require('express'); const mongoose = require('mongoose'); const app = express(); const porta = 3000; mongoose.connect('mongodb://localhost:27017/apiDB', { useNewUrlParser: true, useUnifiedTopology: true }); const usuarioSchema = new mongoose.Schema({ nome: String, idade: Number, }); const Usuario = mongoose.model('Usuario', usuarioSchema); app.get('/api/usuarios', async (req, res) => { const usuarios = await Usuario.find(); res.json(usuarios); }); app.listen(porta, () => { console.log(`Servidor Express rodando em http://localhost:${porta}/`); });3. Implementando Autenticação e Paginação
Adicionando Autenticação JWT:
Integre autenticação utilizando JSON Web Tokens (JWT) para proteger rotas sensíveis.
Exemplo Avançado:
npm install jsonwebtoken const express = require('express'); const mongoose = require('mongoose'); const jwt = require('jsonwebtoken'); const app = express(); const porta = 3000; // Configuração do JWT const chaveSecreta = 'chave-secreta-super-segura'; app.use(express.json()); // Middleware de autenticação const autenticacaoMiddleware = (req, res, next) => { const token = req.header('x-auth-token'); if (!token) return res.status(401).json({ mensagem: 'Acesso negado. Token não fornecido.' }); try { const decodificado = jwt.verify(token, chaveSecreta); req.usuario = decodificado; next(); } catch (ex) { res.status(400).json({ mensagem: 'Token inválido.' }); } }; app.get('/api/usuarios', autenticacaoMiddleware, async (req, res) => { const usuarios = await Usuario.find(); res.json(usuarios); }); app.post('/api/login', (req, res) => { // Lógica de autenticação e geração do token }); app.listen(porta, () => { console.log(`Servidor Express rodando em http://localhost:${porta}/`); });Adicionando Paginação:
Implemente a paginação para lidar com grandes conjuntos de dados.
Exemplo:
app.get('/api/usuarios', autenticacaoMiddleware, async (req, res) => { const pagina = parseInt(req.query.pagina) || 1; const tamanhoPagina = parseInt(req.query.tamanhoPagina) || 10; const usuarios = await Usuario.find() .skip((pagina - 1) * tamanhoPagina) .limit(tamanhoPagina); res.json(usuarios); });Desenvolvendo uma API Segura com Node.js
Exemplo Prático de Acesso Através de Usuário Logado
Desenvolver uma API segura é essencial para proteger dados sensíveis e garantir a integridade das operações. Neste artigo, iremos explorar um exemplo prático de uma API em Node.js que exige autenticação para acesso. Utilizaremos o Express.js para criar a API e JSON Web Tokens (JWT) para autenticação.
Configurando o Projeto:
Antes de começarmos, assegure-se de ter o Node.js instalado em sua máquina. Inicie um novo projeto Node.js e instale as dependências necessárias.
- Inicialize o projeto:
mkdir api-segura cd api-segura npm init -y- Instale as dependências:
npm install express mongoose jsonwebtokenCriando a API com Autenticação:
Vamos criar uma API simples que requer autenticação para acessar recursos protegidos.
Exemplo de Estrutura de Arquivos:
api-segura |-- index.js |-- models | |-- usuario.js |-- routes | |-- autenticacao.js | |-- recursoProtegido.js- Crie um arquivo
models/usuario.jspara o modelo de usuário:
const mongoose = require('mongoose'); const usuarioSchema = new mongoose.Schema({ nome: { type: String, required: true }, email: { type: String, required: true, unique: true }, senha: { type: String, required: true }, }); const Usuario = mongoose.model('Usuario', usuarioSchema); module.exports = Usuario;- Crie um arquivo
routes/autenticacao.jspara as rotas de autenticação:
const express = require('express'); const router = express.Router(); const Usuario = require('../models/usuario'); const jwt = require('jsonwebtoken'); // Rota para autenticação router.post('/login', async (req, res) => { const { email, senha } = req.body; // Verifica as credenciais (simplificado para fins ilustrativos) const usuario = await Usuario.findOne({ email, senha }); if (usuario) { // Gera um token JWT válido por 1 hora const token = jwt.sign({ usuarioId: usuario._id }, 'chave-secreta', { expiresIn: '1h' }); res.json({ token }); } else { res.status(401).json({ mensagem: 'Credenciais inválidas' }); } }); module.exports = router;- Crie um arquivo
routes/recursoProtegido.jspara as rotas do recurso protegido:
const express = require('express'); const router = express.Router(); const autenticacaoMiddleware = require('../middlewares/autenticacao'); // Rota protegida - somente acessível com token válido router.get('/recurso-protegido', autenticacaoMiddleware, (req, res) => { res.json({ mensagem: 'Este é um recurso protegido!' }); }); module.exports = router;- Crie um arquivo
middlewares/autenticacao.jspara o middleware de autenticação:
const jwt = require('jsonwebtoken'); const autenticacaoMiddleware = (req, res, next) => { const token = req.header('Authorization'); if (!token) { return res.status(401).json({ mensagem: 'Token não fornecido' }); } try { const decodificado = jwt.verify(token, 'chave-secreta'); req.usuarioId = decodificado.usuarioId; next(); } catch (ex) { res.status(401).json({ mensagem: 'Token inválido' }); } }; module.exports = autenticacaoMiddleware;- Finalmente, no arquivo
index.js, configure e utilize as rotas:
const express = require('express'); const mongoose = require('mongoose'); const autenticacaoRoutes = require('./routes/autenticacao'); const recursoProtegidoRoutes = require('./routes/recursoProtegido'); const app = express(); const porta = 3000; mongoose.connect('mongodb://localhost:27017/apiSeguraDB', { useNewUrlParser: true, useUnifiedTopology: true }); app.use(express.json()); // Rotas de autenticação app.use('/api/autenticacao', autenticacaoRoutes); // Rotas protegidas app.use('/api', recursoProtegidoRoutes); app.listen(porta, () => { console.log(`Servidor Express rodando em http://localhost:${porta}/`); });Testando a API:
- Execute o servidor:
node index.js- Realize uma requisição de autenticação: Utilize ferramentas como Postman ou
curlpara realizar uma requisição POST parahttp://localhost:3000/api/autenticacao/logincom o corpo contendoemailesenha. Receba o token de autenticação. - Acesse o recurso protegido: Faça uma requisição GET para
http://localhost:3000/api/recurso-protegidoadicionando o token como cabeçalhoAuthorization. Se o token for válido, a resposta será o acesso ao recurso protegido.
Este exemplo prático demonstra a criação de uma API segura com Node.js, utilizando autenticação via JWT. Proteger recursos sensíveis é uma prática crucial no desenvolvimento web moderno, e o Node.js, com seu modelo assíncrono e eficiente, oferece uma base sólida para alcançar esse objetivo.
Aprofunde-se na compreensão dos conceitos apresentados, experimente em seus próprios projetos e explore outras técnicas de segurança, como autorização, para construir APIs robustas e seguras. A segurança é uma jornada contínua, e ao aplicar esses princípios, você estará construindo sistemas mais resilientes e confiáveis.
Conclusão: Capacitando-se em Desenvolvimento de APIs com Node.js
Do básico ao avançado, estes exemplos demonstram a progressão no desenvolvimento de APIs com Node.js. Ao criar APIs simples, adicionar middlewares, integrar bancos de dados, implementar autenticação e incluir recursos avançados como paginação, você constrói uma base sólida para o desenvolvimento de APIs robustas e eficientes.
Aplique esses conceitos em seus projetos e continue explorando novas técnicas e ferramentas para aprimorar suas habilidades em desenvolvimento de APIs com Node.js. Com uma base sólida, você estará preparado para enfrentar desafios complexos e criar soluções poderosas no mundo das APIs modernas.
Deixe um comentário