REST (Representational State Transfer)

REST (Representational State Transfer) est un style d'architecture logicielle définissant un ensemble de contraintes pour créer des services web. Introduit par Roy Fielding en 2000, REST utilise les protocoles et méthodes HTTP standard pour permettre une communication client-serveur sans état, scalable et facile à maintenir.

Fondements

• Architecture client-serveur avec séparation des préoccupations entre interface utilisateur et stockage de données
• Communication sans état (stateless) où chaque requête contient toutes les informations nécessaires
• Ressources identifiables par URI avec représentations multiples (JSON, XML, HTML)
• Utilisation des méthodes HTTP standard (GET, POST, PUT, DELETE, PATCH) pour manipuler les ressources

Avantages

• Scalabilité horizontale facilitée grâce au principe stateless et à la mise en cache
• Simplicité d'implémentation utilisant les standards web existants (HTTP, URI)
• Interopérabilité entre plateformes et langages de programmation différents
• Performance optimisée via la mise en cache HTTP native
• Évolutivité du système avec couplage faible entre client et serveur

Exemple concret

Voici une API REST pour gérer des utilisateurs, illustrant les principes fondamentaux et les méthodes HTTP :

// Définition des routes REST pour la ressource "users"
import express, { Request, Response } from 'express';

const app = express();
app.use(express.json());

// GET /api/users - Récupérer tous les utilisateurs
app.get('/api/users', async (req: Request, res: Response) => {
  const users = await db.users.findAll();
  res.status(200).json({
    data: users,
    meta: { total: users.length }
  });
});

// GET /api/users/:id - Récupérer un utilisateur spécifique
app.get('/api/users/:id', async (req: Request, res: Response) => {
  const user = await db.users.findById(req.params.id);
  if (!user) {
    return res.status(404).json({ error: 'User not found' });
  }
  res.status(200).json({ data: user });
});

// POST /api/users - Créer un nouvel utilisateur
app.post('/api/users', async (req: Request, res: Response) => {
  const newUser = await db.users.create(req.body);
  res.status(201)
    .location(`/api/users/${newUser.id}`)
    .json({ data: newUser });
});

// PUT /api/users/:id - Remplacer complètement un utilisateur
app.put('/api/users/:id', async (req: Request, res: Response) => {
  const updated = await db.users.replace(req.params.id, req.body);
  res.status(200).json({ data: updated });
});

// PATCH /api/users/:id - Modifier partiellement un utilisateur
app.patch('/api/users/:id', async (req: Request, res: Response) => {
  const updated = await db.users.update(req.params.id, req.body);
  res.status(200).json({ data: updated });
});

// DELETE /api/users/:id - Supprimer un utilisateur
app.delete('/api/users/:id', async (req: Request, res: Response) => {
  await db.users.delete(req.params.id);
  res.status(204).send();
});

Mise en œuvre

1. Identifier et modéliser les ressources métier avec des noms au pluriel (/users, /products)
2. Définir une structure d'URI cohérente et hiérarchique pour représenter les relations
3. Implémenter les méthodes HTTP appropriées respectant leur sémantique (GET idempotent, POST non-idempotent)
4. Utiliser les codes de statut HTTP standard (200 OK, 201 Created, 404 Not Found, 500 Internal Error)
5. Définir un format de représentation cohérent (JSON recommandé) avec versioning de l'API
6. Implémenter HATEOAS optionnellement pour découvrabilité (hypermedia as the engine of application state)
7. Configurer les headers de cache (Cache-Control, ETag) pour optimiser les performances
8. Sécuriser avec authentification (OAuth 2.0, JWT) et HTTPS obligatoire

Outils associés

• Swagger/OpenAPI pour documentation et spécification d'API REST
• Postman et Insomnia pour tests et développement d'API
• Express.js, FastAPI, Spring Boot comme frameworks backend REST
• Axios, Fetch API pour consommation d'APIs REST côté client
• RESTful API Modeling Language (RAML) pour conception d'API
• JSON Schema pour validation de payloads

REST reste l'architecture dominante pour les APIs web publiques grâce à sa simplicité et son adoption universelle. Bien qu'alternatives comme GraphQL gagnent en popularité pour des cas spécifiques, REST offre un excellent équilibre entre performance, maintenabilité et standardisation pour la majorité des projets. Son alignement avec les standards HTTP en fait un choix stratégique pour des systèmes interopérables et évolutifs.