Dans cet article, je vais plonger en profondeur dans les principaux styles architecturaux d'API dans le monde de la programmation digne de discussion d'aujourd'hui, ainsi que quelques implémentations courantes en Python et JavaScript.
Tout d’abord, que sont les API ?
Le style architectural API (Application Programming Interface) définit la manière dont les différents composants d'un système logiciel communiquent et interagissent entre eux.
Il existe plusieurs styles architecturaux pour concevoir des API, voici les huit principaux :
1. Appel de procédure à distance (RPC) :
RPC consiste à appeler des procédures ou des fonctions sur des serveurs distants comme si elles étaient locales. Il résume la communication réseau et permet aux clients d'invoquer des méthodes de service à distance. Des exemples d'API RPC incluent gRPC et XML-RPC.
Implémentation en Python
# main.py
import grpc
from rpc_example_pb2 import HelloRequest
from rpc_example_pb2_grpc import GreeterServicer, add_GreeterServicer_to_server
class Greeter(GreeterServicer):
def SayHello(self, request, context):
return HelloReply(message='Hello, ' + request.name)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('[::]:50051')
server.start()
server.wait_for_termination()
Implémentation en JavaScript
// server.js
const {
GreeterClient } = require('./rpc_example_pb_grpc.js');
const {
HelloRequest } = require('./rpc_example_pb.js');
const client = new GreeterClient('http://localhost:8080');
const request = new HelloRequest();
request.setName('John');
client.sayHello(request, {
}, (error, response) => {
if (!error) {
console.log('Greeting:', response.getMessage());
}
});
2. Transfert d'État représentatif (REST) :
REST est un style architectural large et couramment utilisé pour créer des API évolutives et maintenables basées sur un ensemble de contraintes. Une API RESTful utilise des méthodes HTTP (GET, POST, PUT/PATCH, DELETE) pour effectuer des opérations CRUD sur les ressources représentées par des URL. Ils s'appuient sur une communication sans état et utilisent des codes d'état standard pour l'interprétation des réponses.
Implémentation en Python
# main.py
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/hello', methods=['GET'])
def hello():
return jsonify({
'message': 'Hello, World!'})
if __name__ == '__main__':
app.run(debug=True)
JavaScript 中的实现
// server.js
const express = require('express');
const app = express();
app.get('/hello', (req, res) => {
res.json({
message: 'Hello, World!' });
});
app.listen(3000, () => {
console.log('Server is running on port 3000');
});
3. Protocole d'accès aux objets simples (SOAP) :
SOAP est un protocole de communication entre services utilisant XML. Il se concentre sur la structure des messages et comprend un ensemble de normes pour divers aspects de la communication tels que la sécurité et les transactions. L'utilisation des API SOAP peut être plus complexe que REST.
Implémentation en Python
#main.py
from zeep import Client
client = Client('http://www.example.com/webservice?wsdl')
response = client.service.MethodName(param1=value1, param2=value2)
print(response)
Implémentation en JavaScript
// server.py
const axios = require('axios');
const requestData = `
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:web="http://www.example.com/webservice">
<soapenv:Header/>
<soapenv:Body>
<web:MethodName>
<web:param1>value1</web:param1>
<web:param2>value2</web:param2>
</web:MethodName>
</soapenv:Body>
</soapenv:Envelope>
`;
axios.post('http://www.example.com/webservice', requestData, {
headers: {
'Content-Type': 'text/xml' }
})
.then(response => {
console.log(response.data);
})
.catch(error => {
console.error(error);
});
4. Langage de requête graphique (GraphQL) :
GraphQL est un langage de requête et un environnement d'exécution API qui permettent aux clients de demander exactement les données dont ils ont besoin. Contrairement à REST, où le serveur décide de la forme de la réponse, un client GraphQL spécifie la structure de la réponse. Cela réduit la sur-récupération et la sous-récupération des données.
Implémentation en JavaScript
// server.js
const express = require('express');
const {
graphqlHTTP } = require('express-graphql');
const {
GraphQLSchema, GraphQLObjectType, GraphQLString } = require('graphql');
const app = express();
const QueryType = new GraphQLObjectType({
name: 'Query',
fields: {
hello: {
type: GraphQLString,
resolve: () => 'Hello, world!'
}
}
});
const schema = new GraphQLSchema({
query: QueryType
});
app.use('/graphql', graphqlHTTP({
schema: schema,
graphiql: true,
}));
app.listen(3000, () => {
console.log('GraphQL server is running on port 3000');
});
Chacun de ces styles architecturaux présente ses propres avantages et inconvénients, et le choix du style dépend de facteurs tels que la nature de l'application, les exigences de communication et la familiarité de l'équipe de développement avec la technologie. Ceci n'est qu'une partie du style architectural, les autres seront expliquées et discutées prochainement. Ne le manquez pas.