QU’EST-CE QU’UNE API RESTful :

L'API RESTful est une interface que deux systèmes informatiques utilisent pour échanger des
informations en toute sécurité sur Internet.
Autrement une API RESTful est comme un pont qui permet à deux systèmes informatiques de se
parler et de partager des informations sur Internet. Tout en utilisant un ensemble standard de règles
pour créer, récupérer, mettre à jour et supprimer des ressources que lui-même il nous fournit.
Par exemple, pour générer des fiches de paie mensuelles, votre système de comptabilité interne doit
partager des données avec le système bancaire de votre client pour automatiser la facturation, et
communiquer avec une application interne de feuille de temps.
Ou encore prenons l'exemple d'une librairie. Imaginez que vous disposez d'une application Web qui
permet aux utilisateurs d'effectuer diverses opérations sur des livres, telles que l'ajout d'un nouveau
livre, la récupération des détails du livre, la mise à jour des informations sur le livre et la suppression
de livres. Voici comment ces opérations peuvent être mises en œuvre à l'aide d'une API RESTful :

1. Ajout d'un nouveau livre (requête POST) : pour ajouter un nouveau livre à la librairie, vous
devez envoyer une requête POST au point de terminaison de l'API /books. La demande
comprendrait les données nécessaires pour le nouveau livre, telles que son titre, son auteur
et son numéro ISBN. L'API créerait alors une nouvelle ressource de livre et renverrait une
réponse avec les détails du livre nouvellement créé, ainsi qu'un identifiant unique.

2. Récupération des détails du livre (requête GET) : si vous souhaitez récupérer les détails d'un
livre spécifique, vous devez envoyer une requête GET au point de terminaison de l'API
/books/{bookId}, où {bookId}est l'identifiant unique du livre. L'API récupère la ressource de
livre correspondante dans la base de données et renvoie les détails du livre dans la réponse.

3. Mise à jour des informations sur le livre (demande PUT ou PATCH) : pour mettre à jour les
informations d'un livre, vous devez envoyer une demande PUT ou PATCH au point de
terminaison de l'API /books/{bookId}. La demande inclurait les données mises à jour pour le
livre. L'API localisera le livre avec l'ID spécifié, modifiera ses attributs avec les nouvelles
données et renverra une réponse indiquant le succès de la mise à jour.

4. Suppression d'un livre (demande DELETE) : si vous souhaitez supprimer un livre de la librairie,
vous devez envoyer une demande DELETE au point de terminaison de l'API /books/{bookId}.
L'API localisera le livre avec l'ID fourni et le supprimera de la base de données. La réponse
confirmerait la suppression.

"API RESTful" et "API REST" font référence au même concept. Les deux termes décrivent une API
(Application Programming Interface) qui suit les principes et les contraintes du style architectural
REST (Representational State Transfer). Les API RESTful permettent la communication entre les
systèmes informatiques sur Internet à l'aide de méthodes HTTP standard, telles que GET, POST, PUT
et DELETE, et elles échangent souvent des données dans des formats largement pris en charge tels
que JSON ou XML. Ainsi, que vous l'appeliez une "API RESTful" ou une "API REST", vous faites
essentiellement référence à une API qui adhère aux principes de REST.
 Qu'est-ce qu'une API ?
Une interface de programme d'application (API) définit les règles que vous devez suivre pour
communiquer avec d'autres systèmes logiciels. Les développeurs exposent ou créent des API
afin que d'autres applications puissent communiquer avec leurs applications de manière
programmatique. Par exemple, l'application de feuille de temps expose une API qui demande
le nom complet d'un employé et une plage de dates. Lorsqu'il reçoit ces informations, il traite
en interne la feuille de temps de l'employé et renvoie le nombre d'heures travaillées dans
cette plage de dates.
Autrement Une API, ou Application Programming Interface, est un ensemble de règles et de
protocoles qui permet à différentes applications logicielles de communiquer et d'interagir
entre elles. Il définit les méthodes et les formats de données que les applications peuvent
utiliser pour demander et échanger des informations.
--------------------------------------------------------------PAUSE1

Lors de la communication avec d'autres systèmes logiciels via une API, il est essentiel de
suivre certaines règles ou meilleures pratiques pour assurer une communication efficace et
cohérente. Voici quelques règles communes définies par les API :

1. Utiliser des protocoles standardisés : les API utilisent généralement des protocoles
standard tels que HTTP(S) ou WebSocket pour la communication. Le respect de ces
protocoles garantit la compatibilité et l'interopérabilité entre les différents systèmes.

2. Utilisez des points de terminaison bien définis : les API définissent des points de
terminaison spécifiques (URL) qui correspondent à différentes ressources ou actions.
Il est important de comprendre et d'utiliser correctement ces points de terminaison
pour accéder à la fonctionnalité souhaitée.

Utilisez des URI descriptifs et cohérents : les URI doivent être intuitifs et refléter les
ressources qu'ils représentent. Utilisez des noms pour représenter les ressources et
évitez les verbes ou les actions dans l'URI. Par exemple, /books au lieu de /getBooks.

3. Authentifier et autoriser les demandes : les API nécessitent souvent une

authentification et une autorisation pour garantir un accès sécurisé. Vous devrez
peut-être inclure des jetons d'authentification ou des clés API dans vos demandes
pour vous authentifier et obtenir un accès autorisé.

4. Suivre les méthodes de requête : les API utilisent différentes méthodes de requête
HTTP (GET, POST, PUT, DELETE, etc.) pour effectuer des actions spécifiques. Utilisez la
 méthode de requête appropriée en fonction de l'opération prévue et suivez la
sémantique associée à chaque méthode.

Utiliser correctement les méthodes HTTP : Utilisez les méthodes HTTP appropriées
(GET, POST, PUT, DELETE, etc.) pour effectuer les actions correspondantes sur les
ressources. Évitez de l'utiliser GET pour les opérations d'écriture ou POST de
récupération.

5. Gérer les codes de réponse : les API renvoient des codes de réponse (codes d'état
http ou encore ligne d’état) pour indiquer le succès ou l'échec d'une demande. Gérez
ces codes de réponse de manière appropriée pour déterminer le résultat de votre
demande et gérez les erreurs ou les exceptions en conséquence.

La ligne d'état contient un code d'état à trois chiffres qui indique le succès ou l'échec
de la requête. Par exemple, les codes 2XX indiquent un succès, mais les codes 4XX et
5XX indiquent des erreurs. Les codes 3XX indiquent une redirection d'URL.

Voici quelques codes d'état courants :

200 : réponse générique de succès

201 : réponse de succès de la méthode POST
400 : demande incorrecte que le serveur ne peut pas traiter
404 : ressource non trouvée

---------------------------------------------------ARRET

6. Utiliser les formats de demande et de réponse : les API ont souvent des formats de
données spécifiques pour les charges utiles de demande (par exemple, JSON, XML) et
les charges utiles de réponse. Assurez-vous d'envoyer les demandes dans le bon
format et d'analyser les réponses de manière appropriée.

Exemple : envoi d'une requête avec une charge utile JSON pour mettre à jour les
informations utilisateur et analyse de la réponse JSON reçue de l'API.

7. Gérer la pagination et le filtrage : les API qui renvoient de grands ensembles de

données peuvent implémenter des mécanismes de pagination ou de filtrage. Suivez
la documentation de l'API pour gérer correctement les paramètres de pagination et
de filtrage afin de récupérer les données souhaitées.
 Exemple : inclure des paramètres de pagination (par exemple, page et limite) dans
une requête GET pour récupérer une page de résultats spécifique, ou utiliser des
paramètres de requête pour filtrer les résultats en fonction de certains critères.

8. Respectez la limitation de débit : certaines API imposent des limites de débit pour
contrôler le nombre de requêtes que vous pouvez effectuer dans un délai spécifique.
Respectez ces limites pour éviter d'être bloqué ou limité par le fournisseur d'API.

9. Gestion des versions : les API peuvent introduire des modifications au fil du temps. Il
est important d'envisager la gestion des versions pour maintenir la compatibilité
descendante. Spécifiez la version de l'API dans vos requêtes ou utilisez des stratégies
de gestion des versions appropriées pour garantir des transitions fluides et éviter les
modifications avec rupture.

Exemple : spécification de la version de l'API dans l'URL de la demande (par exemple,

/v1/users/{userId}) pour garantir la compatibilité avec la version souhaitée de l'API.

10. Lire la documentation de l'API : consulter la documentation de l'API pour

comprendre les points de terminaison disponibles, les formats de demande/réponse,
les méthodes d'authentification et toute directive ou limitation spécifique fournie
par le fournisseur d'API.

Ou bien encore une documentation : créez une documentation d'API claire et

complète qui explique les points de terminaison, leur objectif, les paramètres requis
et les réponses attendues. Incluez des exemples et des extraits de code pour aider les
développeurs à utiliser efficacement l'API.

Le respect de ces règles et directives permet de garantir que votre communication avec d'autres
systèmes logiciels via des API est cohérente, fiable et conforme aux attentes définies par le
fournisseur d'API. Il favorise une intégration fluide et une utilisation efficace des capacités de l'API.

-------------------------------------------------------------------------------PAUSE 2
Les API sont couramment utilisées dans le développement Web pour permettre l'intégration
et l'interaction entre différents systèmes, services ou plates-formes. Ils fournissent aux
développeurs un moyen standardisé d'accéder à certaines fonctionnalités ou données à
partir d'applications ou de services externes sans avoir besoin de comprendre les détails de
mise en œuvre sous-jacents.

Voici un exemple d'API : l'API Google Maps. L'API Google Maps permet aux développeurs
d'intégrer des cartes et des services liés à la localisation dans leurs propres applications. En
faisant des requêtes API, les développeurs peuvent récupérer des données cartographiques,
effectuer un géocodage (conversion d'adresses en coordonnées géographiques), calculer des
directions, etc. Cette API permet aux développeurs d'exploiter l'infrastructure et les
fonctionnalités de cartographie de Google dans leurs propres applications, améliorant ainsi
l'expérience utilisateur avec des services basés sur la localisation.

Par exemple aussi : l'API OpenWeatherMap fournit des données météorologiques pour
divers endroits dans le monde. L'application peut envoyer une requête API à
OpenWeatherMap, en spécifiant l'emplacement souhaité (par exemple, le nom de la ville ou
les coordonnées géographiques) et la clé API.

L'API répond avec une réponse au format JSON ou XML contenant des informations
météorologiques pertinentes telles que la température, l'humidité, la vitesse du vent et les
conditions (par exemple, ensoleillé, nuageux, pluvieux). L'application peut alors analyser et
afficher ces informations à l'utilisateur.

En utilisant l'API OpenWeatherMap, l'application météorologique peut récupérer et

présenter dynamiquement des données météorologiques à jour sans avoir à maintenir sa
propre base de données ou infrastructure météorologique.

-------------------------------------------------------------ARRET

Vous pouvez considérer une API Web comme une passerelle entre les clients et les
ressources sur le Web.

Clients
Les clients sont des utilisateurs qui veulent accéder à des informations à partir du Web. Le
client peut être une personne ou un système logiciel qui utilise l'API. Par exemple, les
développeurs peuvent écrire des programmes qui accèdent aux données météorologiques
d'un système météorologique. Ou vous pouvez accéder aux mêmes données à partir de votre
navigateur lorsque vous visitez directement le site Web de la météo.

Ressources
Les ressources sont les informations que les différentes applications fournissent à leurs
clients. Les ressources peuvent être des images, des vidéos, du texte, des chiffres ou tout
type de données. La machine qui fournit la ressource au client est également appelée le
serveur. Les organisations utilisent les API pour partager des ressources et fournir des
services Web tout en maintenant la sécurité, le contrôle et l'authentification. En outre, les
API les aident à déterminer quels clients ont accès à des ressources internes spécifiques.

Résumer

REST, qui signifie Representational State Transfer, est un style architectural et un ensemble
de principes pour la conception d'applications en réseau. Il est couramment utilisé dans le
développement de services Web et d'API. Les systèmes RESTful se caractérisent par leur
simplicité, leur évolutivité et leur absence d'état.

Les principes clés de REST incluent :

Communication sans état : le serveur ne stocke aucun état du client. Chaque requête du
client doit contenir toutes les informations nécessaires pour que le serveur puisse la traiter.

Architecture client-serveur : le client et le serveur sont des entités distinctes qui

communiquent sur un réseau. Le client est responsable de l'interface utilisateur, tandis que
le serveur gère le stockage et le traitement des données.

Interface uniforme : l'interaction entre le client et le serveur est normalisée à l'aide d'un
ensemble de règles bien définies et cohérentes. Cela inclut l'utilisation de méthodes HTTP
standard (GET, POST, PUT, DELETE) pour des opérations spécifiques et l'utilisation d'URI
(Uniform Resource Identifiers) pour identifier et accéder aux ressources.

Orienté ressources : les ressources sont le concept clé de REST. Ils représentent toutes les
informations qui peuvent être nommées et adressées, telles qu'un utilisateur, un produit ou
un article. Les ressources sont accessibles et manipulées à l'aide des méthodes HTTP.

-----------------------------------------------------------------PAUSE samedi

Voici un exemple d'API RESTful pour gérer une collection de livres :

GET /books : Récupère une liste de tous les livres.

GET /books/{id} : récupère les détails d'un livre spécifique identifié par {id}.
POST /books : créez un nouveau livre en envoyant les détails du livre dans le corps de la
requête.
PUT /books/{id} : mettre à jour les détails d'un livre spécifique identifié par {id}.
DELETE /books/{id} : supprimer un livre spécifique identifié par {id}.
Dans cet exemple, le client interagit avec le serveur à l'aide de méthodes HTTP et d'URI pour
effectuer des opérations sur les ressources du livre. Le serveur répond avec les données
demandées ou les codes d'état appropriés.

Les API RESTful fournissent une approche standardisée et évolutive pour créer des systèmes
distribués et permettre l'interopérabilité entre différentes applications et plates-formes.

COMMENT FONCTIONNE LES API RESTful :

Les API RESTful fonctionnent sur la base d'un modèle de communication client-serveur et des
principes du style architectural REST.
Voici un aperçu de haut niveau de leur fonctionnement :

Le client envoie une demande : le client (tel qu'un navigateur Web ou une application
mobile) lance une demande pour interagir avec une ressource sur le serveur. La demande est
généralement envoyée via HTTP ou HTTPS.

Format de la requête : la requête comprend une URL (Uniform Resource Locator) qui
identifie la ressource, une méthode HTTP (GET, POST, PUT, DELETE, etc.) qui spécifie l'action
à effectuer sur la ressource, ainsi que des en-têtes et des paramètres facultatifs pour
Informations Complémentaires.

Le serveur traite la demande : le serveur reçoit la demande et interprète la méthode HTTP et

l'URL pour déterminer l'action appropriée à entreprendre. Il peut valider la demande,
authentifier le client si nécessaire et effectuer tout traitement requis.

Échange de données : le serveur peut récupérer ou modifier des données à partir d'une base
de données ou d'un autre système de stockage en fonction de l'opération demandée. Il traite
la demande et prépare une réponse.

Format de réponse : le serveur construit une réponse HTTP qui inclut un code d'état
approprié pour indiquer le succès ou l'échec de la demande, ainsi que des en-têtes facultatifs
et un corps de réponse contenant les données demandées ou d'autres informations
pertinentes.
Réponse envoyée au client : le serveur renvoie la réponse HTTP au client, généralement au
format JSON ou XML. Le client reçoit et traite la réponse.

Traitement côté client : le client interprète la réponse en fonction du code d'état reçu. Si la
demande a réussi (par exemple, code d'état 200), le client peut extraire et utiliser les
données reçues du corps de la réponse. S'il y a eu une erreur (par exemple, code d'état 404),
le client peut gérer l'erreur en conséquence.

Répéter ou mettre fin à l'interaction : le client peut choisir d'envoyer des requêtes
supplémentaires au serveur pour effectuer plus d'opérations ou récupérer plus de données.
L'interaction entre le client et le serveur peut se poursuivre jusqu'à ce que les tâches
souhaitées soient terminées ou que le client mette fin à la communication.

Les API RESTful fournissent un moyen standardisé pour les clients et les serveurs de
communiquer, permettant aux clients d'accéder et de manipuler les ressources sur le serveur
à l'aide de méthodes et de protocoles HTTP bien définis. La simplicité et la flexibilité des API
RESTful les rendent largement adoptées pour créer des services Web et permettre
l'interopérabilité entre différents systèmes et plates-formes.

BEST PRACTICE REST API :

Oui, voici quelques bonnes pratiques à prendre en compte lors de la conception et de la mise
en œuvre d'API RESTful :

Utilisez des URI descriptifs et cohérents : les URI doivent être intuitifs et refléter les
ressources qu'ils représentent. Utilisez des noms pour représenter les ressources et évitez les
verbes ou les actions dans l'URI. Par exemple, /books au lieu de /getBooks.

Utiliser correctement les méthodes HTTP : Utilisez les méthodes HTTP appropriées (GET,
POST, PUT, DELETE, etc.) pour effectuer les actions correspondantes sur les ressources. Évitez
de l'utiliser GET pour les opérations d'écriture ou POST de récupération.

Gestion des versions : envisagez d'inclure la gestion des versions dans les URI de l'API pour
permettre une rétrocompatibilité et des transitions fluides lors des mises à jour. Par
exemple, /api/v1/books pour spécifier la version 1 de l'API.
Utilisez des codes d'état HTTP significatifs : renvoyez les codes d'état HTTP appropriés pour
indiquer le succès ou l'échec d'une demande. Par exemple, 200 OK pour une réponse réussie,
404 Not Found pour une ressource qui n'existe pas ou 400 Bad Request pour une requête
invalide.

Mettre en œuvre la pagination et le filtrage : pour les terminaux qui renvoient de grandes
quantités de données, fournissez des options de pagination pour limiter le nombre de
résultats renvoyés. De plus, permettez aux clients d'appliquer des filtres pour affiner les
résultats en fonction de critères spécifiques.

Utilisez une gestion des erreurs et des réponses aux erreurs appropriées : lorsqu'une erreur
se produit, renvoyez des messages d'erreur significatifs et des codes d'erreur pertinents pour
aider les clients à comprendre et à gérer le problème. Incluez des détails supplémentaires
dans la réponse, tels que des descriptions d'erreur ou des codes d'erreur pour faciliter le
dépannage.

Sécurisez les données sensibles : mettez en œuvre des mesures de sécurité appropriées,
telles que l'utilisation de HTTPS pour une communication sécurisée et la prise en compte de
mécanismes d'authentification et d'autorisation pour protéger les données sensibles.

Fournissez une documentation : créez une documentation d'API claire et complète qui
explique les points de terminaison, leur objectif, les paramètres requis et les réponses
attendues. Incluez des exemples et des extraits de code pour aider les développeurs à utiliser
efficacement l'API.

Envisagez d'optimiser la mise en cache et les performances : utilisez les mécanismes de mise
en cache appropriés (par exemple, la mise en cache HTTP) pour améliorer les performances
et réduire les requêtes inutiles. Optimisez la conception de l'API pour minimiser le nombre
d'allers-retours et réduire la taille des charges utiles dans la mesure du possible.

Ce ne sont là que quelques bonnes pratiques à garder à l'esprit lors de la conception d'API
RESTful. Le respect de ces pratiques peut contribuer à assurer la cohérence, la facilité
d'utilisation et une meilleure intégration avec les applications clientes.

ARRET
ARCHITECTURE MICROSERVICES :
L'architecture de microservices est un style architectural utilisé dans le développement de
logiciels qui structure une application comme une collection de petits services indépendants.
Chaque service représente une capacité métier spécifique et peut être développé, déployé et
mis à l'échelle indépendamment.

En termes simples, imaginez une architecture de microservices comme décomposant une

grande application en blocs de construction plus petits et autonomes. Chaque microservice
se concentre sur une tâche ou une fonctionnalité spécifique, telle que l'authentification des
utilisateurs, le traitement des paiements ou le stockage des données. Ces microservices
communiquent entre eux via des API (Application Programming Interfaces) bien définies.

Les principales caractéristiques de l'architecture des microservices incluent :

1. Indépendance des services : chaque microservice peut être développé, déployé et

mis à l'échelle indépendamment sans affecter les autres services. Cela permet une
flexibilité, une agilité et une maintenance plus facile.

2. Couplage lâche : les microservices communiquent entre eux via des API bien définies,
favorisant le couplage lâche. Les modifications apportées à un microservice n'ont pas
d'incidence sur les autres services, ce qui permet aux équipes de travailler
simultanément sur différents services.

3. Évolutivité : étant donné que les microservices sont des unités indépendantes, ils
peuvent être mis à l'échelle individuellement en fonction de besoins spécifiques. Cela
garantit une utilisation efficace des ressources et de meilleures performances.

4. Résilience et isolation des pannes : les défaillances d'un microservice n'ont pas
d'impact sur l'ensemble du système. Les défauts peuvent être isolés et le système
peut continuer à fonctionner avec un minimum de perturbations.

5. Diversité technologique : l'architecture des microservices permet l'utilisation de

différentes technologies et langages de programmation pour chaque microservice,
en fonction des exigences spécifiques. Cela favorise la flexibilité et l'utilisation des
meilleurs outils pour chaque tâche.

Dans l'ensemble, l'architecture des microservices favorise la modularité, la flexibilité et

l'évolutivité, ce qui la rend adaptée aux applications complexes qui doivent être agiles,
hautement évolutives et facilement maintenables.
METTRE EN PLACE UNE ARCHITECTURE MICROSERVICES :

La mise en place d'une architecture de microservices comporte plusieurs étapes. Voici un

guide simplifié et facile à comprendre :

Identifiez le domaine d'activité : divisez votre application en domaines ou fonctionnalités

d'entreprise plus petits et indépendants. Chaque domaine doit représenter une capacité
métier spécifique.

Définir les limites de service : déterminez les limites de chaque microservice en fonction des
domaines commerciaux identifiés. Un microservice doit être autonome et responsable d'un
ensemble spécifique de fonctionnalités.

Concevoir des interfaces de service : définissez les API ou les interfaces que chaque
microservice exposera pour communiquer avec d'autres services. Ces API doivent être bien
définies et respecter les principes de couplage lâche et de cohésion élevée.

Choisissez le protocole de communication : choisissez un protocole de communication qui

permet la communication interservices. Les choix courants incluent HTTP/REST, les systèmes
de messagerie (par exemple, RabbitMQ) ou les architectures pilotées par les événements
(par exemple, Apache Kafka).

Mettre en œuvre des microservices : développez chaque microservice en tant qu'unité

indépendante et déployable. Chaque microservice doit avoir sa propre base de code, sa
propre base de données et sa propre logique métier. Utiliser des technologies et des cadres
appropriés pour la mise en œuvre.

Gérer les dépendances de service : gérez avec soin les dépendances entre les microservices.
Minimisez les dépendances directes et utilisez des techniques telles que la découverte de
services (par exemple, Netflix Eureka) ou les passerelles API pour faciliter la communication
entre les services.

Déployer des microservices : déployez chaque microservice en tant qu'instance ou conteneur

distinct. Vous pouvez utiliser des outils de conteneurisation comme Docker ou des plates-
formes d'orchestration de conteneurs comme Kubernetes pour un déploiement et une mise
à l'échelle efficaces.

Surveiller et gérer : implémentez des mécanismes de surveillance et de journalisation pour

suivre les performances, la santé et la disponibilité des microservices. Utilisez des outils de
journalisation et de surveillance centralisés pour gagner en visibilité sur l'ensemble de
l'architecture.

Mise à l'échelle et équilibre de charge : à mesure que votre application se développe, faites
évoluer les microservices individuels indépendamment en fonction de la demande. Utilisez
des techniques d'équilibrage de charge pour répartir uniformément les demandes entrantes
sur plusieurs instances du même microservice.

Amélioration continue : adoptez une culture d'amélioration continue. Refactorisez et

optimisez les microservices en fonction des modèles d'utilisation, des commentaires et de
l'évolution des besoins de l'entreprise. Surveillez les mesures de performance et de fiabilité
et résolvez les goulots d'étranglement ou les problèmes.

N'oubliez pas que la configuration d'une architecture de microservices nécessite une

planification, une conception et une prise en compte minutieuses des exigences spécifiques
de votre application. Il est important de trouver un équilibre entre la complexité de la gestion
des systèmes distribués et les avantages d'évolutivité, de flexibilité et de maintenabilité
qu'offrent les microservices.

------------------------------------------------------PAUSE LUNDI