REST (Representational State Transfer)

REST (Representational State Transfer) est un style d'architecture logicielle défini par Roy Fielding en 2000, qui établit les principes de conception pour les services web distribués. Basé sur le protocole HTTP, REST structure les interactions client-serveur autour de ressources identifiées par des URI et manipulées via des méthodes HTTP standardisées. Cette approche favorise la scalabilité, la simplicité et l'interopérabilité entre systèmes hétérogènes.

Fondements de l'architecture REST

• Architecture client-serveur avec séparation stricte des préoccupations et communication sans état
• Ressources identifiées par des URI uniques et manipulées via des représentations (JSON, XML)
• Interface uniforme basée sur les méthodes HTTP (GET, POST, PUT, DELETE, PATCH)
• Système en couches permettant mise en cache, load balancing et sécurité intermédiaire

Avantages métier et techniques

• Scalabilité horizontale facilitée grâce au stateless et à la mise en cache HTTP
• Interopérabilité maximale permettant l'intégration avec n'importe quelle plateforme supportant HTTP
• Simplicité de développement et de compréhension grâce aux conventions standardisées
• Performance optimisée par la mise en cache côté client et les CDN
• Évolutivité des API sans rupture de compatibilité via le versioning d'URI

Exemple concret d'API REST

// Définition des endpoints REST pour une ressource User
interface User {
  id: string;
  name: string;
  email: string;
}

class UsersAPI {
  private baseURL = 'https://api.example.com/v1';

  // GET /users - Liste tous les utilisateurs
  async getUsers(params?: { page?: number; limit?: number }): Promise<User[]> {
    const queryString = new URLSearchParams(params as any).toString();
    const response = await fetch(`${this.baseURL}/users?${queryString}`, {
      method: 'GET',
      headers: { 'Accept': 'application/json' }
    });
    return response.json();
  }

  // GET /users/:id - Récupère un utilisateur spécifique
  async getUser(id: string): Promise<User> {
    const response = await fetch(`${this.baseURL}/users/${id}`, {
      method: 'GET',
      headers: { 'Accept': 'application/json' }
    });
    return response.json();
  }

  // POST /users - Crée un nouvel utilisateur
  async createUser(user: Omit<User, 'id'>): Promise<User> {
    const response = await fetch(`${this.baseURL}/users`, {
      method: 'POST',
      headers: { 
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      },
      body: JSON.stringify(user)
    });
    return response.json();
  }

  // PUT /users/:id - Remplace complètement un utilisateur
  async updateUser(id: string, user: Omit<User, 'id'>): Promise<User> {
    const response = await fetch(`${this.baseURL}/users/${id}`, {
      method: 'PUT',
      headers: { 
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      },
      body: JSON.stringify(user)
    });
    return response.json();
  }

  // PATCH /users/:id - Mise à jour partielle
  async patchUser(id: string, updates: Partial<User>): Promise<User> {
    const response = await fetch(`${this.baseURL}/users/${id}`, {
      method: 'PATCH',
      headers: { 
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      },
      body: JSON.stringify(updates)
    });
    return response.json();
  }

  // DELETE /users/:id - Supprime un utilisateur
  async deleteUser(id: string): Promise<void> {
    await fetch(`${this.baseURL}/users/${id}`, {
      method: 'DELETE'
    });
  }
}

Mise en œuvre d'une API REST

1. Identifier et modéliser les ressources métier (utilisateurs, produits, commandes)
2. Définir la structure des URI en suivant une hiérarchie logique (/api/v1/resources/{id})
3. Mapper les opérations CRUD aux méthodes HTTP appropriées (GET, POST, PUT, DELETE, PATCH)
4. Implémenter la négociation de contenu via les headers Accept et Content-Type
5. Définir les codes de statut HTTP appropriés (200, 201, 404, 400, 500)
6. Intégrer l'authentification (OAuth 2.0, JWT) et l'autorisation basée sur les rôles
7. Mettre en place le versioning d'API (URI, header ou paramètre)
8. Documenter l'API avec OpenAPI/Swagger pour faciliter l'adoption

Outils et frameworks REST

• Express.js et Fastify pour Node.js, Spring Boot pour Java
• Postman et Insomnia pour tester et documenter les API
• Swagger/OpenAPI pour la spécification et génération de documentation
• Kong et API Gateway pour la gestion, sécurité et monitoring
• REST Client (VS Code) et HTTPie pour les tests en ligne de commande

REST demeure l'architecture dominante pour les API web grâce à sa simplicité, sa scalabilité et son alignement parfait avec le protocole HTTP. En adoptant les principes REST, les organisations créent des interfaces programmatiques interopérables qui accélèrent l'intégration de systèmes, facilitent les architectures microservices et permettent l'exposition sécurisée de fonctionnalités métier. La maîtrise de REST constitue une compétence fondamentale pour tout développeur construisant des applications distribuées modernes.