Come Costruire una REST API con Node.js ed Express: Tutorial Completo

by

Se stai cercando una guida concreta per costruire una REST API con Node.js ed Express, sei nel posto giusto. In questo tutorial non ci limiteremo a esempi teorici da manuale: costruiremo insieme un sistema reale di gestione utenti, con routing completo, gestione degli errori, validazione e connessione al database. Alla fine avrai un progetto funzionante che potrai riutilizzare come base per i tuoi lavori.

Perché scegliere Node.js ed Express per una REST API

Node.js è oggi uno degli ambienti più utilizzati per lo sviluppo backend grazie alla sua natura asincrona e alle performance elevate. Express è il framework minimalista che semplifica la creazione di server web e API RESTful, riducendo drasticamente il boilerplate. C’è una buona spiegazione del tema su welovedevs.com.

I vantaggi principali di questa combinazione:

  • Velocità di sviluppo: pochi comandi per avere un server funzionante
  • Ecosistema npm: migliaia di pacchetti pronti all’uso
  • Scalabilità: gestione efficiente di migliaia di richieste concorrenti
  • Community attiva: documentazione e supporto sempre aggiornati
  • Flessibilità: si integra con qualsiasi database (SQL o NoSQL)
nodejs code laptop

Il progetto: API per la gestione utenti

Costruiremo una REST API completa che permetterà di:

  1. Registrare nuovi utenti
  2. Recuperare la lista di tutti gli utenti
  3. Ottenere i dettagli di un singolo utente
  4. Aggiornare le informazioni di un utente
  5. Eliminare un utente dal sistema

Struttura degli endpoint REST

Metodo HTTP Endpoint Descrizione
GET /api/users Elenca tutti gli utenti
GET /api/users/:id Recupera un utente specifico
POST /api/users Crea un nuovo utente
PUT /api/users/:id Aggiorna un utente esistente
DELETE /api/users/:id Elimina un utente

Step 1: Configurazione dell’ambiente

Assicurati di avere installato Node.js (versione 20 LTS o superiore, consigliata nel 2026). Crea la cartella del progetto e inizializza npm:

mkdir gestione-utenti-api
cd gestione-utenti-api
npm init -y
npm install express mongoose dotenv
npm install --save-dev nodemon

Aggiungi nel package.json lo script di avvio:

"scripts": {
  "start": "node server.js",
  "dev": "nodemon server.js"
}
nodejs code laptop

Step 2: Creazione del server Express

Crea il file server.js nella root del progetto:

const express = require('express');
const mongoose = require('mongoose');
require('dotenv').config();

const userRoutes = require('./routes/userRoutes');

const app = express();
const PORT = process.env.PORT || 3000;

// Middleware per parsing JSON
app.use(express.json());

// Connessione al database
mongoose.connect(process.env.MONGO_URI)
  .then(() => console.log('Database connesso'))
  .catch(err => console.error('Errore connessione DB:', err));

// Rotte
app.use('/api/users', userRoutes);

// Middleware gestione errori
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(err.status || 500).json({
    error: err.message || 'Errore interno del server'
  });
});

app.listen(PORT, () => {
  console.log(`Server attivo sulla porta ${PORT}`);
});

Step 3: Definizione del modello utente

Crea la cartella models e il file User.js:

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  nome: { type: String, required: true, trim: true },
  email: { 
    type: String, 
    required: true, 
    unique: true, 
    lowercase: true 
  },
  ruolo: { 
    type: String, 
    enum: ['admin', 'utente'], 
    default: 'utente' 
  },
  attivo: { type: Boolean, default: true }
}, { timestamps: true });

module.exports = mongoose.model('User', userSchema);
nodejs code laptop

Step 4: Creazione del controller

Nella cartella controllers, crea userController.js:

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

// GET tutti gli utenti
exports.getUsers = async (req, res, next) => {
  try {
    const users = await User.find();
    res.json(users);
  } catch (err) {
    next(err);
  }
};

// GET singolo utente
exports.getUserById = async (req, res, next) => {
  try {
    const user = await User.findById(req.params.id);
    if (!user) {
      return res.status(404).json({ error: 'Utente non trovato' });
    }
    res.json(user);
  } catch (err) {
    next(err);
  }
};

// POST nuovo utente
exports.createUser = async (req, res, next) => {
  try {
    const newUser = await User.create(req.body);
    res.status(201).json(newUser);
  } catch (err) {
    next(err);
  }
};

// PUT aggiorna utente
exports.updateUser = async (req, res, next) => {
  try {
    const updated = await User.findByIdAndUpdate(
      req.params.id, 
      req.body, 
      { new: true, runValidators: true }
    );
    if (!updated) {
      return res.status(404).json({ error: 'Utente non trovato' });
    }
    res.json(updated);
  } catch (err) {
    next(err);
  }
};

// DELETE utente
exports.deleteUser = async (req, res, next) => {
  try {
    const deleted = await User.findByIdAndDelete(req.params.id);
    if (!deleted) {
      return res.status(404).json({ error: 'Utente non trovato' });
    }
    res.json({ message: 'Utente eliminato con successo' });
  } catch (err) {
    next(err);
  }
};

Step 5: Definizione delle rotte

Nella cartella routes, crea userRoutes.js:

const express = require('express');
const router = express.Router();
const userController = require('../controllers/userController');

router.get('/', userController.getUsers);
router.get('/:id', userController.getUserById);
router.post('/', userController.createUser);
router.put('/:id', userController.updateUser);
router.delete('/:id', userController.deleteUser);

module.exports = router;
nodejs code laptop

Step 6: File .env e test dell’API

Crea un file .env nella root:

PORT=3000
MONGO_URI=mongodb://localhost:27017/gestione_utenti

Avvia il server con npm run dev e testa gli endpoint con Postman, Insomnia o direttamente con curl:

curl -X POST http://localhost:3000/api/users \
  -H "Content-Type: application/json" \
  -d '{"nome":"Mario Rossi","email":"[email protected]"}'

Best practice per una REST API professionale

Il progetto che hai costruito è funzionante, ma in produzione dovresti aggiungere:

  • Validazione avanzata con librerie come Joi o express-validator
  • Autenticazione JWT per proteggere gli endpoint
  • Rate limiting con express-rate-limit per prevenire abusi
  • Logging strutturato con Winston o Pino
  • Documentazione API con Swagger/OpenAPI
  • Test automatici con Jest o Mocha
  • CORS configurato correttamente per il frontend
  • Helmet per proteggere gli header HTTP

Struttura delle cartelle consigliata

gestione-utenti-api/
├── controllers/
├── models/
├── routes/
├── middlewares/
├── config/
├── utils/
├── tests/
├── .env
├── server.js
└── package.json

FAQ: Domande frequenti sulle REST API con Node.js ed Express

Quale database scegliere per una REST API in Node.js?

Dipende dal caso d’uso. MongoDB con Mongoose è ideale per dati flessibili e prototipi rapidi. PostgreSQL o MySQL con Sequelize o Prisma sono preferibili per relazioni complesse e transazioni. Building RESTful APIs with Node.js and Express affronta la stessa domanda da un’altra angolazione.

Express è ancora la scelta migliore nel 2026?

Express rimane il framework più diffuso e stabile. Alternative valide sono Fastify (più performante) e NestJS (architettura enterprise). Per la maggior parte dei progetti, Express offre il miglior compromesso tra semplicità e potenza.

Come proteggere una REST API da attacchi?

Implementa autenticazione JWT, usa HTTPS, valida sempre gli input, applica rate limiting, configura CORS in modo restrittivo e mantieni aggiornate tutte le dipendenze con npm audit. Altro su https://freecodecamp.org.

Serve TypeScript per costruire una REST API?

Non è obbligatorio, ma altamente consigliato per progetti medio-grandi. TypeScript aggiunge type safety, migliora la manutenibilità e riduce i bug in produzione.

Come deployare l’API in produzione?

Le opzioni più diffuse sono Render, Railway, Vercel, Heroku e AWS. Per progetti containerizzati, Docker con Kubernetes o servizi come DigitalOcean App Platform sono ottime scelte.

Conclusione

Hai appena costruito una REST API completa con Node.js ed Express partendo da zero fino a un sistema di gestione utenti pienamente funzionante. La chiave per crescere come sviluppatore backend è partire da progetti reali come questo e iterare aggiungendo funzionalità avanzate come autenticazione, testing e deployment.

Se hai bisogno di supporto per sviluppare la tua API personalizzata o vuoi integrarla in un progetto più ampio, il team di Alede Ro Design è a tua disposizione per consulenze e sviluppo su misura.

Leave a Comment