SYSTÈMES
DISTRIBUÉS
Dr. Mayssa Trabelsi
[email protected]
Année universitaire
2024/2025
Chapitre III
Les appels de procédure distants
RPC (Remote Procedure Call)
2
Introduction
■ Réalisation d’une communication client/serveur:
1. Le client demande un service (envoi d’une requête)
2. Le serveur exécute le service
3. Le serveur retourne une réponse au client
■ Communication:
• Bas niveau: utilisation directe du transport: Socket
• Haut niveau: intégration dans un langage de programmation : RPC
3
Définition
■ Appel de procédure à distance (Remote Procedure Call, ou RPC) : un outil pour
construire des applications client-serveur dans un langage de haut niveau
■ L’appel et le retour ont lieu sur un site, l’exécution se déroule sur un site distinct
■ L’effet de l’appel doit être identique dans les deux situations (local et distant)
4
RPC : principe
Serveur Client
Envoi de l’appel
Interpréter la requête Appel de la procédure
Appel de la procédure
Exécution
Résultat Résultat
5
Avantages attendus
■ Facilité de programmation
• La complexité des protocoles de communication est cachée
• Ne pas avoir à programmer des échanges au niveau réseau
■ Facilité de mise au point : une application peut être mise au point sur un site unique,
puis déployée sur plusieurs sites
■ Portabilité : résulte de l’usage d’un langage de haut niveau
• Indépendance par rapport au système de communication
6
Problèmes de réalisation
■ Transmission des paramètres
• conversion entre la forme interne, propre à un langage, et une forme adaptée à la
transmission
■ Gestion des processus
• Séquentielle et parallèle
■ Réaction aux défaillances
• Trois modes de défaillance indépendants : client, serveur, réseau
7
Mise en œuvre
Mise en œuvre
Par migration Par appel léger
(LRPC)
Par mémoire
Par messages
partagée
8
Réalisation par migration
Principe Avantage Inconvénients
• Le code et les • Très efficace pour de • Univers d’exécutions
données de la nombreux appels homogènes (ex
procédure distante machine virtuelle).
sont amenés sur le • Performances selon le
site appelant pour y volume de codes et
être exécutés par un de données.
appel local habituel.
9
Réalisation en mémoire partagée
répartie
Principe Avantages Inconvénients
• La procédure est • Efficace en cas • Univers de systèmes
installée pour le nombreux appels homogènes
client comme pour le • Efficace si tout le • Problèmes de partage
serveur dans la code et les données selon la cohérence de
mémoire virtuelle ne sont pas visités la mémoire répartie
partagée répartie
10
Réalisation par appel léger
Principe Avantage Inconvénients
• Processus locaux • Transmission d’appel • Uniquement applicable
s’exécutant sur la même très performant dans une même
machine
machine
• Segment de mémoire
partagée entre le client et le
serveur qui contient une
pile pour les paramètres
d’appel et de réponse
-> LRPC (Lightweight RPC)
11
Réalisation par message (RPC)
Principe Avantage Inconvénients
• Deux messages (au moins) • Le premier modèle • Peu efficace pour de
échangés: requête et réponse implémenté très nombreux appels
o Le premier message
• Supporte l’hétérogénéité
correspondant à la requête est
• La plus simple à réaliser
celui de l’appel de procédure,
porteur des paramètres d’appel.
o Le second message
correspondant à la réponse est
celui du retour de procédure
porteur des paramètres
résultats.
12
Notion des souches
■ Souches (ou Stubs) =Talons = Squelettes (ou Skeletons)...
■ Objectif: transformer l’appel local en un appel distant
■ La souche client ("client stub")
■ La souche serveur ("server stub")
13
Etapes de RPC par messages
■ Étape 1 : Le client réalise un appel procédural
vers la procédure souche client, la souche client
collecte les paramètres, les emballe dans le
message d’appel Client Serveur
■ Étape 2 : La souche client demande à une entité 1 10 6 5
de transport locale la transmission du message
d'appel
Client stub Serveur stub
■ Étape 3 : Le message d’appel est transmis sur
4
un réseau au site serveur 2 9 7
■ Étape 4 : Le message d’appel est délivré à la 3
souche serveur. La souche serveur déballe les Transport Client Transport Serveur
8
paramètres
■ Étape 5 : La souche serveur réalise l’appel
effectif de la procédure serveur
14
Etapes de RPC par messages
■ Étape 6: La procédure serveur ayant terminé son
exécution transmet à la souche serveur dans son
retour de procédure les paramètres résultats. La
souche serveur collecte les paramètres retour, les
emballe dans un message. Client Serveur
■ Étape 7: La procédure souche serveur demande 1 10 6 5
à l ’entité de transport serveur la transmission du
message de réponse.
Client stub Serveur stub
■ Étape 8 : Le message de réponse est transmis
9 7 4
sur un réseau au site client. 2
■ Étape 9 : Le message de réponse est délivré à la 3
souche client. La souche client déballe les Transport Client Transport Serveur
8
paramètres résultats.
■ Étape 10 : La procédure souche client transmet
les résultats au client en effectuant un retour
habituel de procédure en mode local. 15
Exercice: Application de salutations
■ Implémentation d'un appel de procédure distante (RPC) simple en Python.
■ Objectif : Faire communiquer un client et un serveur via RPC.
■ Côté Serveur :
• Créer un serveur RPC qui écoute les requêtes sur le port 8000.
• Définir une fonction bonjour() retournant la chaîne de caractères "Bonjour du serveur !".
• Enregistrer la fonction bonjour() pour la rendre accessible via RPC sous le nom "bonjour".
• Démarrer le serveur RPC.
■ Côté Client :
• Créer un proxy pour établir la communication avec le serveur RPC.
• Appeler la fonction distante bonjour() sur le serveur.
• Afficher la réponse reçue du serveur.
■ Résultat attendu :
• Le client affiche le message "Bonjour du serveur !".
16
Exercice: Calculatrice distante
■ Créer un système client-serveur où le client peut demander au serveur d'effectuer une
opération mathématique simple (addition).
■ Créer le serveur
■ Le serveur Python sera configuré pour écouter les demandes de calculs du client.
■ Le serveur aura une fonction :
✓ addition(a, b) : renvoie la somme de a et b.
17
Serveur RPC
# Importe le module pour créer un serveur XML- Explications
RPC
■ XML-RPC : Un protocole de communication
from xmlrpc.server import SimpleXMLRPCServer basé sur XML qui permet de faire des appels
# Crée un serveur sur l'ordinateur local, sur le port de procédures entre machines distantes via
8000 HTTP.
server = SimpleXMLRPCServer(("localhost", 8000)) ■ On importe le module SimpleXMLRPCServer
qui permet de créer un serveur XML-RPC en
print("Serveur RPC en écoute sur le port 8000...") Python.
# Définition de la fonction addition ■ server.register_function(addition, "addition") :
def addition(a, b): Ici, on dit au serveur d'ajouter la fonction
addition pour qu'elle soit accessible par le
return a + b client.
# Enregistrer la fonction pour qu'elle soit accessible
■ Le deuxième argument "addition" est le nom
via RPC
que le client utilise pour appeler cette fonction.
server.register_function(addition, "addition")
■ server.serve_forever() : Cette ligne démarre le
# Démarrer le serveur (il écoute de manière continue) serveur et le met en mode écoute en continu
server.serve_forever() pour traiter toutes les demandes d'appel de
fonction provenant des clients.
18
Client RPC
Explications
■ Importation de ServerProxy : Elle est essentielle
pour que le client puisse se connecter au serveur
from xmlrpc.client import ServerProxy XML-RPC. Sans cette importation, le client ne
pourrait pas appeler les fonctions distantes
# Se connecter au serveur RPC définies sur le serveur.
client = ServerProxy("http://localhost:8000/") ■ ServerProxy ("http://localhost:8000/") : Ici, le
client crée une connexion en utilisant l’URL
# Appeler la fonction addition sur le serveur fournie.
a=5 ■ def addition(a, b): : On définit une fonction
simple appelée addition qui prend deux
b = 10 paramètres (a et b).
■ return a + b : La fonction retourne la somme de a
resultat = client.addition(a, b) et b.
print(f"Le résultat de {a} + {b} est : {resultat}") Résultat attendu
Le client devrait afficher :
Le résultat de 5 + 10 est : 15
19
Diagramme de RPC par messages
Stub
Stub serveur
client
■ Les talons (ou souches) client et serveur sont créés à partir d’une description d’interface
20
Utilisation d’un IDL
(Interface Definition Language)
▪ Un langage pour la spécification des interfaces entre les clients et les
serveurs
▪ Une interface ou un contrat entre le client et le serveur : fichier .x
▪ Définition des types et natures des paramètres
• IN, OUT, IN-OUT, par valeur, par référence
▪ Définition indépendante de la plate-forme
• Indépendante du langage, de l’OS et de la machine
▪ Utilisation de ces définitions pour générer automatiquement :
• Le talon client (ou proxy, ou stub)
• Le talon serveur (ou squelette, ou skeleton)
21
Utilisation d’un IDL
22
Étapes de l'appel RPC
1) Définition des procédures dans le fichier .x
2) Génération automatique des stub (client) et skeleton (serveur)
3) Implémentation des fonctions côté serveur
4) Le client appelle une fonction via le stub
5) Le skeleton côté serveur reçoit l'appel et exécute la fonction
23
Structure Générale du Fichier .x
[Definition des constantes]
[Definition des types]
/* Déclaration du programme et de ses versions */
program NOM_DU_PROGRAMME {
/* Déclaration d'une version du programme */
version NOM_VERSION {
/* Définition des procédures */
TYPE_RESULTAT nom_procedure (type_du_parametre) = NUM_PROCEDURE;
} = NUM_VERSION;
} = NUM_PROGRAMME;
24
Structure Générale du Fichier .x
[Definition des constantes]
Un fichier .x peut contenir un ou plusieurs
[Definition des types] programmes,
/* Déclaration du programme et de ses versions */
program NOM_DU_PROGRAMME {
/* Déclaration d'une version du programme */
version NOM_VERSION {
/* Définition des procédures */
TYPE_RESULTAT nom_procedure (type_du_parametre) = NUM_PROCEDURE;
} = NUM_VERSION;
} = NUM_PROGRAMME;
25
Structure Générale du Fichier .x
• Programme = ensemble de
[Definition des constantes] fonctions/services.
[Definition des types] • Chaque programme possède un nom avec un
/* Déclaration du programme et de ses versions */ numéro associé.
program NOM_DU_PROGRAMME { • Un programme peut exister en plusieurs
versions
/* Déclaration d'une version du programme */
version NOM_VERSION {
/* Définition des procédures */
TYPE_RESULTAT nom_procedure (type_du_parametre) = NUM_PROCEDURE;
} = NUM_VERSION;
} = NUM_PROGRAMME;
26
Structure Générale du Fichier .x
[Definition des constantes]
[Definition des types]
/* Déclaration du programme et de ses versions */ • Chaque version est identifiée par un nom et
program NOM_DU_PROGRAMME { un numéro associé
/* Déclaration d'une version du programme */ • Chaque version définit une liste de fonctions
• Chaque fonction est identifiée par un
version NOM_VERSION {
numéro unique
/* Définition des procédures */
TYPE_RESULTAT nom_procedure (type_du_parametre) = NUM_PROCEDURE;
} = NUM_VERSION;
} = NUM_PROGRAMME;
27
Structure Générale du Fichier .x
[Definition des constantes]
[Definition des types]
/* Déclaration du programme et de ses versions */
program NOM_DU_PROGRAMME {
/* Déclaration d'une version du programme */
Numéro du programme en RPC :
version NOM_VERSION {
- Unique
/* Définition des procédures */ - Identifiant de 32 bits (souvent en hexadécimal,
TYPE_RESULTAT nom_procedure ex. 0x20000001)
(type_du_parametre) = NUM_PROCEDURE; - Organisés en plages :
} = NUM_VERSION; • système (0x00000000 - 0x1FFFFFFF),
• utilisateur (0x20000000 - 0x5FFFFFFF)
} = NUM_PROGRAMME;
• expérimentale (0x60000000+).
28
Structure Générale du Fichier .x
[Definition des constantes]
[Definition des types]
/* Déclaration du programme et de ses versions */
program NOM_DU_PROGRAMME {
/* Déclaration d'une version du programme */
version NOM_VERSION { 1. Le numéro de procédure : Commence toujours
/* Définition des procédures */ à partir de 1 et puis incrémenter
TYPE_RESULTAT nom_procedure séquentiellement
(type_du_parametre) = NUM_PROCEDURE; 2. Le numéro de version du programme :
} = NUM_VERSION; Commence typiquement à partir de 1 et puis
incrémenter
} = NUM_PROGRAMME;
29
Exemple: Programme CALCULATOR
program CALCULATOR {
// Version 1 : Fonctionnalités de base
version V1 {
int add(int a, int b) = 1; // Addition
int subtract(int a, int b) = 2; // Soustraction
} = 1;
// Version 2 : Fonctionnalités avancées
version V2 {
int multiply(int a, int b) = 1; // Multiplication
int divide(int a, int b) = 2; // Division
} = 2;
} = 0x20000001;
30
Exercice : Définir une interface pour un service de
gestion d'étudiants
Vous devez créer un fichier .x décrivant un programme RPC qui offre des fonctionnalités
pour gérer une base de données d'étudiants.
• Le programme s'appelle STUDENT_MANAGER
• Il est identifié par le numéro de programme 0x20000005
• Il a une seule version
• Le programme propose les procédures suivantes :
✓ add_student(int id, string name) : ajoute un étudiant avec un identifiant et un
nom.
✓ get_student(int id) : retourne le nom de l'étudiant correspondant à l'identifiant
donné.
✓ delete_student(int id) : supprime un étudiant à partir de son identifiant.
✓ count_students() : retourne le nombre total d'étudiants dans la base.
31
Correction exercice : Définir une interface
pour un service de gestion d'étudiants
program STUDENT_MANAGER {
version V1 {
void add_student(int id, string name) = 1;
string get_student(int id) = 2;
void delete_student(int id) = 3;
int count_students() = 4;
} = 1; // Version 1
} = 0x20000005; // Numéro unique du programme
32
Exercice : Définir une interface pour un
service météo
■ Le programme s'appelle WEATHER_SERVICE
■ Il est identifié par le numéro de programme 0x20000010.
■ Il dispose de deux versions :
1. Version 1 : Permet uniquement de récupérer des informations météo
✓ get_temperature(string city) : retourne la température actuelle d’une ville
donnée.
✓ get_humidity(string city) : retourne le taux d'humidité actuel d’une ville
donnée.
✓ get_forecast(string city, int days) : retourne les prévisions météo pour les
prochains jours (jusqu’à 7 jours max).
2. Version 2 : Ajoute des fonctionnalités pour mettre à jour les données météo:
✓ Les trois procédures de la version 1.
✓ update_weather (string city, float temperature, int humidity) : met à jour
les données météo pour une ville.
33
Correction Exercice : une interface pour
un service météo
■ program WEATHER_SERVICE {
■ version V1 {
■ float get_temperature(string city) = 1;
■ int get_humidity(string city) = 2;
■ string get_forecast(string city, int days) = 3;
■ } = 1; // Version 1
■ version V2 {
■ float get_temperature(string city) = 1;
■ int get_humidity(string city) = 2;
■ string get_forecast(string city, int days) = 3;
■ void update_weather(string city, float temperature, int humidity) = 4;
■ } = 2; // Version 2
■ } = 0x20000010; // Numéro unique du programme
34
FIN
35
