REST (Representational State Transfer) est un style d'architecture logicielle utilisé pour concevoir des interfaces pour les applications réseau.
L'API REST (Application Programming Interface) est une interface de service Web construite sur les principes REST, permettant à différents systèmes de communiquer et d'échanger des données via le protocole HTTP.

Les principales caractéristiques de l'API REST incluent :
- Absence d'état (Stateless) : Chaque requête contient toutes les informations nécessaires pour traiter cette requête
- Axé sur les ressources (Resource-based) : Toutes les données sont traitées comme des ressources, identifiées par des URI
- Interface uniforme : Utilise les méthodes HTTP standard (GET, POST, PUT, DELETE, etc.)
- Capacité de mise en cache (Cacheable) : Les réponses peuvent être explicitement marquées comme pouvant être mises en cache ou non
Concepts fondamentaux de l'API REST
1. Ressource
Dans REST, une ressource est toute information pouvant être nommée, comme un utilisateur, un produit, une commande, etc. Chaque ressource possède un identifiant unique (URI).
2. Méthodes HTTP
Les API REST utilisent les méthodes HTTP standard pour définir les opérations sur les ressources :
| Méthode HTTP | Description | Idempotence | Sécurité |
|---|---|---|---|
| GET | Récupérer une ressource | Oui | Oui |
| POST | Créer une nouvelle ressource | non | non |
| PUT | Mettre à jour une ressource entière | Oui | non |
| PATCH | Mettre à jour partiellement une ressource | non | non |
| DELETE | Supprimer une ressource | Oui | non |
3. Codes de statut
Les codes de statut HTTP indiquent le résultat du traitement d'une requête :
| Code d'état | Catégorie | Codes de statut courants |
|---|---|---|
| 2xx | Succès | 200 OK, 201 Created |
| 3xx | Redirection | 301 Déplacé de façon permanente |
| 4xx | Erreurs client | 400 Bad Request, 404 Not Found |
| 5xx | Erreurs serveur | 500 Erreur interne du serveur |
4. Formats de données
Formats d'échange de données courants pour les API REST :
- JSON(JavaScript Object Notation)
- XML(eXtensible Markup Language)
- Parfois, des formats tels que YAML, CSV, etc., sont également utilisés.
Bonnes pratiques de conception d'API REST
1. Principes de conception d'URI
- Utilisez des noms plutôt que des verbes pour représenter les ressources
- Bon :
/users - Mauvais :
/getUsers
- Bon :
- Utilisez des lettres minuscules et des traits d'union (-)
- Évitez les extensions de fichier
- Utilisez le pluriel pour les collections
- Représentez les relations de manière hiérarchique :
/users/{id}/orders
2. Versionnage
Il est recommandé d'inclure les informations de version de l'API dans l'URI ou les en-têtes de requête :
- Chemin URI :
/v1/users - En-tête de requête :
Accept: application/vnd.myapi.v1+json
3. Filtrage, tri et pagination
Pour les ressources de collection, fournissez des paramètres de requête :
- Filtrage :
/users?role=admin - Tri :
/users?sort=-created_at - Pagination :
/users?page=2&limit=10
4. Sécurité
- Utiliser HTTPS
- Implémenter l'authentification (OAuth2, JWT)
- Limiter la fréquence des requêtes
- Valider les données d'entrée
Exemple d'API REST
Exemple d'API de gestion des utilisateurs
Exemple
GET /api/v1/users
Accept: application/json
# Créer un nouvel utilisateur
POST /api/v1/users
Content-Type: application/json
{
"name": "Zhang San",
"email": "zhangsan@example.com"
}
# Obtenir un utilisateur spécifique
GET /api/v1/users/123
Accept: application/json
# Mettre à jour les informations de l'utilisateur
PUT /api/v1/users/123
Content-Type: application/json
{
"name": "Zhang San (Mis à jour)",
"email": "new-email@example.com"
}
# Supprimer un utilisateur
DELETE /api/v1/users/123
Exemple de réponse
Exemple
{
"status": "success",
"data": {
"id": 123,
"name": "Zhang San",
"email": "zhangsan@example.com",
"created_at": "2023-01-01T00:00:00Z"
}
}
// Réponse d'erreur
{
"status": "error",
"message": "Utilisateur non trouvé",
"code": 404
}
Outils pour tester les API REST
- Postman: un outil puissant de test d'API
- cURL: outil en ligne de commande
- Insomnia: client léger de test d'API
- Swagger/OpenAPI: outil de documentation et de test d'API
Exemple cURL
Exemple
curl -X GET https://api.example.com/users/123 \
-H "Accept: application/json"
# Requête POST
curl -X POST https://api.example.com/users \
-H "Content-Type: application/json" \
-d '{"name":"Li Si","email":"lisi@example.com"}'
Frameworks de développement d'API REST
Selon le langage de programmation, il existe divers frameworks disponibles pour développer des API REST :
| Langage | Frameworks populaires |
|---|---|
| JavaScript | Express.js, NestJS |
| Python | Django REST Framework, Flask |
| Java | Spring Boot |
| PHP | Laravel, Symfony |
| Ruby | Ruby on Rails |
| Go | Gin, Echo |
I. Principes de conception de base
1. Adopter des conventions de nommage claires
Principes de base:
- Utiliser des noms (plutôt que des verbes) pour représenter les ressources
- Utilisez le pluriel pour les collections
- Maintenez une nomenclature cohérente et intuitive
Exemples:
✅ Bonne conception : /users, /products, /orders
-
❌ Mauvaise conception : /getUsers, /addProduct, /all-orders
Recommandations supplémentaires:
- Utilisez une nomenclature hiérarchique pour les ressources afin de refléter les relations entre les ressources :
/companies/{companyId}/departments/{departmentId}/employees - Pour améliorer la lisibilité, utilisez des traits d'union (kebab-case) dans les noms de ressources composés de plusieurs mots :
/shipping-addressesau lieu de/shippingaddresses - Maintenez la cohérence de la nomenclature lors des itérations de version de l'API, et évitez les changements inutiles qui prêtent à confusion chez les clients.
2. Utiliser correctement les méthodes HTTP
Utilisation de base:
- GET : Lire une ressource (idempotent)
- POST : Créer une nouvelle ressource
- PUT : Mettre à jour une ressource complète (idempotent)
- PATCH : Mettre à jour partiellement une ressource
- DELETE : Supprimer une ressource (idempotent)
Exemples:
GET /users # 获取用户列表 GET /users/123 # 获取特定用户 POST /users # 创建新用户 PUT /users/123 # 完全更新用户 PATCH /users/123 # 部分更新用户 DELETE /users/123 # 删除用户
Recommandations supplémentaires:
- Comprendre l'importance de l'idempotence : GET, PUT et DELETE sont des opérations idempotentes ; plusieurs appels produisent le même résultat.
- Pour les opérations par lots, envisagez d'utiliser POST au lieu de PUT, car PUT attend généralement que le client spécifie clairement un identifiant de ressource.
- Lors de la conception d'opérations PATCH, envisagez d'utiliser des formats standard comme JSON Patch (RFC 6902) ou JSON Merge Patch (RFC 7386).
- Pour les opérations complexes, vous pouvez utiliser des extensions de ressource :
POST /users/123/activateComparerPOST /activateUser/123Plus conforme aux principes REST
3. Utiliser les codes de statut HTTP appropriés
Codes de statut courants:
- 200 OK : Requête réussie
- 201 Created : Ressource créée avec succès
- 204 No Content : Succès mais aucun contenu renvoyé (par ex., opération DELETE)
- 400 Bad Request : Erreur client
- 401 Unauthorized : Non authentifié
- 403 Interdit : Aucune permission
- 404 Non trouvé : La ressource n'existe pas
- 409 Conflit : Conflit de ressource
- 500 Erreur interne du serveur : Erreur du serveur
Recommandations d'extensions:
- Utilisez des codes d'état plus détaillés pour améliorer l'expressivité de l'API :
- 429 Trop de requêtes : Taux de requêtes dépassé
- 405 Méthode non autorisée : Méthode HTTP non prise en charge
- 415 Type de média non pris en charge : Type de contenu non pris en charge
- 422 Entité non traitable : Erreur sémantique
- Pour simplifier la gestion côté client, restez cohérent au sein des principales catégories d'erreurs : erreurs client (4xx) et erreurs serveur (5xx)
- Fournissez toujours des messages d'erreur et des codes d'erreur significatifs avec les codes d'état
II. Conception des requêtes et du filtrage
4. Mettre en œuvre une pagination efficace
Implémentation de base:
- Utiliser
limitetoffsetoupageetsizeparameters - Inclure les métadonnées de pagination dans la réponse
Exemple:
GET /products?limit=20&offset=40 GET /products?page=3&size=20
Exemple de réponse :
{
"data": [...],
"pagination": {
"total": 523,
"pages": 27,
"current_page": 3,
"per_page": 20,
"next": "/products?page=4&size=20",
"prev": "/products?page=2&size=20"
}
}
Recommandations d'extensions:
- Envisagez d'utiliser la pagination par curseur, en particulier lorsque vous traitez de grands ensembles de données ou des données fréquemment mises à jour
- Définissez des valeurs de pagination par défaut raisonnables et des limites maximales pour éviter que les requêtes surdimensionnées n'affectent les performances
- Fournissez des liens HATEOAS dans les réponses de pagination pour la navigation client (par exemple, les liens next/prev dans l'exemple ci-dessus)
- Pour les données de séries temporelles, une pagination temporelle peut être utilisée :
GET /events?since=2023-01-01T00:00:00Z&until=2023-01-31T23:59:59Z
5. Fournir un filtrage, un tri et une recherche flexibles
Implémentation de base:
- Utilisez des paramètres de requête pour le filtrage :
?status=active - Utiliser
sortparamètre pour le tri :?sort=created_at - Prendre en charge le tri sur plusieurs champs et l'ordre croissant/décroissant :
?sort=price:asc,rating:desc
Exemple:
GET /products?category=electronics&price_min=100&price_max=500&sort=price:asc GET /users?role=admin&search=john
Recommandations d'extensions:
- Fournir une syntaxe d'expression pour les requêtes complexes :
?price=gt:100,lt:500 - Implémenter des options de correspondance partielle et de recherche floue :
?name=like:john - Prendre en charge la sélection de champs, permettant aux clients de spécifier les champs dont ils ont besoin :
?fields=id,name,email - Envisager d'implémenter des points de terminaison GraphQL comme complément pour les requêtes particulièrement complexes
- Fournir des filtres prédéfinis pour les combinaisons de filtres courantes :
?filter=recentPeut être équivalent à?created_after=30days&sort=created_at:desc
6. Mettre en œuvre un versionnement efficace de l'API
Méthodes principales:
- Version par chemin d'URL :
/api/v1/users - Version par paramètre de requête :
/api/users?version=1 - Version par en-tête de requête :
Accept: application/vnd.company.v1+json
Recommandations d'extensions:
- Le versionnement par chemin d'URL est le plus intuitif mais conduit à des URI instables
- Le versionnement par en-tête de requête garde les URI stables mais est moins intuitif pour les clients
- Suivez les principes de versionnage sémantique lors des itérations de version :
- Les modifications rétrocompatibles utilisent des numéros de version mineure (v1.1)
- Les modifications incompatibles utilisent des numéros de version majeure (v2)
- Prévoyez une période de migration entre les anciennes et les nouvelles versions pour permettre aux clients d'effectuer une transition en douceur
- Indiquez clairement le statut du cycle de vie de chaque version d'API dans la documentation : développement, stable, obsolète, décommissionné
III. Conception des réponses
7. Concevoir une structure de réponse cohérente
Structure de base:
- Utilisez des objets enveloppes pour distinguer les données des métadonnées
- Conservez un format de réponse d'erreur cohérent
Exemple de réponse de succès:
{
"status": "success",
"data": {
"id": 123,
"name": "Example Product",
"price": 99.99
},
"meta": {
"timestamp": "2023-06-15T08:30:00Z"
}
}
Exemple de réponse d'erreur :
{
"status": "error",
"error": {
"code": "VALIDATION_ERROR",
"message": "Invalid input data",
"details": [
{"field": "email", "message": "Must be a valid email address"}
]
},
"meta": {
"timestamp": "2023-06-15T08:30:00Z",
"request_id": "req-123456"
}
}
Recommandations d'extensions:
- Incluez des codes d'erreur uniques dans les réponses d'erreur pour le dépannage et la référence de documentation
- Pour les erreurs complexes, fournissez des détails d'erreur structurés, en particulier pour les erreurs de validation de formulaire
- Incluez un identifiant de requête (request_id) pour le suivi des journaux et le support client
- Envisagez la prise en charge de l'internationalisation, en fournissant des versions multilingues des messages d'erreur ou des correspondances de codes d'erreur
- Évitez de divulguer des informations sensibles ou des détails d'implémentation dans les messages d'erreur
8. Implémenter les principes HATEOAS
Concept de base:
- HATEOAS(Hypermedia as the Engine of Application State)
- Incluez des liens vers des ressources associées dans les réponses pour rendre l'API auto-descriptive
Exemple:
{
"data": {
"id": 123,
"name": "John Doe"
},
"links": {
"self": "/users/123",
"orders": "/users/123/orders",
"update": {"href": "/users/123", "method": "PUT"},
"delete": {"href": "/users/123", "method": "DELETE"}
}
}
Recommandations d'extensions:
- Utilisez des noms de relation de lien standardisés (tels que définis dans les spécifications HAL ou JSON:API)
- Incluez des informations de contexte pour les liens, telles que la méthode HTTP et le type de média requis
- Générez dynamiquement des liens en fonction des autorisations de l'utilisateur, en affichant uniquement les actions disponibles pour l'utilisateur actuel
- Envisagez d'utiliser JSON Schema pour fournir une auto-description des formats de données d'entrée
9. Choisir des formats de sérialisation appropriés
Formats courants:
- JSON : le plus couramment utilisé, léger et facile à analyser
- XML : plus strict mais plus verbeux
- MessagePack : format binaire, adapté aux scénarios sensibles aux performances
Recommandations d'extensions:
- Utilisez la négociation de contenu pour prendre en charge plusieurs formats : le client utilise l'
Accepten-tête pour spécifier le format souhaité - Pour JSON, suivez une convention de nommage cohérente (camelCase ou snake_case)
- Tenez compte des exigences propres à certains scénarios :
- Le format CSV est adapté à l'export de grandes quantités de données
- Protocol Buffers ou gRPC sont adaptés à la communication de microservices à haute performance
- JSON-LD est adapté aux scénarios nécessitant des données sémantiques
- Fournir des modèles de données et des noms de champs cohérents entre les différents formats
IV. Sécurité et performances
10. Mettre en œuvre une authentification et une autorisation efficaces
Méthodes courantes:
- Clés API : adaptées à la communication de service à service
- OAuth 2.0 : adapté à l'autorisation par des tiers
- JWT (JSON Web Tokens) : adapté à l'authentification sans état
Recommandations d'extensions:
- Choisir les flux d'autorisation appropriés pour les différents scénarios d'utilisation de l'API :
- Utilisateur vers serveur : flux de code d'autorisation
- Serveur vers serveur : flux d'identifiants client
- Mettre en œuvre un contrôle granulaire des permissions, en suivant le principe du moindre privilège
- Mettre en œuvre des mécanismes de rotation et de révocation des clés API
- Utiliser les scopes OAuth 2.0 standard pour définir les permissions
- Envisagez de mettre en œuvre le contrôle d'accès basé sur les attributs (ABAC) pour les scénarios d'autorisation complexes
11. Implémenter la limitation de débit et la régulation
Implémentation de base:
- Utilisez la limitation du débit des requêtes pour protéger l'API
- Fournissez les informations de limite dans les en-têtes de réponse
Exemple d'en-tête de réponse:
X-RateLimit-Limit: 100 X-RateLimit-Remaining: 95 X-RateLimit-Reset: 1623760800
Recommandations d'extensions:
- Implémentez des limites à plusieurs niveaux :
- Limiter par adresse IP (prévenir les abus anonymes)
- Limiter par utilisateur/clé API (utilisation équitable)
- Limiter par ressource/point de terminaison (protéger les opérations sensibles)
- Proposez des forfaits premium ou des options de mise à l'échelle à la demande
- Utilisez les algorithmes de seau à jetons ou de seau percé pour gérer le trafic en rafale
- Mettez en œuvre une régulation adaptative pour ajuster dynamiquement les limites en fonction de la charge du système
- Fournir des canaux prioritaires ou une capacité réservée pour les clients critiques
12. Utiliser la mise en cache de manière appropriée
Implémentation de base:
- Utiliser les ETags et les en-têtes If-None-Match
- Définir des directives Cache-Control appropriées
Exemple:
Cache-Control: max-age=3600, must-revalidate ETag: "33a64df551425fcc55e4d42a148795d9f25f89d4"
Recommandations d'extensions:
- Définir différentes stratégies de mise en cache selon le type de ressource :
- Contenu statique : max-age plus long
- Données personnelles : max-age plus court ou directive private
- Données changeant fréquemment : utiliser ETag au lieu de max-age
- Implémenter des requêtes conditionnelles (If-Modified-Since, If-None-Match) pour réduire l'utilisation de la bande passante
- Envisager de mettre en œuvre la mise en cache au niveau de la passerelle API ou du CDN
- Fournir des mécanismes d'invalidation du cache, en particulier pour les ressources qui doivent être mises à jour soudainement
- Utiliser des tags de cache pour une gestion fine du cache
13. Prise en charge de la compression du contenu
Implémentation de base:
- Prise en charge de la compression gzip et Brotli
- Utiliser les en-têtes Accept-Encoding et Content-Encoding
Recommandations d'extensions:
- Appliquer automatiquement la compression aux réponses volumineuses, mais éviter de compresser les petites réponses (<1KB)
- Optimiser les niveaux de compression pour différents types de contenu
- Dans les scénarios sensibles aux performances, envisager de précompresser les réponses courantes
- Surveiller le taux de compression et l'utilisation du CPU pour trouver l'équilibre optimal
- Envisager de gérer la compression au niveau du proxy/de la passerelle pour réduire la charge sur les serveurs d'application
V. Documentation et maintenabilité
14. Fournir une documentation complète de l'API
Implémentation de base:
- Utiliser la spécification OpenAPI/Swagger
- Inclure des exemples de requêtes et de réponses
Recommandations étendues:
- Adopter une approche « docs-as-code », en versionnant la spécification de l'API avec le code
- Fournir un navigateur d'API interactif qui permet aux développeurs de tester l'API directement
- Inclure des tutoriels pour les cas d'usage courants et les scénarios d'intégration
- Fournir des extraits de code d'exemple pour chaque point de terminaison (dans plusieurs langages de programmation)
- Implémenter un journal des modifications de l'API qui marque clairement les fonctionnalités dépréciées et les nouvelles fonctionnalités
- Envisager de créer une communauté de développeurs ou un forum pour favoriser le partage de connaissances
15. Surveillance et journalisation
Implémentation de base:
- Enregistrer les temps de requête/réponse
- Suivre les taux d'erreur et les schémas d'utilisation
Recommandations étendues:
- Implémenter le traçage distribué à l'aide de W3C Trace Context ou de normes similaires
- Mettre en place des métriques de surveillance multidimensionnelles :
- Frammistaða endapunkta (P95/P99 biðtími)
- Villutíðni og tegundadreifing
- Notkunarmynstur biðlara
- Auðlindanotkun (CPU, minni, bandvídd)
- Útfærðu snjallar viðvaranir sem greina frávikamynstur í stað einfaldra þröskulda
- Veittu þróunarkonsól sem gerir notendum API kleift að skoða eigin notkunartölfræði
- Notaðu skipulögð loggsnið (eins og JSON) til að auðvelda greiningu og leit í loggum
16. Veittu gagnlegar villuaflúsunarupplýsingar
Implémentation de base:
- Veittu skýr villuskilaboð
- Hafðu með einstaka villukóða
Recommandations étendues:
- Stilltu ítarstig villna eftir umhverfi (forðastu að leka viðkvæmum upplýsingum í framleiðslu)
- Útfærðu villumiðstöð sem tengir villukóða við ítarlegar leiðbeiningar um úrræðaleit
- Fournir des liens d'aide contextuelle
- Fournir des suggestions de correction automatisées pour les erreurs courantes
- Fournir des traces de pile et un contexte plus détaillés dans les environnements de développement
- Mettre en œuvre des mécanismes de signalement automatique pour les erreurs critiques
VI. Considérations de conception avancées
17. Traitement par lots et opérations asynchrones
Traitement par lots:
- Prendre en charge les opérations de création, mise à jour et suppression par lots
- Fournir des options de gestion des succès partiels
Exemples d'opérations par lots:
POST /users/batch
{
"operations": [
{"method": "POST", "path": "/users", "body": {"name": "User 1"}},
{"method": "PUT", "path": "/users/123", "body": {"name": "Updated User"}}
]
}
Opérations asynchrones:
- Retourner 202 Accepted pour les tâches de longue durée
- Fournir des points de terminaison d'état des tâches
Exemples de flux asynchrones:
POST /reports/generate
Response: 202 Accepted
Location: /tasks/abc-123
GET /tasks/abc-123
Response: {"status": "processing", "progress": 45, "eta": "30s"}
GET /tasks/abc-123
Response: {"status": "completed", "result": "/reports/xyz-789"}
Recommandations étendues:
- Implémenter des notifications asynchrones basées sur webhook qui rappellent le client lorsqu'une tâche se termine
- Fournir des options d'atomicité pour les opérations par lots (tout réussit ou tout échoue)
- Prendre en charge les dépendances dans les opérations par lots (une opération dépend du résultat d'une autre)
- Fournir des mécanismes de tâches et des capacités d'annulation
- Implémenter des stratégies de nouvelle tentative de tâche et des mécanismes de gestion des échecs
18. Tenir compte de l'évolution de la conception d'API
Principes de base:
- Utiliser l'ajout plutôt que la modification
- Éviter la suppression ; déprécier d'abord, puis supprimer
- Maintenir la rétrocompatibilité
Recommandations étendues:
- Établir une politique claire de cycle de vie d'API :
- Attentes en matière de stabilité pour les versions Preview/Alpha/Beta
- Période de dépréciation (généralement au moins 6-12 mois)
- Période de maintenance pour les versions de support à long terme (LTS)
- Utilisez des feature flags pour déployer progressivement de nouvelles fonctionnalités
- Mettez en place des analyses d'utilisation de l'API pour comprendre quels endpoints et fonctionnalités ne sont plus utilisés
- Fournissez des outils et des exemples de migration pour aider les clients à passer aux nouvelles versions
- Prévoyez des points d'extension dès la conception, tels que la prise en charge de champs personnalisés ou de métadonnées
VII. Optimisations spécifiques au secteur et nouvelles tendances
Optimisation de l'API pour les applications mobiles
- Implémentez des endpoints GraphQL pour permettre aux clients mobiles de demander précisément les données dont ils ont besoin
- Prenez en charge les réponses partielles pour réduire l'utilisation de la bande passante :
?fields=id,name,thumbnail - Fournissez des API de préchargement par lots pour réduire les allers-retours réseau
- Envisagez une conception réactive qui adapte la taille des réponses en fonction des capacités des appareils et des conditions réseau
- Mettez en œuvre des mécanismes de synchronisation incrémentielle qui ne transmettent que les données modifiées
Considérations sur les API IoT (Internet of Things)
- Prendre en charge des protocoles légers (tels que MQTT ou CoAP)
- Mettez en œuvre des modèles d’état des appareils et une communication bidirectionnelle
- Optimisez l’utilisation de la bande passante à l’aide de formats binaires et de compression
- Concevez des opérations hors ligne et des stratégies de résolution des conflits
- Fournissez des API de gestion des appareils et de mise à jour du firmware
Approche de développement API-First
- Adoptez une approche privilégiant d’abord la conception plutôt que le code
- Utilisez des modèles d’API pour piloter le processus de développement (par exemple, générer du code à partir de spécifications OpenAPI)
- Mettez en œuvre des processus de revue de conception d’API pour garantir la cohérence et la qualité
- Établir des guides de style d'API et une documentation des meilleures pratiques
- Utiliser des tests de contrat pour garantir que les implémentations sont conformes aux spécifications
VIII. Résumé
Une API REST bien conçue nécessite d'équilibrer soigneusement de multiples facteurs, notamment la convivialité, la performance, la sécurité et la maintenabilité. En suivant ces meilleures pratiques, les équipes de développement peuvent créer des API qui adhèrent à la fois aux principes REST et répondent aux besoins des applications modernes. La clé est de maintenir la cohérence, l'intuitivité, et de toujours penser du point de vue des consommateurs d'API. À mesure que l'économie des API continue d'évoluer, une conception d'API de haute qualité deviendra un facteur clé de réussite organisationnelle.
IX. Lectures complémentaires
- API Web RESTful (Leonard Richardson, Mike Amundsen)
- Modèles de conception d'API (JJ Geewax)
- La conception des API Web : Meilleures pratiques pour la création d'applications modernes (Arnaud Lauret)
- Guide de sécurité des API REST (OWASP)
- Modèle de maturité de Richardson : Comprendre les niveaux d'évolution des API REST