Guida completa e pratica alle API REST
In questo documento dettagliato scoprirai tutto ciò che serve per comprendere, progettare e implementare API RESTful efficaci e scalabili. L’obiettivo è fornirti un testo esaustivo, ricco di esempi pratici e linee guida per gestire ogni aspetto dell’architettura REST.
Introduzione: cosa sono le API REST e perchè usarle
Le API REST (Representational State Transfer) sono interfacce che permettono a due sistemi software di comunicare tramite il protocollo HTTP, seguendo principi chiari progettati da Roy Fielding. REST è oggi uno standard dominante nelle architetture web e mobile per la sua semplicità, flessibilità e interoperabilità.
- Separazione netta tra frontend e backend
- Indipendenza dallo stato della sessione, garantendo scalabilità
- Utilizzo di metodi HTTP standard (GET, POST, PUT, DELETE, PATCH)
- Formati dati leggibili e interoperabili (es. JSON)
- Possibilità di caching per migliorare performance
I sei principi fondamentali di REST
Secondo Roy Fielding un’API REST deve rispettare questi vincoli per essere considerata tale:
- Client-server: Il client (interfaccia utente) è separato dal server (dati e logica); ogni ruolo è distinto per semplificare e scalare.
- Stateless: Ogni richiesta contiene tutte le informazioni necessarie; il server non conserva stato tra più richieste.
- Cacheable: Le risposte devono indicare se possono essere salvate temporaneamente, migliorando i tempi di risposta.
- Uniform Interface: Definisce un’interfaccia comune, tramite URL descrittivi, metodi HTTP e formati standard (JSON, XML, ecc.)
- Layered System: L’architettura può essere strutturata a livelli intermedi (proxy, load balancer) senza modificare la comunicazione cliente-server.
- Code on Demand (facoltativo): Il server può inviare codice eseguibile per estendere le funzionalità del client (es. javascript).
Struttura degli Endpoint e metodi HTTP
Gli endpoint REST rappresentano risorse, identificabili tramite URL “leggibili” (nouns). Ogni azione è eseguita tramite uno dei seguenti metodi HTTP:
| Metodo | Descrizione | Uso tipico |
|---|---|---|
GET |
Recupera dati senza modificarli | Ottenere risorse o liste |
POST |
Crea una nuova risorsa | Inserire nuovi record |
PUT |
Sostituisce (update) una risorsa intera | Aggiornare un’intera entità |
PATCH |
Aggiorna parzialmente una risorsa | Modifiche parziali, più efficienti |
DELETE |
Elimina una risorsa | Cancellazione |
Esempio URL Endpoints
Supponiamo di avere una API per gestire utenti:
GET https://api.tuosito.it/v1/users # lista utenti
GET https://api.tuosito.it/v1/users/123 # utente singolo id=123
POST https://api.tuosito.it/v1/users # crea nuovo utente
PUT https://api.tuosito.it/v1/users/123 # aggiorna completamente utente 123
PATCH https://api.tuosito.it/v1/users/123 # modifica parziale utente 123
DELETE https://api.tuosito.it/v1/users/123 # elimina utente 123
Esempi pratici di payload JSON
Creazione di un utente (POST)
{
"nome":"Maria",
"cognome":"Bianchi",
"email":"[email protected]",
"eta":29,
"indirizzo":{
"via":"Via Roma 42",
"citta":"Roma",
"cap":"00100"
}
}
Aggiornamento parziale (PATCH)
Aggiorniamo solo l’email e la città dell’utente:
{
"email":"[email protected]",
"indirizzo":{
"citta":"Milano"
}
}
Filtri, ricerca e paginazione
Gestire molti dati richiede l’uso di filtri e paginazione per ottimizzare le risposte:
Filtri in query string
GET https://api.tuosito.it/v1/users?eta=30&citta=Roma
Qui si richiedono utenti con età 30 e città Roma.
Paginazione
GET https://api.tuosito.it/v1/users?page=2&limit=15
Questo recupera la seconda pagina con 15 utenti per pagina.
Esempio concreto con fetch JS
fetch('https://api.tuosito.it/v1/users?citta=Roma&page=1&limit=10')
.then(res => res.json())
.then(data => console.log(data))
.catch(err => console.error(err));
{
"page":1,
"limit":10,
"total":245,
"users":[
]
}
Sicurezza nelle API REST
Le API esposte su internet devono essere sicure per proteggere dati e risorse:
- HTTPS obbligatorio: crittografia dei dati in transito.
- Autenticazione: ad esempio tramite token JWT (JSON Web Token), OAuth2 o API key.
- Autorizzazione: controlli su chi può accedere o modificare quali risorse.
- Rate limiting: limitare numero richieste per prevenire abusi e attacchi DDoS.
- Validazione: controllare integrità e conformità dei dati inviati dai client.
Esempio di autenticazione con token Bearer:
fetch("https://api.tuosito.it/v1/users", {
headers: {
Authorization: "Bearer il-tuo-token-qui"
}
});
Versionamento delle API
Mantenere la retrocompatibilità è fondamentale quando aggiorni le API. Ecco come approcciare il versionamento:
- Versione nell'URL: più comune e evidente, es:
https://api.tuosito.it/v1/,/v2/, ecc. - Versione negli headers HTTP: più pulito, usa header personalizzati (es.
X-API-Version). - Semantica: aggiorna major per breaking changes, minor per aggiunte compatibili.
Mantieni sempre documentazione chiara per ogni versione e pianifica migrazioni per clienti.
Strumenti e risorse utili per lavorare con API REST
- Postman: Client per test API con interfaccia grafica accessibile.
- Insomnia: Alternativa leggera e potente per test e automazione.
- Swagger / OpenAPI: Standard per documentare e generare API.
- curl: Utility da terminale, potente per test rapidi.
- Strumenti di validazione JSON: come JSONLint.
Conclusione e consigli per un’API REST di successo
Per concludere, ti consigliamo di mantenere sempre:
- Coerenza nelle URL e nei nomi degli endpoint
- Documentazione sempre aggiornata e comprensibile
- Test automatici e manuali per prevenire regressioni
- Monitoraggio dei tempi di risposta e errori
Questo ti permetterà di fornire un servizio stabile, sicuro e di facile integrazione per i tuoi sviluppatori e clienti.
Guida gratuita offerta da Vivacity Design.