6 Architectures d'API que Vous Devez Connaître - ANWER AWLED BELHEDI

6 Architectures d’API que Vous Devez Connaître

Introduction :

Les interfaces de programmation d’application, ou API (Application Programming Interfaces), sont au cœur du développement d’applications modernes. Elles permettent aux applications de communiquer entre elles, d’échanger des données et de fournir des fonctionnalités essentielles aux utilisateurs. Parmi les différentes architectures d’API disponibles, six se démarquent par leur importance et leur utilisation répandue. Dans cet article, nous explorerons ces six architectures d’API que tout développeur devrait connaître.

1. REST (Representational State Transfer)

REST est l’une des architectures d’API les plus populaires et largement utilisées. Elle repose sur le principe fondamental de l’état représentatif, où chaque ressource est identifiée par une URL unique. Les interactions avec les ressources REST se font généralement via les méthodes HTTP standard telles que GET, POST, PUT et DELETE. REST est connu pour sa simplicité, sa scalabilité et sa facilité d’utilisation.

Voici un exemple simple d’utilisation de l’architecture REST pour une API fictive de gestion des tâches (to-do list) en utilisant les méthodes HTTP standard :

Supposons que nous souhaitons créer une API pour gérer des tâches. Voici comment nous pourrions concevoir cette API REST :

1- Liste de Tâches

Méthode HTTP : GET
URL : https://api.example.com/tasks
Description : Cette requête permet de récupérer la liste de toutes les tâches.

GET https://api.example.com/tasks

2- Détail d’une Tâche

Méthode HTTP : GET
URL : https://api.example.com/tasks/{task_id}
Description : Cette requête permet de récupérer les détails d’une tâche spécifique en spécifiant son identifiant.

GET https://api.example.com/tasks/123

3- Création d’une Tâche

Méthode HTTP : GET
URL : https://api.example.com/tasks/{task_id}
Description : Cette requête permet de récupérer les détails d’une tâche spécifique en spécifiant son identifiant.

POST https://api.example.com/tasks Content-Type: application/json 
{ 
"title": "Faire les courses", "description": "Acheter des fruits et légumes." 
}

4- Mise à Jour d’une Tâche

Méthode HTTP : PUT
URL : https://api.example.com/tasks/{task_id}
Description : Cette requête permet de mettre à jour les détails d’une tâche spécifique en spécifiant son identifiant et en fournissant les nouvelles informations au format JSON dans le corps de la requête.

PUT https://api.example.com/tasks/123
Content-Type: application/json

{
    "title": "Faire les courses",
    "description": "Acheter des fruits, légumes et du lait."
}

5- Suppression d’une Tâche

Méthode HTTP : DELETE
URL : https://api.example.com/tasks/{task_id}
Description : Cette requête permet de supprimer une tâche spécifique en spécifiant son identifiant.

DELETE https://api.example.com/tasks/123

Cet exemple illustre comment une API REST peut être conçue autour des actions CRUD (Create, Read, Update, Delete) pour gérer les tâches. Chaque endpoint (URL) correspond à une action spécifique, et les méthodes HTTP indiquent l’opération à effectuer sur les ressources. Les données sont généralement échangées au format JSON pour les requêtes et les réponses.

2. Webhook

Les webhooks sont un mécanisme d’API qui permet à une application de fournir des données en temps réel à une autre application. Plutôt que de demander périodiquement des mises à jour, une application peut s’abonner à des webhooks pour être avertie immédiatement lorsqu’un événement spécifique se produit. Cette architecture est essentielle pour les notifications en temps réel et les intégrations rapides entre applications.

Voici un exemple simple d’utilisation d’un webhook :

Supposons que vous avez une application de messagerie instantanée, et vous souhaitez que votre application envoie une notification chaque fois qu’un nouvel utilisateur s’inscrit. Voici comment cela pourrait être mis en œuvre en utilisant un webhook :

Inscription d’un Nouvel UtilisateurLorsqu’un nouvel utilisateur s’inscrit sur votre application, vous collectez ses informations, y compris son nom d’utilisateur et son adresse e-mail.
Webhook ConfigurationVous avez préalablement configuré un webhook sur votre serveur pour gérer les notifications d’inscription. Le webhook est configuré pour écouter les événements d’inscription et déclencher une action lorsqu’un nouvel utilisateur s’inscrit.
Envoi des Données via WebhookAprès avoir collecté les informations de l’utilisateur, vous utilisez une requête HTTP POST pour envoyer ces données à l’URL du webhook que vous avez configuré sur votre serveur. Les données sont généralement envoyées au format JSON.

POST https://webhook.example.com/new-user
Content-Type: application/json

{
    "username": "nouvel_utilisateur",
    "email": "[email protected]"
}

4. Réception et Traitement sur le ServeurLe serveur hébergeant le webhook reçoit les données de la nouvelle inscription et déclenche une action en réponse à l’événement. Par exemple, il pourrait envoyer une notification de bienvenue à l’utilisateur par e-mail, stocker les données de l’utilisateur dans une base de données, ou effectuer d’autres opérations personnalisées en fonction des besoins de votre application.

L’utilisation de webhooks permet de connecter des applications tierces ou des services externes à votre application afin de déclencher des actions en temps réel en réponse à des événements spécifiques. Cela permet d’automatiser des tâches, d’intégrer des services externes et d’améliorer l’expérience utilisateur en fournissant des mises à jour en temps réel.

3. SOAP (Simple Object Access Protocol)

SOAP est un protocole basé sur XML qui permet aux applications de communiquer via des messages structurés. Bien que moins courant que REST, SOAP est encore utilisé dans certaines applications, en particulier dans les services web d’entreprise. Il offre une norme stricte pour la communication, ce qui peut être avantageux dans certains cas.

Voici un exemple simple d’utilisation de SOAP avec un service Web fictif qui fournit des informations sur les pays en fonction de leur code ISO.

1. Création d’un Client SOAP en Python

Dans cet exemple, nous allons créer un client SOAP en Python pour interagir avec un service Web fictif. Pour cela, vous pouvez utiliser la bibliothèque zeep pour faciliter la communication SOAP.

from zeep import Client

# Créez un client SOAP pour le service Web
client = Client('https://www.example.com/country-info?wsdl')

# Appelez une méthode du service Web
response = client.service.getCountryInfoByISO('US')

# Affichez la réponse du service Web
print(response)

2. Service Web Fictif

Supposons que vous avez un service Web fictif hébergé à l’URL https://www.example.com/country-info?wsdl. Ce service Web expose une méthode getCountryInfoByISO qui prend un code ISO de pays en entrée et renvoie des informations sur ce pays au format XML.

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
                 xmlns:tns="https://www.example.com/country-info"
                 targetNamespace="https://www.example.com/country-info">
    <wsdl:types>
        <schema xmlns="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
            <element name="getCountryInfoByISO">
                <complexType>
                    <sequence>
                        <element name="isoCode" type="string"/>
                    </sequence>
                </complexType>
            </element>
            <element name="getCountryInfoByISOResponse">
                <complexType>
                    <sequence>
                        <element name="countryInfo" type="string"/>
                    </sequence>
                </complexType>
            </element>
        </schema>
    </wsdl:types>
    <wsdl:message name="getCountryInfoByISORequest">
        <wsdl:part name="parameters" element="tns:getCountryInfoByISO"/>
    </wsdl:message>
    <wsdl:message name="getCountryInfoByISOResponse">
        <wsdl:part name="parameters" element="tns:getCountryInfoByISOResponse"/>
    </wsdl:message>
    <wsdl:portType name="CountryInfoPort">
        <wsdl:operation name="getCountryInfoByISO">
            <wsdl:input message="tns:getCountryInfoByISORequest"/>
            <wsdl:output message="tns:getCountryInfoByISOResponse"/>
        </wsdl:operation>
    </wsdl:portType>
    <wsdl:binding name="CountryInfoBinding" type="tns:CountryInfoPort">
        <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
        <wsdl:operation name="getCountryInfoByISO">
            <soap:operation soapAction="https://www.example.com/country-info/getCountryInfoByISO"/>
            <wsdl:input>
                <soap:body use="literal"/>
            </wsdl:input>
            <wsdl:output>
                <soap:body use="literal"/>
            </wsdl:output>
        </wsdl:operation>
    </wsdl:binding>
    <wsdl:service name="CountryInfoService">
        <wsdl:port name="CountryInfoPort" binding="tns:CountryInfoBinding">
            <soap:address location="https://www.example.com/country-info"/>
        </wsdl:port>
    </wsdl:service>
</wsdl:definitions>

3. Appel de la Méthode du Service Web

Le client SOAP appelle la méthode getCountryInfoByISO du service Web en fournissant un code ISO en entrée, par exemple ‘US’. Le service Web renvoie des informations sur les États-Unis sous forme de réponse XML, qui peuvent être ensuite traitées par le client.

Cet exemple illustre comment utiliser SOAP pour communiquer avec un service Web en envoyant des requêtes et en recevant des réponses au format XML. Le client SOAP utilise la bibliothèque zeep pour simplifier la communication avec le service Web.

4. MQTT (Message Queuing Telemetry Transport)

MQTT est un protocole de messagerie ultra-léger conçu pour les appareils IoT (Internet des objets). Il permet une communication efficace entre les appareils et les serveurs, tout en minimisant la consommation de bande passante. MQTT est idéal pour les cas d’utilisation où la faible utilisation des ressources est cruciale.

Voici un exemple simple d’utilisation de MQTT en Python avec la bibliothèque paho-mqtt pour publier et recevoir des messages.

1- Installation de la bibliothèque paho-mqtt

Assurez-vous d’installer la bibliothèque paho-mqtt en utilisant pip :

pip install paho-mqtt

2- Exemple de Publication

Voici un exemple de code Python pour publier un message sur un canal MQTT.

import paho.mqtt.client as mqtt

# Paramètres du broker MQTT
broker_address = "mqtt.eclipse.org"  # Exemple de broker public
port = 1883
topic = "example/topic"  # Nom du canal/topic

# Créer un client MQTT
client = mqtt.Client("PublisherClient")

# Connexion au broker MQTT
client.connect(broker_address, port)

# Message à publier
message = "Hello, MQTT!"

# Publication du message
client.publish(topic, message)

# Déconnexion du broker MQTT
client.disconnect()

3- Exemple de Souscription

Voici un exemple de code Python pour souscrire à un canal MQTT et recevoir des messages.

import paho.mqtt.client as mqtt

# Paramètres du broker MQTT
broker_address = "mqtt.eclipse.org"  # Exemple de broker public
port = 1883
topic = "example/topic"  # Nom du canal/topic

# Fonction de rappel pour gérer les messages reçus
def on_message(client, userdata, message):
    print(f"Message reçu sur le canal {message.topic}: {message.payload.decode('utf-8')}")

# Créer un client MQTT
client = mqtt.Client("SubscriberClient")

# Configurer la fonction de rappel
client.on_message = on_message

# Connexion au broker MQTT
client.connect(broker_address, port)

# Souscrire au canal/topic
client.subscribe(topic)

# Boucle de traitement des messages
client.loop_forever()

4- Exécution des Exemples

– Exécutez le code du publisher pour publier un message sur le canal MQTT spécifié.

– Ensuite, exécutez le code du subscriber pour souscrire au même canal et recevoir les messages publiés.

Lorsque vous exécutez ces exemples, le publisher enverra un message au broker MQTT, et le subscriber recevra ce message et l’affichera. Assurez-vous de remplacer les paramètres du broker MQTT (comme broker_address et port) par les informations de votre propre broker MQTT si nécessaire.

Cet exemple illustre comment utiliser MQTT pour la communication entre des appareils IoT ou des systèmes distribués en publiant et en souscrivant à des canaux MQTT.

5. Web Socket

Les Web Sockets sont une technologie qui permet une communication bidirectionnelle en temps réel entre le navigateur et le serveur. Cette architecture est essentielle pour les applications nécessitant des mises à jour en temps réel, telles que les chats en ligne et les jeux multijoueurs.

Voici un exemple simple d’utilisation de WebSocket en JavaScript côté client et côté serveur en utilisant Node.js.

1- Côté Serveur (Node.js)

Nous allons utiliser le module ws (WebSocket) pour créer un serveur WebSocket. Assurez-vous de l’installer avec npm.

npm install ws

Voici un exemple de serveur WebSocket en Node.js :

const WebSocket = require('ws');
const server = new WebSocket.Server({ port: 8080 });

server.on('connection', (socket) => {
  console.log('Nouvelle connexion WebSocket établie');

  // Écoute des messages du client
  socket.on('message', (message) => {
    console.log(`Message reçu du client : ${message}`);

    // Envoyer un message de réponse au client
    socket.send('Message reçu par le serveur : ' + message);
  });

  // Gérer la déconnexion du client
  socket.on('close', () => {
    console.log('Connexion WebSocket fermée');
  });
});

2- Côté Client (JavaScript dans le navigateur)

Vous pouvez créer une page HTML avec un script JavaScript pour gérer la communication WebSocket côté client :

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>WebSocket Client</title>
</head>
<body>
  <h1>WebSocket Client</h1>
  <input type="text" id="messageInput" placeholder="Entrez un message">
  <button onclick="sendMessage()">Envoyer</button>
  <div id="output"></div>

  <script>
    const socket = new WebSocket('ws://localhost:8080'); // Remplacez l'URL par l'adresse de votre serveur WebSocket

    socket.onopen = () => {
      console.log('Connexion WebSocket ouverte');
    };

    socket.onmessage = (event) => {
      const output = document.getElementById('output');
      output.innerHTML += '<p>' + event.data + '</p>';
    };

    socket.onclose = () => {
      console.log('Connexion WebSocket fermée');
    };

    function sendMessage() {
      const messageInput = document.getElementById('messageInput');
      const message = messageInput.value;
      socket.send(message);
      messageInput.value = '';
    }
  </script>
</body>
</html>

3- Exécution

Exécutez le serveur WebSocket Node.js en utilisant node server.js (ou le nom du fichier serveur que vous avez choisi).
Ouvrez la page HTML côté client dans un navigateur. Assurez-vous que l’URL du serveur WebSocket dans le code client correspond à l’adresse du serveur WebSocket que vous avez démarré.

Vous pouvez maintenant utiliser la page HTML pour envoyer des messages au serveur WebSocket, qui renverra les messages au client et les affichera sur la page. C’est un exemple de communication bidirectionnelle en temps réel avec WebSocket.

6. GraphQL

GraphQL est une architecture d’API flexible qui permet aux clients de demander exactement les données dont ils ont besoin, ni plus ni moins. Contrairement aux API REST traditionnelles, où le serveur dicte la structure de la réponse, GraphQL permet aux clients de spécifier les données souhaitées, ce qui réduit la surcharge de données et améliore les performances.

Voici un exemple simple d’utilisation de GraphQL avec Node.js et Express.

1- Côté Serveur (Node.js)

Vous devrez d’abord installer quelques dépendances :

npm install express express-graphql graphql

Voici un exemple de serveur GraphQL simple avec Express :

const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { GraphQLSchema, GraphQLObjectType, GraphQLString } = require('graphql');

// Définissez un type de données GraphQL
const RootType = new GraphQLObjectType({
  name: 'RootType',
  fields: {
    message: {
      type: GraphQLString,
      resolve: () => 'Hello, GraphQL!'
    }
  }
});

// Créez un schéma GraphQL
const schema = new GraphQLSchema({
  query: RootType
});

const app = express();

app.use('/graphql', graphqlHTTP({
  schema: schema,
  graphiql: true // Active l'interface graphique pour tester les requêtes GraphQL
}));

app.listen(3000, () => {
  console.log('Serveur GraphQL en cours d\'exécution sur le port 3000');
});

Ce serveur GraphQL simple définit un seul type de données “message” qui renvoie une chaîne “Hello, GraphQL!”.

2- Côté Client (Test avec GraphiQL)

Après avoir démarré le serveur GraphQL, vous pouvez accéder à l’interface graphique de test (GraphiQL) en ouvrant http://localhost:3000/graphql dans votre navigateur.

Vous pouvez saisir des requêtes GraphQL dans la zone de texte à gauche et exécuter les requêtes en appuyant sur le bouton “Play” (triangle). Par exemple, vous pouvez saisir :

{
  message
}

Et vous devriez obtenir la réponse :

{
  "data": {
    "message": "Hello, GraphQL!"
  }
}

GraphiQL facilite grandement le test et le débogage des requêtes GraphQL.

3- Côté Client (Utilisation dans une application)

Dans une application réelle, vous utiliseriez une bibliothèque GraphQL côté client (par exemple, Apollo Client) pour effectuer des requêtes GraphQL depuis votre application. Cependant, cela nécessiterait une configuration plus détaillée.

Voici un exemple minimal d’utilisation d’Apollo Client pour effectuer la même requête “message” depuis une application React :

import React from 'react';
import { ApolloClient, InMemoryCache, ApolloProvider, useQuery, gql } from '@apollo/client';

const client = new ApolloClient({
  uri: 'http://localhost:3000/graphql',
  cache: new InMemoryCache()
});

const GET_MESSAGE = gql`
  {
    message
  }
`;

function App() {
  const { loading, error, data } = useQuery(GET_MESSAGE);

  if (loading) return <p>Chargement...</p>;
  if (error) return <p>Erreur : {error.message}</p>;

  return <p>Message GraphQL : {data.message}</p>;
}

function MyApp() {
  return (
    <ApolloProvider client={client}>
      <App />
    </ApolloProvider>
  );
}

export default MyApp;

Dans cet exemple, nous utilisons Apollo Client pour effectuer une requête GraphQL pour obtenir le “message” depuis le serveur GraphQL que nous avons configuré précédemment.

Cet exemple de GraphQL montre comment définir un schéma, exécuter des requêtes et obtenir des réponses côté serveur et côté client. Il s’agit d’une utilisation très basique, mais GraphQL peut gérer des schémas beaucoup plus complexes et répondre à des requêtes spécifiques aux besoins de l’application.

Conclusion :

Ces six architectures d’API jouent un rôle essentiel dans le développement d’applications modernes. Chacune d’entre elles présente des avantages spécifiques en fonction des besoins de votre application. En comprenant ces architectures, vous serez mieux préparé pour créer des applications robustes et performantes qui répondent aux exigences de vos utilisateurs.

Non classé,Web

ANWER AWLED BELHEDI

Développeur Applicatif Full Stack